engine

type AlterTable ¶ added in v0.3.0

type AlterTable struct {
	Table     string
	AddColumn *storage.Column // For ADD COLUMN

}

AlterTable represents an ALTER TABLE statement.

type Binary ¶

type Binary struct {
	Op          string
	Left, Right Expr
}

Binary represents binary operators (+,-,*,/, comparisons, AND/OR).

type CTE ¶

type CTE struct {
	Name   string
	Select *Select
}

CTE represents a Common Table Expression (WITH clause)

type CaseExpr ¶ added in v0.3.0

type CaseExpr struct {
	Operand Expr
	Whens   []CaseWhen
	Else    Expr
}

CaseExpr represents a CASE ... WHEN ... THEN ... [ELSE ...] END expression.

type CaseWhen ¶ added in v0.3.0

type CaseWhen struct {
	When Expr
	Then Expr
}

CaseWhen pairs WHEN condition and THEN result expressions.

type ColumnIndex ¶ added in v0.3.1

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

ColumnIndex provides fast column lookups for better performance

func NewColumnIndex(rows []Row, columns []string) *ColumnIndex

func (idx *ColumnIndex) GetRows(indices []int) []Row

func (idx *ColumnIndex) Lookup(column string, value any) []int

type CompiledQuery ¶

type CompiledQuery struct {
	SQL       string
	Statement Statement
	ParsedAt  time.Time
}

CompiledQuery represents a pre-parsed and cached SQL query.

func (cq *CompiledQuery) Execute(ctx context.Context, db *storage.DB, tenant string) (*ResultSet, error)

type CreateIndex ¶ added in v0.3.0

type CreateIndex struct {
	Name        string
	Table       string
	Columns     []string
	Unique      bool
	IfNotExists bool
}

CreateIndex represents a CREATE INDEX statement.

type CreateTable ¶

type CreateTable struct {
	Name        string
	Cols        []storage.Column
	IsTemp      bool
	AsSelect    *Select
	IfNotExists bool // IF NOT EXISTS clause
}

CreateTable represents a CREATE TABLE statement.

type CreateView ¶ added in v0.3.0

type CreateView struct {
	Name        string
	Select      *Select
	IfNotExists bool
	OrReplace   bool
}

CreateView represents a CREATE VIEW statement.

type Delete ¶

type Delete struct {
	Table string
	Where Expr
}

Delete represents a DELETE statement.

type DropIndex ¶ added in v0.3.0

type DropIndex struct {
	Name     string
	Table    string // Optional: some DBs require table name
	IfExists bool
}

DropIndex represents a DROP INDEX statement.

type DropTable ¶

type DropTable struct {
	Name     string
	IfExists bool // IF EXISTS clause
}

DropTable represents a DROP TABLE statement.

type DropView ¶ added in v0.3.0

type DropView struct {
	Name     string
	IfExists bool
}

DropView represents a DROP VIEW statement.

type ExecEnv ¶

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

type Expr ¶

type Expr interface{}

type ExpressionCache ¶ added in v0.3.1

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

ExpressionCache provides caching for frequently evaluated expressions

func NewExpressionCache() *ExpressionCache

func (ec *ExpressionCache) Clear()

func (ec *ExpressionCache) Get(exprStr string, row Row) (any, bool)

func (ec *ExpressionCache) Set(exprStr string, row Row, result any)

func (ec *ExpressionCache) Stats() (hits, misses int, hitRate float64)

type FromItem ¶

type FromItem struct{ Table, Alias string }

FromItem binds a source table and its alias in FROM/JOIN.

type FuncCall ¶

type FuncCall struct {
	Name     string
	Args     []Expr
	Star     bool
	Distinct bool // For COUNT(DISTINCT col)
}

FuncCall represents a function call, optionally with a star (COUNT(*)).

type HashJoinOptimizer ¶ added in v0.3.1

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

HashJoinOptimizer provides hash-based join optimizations

func (h *HashJoinOptimizer) ProcessOptimizedJoin(leftRows, rightRows []Row, condition Expr, joinType OptimizedJoinType) ([]Row, error)

type InExpr ¶ added in v0.3.0

type InExpr struct {
	Expr   Expr
	Values []Expr
	Negate bool // For NOT IN
}

InExpr represents "expr IN (val1, val2, ...)"

type Insert ¶

type Insert struct {
	Table string
	Cols  []string
	Rows  [][]Expr
}

Insert represents an INSERT statement.

type IsNull ¶

type IsNull struct {
	Expr   Expr
	Negate bool
}

IsNull represents IS [NOT] NULL predicate.

type JoinClause ¶

type JoinClause struct {
	Type  JoinType
	Right FromItem
	On    Expr
}

JoinClause holds a JOIN type with the right side and join condition.

type JoinCondition ¶ added in v0.3.1

type JoinCondition struct {
	LeftColumn  string
	RightColumn string
	Operator    string
	IsEquiJoin  bool
}

JoinCondition represents a parsed join condition

type JoinType ¶

type JoinType int

const (
	// JoinInner represents INNER JOIN.
	JoinInner JoinType = iota
	// JoinLeft represents LEFT (OUTER) JOIN.
	JoinLeft
	// JoinRight represents RIGHT (OUTER) JOIN.
	JoinRight
)

type LikeExpr ¶ added in v0.3.0

type LikeExpr struct {
	Expr    Expr
	Pattern Expr
	Escape  Expr // Optional ESCAPE character
	Negate  bool // For NOT LIKE
}

LikeExpr represents "expr LIKE pattern [ESCAPE char]"

type Literal ¶

type Literal struct{ Val any }

Literal holds a constant value (number, string, bool, NULL).

type OptimizedJoinType ¶ added in v0.3.1

type OptimizedJoinType int

OptimizedJoinType defines the type of join operation for optimizations

const (
	OptimizedJoinTypeInner OptimizedJoinType = iota
	OptimizedJoinTypeLeft
	OptimizedJoinTypeRight
)

type OrderItem ¶

type OrderItem struct {
	Col  string
	Desc bool
}

OrderItem specifies ordering column and direction.

type Parser ¶

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

Parser holds the lexer and current/peek tokens for recursive-descent parsing.

func NewParser(sql string) *Parser

func (p *Parser) ParseStatement() (Statement, error)

type QueryCache ¶

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

QueryCache manages compiled queries.

func NewQueryCache(maxSize int) *QueryCache

func (qc *QueryCache) Clear()

func (qc *QueryCache) Compile(sql string) (*CompiledQuery, error)

func (qc *QueryCache) MustCompile(sql string) *CompiledQuery

func (qc *QueryCache) Size() int

func (qc *QueryCache) Stats() map[string]interface{}

type ResultSet ¶

type ResultSet struct {
	Cols []string
	Rows []Row
}

ResultSet holds the column order and the returned rows from a query. Cols preserve the display order; Rows store values in a case-insensitive map.

func Execute(ctx context.Context, db *storage.DB, tenant string, stmt Statement) (*ResultSet, error)

type Row ¶

type Row map[string]any

Row represents a single result row mapped by lower-cased column name. Keys include both qualified (table.column) and unqualified (column) names to simplify expression evaluation and projection.

type Select ¶

type Select struct {
	Distinct bool
	From     FromItem
	Joins    []JoinClause
	Projs    []SelectItem
	Where    Expr
	GroupBy  []Expr
	Having   Expr
	OrderBy  []OrderItem
	Limit    *int
	Offset   *int
	Union    *UnionClause // For UNION operations
	CTEs     []CTE        // Common Table Expressions
}

Select represents a SELECT query and its clauses.

type SelectItem ¶

type SelectItem struct {
	Expr  Expr
	Alias string
	Star  bool
}

SelectItem represents a projection item, optionally with alias or *.

type Statement ¶

type Statement interface{}

Statement is the root interface for all parsed SQL statements.

type SubqueryExpr ¶ added in v0.3.0

type SubqueryExpr struct {
	Select *Select
}

SubqueryExpr wraps a SELECT used as an expression (scalar subquery).

type Unary ¶

type Unary struct {
	Op   string
	Expr Expr
}

Unary represents unary operators like +, -, NOT.

type UnionClause ¶

type UnionClause struct {
	Type  UnionType
	Right *Select
	Next  *UnionClause // For chaining multiple UNIONs
}

UnionClause represents a set operation chaining RIGHT select with current one.

type UnionType ¶

type UnionType int

const (
	// UnionDistinct corresponds to UNION (distinct).
	UnionDistinct UnionType = iota
	// UnionAll corresponds to UNION ALL.
	UnionAll
	// Except corresponds to EXCEPT.
	Except
	// Intersect corresponds to INTERSECT.
	Intersect
)

type Update ¶

type Update struct {
	Table string
	Sets  map[string]Expr
	Where Expr
}

Update represents an UPDATE statement.

type VarRef ¶

type VarRef struct{ Name string }

VarRef refers to a column (qualified or unqualified) in expressions.