25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
package main
import (
"database/sql"
"encoding/json"
"errors"
"testing"
"time"
)
func TestPLDebugNativeStackRPCPreservesNativeFramesAndRuntimePosition(t *testing.T) {
for _, scenario := range []string{"complete", "missing_identity", "sparse", "conflicting_leaf", "conflicting_entrypoint", "read_error", "invalid_indices"} {
t.Run(scenario, func(t *testing.T) {
integer := func(value int64) sql.NullInt64 { return sql.NullInt64{Int64: value, Valid: true} }
owner, name := " Exact.Owner ", " Leaf.\"\n[Line 999] "
namespace, line := int64(1), int64(21)
stop := plDebugNativeStop{Result: integer(0), Terminated: integer(0), StackDepth: integer(3), Line: integer(line), Reason: integer(9), Namespace: integer(namespace), Program: sql.NullString{String: name, Valid: true}, Owner: sql.NullString{String: owner, Valid: true}}
records := []plDebugNativeStackRecord{}
for i := int64(1); i <= 3; i++ {
records = append(records, plDebugNativeStackRecord{NativeFrameID: i, Namespace: &namespace, Program: &name, Owner: &owner, Line: &line})
}
records[0].Line = nil
switch scenario {
case "missing_identity":
records[1].Owner = nil
case "sparse":
records = append(records[:1], records[2:]...)
case "conflicting_leaf":
other := "different source"
records[2].Program = &other
case "conflicting_entrypoint":
stop.Entrypoint = sql.NullString{String: "Original entrypoint", Valid: true}
other := "different overload"
records[2].Entrypoint = &other
case "invalid_indices":
records[1].NativeFrameID = 1
}
payload, err := json.Marshal(records)
if err != nil {
t.Fatal(err)
}
e := &plDebugManagerTestEngine{targetStarted: make(chan struct{}), targetRelease: make(chan struct{}), cleanupStarted: make(chan struct{}), cleanupRelease: make(chan struct{})}
first := &plDebugBreakpointTestConnector{plDebugManagerTestConnector: plDebugManagerTestConnector{engine: e}, payload: string(payload), complete: 1, stops: []plDebugNativeStop{stop}}
if scenario == "read_error" {
first.executionError = errors.New("native structured backtrace unavailable")
}
second := &plDebugManagerTestConnector{engine: e, base: plDebugCaptureTestConnector{complete: 1}}
r := plDebugPairTestRuntime(first, second)
if resp := plDebugManagerRPC(t, r, "open_session", map[string]interface{}{"agentSessionId": "a"}); resp.Error != nil {
t.Fatal(resp.Error)
}
started := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_start", map[string]interface{}{"agentSessionId": "a", "operationId": "stack-1", "objectType": "ANONYMOUS", "source": "BEGIN NULL; END;"}))
state := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-1"}))
frames := state["frames"].([]plDebugNativeStackFrame)
if state["frameMappingState"] != "verified" || state["complete"] != (scenario == "complete") || len(frames) != 3 || state["stopRevision"] != started["stopRevision"] || state["program"] != name {
t.Fatalf("stack mapping or raw runtime changed: %#v", state)
}
for i, frame := range frames {
if frame.FrameIndex != i || frame.NativeFrameID != int64(3-i) || frame.StackDepth != frame.NativeFrameID {
t.Fatalf("renumbered native frame: %+v", frame)
}
}
if *frames[0].Program != name || *frames[0].Owner != owner || *frames[0].SourceLine != line {
t.Fatal("current raw runtime was lost")
}
if scenario == "complete" && (frames[2].SourceLine != nil || frames[2].NativeFrameID != 1) {
t.Fatal("missing-line outer frame was discarded")
}
if (scenario == "sparse" || scenario == "conflicting_leaf" || scenario == "conflicting_entrypoint" || scenario == "read_error" || scenario == "invalid_indices") && frames[1].IdentityState != "unresolved" {
t.Fatal("inconsistent collection authorized an outer program")
}
if scenario == "conflicting_leaf" && *state["nativeFrames"].([]plDebugNativeStackRecord)[2].Program != "different source" {
t.Fatal("raw conflicting collection was overwritten")
}
if scenario == "conflicting_entrypoint" && (*frames[0].Entrypoint != "Original entrypoint" || *state["nativeFrames"].([]plDebugNativeStackRecord)[2].Entrypoint != "different overload") {
t.Fatal("readonly native entrypoint conflict was hidden")
}
if first.executions != 1 || first.statementCloses != 1 {
t.Fatal("stack read retained references or replayed")
}
ended := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_resume", map[string]interface{}{"debugId": "stack-1"}))
if ended["frameMappingState"] != "unverified" {
t.Fatal("old frame mapping survived execution")
}
if resp := plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-1"}); resp.Error == nil || first.executions != 1 {
t.Fatal("ended operation dispatched another stack read")
}
closed := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_close", map[string]interface{}{"debugId": "stack-1"}))
if closed["releaseState"] != "released" || e.targetAttempts != 1 {
t.Fatal("stack inspection lost original target ownership")
}
})
}
}
func TestPLDebugNativeStackCloseKeepsCanceledControllerReferencesOwned(t *testing.T) {
e := &plDebugManagerTestEngine{targetStarted: make(chan struct{}), targetRelease: make(chan struct{})}
first := &plDebugBreakpointTestConnector{plDebugManagerTestConnector: plDebugManagerTestConnector{engine: e}, readStarted: make(chan struct{}), readUntilCanceled: true}
second := &plDebugManagerTestConnector{engine: e, base: plDebugCaptureTestConnector{complete: 1}}
r := plDebugPairTestRuntime(first, second)
if resp := plDebugManagerRPC(t, r, "open_session", map[string]interface{}{"agentSessionId": "a"}); resp.Error != nil {
t.Fatal(resp.Error)
}
plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_start", map[string]interface{}{"agentSessionId": "a", "operationId": "stack-close", "objectType": "ANONYMOUS", "source": "BEGIN NULL; END;"}))
done := make(chan response, 1)
go func() {
done <- plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-close"})
}()
select {
case <-first.readStarted:
case <-time.After(time.Second):
t.Fatal("stack did not reach original controller")
}
r.mu.RLock()
entry := r.plNativeEntries["stack-close"]
r.mu.RUnlock()
entry.mu.Lock()
entry.cleanupDeadline = time.Now().Add(100 * time.Millisecond)
entry.mu.Unlock()
closed := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_close", map[string]interface{}{"debugId": "stack-close"}))
if closed["releaseState"] != "unknown" || first.base.tx.base.closes != 0 || second.base.tx.base.closes != 0 {
t.Fatal("canceled thin connection was physically released or reused")
}
select {
case resp := <-done:
state := plDebugManagerSnapshot(t, resp)
if state["frameMappingState"] != "unverified" || state["complete"] != false {
t.Fatal("canceled stack read retained a verified mapping")
}
case <-time.After(time.Second):
t.Fatal("original stack action did not finish after cancellation")
}
entry.mu.Lock()
pending := len(entry.nativeReadPending)
entry.mu.Unlock()
if pending != 1 || first.executions != 1 || first.sets != 0 || first.deletes != 0 {
t.Fatalf("native inspection lost its reference owner or dispatched a recovery mutation: pending=%d executions=%d sets=%d deletes=%d", pending, first.executions, first.sets, first.deletes)
}
select {
case <-entry.captureDone:
case <-time.After(time.Second):
t.Fatal("original target did not return after close cancellation")
}
}
func TestPLDebugNativeReadCleanupKeepsReferencesPublishedDuringCleanup(t *testing.T) {
started, release := make(chan struct{}), make(chan struct{})
first := &plDebugNativeCapture{ReferencesPending: true, references: &plDebugCaptureReferences{readAttempted: true, statementCloseAttempted: true, clob: &plDebugClobOutput{memory: true, release: func() error { close(started); <-release; return nil }}}}
second := &plDebugNativeCapture{ReferencesPending: true}
entry := &plDebugNativeEntry{server: &server{plAllocation: &plDebugAllocation{}}, nativeReadPending: []*plDebugNativeCapture{first}}
done := make(chan error, 1)
go func() { done <- entry.finishNativeReads(time.Now().Add(time.Second)) }()
select {
case <-started:
case <-time.After(time.Second):
t.Fatal("reference cleanup did not reach release barrier")
}
entry.mu.Lock()
entry.nativeReadPending = append(entry.nativeReadPending, second)
entry.mu.Unlock()
close(release)
select {
case err := <-done:
if err == nil {
t.Error("cleanup claimed no pending references after another read published its owner")
}
case <-time.After(time.Second):
t.Fatal("reference cleanup did not finish")
}
entry.mu.Lock()
defer entry.mu.Unlock()
if len(entry.nativeReadPending) != 1 || entry.nativeReadPending[0] != second {
t.Fatal("cleanup discarded an inspection reference outside its original snapshot")
}
}
func TestPLDebugNativeStackDoesNotDispatchAfterAuthoritativeLeaseDeadline(t *testing.T) {
e := &plDebugManagerTestEngine{targetStarted: make(chan struct{}), targetRelease: make(chan struct{}), cleanupStarted: make(chan struct{}), cleanupRelease: make(chan struct{})}
first := &plDebugBreakpointTestConnector{plDebugManagerTestConnector: plDebugManagerTestConnector{engine: e}, payload: "[]", complete: 1}
second := &plDebugManagerTestConnector{engine: e, base: plDebugCaptureTestConnector{complete: 1}}
r := plDebugPairTestRuntime(first, second)
if resp := plDebugManagerRPC(t, r, "open_session", map[string]interface{}{"agentSessionId": "a"}); resp.Error != nil {
t.Fatal(resp.Error)
}
plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_start", map[string]interface{}{"agentSessionId": "a", "operationId": "stack-expired", "objectType": "ANONYMOUS", "source": "BEGIN NULL; END;"}))
r.mu.RLock()
entry := r.plNativeEntries["stack-expired"]
r.mu.RUnlock()
entry.mu.Lock()
entry.leaseTimer.Stop()
entry.leaseDeadline = time.Now().Add(-time.Second)
entry.cleanupDeadline = time.Now().Add(100 * time.Millisecond)
entry.mu.Unlock()
state := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-expired"}))
if state["frameMappingState"] != "unverified" || state["closeReason"] != "lease_expired" || first.prepares != 0 || first.executions != 0 {
t.Fatal("delayed timer admitted a stack query after the authoritative deadline")
}
plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_close", map[string]interface{}{"debugId": "stack-expired"}))
select {
case <-entry.captureDone:
case <-time.After(time.Second):
t.Fatal("expired operation lost original cleanup")
}
}
func TestPLDebugNativeStackRejectsReadAfterTargetReturnsWithoutControlReply(t *testing.T) {
name, owner := "raw, run_info.reason = 25\nname", "Mixed Owner"
namespace, line := int64(0), int64(21)
payload, _ := json.Marshal([]plDebugNativeStackRecord{{NativeFrameID: 1, Namespace: &namespace, Program: &name, Owner: &owner, Line: &line}})
e := &plDebugManagerTestEngine{targetStarted: make(chan struct{}), targetRelease: make(chan struct{})}
first := &plDebugBreakpointTestConnector{plDebugManagerTestConnector: plDebugManagerTestConnector{engine: e}, payload: string(payload), complete: 1}
second := &plDebugManagerTestConnector{engine: e, base: plDebugCaptureTestConnector{complete: 1}}
r := plDebugPairTestRuntime(first, second)
if resp := plDebugManagerRPC(t, r, "open_session", map[string]interface{}{"agentSessionId": "a"}); resp.Error != nil {
t.Fatal(resp.Error)
}
plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_start", map[string]interface{}{"agentSessionId": "a", "operationId": "stack-returned", "objectType": "ANONYMOUS", "source": "BEGIN NULL; END;"}))
plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-returned"}))
r.mu.RLock()
entry := r.plNativeEntries["stack-returned"]
r.mu.RUnlock()
e.release.Do(func() { close(e.targetRelease) })
select {
case <-entry.captureDone:
case <-time.After(time.Second):
t.Fatal("original target did not return")
}
if resp := plDebugManagerRPC(t, r, "pl_debug_get_stack", map[string]interface{}{"debugId": "stack-returned"}); resp.Error == nil || first.executions != 1 {
t.Fatal("cached paused stop admitted a read after the target returned")
}
state := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_status", map[string]interface{}{"debugId": "stack-returned"}))
if state["frameMappingState"] != "unverified" || state["sourceRef"] != nil {
t.Fatal("returned target retained active frame/source authority")
}
closed := plDebugManagerSnapshot(t, plDebugManagerRPC(t, r, "pl_debug_close", map[string]interface{}{"debugId": "stack-returned"}))
if closed["releaseState"] != "released" || e.targetAttempts != 1 {
t.Fatal("returned target was replayed or lost cleanup")
}
}