cydb

type ArithExpr struct {
	Left  Expression // 左侧表达式
	Right Expression // 右侧表达式
	Op    string     // 运算符（+, -, *, /, %）
	Alias string     // 别名（可选）
}

type BuildResult struct {
	SQL        string   `json:"sql"`         // 生成的SQL语句
	ParamOrder []string `json:"param_order"` // 参数顺序列表（用于维持顺序）
}

type BuildSql interface {
	GetFieldsString(dt DatabaseTransformer, skipAS bool) (string, error)
	GetPkFieldsString(dt DatabaseTransformer, skipAS bool) (string, error)
	GetValuesString(dt DatabaseTransformer, all bool) (string, []string, error)
	GetAssignString(dt DatabaseTransformer, all bool) (string, []string, error)
}

type CRUDOperations interface {
	// Insert inserts a single record
	Insert(ctx context.Context, tableName string, data map[string]any) (int64, error)
	// BatchInsert inserts multiple records
	BatchInsert(ctx context.Context, tableName string, data []map[string]any) (int64, error)
	// Update updates records matching the condition
	Update(ctx context.Context, tableName string, data map[string]any, condition map[string]any) (int64, error)
	// Delete deletes records matching the condition
	Delete(ctx context.Context, tableName string, condition map[string]any) (int64, error)
	// Replace replaces a record (upsert operation)
	Replace(ctx context.Context, tableName string, data map[string]any) (int64, error)
}

type CRUDSqlFuncName string

type CaseExpr struct {
	Value       Expression       // 用于简单 CASE 表达式的比较值，搜索 CASE 表达式为 nil
	WhenClauses []WhenThenClause // WHEN-THEN 子句列表
	ElseClause  Expression       // ELSE 子句（可选）
	Alias       string           // 别名（可选）
}

type Condition struct {
	Condition string
	Fields    []string
}

type Config struct {
	Connections []DBConnection `yaml:"connections"`
}

type DBCli struct {
	// contains filtered or unexported fields
}

type DBColumn struct {
	Name        string
	DBFieldType DBFieldType
	ColumnKey   string
	OrgDataType string
	Nullable    bool
}

type DBConnection struct {
	// Key is a unique identifier for the connection (e.g., "primary_db", "log_db").
	Key string `yaml:"key"`
	// Type specifies the database type, e.g., "mysql", "oracle", "sqlite", "postgresql".
	Type string `yaml:"type"`

	// Fields for MySQL, PostgreSQL and Oracle
	Host   string `yaml:"host,omitempty"`
	Port   int    `yaml:"port,omitempty"`
	Un     string `yaml:"un,omitempty"`
	Pw     string `yaml:"pw,omitempty"`
	DBName string `yaml:"dbname,omitempty"`

	// Fields for Oracle
	Service string `yaml:"service,omitempty"`
	Role    string `yaml:"role,omitempty"`

	// Field for SQLite
	Path string `yaml:"path,omitempty"`

	// Fields for PostgreSQL
	SSLMode string `yaml:"sslmode,omitempty"` // disable, require, verify-ca, verify-full
	Schema  string `yaml:"schema,omitempty"`  // default schema (search_path)
}

type DBFieldType int

type DBMgr struct {
	// contains filtered or unexported fields
}

type DDLSqlFunc func(cli DatabaseClient, name ...string) (*SqlContent, error)

type DDLSqlFuncName string

type DatabaseClient interface {
	// Basic metadata
	DBType() string
	Database() string

	// Core functionality that exists in current DBCli
	Query(sql string, args ...interface{}) ([]map[string]interface{}, error)
	Select(dest interface{}, query string, args ...interface{}) error
	Get(dest interface{}, query string, args ...interface{}) error
	Excute(sql string, arguments ...interface{}) (int64, error)

	// Connection management
	Close() error

	// Legacy compatibility
	PW() string
	NQuery(sql string, data any) ([]map[string]any, error)
	NQueryOne(sql string, data any) (map[string]any, error)
}

type DatabaseError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
	Details string `json:"details,omitempty"`
	Cause   error  `json:"-"`
}

type DatabaseManager interface {
	// GetClient returns a database client by key
	GetClient(key string) (DatabaseClient, error)
	// AddClient adds a new database client
	AddClient(key string, client DatabaseClient)
	// RemoveClient removes a database client
	RemoveClient(key string)
	// CloseAll closes all database connections
	CloseAll() error
	// ListClients returns all client keys
	ListClients() []string
}

type DatabaseMetadata interface {
	// Type returns the database type (mysql, oracle, sqlite, etc.)
	Type() string
	// Name returns the database name
	Name() string
	// Version returns the database version (if available)
	Version(ctx context.Context) (string, error)
}

type DatabaseTransformer interface {
	EscapeTableName(tableName string) string
	EscapeColumnName(columnName string) string
	BuildPagination(limit, offset string) string
	SupportsBatch() bool

	BuildReplaceSQL(tableName string, buildSql BuildSql) (string, []string, error)
	BuildUpsertSQL(tableName string, buildSql BuildSql) (string, []string, error)
}

type DefaultDBFieldType int

type Expression interface {
	ToSQL(dt DatabaseTransformer) (string, error)
	GetFields() []string
	SetAlias(alias string) Expression
}

type ExtraData interface {
	IsBlockEnd(string) bool
}

type FieldData struct {
	Name        string
	Type        DBFieldType
	OrgDataType string
	Data        interface{}
	IsPK        bool
	IsUQ        bool
	Nullable    bool
	Index       int
}

type FuncExpr struct {
	Name     string       // 函数名称，如 SUM, COUNT, MAX 等
	Args     []Expression // 函数参数
	Distinct bool         // 是否使用 DISTINCT
	Alias    string       // 别名（可选）
}

type FuncPreProcessSqlLine func(ctx *ParseContext, pline *string) (PreRetType, error)

type FuncSQLStatementCallback func(sqlStatement *SQLStatement) error

type FuncWithBuilder func(SQLBuilder) SQLBuilder

type IDBOperWrapper interface {
	BindNamed(query string, arg interface{}) (string, []interface{}, error)
	Exec(query string, args ...any) (sql.Result, error)
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
	Get(dest interface{}, query string, args ...interface{}) error
	GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error
	MustExec(query string, args ...interface{}) sql.Result
	MustExecContext(ctx context.Context, query string, args ...interface{}) sql.Result
	NamedExec(query string, arg interface{}) (sql.Result, error)
	NamedExecContext(ctx context.Context, query string, arg interface{}) (sql.Result, error)
	NamedQuery(query string, arg interface{}) (*sqlx.Rows, error)
	Prepare(query string) (*sql.Stmt, error)
	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
	PrepareNamed(query string) (*sqlx.NamedStmt, error)
	PrepareNamedContext(ctx context.Context, query string) (*sqlx.NamedStmt, error)
	Preparex(query string) (*sqlx.Stmt, error)
	PreparexContext(ctx context.Context, query string) (*sqlx.Stmt, error)
	Query(query string, args ...any) (*sql.Rows, error)
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
	QueryRow(query string, args ...any) *sql.Row
	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
	QueryRowx(query string, args ...interface{}) *sqlx.Row
	QueryRowxContext(ctx context.Context, query string, args ...interface{}) *sqlx.Row
	Queryx(query string, args ...interface{}) (*sqlx.Rows, error)
	QueryxContext(ctx context.Context, query string, args ...interface{}) (*sqlx.Rows, error)
	Select(dest interface{}, query string, args ...interface{}) error
	SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error
}

type IRepo interface {
	GetDBCli() *DBCli
	SetDBCli(*DBCli)
}

type LikePatternType int

type LiteralValue struct {
	Value  any  // 实际值
	Embed  bool // 是否直接嵌入
	Fields []string
}

type MigrateFileFunc func(pm *MigrateSQLParam) *MigrateSQLParam

type MigrateInfo struct {
	Key    string
	DBType string
}

type MigrateSQLParam struct {
	// contains filtered or unexported fields
}

type OP string

type OrderBy struct {
	Column    []Expression
	Direction string // ASC, DESC
}

type PARAMS = map[string]interface{}

type ParameterValue struct {
	Name string // 参数名
}

type ParseContext struct {
	// CurrentStmt 当前正在构建的 SQL 语句
	CurrentStmt strings.Builder
	// StartLineNum 当前语句的起始行号
	StartLineNum int
	// CurrentLineNum 当前处理的行号
	CurrentLineNum int
	// LineContent 当前行的内容
	LineContent string
	// HasContent 标记当前是否有内容正在处理
	HasContent bool
	// BlockIndex 块索引，用于标识 SQL 语句块
	BlockIndex int
	// CurrentType 当前 SQL 语句的类型
	CurrentType SQLType
	// TypeWord 类型关键字
	TypeWord string
	// TraceWord 用于跟踪关键字
	TraceWord *TraceWord
	// ExpectedStringEnd 期望的字符串结束标记
	ExpectedStringEnd string
	// IsMultiLineComment 是否在多行注释中
	IsMultiLineComment bool
	// Filter SQL 过滤器
	Filter []string
	// Extra 额外的特定于方言的数据
	Extra ExtraData
	// WordCallback 处理单词的回调函数
	WordCallback ProcessWordCallback
	// PreProcessSqlLine 预处理 SQL 行的回调函数
	PreProcessSqlLine FuncPreProcessSqlLine
}

type ParseMysqlContext struct {
	// contains filtered or unexported fields
}

type PreRetType int

type ProcessWordCallback func(ctx *ParseContext, word *cyutil.WordInfo) (bool, error)

type QueryExecutor interface {
	// Query executes a query and returns raw results
	Query(ctx context.Context, sql string, args ...any) ([]map[string]any, error)
	// QueryRow executes a query that is expected to return at most one row
	QueryRow(ctx context.Context, sql string, args ...any) (map[string]any, error)
	// Exec executes a statement that doesn't return rows
	Exec(ctx context.Context, sql string, args ...any) (sql.Result, error)
}

type QueryMetadata struct {
	ExecutionTime time.Duration `json:"execution_time"`
	RowsAffected  int64         `json:"rows_affected"`
	QueryHash     string        `json:"query_hash,omitempty"`
}

type ReadSQLFileOptions struct {
	// BufferSize 扫描器的缓冲区大小
	BufferSize int
	// MigrationMode 迁移模式过滤器 ("Up", "Down" 或空字符串表示不过滤)
	MigrationMode string
	// Filter SQL 过滤器，用于过滤特定类型的 SQL 语句
	Filter []string

	// WordCallback 单词回调函数，用于处理 SQL 语句中的单词
	WordCallback ProcessWordCallback

	// PreProcessSqlLine 预处理 SQL 行的回调函数
	PreProcessSqlLine FuncPreProcessSqlLine
}

type ResultSet[T any] struct {
	Data       []T           `json:"data"`
	TotalCount int64         `json:"total_count,omitempty"`
	Page       int           `json:"page,omitempty"`
	PageSize   int           `json:"page_size,omitempty"`
	Metadata   QueryMetadata `json:"metadata,omitempty"`
}

type RowData struct {
	Data []*FieldData
}

type SQLBuilder interface {
	Type(t SQLOperationType) SQLBuilder
	Database(db string) SQLBuilder
	Table(table any) SQLBuilder
	Fields(columns any, reset ...bool) SQLBuilder
	// PrimaryKeys 指定主键字段，用于REPLACE和UPSERT操作
	PrimaryKeys(keys ...string) SQLBuilder
	Distinct(distinct bool) SQLBuilder
	Values(data ...[]Expression) SQLBuilder
	ValuesAppend(data ...[]Expression) SQLBuilder
	SubQueryValues(builder SQLBuilder) SQLBuilder
	Update(columns any) SQLBuilder
	UpdateExpr(updates ...Expression) SQLBuilder
	Count(fields string) SQLBuilder
	Select(fields any) SQLBuilder
	From(tableSrc any) SQLBuilder
	Where(fv Where, reset ...bool) SQLBuilder
	WhereAnd(fvs ...Where) SQLBuilder
	WhereOr(fvs ...Where) SQLBuilder
	Join(tableSrc TableSource, condition ...Where) SQLBuilder
	LeftJoin(tableSrc TableSource, condition ...Where) SQLBuilder
	RightJoin(tableSrc TableSource, condition ...Where) SQLBuilder
	InnerJoin(tableSrc TableSource, condition ...Where) SQLBuilder
	GroupBy(columns any) SQLBuilder
	Having(fv Where) SQLBuilder
	HavingAnd(fvs ...Where) SQLBuilder
	HavingOr(fvs ...Where) SQLBuilder
	OrderBy(orderBy ...OrderBy) SQLBuilder
	Limit(limit int) SQLBuilder
	LimitPlaceholder(limit string) SQLBuilder
	Offset(offset int) SQLBuilder
	OffsetPlaceholder(offset string) SQLBuilder

	// 统一的构建方法，通过选项控制不同的构建方式
	Build(dt DatabaseTransformer) (*BuildResult, error)
}

type SQLDialect interface {
	// DDL operations
	GetDDLSqlFunc(funcName DDLSqlFuncName) (DDLSqlFunc, error)
	GetSortedSqlFunc(funcName SortFuncName) (SortedSqlFunc, error)

	// Schema operations - using DatabaseClient instead of specific type
	GetTableColumns(cli DatabaseClient, database, tableName string) ([]*DBColumn, error)
	IsTableExist(cli DatabaseClient, tableName string) (bool, error)

	// SQL preprocessing and utilities
	PreProcess(sql string, param ...int) string
	GetReplaceSql(cli DatabaseClient, table string, rd *RowData) (string, error)
	MakeSureDBExists(cli DatabaseClient, dbName string) error
	ReadSQLFile(r io.Reader, callback FuncSQLStatementCallback, options ...func(*ReadSQLFileOptions)) error
	GetConnectStr(dbConn *DBConnection) (string, string)
	GetDefaultTypeName(tp DefaultDBFieldType) string
}

type SQLOperationType string

type SQLParseError struct {
	// Message 错误消息
	Message string
	// LineNum 发生错误的行号
	LineNum int
	// LineText 发生错误的行文本
	LineText string
	// ErrorType 错误类型
	ErrorType string
}

type SQLStatement struct {
	Index     int
	StartLine int
	EndLine   int
	Type      string
	Content   string
}

type SQLType interface {
	// AsInt 返回 SQL 类型的整数表示
	AsInt() int
	// String 返回 SQL 类型的字符串表示
	String() string
	// IsBlock 判断该 SQL 类型是否为块级语句（如存储过程、函数等）
	IsBlock() bool

	// IsNull 判断该 SQL 类型是否为空
	IsNull() bool
}

type SchemaInspector interface {
	// GetTableColumns returns column information for a table
	GetTableColumns(ctx context.Context, database, tableName string) ([]*DBColumn, error)
	// IsTableExist checks if a table exists
	IsTableExist(ctx context.Context, tableName string) (bool, error)
	// GetTableNames returns all table names in the database
	GetTableNames(ctx context.Context, database string) ([]string, error)
}

type SimpleExpr struct {
	Field  string     // 字段名
	Table  string     // 表名（可选）
	Schema string     // 模式名（可选）
	Alias  string     // 别名（可选）
	Value  Expression // 值（可选）
}

type SortFuncName string

type SortedSqlFunc func(cli DatabaseClient, names []string) ([]*SqlContent, error)

type SqlContent struct {
	Name    string
	Content string
}

type SubQuery struct {
	Builder SQLBuilder
	Alias   string
	// contains filtered or unexported fields
}

type Table struct {
	Schema string // 数据库/schema名称
	Name   string // 表名
	Alias  string // 表别名
}

type TableSource interface {
	GetAlias() string
	ToSQL(dt DatabaseTransformer) (string, error)
}

type TraceWord struct {
	// Key 表示当前关键字
	Key string
	// Skip 表示跳过的字符数
	Skip int
	// NextKeys 表示可能的下一个关键字及其对应的 SQL 类型
	NextKeys map[string]SQLType
}

type Transaction interface {
	QueryExecutor
	TypedQueryExecutor
	// Commit commits the transaction
	Commit() error
	// Rollback rolls back the transaction
	Rollback() error
}

type TransactionManager interface {
	// Begin starts a new transaction
	Begin(ctx context.Context) (Transaction, error)
	// BeginTx starts a new transaction with options
	BeginTx(ctx context.Context, opts *sql.TxOptions) (Transaction, error)
}

type TypedQueryExecutor interface {
	// Select scans query results into a slice
	Select(ctx context.Context, dest any, query string, args ...any) error
	// Get scans a single row into dest
	Get(ctx context.Context, dest any, query string, args ...any) error
}

type Value interface {
	GetValue() (string, error)
	// contains filtered or unexported methods
}

type WhenThenClause struct {
	When Expression // WHEN 条件
	Then Expression // THEN 结果
}

type Where interface {
	ToCondition(dt DatabaseTransformer) (*Condition, error)
}

type WhereOP string

type WhereOptionFunc func(*whereItem) *whereItem