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 (
"context"
"database/sql/driver"
"errors"
"fmt"
"time"
)
type plDebugStatement struct {
driver.Stmt
allocation *plDebugAllocation
closeRequested bool
closeStarted bool
closeDone chan struct{}
closeDeadline time.Time
closeErr error
}
func (s *plDebugStatement) Close() error {
a := s.allocation
a.mu.Lock()
if !s.closeRequested {
s.closeRequested = true
s.closeDone = make(chan struct{})
a.closingStatements++
s.closeDeadline = time.Now().Add(plDebugReleaseTimeout)
if !a.cleanupDeadline.IsZero() && a.cleanupDeadline.Before(s.closeDeadline) {
s.closeDeadline = a.cleanupDeadline
}
}
if a.active != nil || a.unknown || len(a.rows) != 0 {
a.mu.Unlock()
return errPLDebugAllocationUnknown
}
if !s.closeStarted {
s.closeStarted = true
go s.closeRaw()
}
done, deadline := s.closeDone, s.closeDeadline
a.mu.Unlock()
select {
case <-done:
return s.result()
default:
}
timer := time.NewTimer(time.Until(deadline))
defer timer.Stop()
select {
case <-done:
return s.result()
case <-timer.C:
return errPLDebugAllocationUnknown
}
}
func (s *plDebugStatement) result() error {
s.allocation.mu.Lock()
defer s.allocation.mu.Unlock()
return s.closeErr
}
func (s *plDebugStatement) closeRaw() {
var err error
defer func() {
if recovered := recover(); recovered != nil {
err = fmt.Errorf("PL/SQL statement close panicked: %v", recovered)
}
a := s.allocation
a.mu.Lock()
s.closeErr = err
if err != nil {
a.unknown = true
} else {
delete(a.statements, s)
}
a.closingStatements--
close(s.closeDone)
retiring := a.retiring && !a.unknown && len(a.statements) == 0 && len(a.rows) == 0
a.mu.Unlock()
if retiring {
_ = a.close()
}
}()
err = s.Stmt.Close()
}
func (s *plDebugStatement) CheckNamedValue(value *driver.NamedValue) error {
if checker, ok := s.Stmt.(driver.NamedValueChecker); ok {
return checker.CheckNamedValue(value)
}
return driver.ErrSkip
}
func (s *plDebugStatement) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
return s.allocation.exec(ctx, func(private context.Context) (driver.Result, error) {
if stmt, ok := s.Stmt.(driver.StmtExecContext); ok {
return stmt.ExecContext(private, args)
}
values := make([]driver.Value, len(args))
for i, arg := range args {
if arg.Name != "" {
return nil, errors.New("legacy PL/SQL statement does not support named arguments")
}
values[i] = arg.Value
}
return s.Stmt.Exec(values)
})
}
func (s *plDebugStatement) Exec(args []driver.Value) (driver.Result, error) {
values := make([]driver.NamedValue, len(args))
for i, arg := range args {
values[i] = driver.NamedValue{Ordinal: i + 1, Value: arg}
}
return s.ExecContext(context.Background(), values)
}
func (s *plDebugStatement) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
return s.allocation.query(ctx, func(private context.Context) (driver.Rows, error) {
if stmt, ok := s.Stmt.(driver.StmtQueryContext); ok {
return stmt.QueryContext(private, args)
}
values := make([]driver.Value, len(args))
for i, arg := range args {
if arg.Name != "" {
return nil, errors.New("legacy PL/SQL statement does not support named arguments")
}
values[i] = arg.Value
}
return s.Stmt.Query(values)
})
}
func (s *plDebugStatement) Query(args []driver.Value) (driver.Rows, error) {
values := make([]driver.NamedValue, len(args))
for i, arg := range args {
values[i] = driver.NamedValue{Ordinal: i + 1, Value: arg}
}
return s.QueryContext(context.Background(), values)
}