opfsql 0.0.2

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# opfsql
+
+Lightweight SQL engine written in TypeScript. ~40 KB gzipped, zero native dependencies. Runs in browser workers via OPFS.
+
+[Live Client](https://talerok.github.io/opfsql/client/) | [Benchmark](https://talerok.github.io/opfsql/benchmark/)
+
+## Quick Start
+
+```ts
+import { WorkerEngine } from "opfsql";
+
+const engine = new WorkerEngine(new URL("./worker.ts", import.meta.url));
+await engine.open("my-db");
+const conn = await engine.connect();
+
+await conn.exec(`
+  CREATE TABLE users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    email TEXT UNIQUE
+  )
+`);
+
+await conn.exec("INSERT INTO users (name, email) VALUES ($1, $2)", [
+  "Alice",
+  "alice@example.com",
+]);
+
+const [result] = await conn.exec("SELECT * FROM users");
+// result.type === "rows"
+// result.rows === [{ id: 1, name: "Alice", email: "alice@example.com" }]
+
+await conn.disconnect();
+await engine.close();
+```
+
+## API
+
+### `WorkerEngine`
+
+| Method                | Returns               | Description                       |
+| --------------------- | --------------------- | --------------------------------- |
+| `engine.open(dbName)` | `Promise<void>`       | Open database in worker           |
+| `engine.connect()`    | `Promise<Connection>` | Create a new connection (session) |
+| `engine.close()`      | `Promise<void>`       | Close the database                |
+
+### `Connection`
+
+| Method                    | Returns                            | Description                                       |
+| ------------------------- | ---------------------------------- | ------------------------------------------------- |
+| `conn.exec(sql, params?)` | `Promise<Result[]>`                | Execute one or more SQL statements                |
+| `conn.prepare(sql)`       | `Promise<RemotePreparedStatement>` | Prepare a single statement for repeated execution |
+| `conn.getSchema()`        | `Promise<CatalogData>`             | Get current database schema                       |
+| `conn.disconnect()`       | `Promise<void>`                    | Close the connection                              |
+
+### `RemotePreparedStatement`
+
+| Method              | Returns           | Description                      |
+| ------------------- | ----------------- | -------------------------------- |
+| `stmt.run(params?)` | `Promise<Result>` | Execute with optional parameters |
+| `stmt.free()`       | `Promise<void>`   | Release the prepared statement   |
+
+### `Result`
+
+```ts
+type Result =
+  | { type: "rows"; rows: Row[] }
+  | { type: "ok"; rowsAffected: number };
+
+type Row = Record<string, Value>;
+type Value = string | number | boolean | null | JsonValue | Uint8Array;
+```
+
+### Parameters
+
+Use `$1`, `$2`, etc. for parameterized queries:
+
+```ts
+await conn.exec("SELECT * FROM users WHERE id = $1 AND name = $2", [1, "Alice"]);
+```
+
+## Supported SQL
+
+### Data Types
+
+`INTEGER`, `BIGINT`, `SMALLINT`, `FLOAT`/`REAL`, `DOUBLE`, `TEXT`/`VARCHAR`/`CHAR`, `BLOB`, `BOOLEAN`, `JSON`
+
+### Statements
+
+| Statement                       | Notes                                                              |
+| ------------------------------- | ------------------------------------------------------------------ |
+| `SELECT`                        | `DISTINCT`, column aliases, table aliases, `SELECT` without `FROM` |
+| `INSERT`                        | Multi-row, `INSERT...SELECT`, `ON CONFLICT DO NOTHING/UPDATE`      |
+| `UPDATE`                        | Expressions in `SET`                                               |
+| `DELETE`                        | With or without `WHERE`                                            |
+| `CREATE TABLE`                  | `IF NOT EXISTS`, column and table-level constraints                |
+| `ALTER TABLE`                   | `ADD COLUMN`, `DROP COLUMN`                                        |
+| `DROP TABLE`                    | `IF EXISTS`                                                        |
+| `CREATE INDEX`                  | `UNIQUE`, multi-column, expression-based, `IF NOT EXISTS`          |
+| `DROP INDEX`                    |                                                                    |
+| `BEGIN` / `COMMIT` / `ROLLBACK` | Snapshot isolation, autocommit for standalone statements           |
+| `EXPLAIN`                       | Shows optimized logical plan for any statement                     |
+
+### Clauses
+
+| Clause                | Notes                                                  |
+| --------------------- | ------------------------------------------------------ |
+| `WHERE`               | All comparison, logical, and arithmetic operators      |
+| `ORDER BY`            | Multi-column, `ASC`/`DESC`, `NULLS FIRST`/`NULLS LAST` |
+| `GROUP BY`            | Multiple columns                                       |
+| `HAVING`              |                                                        |
+| `LIMIT` / `OFFSET`    |                                                        |
+| `JOIN`                | `INNER`, `LEFT`, `CROSS`; `ON` and `USING`             |
+| `UNION` / `UNION ALL` | Chainable                                              |
+| `WITH` (CTE)          | Multiple CTEs, `WITH RECURSIVE`                        |
+
+### Expressions
+
+| Expression  | Examples                                                 |
+| ----------- | -------------------------------------------------------- |
+| Arithmetic  | `+`, `-`, `*`, `/`, `%`                                  |
+| Comparison  | `=`, `!=`/`<>`, `<`, `<=`, `>`, `>=`                     |
+| Logical     | `AND`, `OR`, `NOT`                                       |
+| String      | `\|\|` (concatenation)                                   |
+| Pattern     | `LIKE`, `NOT LIKE`                                       |
+| Range       | `BETWEEN`, `NOT BETWEEN`                                 |
+| Set         | `IN (...)`, `NOT IN (...)`                               |
+| Null check  | `IS NULL`, `IS NOT NULL`                                 |
+| Conditional | `CASE WHEN ... THEN ... ELSE ... END`                    |
+| Cast        | `CAST(expr AS type)`                                     |
+| Subquery    | Scalar, `EXISTS`, `NOT EXISTS`, `ANY`, `ALL`, correlated |
+| JSON path   | `data.name`, `items[0]`, `data.items[0].title`           |
+
+### Functions
+
+**Aggregate:** `COUNT(*)`, `COUNT(col)`, `COUNT(DISTINCT col)`, `SUM`, `AVG`, `MIN`, `MAX`
+
+**String:** `UPPER`, `LOWER`, `LENGTH`, `TRIM`, `LTRIM`, `RTRIM`, `SUBSTR`/`SUBSTRING`, `REPLACE`, `CONCAT`
+
+**Math:** `ABS`, `ROUND`, `FLOOR`, `CEIL`/`CEILING`
+
+**Hash:** `MD5`
+
+**Utility:** `COALESCE`, `NULLIF`, `TYPEOF`
+
+### Constraints
+
+`PRIMARY KEY`, `UNIQUE`, `NOT NULL`, `DEFAULT`, `AUTOINCREMENT`, `FOREIGN KEY` (parsed, not enforced)
+
+### Other
+
+- Comments: `-- single line`, `/* block */`
+- Quoted identifiers: `"my column"`
+- Blob literals: `x'DEADBEEF'`
+- Boolean literals: `TRUE`, `FALSE`
+
+## Architecture
+
+```
+Lexer --> Parser --> Binder --> Optimizer --> Executor
+                       |                        |
+                    Catalog              +------+------+
+                                         |             |
+                                     RowManager   IndexManager
+                                         |             |
+                                     TableBTree   IndexBTree
+                                         |             |
+                                         +------+------+
+                                                |
+                                            PageStore
+                                        (WAL + page cache)
+                                                |
+                                              OPFS
+```
+
+- **Lexer / Parser** — SQL text to AST
+- **Binder** — resolves names, types, and constraints against the catalog
+- **Optimizer** — rewrites logical plan (predicate pushdown, join reordering, index selection)
+- **Executor** — pull-based iterator model (volcano), executes physical operators
+- **RowManager / IndexManager** — logical layer over B-trees, handles row CRUD and index maintenance
+- **TableBTree / IndexBTree** — B+ trees for row storage (keyed by rowId) and secondary indexes (composite keys → rowId buckets)
+- **PageStore** — page-level I/O with LRU cache and WAL for crash safety
+- **OPFS** — Origin Private File System (synchronous access handle in workers)
+
+## Not Supported (vs SQLite)
+
+| Feature                                                      | Status                       |
+| ------------------------------------------------------------ | ---------------------------- |
+| Window functions (`OVER`, `PARTITION BY`, `ROW_NUMBER`, ...) | Not supported                |
+| `RIGHT JOIN` / `FULL OUTER JOIN`                             | Not supported                |
+| Views (`CREATE VIEW`)                                        | Not supported                |
+| Triggers                                                     | Not supported                |
+| Savepoints                                                   | Not supported                |
+| `CHECK` constraints                                          | Not supported                |
+| `ATTACH` / `DETACH`                                          | Not supported                |
+| `PRAGMA`                                                     | Not supported                |
+| Collation                                                    | Not configurable             |
+| Type affinity                                                | Strict logical types instead |

package/dist/binder/core/context.d.ts

@@ -0,0 +1,15 @@
+import type { ICatalog } from "../../store/types.js";
+import type { BoundAggregateExpression, BoundExpression } from "../types.js";
+import { BindScope } from "./scope.js";
+export interface BindContext {
+    catalog: ICatalog;
+    nextTableIndex(): number;
+    resetTableIndex(): void;
+    createScope(): BindScope;
+}
+export interface AggregateContext {
+    aggregates: BoundAggregateExpression[];
+    groups: BoundExpression[];
+    groupIndex: number;
+}
+export declare function createBindContext(catalog: ICatalog): BindContext;

package/dist/binder/core/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class BindError extends Error {
+    readonly name = "BindError";
+    constructor(message: string);
+}

package/dist/binder/core/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedExpression } from "../../parser/types.js";
+import type { TableSchema } from "../../store/types.js";
+import type { BindContext } from "./context.js";
+export declare function requireTable(ctx: BindContext, name: string): TableSchema;
+export declare function evalConstantInt(expr: ParsedExpression): number;
+export declare function evalConstantValue(expr: ParsedExpression): string | number | boolean | null;

package/dist/binder/core/operators.d.ts

@@ -0,0 +1,12 @@
+import type { TableSchema } from "../../store/types.js";
+import type * as BT from "../types.js";
+import type { BindContext } from "./context.js";
+import type { BindingEntry } from "./scope.js";
+export declare function makeEmptyGet(ctx: BindContext): BT.LogicalGet;
+export declare function makeGet(entry: BindingEntry, schema: TableSchema): BT.LogicalGet;
+export declare function makeFilter(child: BT.LogicalOperator, exprs: BT.BoundExpression[]): BT.LogicalFilter;
+export declare function makeDistinct(child: BT.LogicalOperator): BT.LogicalDistinct;
+export declare function makeOrderBy(child: BT.LogicalOperator, boundOrders: BT.BoundOrderByNode[]): BT.LogicalOrderBy;
+export declare function makeLimit(child: BT.LogicalOperator, limitVal: number | null, offsetVal: number): BT.LogicalLimit;
+export declare function makeAggregate(child: BT.LogicalOperator, groups: BT.BoundExpression[], aggregates: BT.BoundAggregateExpression[], groupIndex: number, aggregateIndex: number, havingExpression: BT.BoundExpression | null): BT.LogicalAggregate;
+export declare function makeProjection(child: BT.LogicalOperator, tableIndex: number, expressions: BT.BoundExpression[], aliases: (string | null)[]): BT.LogicalProjection;

package/dist/binder/core/plan-utils.d.ts

@@ -0,0 +1,4 @@
+import type { ColumnDef, LogicalType } from "../../store/types.js";
+import type { LogicalOperator, LogicalProjection } from "../types.js";
+export declare function findProjection(plan: LogicalOperator): LogicalProjection | null;
+export declare function extractColumnsFromPlan(plan: LogicalOperator, types: LogicalType[]): ColumnDef[];

package/dist/binder/core/scope.d.ts

@@ -0,0 +1,34 @@
+import type { TableSchema } from "../../store/types.js";
+import type { BoundColumnRefExpression, LogicalOperator } from "../types.js";
+export interface BindingEntry {
+    tableIndex: number;
+    tableName: string;
+    alias: string;
+    schema: TableSchema;
+}
+interface CTEEntry {
+    plan: LogicalOperator;
+    index: number;
+    aliases: string[];
+}
+export declare class BindScope {
+    private parent?;
+    private bindings;
+    private ctes;
+    private tableIndexCounter;
+    constructor(tableIndexCounter: () => number, parent?: BindScope | undefined);
+    addTable(tableName: string, alias: string, schema: TableSchema): BindingEntry;
+    resolveColumn(columnName: string, tableAlias?: string): BoundColumnRefExpression;
+    resolveColumnIn(columnName: string, entries: BindingEntry[]): BoundColumnRefExpression;
+    findByAlias(alias: string): BindingEntry | undefined;
+    getAllBindings(): BindingEntry[];
+    addCTE(name: string, plan: LogicalOperator, index: number, aliases?: string[]): void;
+    getCTE(name: string): CTEEntry | undefined;
+    createChildScope(): BindScope;
+    createIsolatedScope(): BindScope;
+    private resolveQualified;
+    private resolveUnqualified;
+    private findMatchingColumns;
+    private collectCTEs;
+}
+export {};

package/dist/binder/core/type-check.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalType } from "../../store/types.js";
+import type { BoundExpression } from "../types.js";
+export declare function checkTypeCompatibility(left: LogicalType, right: LogicalType): LogicalType;
+export declare function resolveArithmeticType(left: LogicalType, right: LogicalType): LogicalType;
+export declare function resolveScalarFunctionReturnType(name: string, children: BoundExpression[]): LogicalType;

package/dist/binder/core/type-map.d.ts

@@ -0,0 +1,8 @@
+import { ExpressionType } from "../../parser/types.js";
+import type { LogicalType } from "../../store/types.js";
+import type { ComparisonType, OperatorType } from "../types.js";
+export declare function mapParserType(parserType: {
+    id: string;
+}): LogicalType;
+export declare function mapComparisonType(exprType: ExpressionType): ComparisonType;
+export declare function mapOperatorType(exprType: ExpressionType): OperatorType;

package/dist/binder/core/utils/eval-constant.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedExpression } from "../../../parser/types.js";
+import type { Value } from "../../../store/types.js";
+export declare function evalConstantInt(expr: ParsedExpression): number;
+export declare function evalConstantValue(expr: ParsedExpression): Value;

package/dist/binder/core/utils/extract-columns.d.ts

@@ -0,0 +1,4 @@
+import type { ColumnDef, LogicalType } from "../../../store/types.js";
+import type { LogicalOperator, LogicalProjection } from "../../types.js";
+export declare function findProjection(plan: LogicalOperator): LogicalProjection | null;
+export declare function extractColumnsFromPlan(plan: LogicalOperator, types: LogicalType[]): ColumnDef[];

package/dist/binder/core/utils/find-column.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "../../../store/types.js";
+export declare function findColumnIndex(schema: TableSchema, columnName: string): number;
+export declare function findColumnIndexOrThrow(schema: TableSchema, columnName: string): number;
+export declare function getPrimaryKeyColumns(schema: TableSchema): number[];

package/dist/binder/core/utils/require-table.d.ts

@@ -0,0 +1,3 @@
+import type { TableSchema } from "../../../store/types.js";
+import type { BindContext } from "../context.js";
+export declare function requireTable(ctx: BindContext, name: string): TableSchema;

package/dist/binder/expression/aggregate.d.ts

@@ -0,0 +1,11 @@
+import type { FunctionExpression, ParsedExpression } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { BoundAggregateExpression } from "../types.js";
+export declare const AGGREGATE_FUNCTIONS: Set<string>;
+export declare function detectAggregates(exprs: ParsedExpression[]): boolean;
+export declare function exprContainsAggregate(expr: ParsedExpression): boolean;
+export declare function checkNoAggregates(expr: ParsedExpression, context?: string): void;
+export declare function extractAggregates(ctx: BindContext, exprs: ParsedExpression[], scope: BindScope): BoundAggregateExpression[];
+export declare function extractAggregatesFromExpr(ctx: BindContext, expr: ParsedExpression, scope: BindScope): BoundAggregateExpression[];
+export declare function bindAggregate(ctx: BindContext, expr: FunctionExpression, scope: BindScope): BoundAggregateExpression;

package/dist/binder/expression/between.d.ts

@@ -0,0 +1,5 @@
+import type { BetweenExpression } from '../../parser/types.js';
+import type { BoundBetweenExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindBetween(ctx: BindContext, expr: BetweenExpression, scope: BindScope, aggCtx?: AggregateContext): BoundBetweenExpression;

package/dist/binder/expression/case.d.ts

@@ -0,0 +1,5 @@
+import type { CaseExpression } from "../../parser/types.js";
+import type { AggregateContext, BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { BoundCaseExpression } from "../types.js";
+export declare function bindCase(ctx: BindContext, expr: CaseExpression, scope: BindScope, aggCtx?: AggregateContext): BoundCaseExpression;

package/dist/binder/expression/cast.d.ts

@@ -0,0 +1,5 @@
+import type { CastExpression } from '../../parser/types.js';
+import type { BoundCastExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindCast(ctx: BindContext, expr: CastExpression, scope: BindScope, aggCtx?: AggregateContext): BoundCastExpression;

package/dist/binder/expression/column-ref.d.ts

@@ -0,0 +1,5 @@
+import type { ColumnRefExpression } from '../../parser/types.js';
+import type { BoundExpression } from '../types.js';
+import type { AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindColumnRef(expr: ColumnRefExpression, scope: BindScope, aggCtx?: AggregateContext): BoundExpression;

package/dist/binder/expression/comparison.d.ts

@@ -0,0 +1,5 @@
+import type { ComparisonExpression } from '../../parser/types.js';
+import type { BoundExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindComparison(ctx: BindContext, expr: ComparisonExpression, scope: BindScope, aggCtx?: AggregateContext): BoundExpression;

package/dist/binder/expression/conjunction.d.ts

@@ -0,0 +1,5 @@
+import type { ConjunctionExpression } from '../../parser/types.js';
+import type { BoundConjunctionExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindConjunction(ctx: BindContext, expr: ConjunctionExpression, scope: BindScope, aggCtx?: AggregateContext): BoundConjunctionExpression;

package/dist/binder/expression/constant.d.ts

@@ -0,0 +1,3 @@
+import type { ConstantExpression } from '../../parser/types.js';
+import type { BoundConstantExpression } from '../types.js';
+export declare function bindConstant(expr: ConstantExpression): BoundConstantExpression;

package/dist/binder/expression/function.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionExpression } from '../../parser/types.js';
+import type { BoundExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindFunction(ctx: BindContext, expr: FunctionExpression, scope: BindScope, aggCtx?: AggregateContext): BoundExpression;

package/dist/binder/expression/index.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedExpression } from '../../parser/types.js';
+import type { BoundExpression } from '../types.js';
+import type { BindContext, AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindExpression(ctx: BindContext, expr: ParsedExpression, scope: BindScope, aggCtx?: AggregateContext): BoundExpression;

package/dist/binder/expression/operator.d.ts

@@ -0,0 +1,5 @@
+import type { OperatorExpression } from "../../parser/types.js";
+import type { AggregateContext, BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { BoundOperatorExpression } from "../types.js";
+export declare function bindOperator(ctx: BindContext, expr: OperatorExpression, scope: BindScope, aggCtx?: AggregateContext): BoundOperatorExpression;

package/dist/binder/expression/parameter.d.ts

@@ -0,0 +1,4 @@
+import type { ParameterExpression } from '../../parser/types.js';
+import type { BoundParameterExpression } from '../types.js';
+/** Parameters have unknown type at bind time — resolved to ANY at runtime. */
+export declare function bindParameter(expr: ParameterExpression): BoundParameterExpression;

package/dist/binder/expression/same-expression.d.ts

@@ -0,0 +1,3 @@
+import type * as BT from "../types.js";
+export declare function sameExpression(a: BT.BoundExpression, b: BT.BoundExpression): boolean;
+export declare function sameAggregate(a: BT.BoundAggregateExpression, b: BT.BoundAggregateExpression): boolean;

package/dist/binder/expression/star.d.ts

@@ -0,0 +1,5 @@
+import type { StarExpression } from '../../parser/types.js';
+import type { BoundColumnRefExpression } from '../types.js';
+import type { AggregateContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindStar(expr: StarExpression, scope: BindScope, aggCtx?: AggregateContext): BoundColumnRefExpression[];

package/dist/binder/expression/subquery.d.ts

@@ -0,0 +1,5 @@
+import type { SubqueryExpression } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { BoundSubqueryExpression } from "../types.js";
+export declare function bindSubquery(ctx: BindContext, expr: SubqueryExpression, scope: BindScope): BoundSubqueryExpression;

package/dist/binder/index.d.ts

@@ -0,0 +1,30 @@
+import type { Statement } from "../parser/types.js";
+import type { ICatalog } from "../store/types.js";
+import type { LogicalOperator } from "./types.js";
+export declare class Binder {
+    private ctx;
+    constructor(catalog: ICatalog);
+    bindStatement(stmt: Statement): LogicalOperator;
+}
+export { BindError } from "./core/errors.js";
+export { BindScope, type BindingEntry } from "./core/scope.js";
+export * from "./types.js";
+import type { TableSchema } from "../store/types.js";
+import type { BindingEntry } from "./core/scope.js";
+import type { BoundColumnRefExpression } from "./types.js";
+export interface IBinder {
+    bindStatement(stmt: Statement): LogicalOperator;
+}
+export interface IBindScope {
+    addTable(tableName: string, alias: string, schema: TableSchema): BindingEntry;
+    resolveColumn(columnName: string, tableAlias?: string): BoundColumnRefExpression;
+    resolveColumnIn(columnName: string, entries: BindingEntry[]): BoundColumnRefExpression;
+    findByAlias(alias: string): BindingEntry | undefined;
+    getAllBindings(): BindingEntry[];
+    addCTE(name: string, plan: LogicalOperator, index: number): void;
+    getCTE(name: string): {
+        plan: LogicalOperator;
+        index: number;
+    } | undefined;
+    createChildScope(): IBindScope;
+}

package/dist/binder/statement/alter-table.d.ts

@@ -0,0 +1,4 @@
+import type { AlterTableStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindAlterTable(ctx: BindContext, stmt: AlterTableStatement): BT.LogicalAlterTable;

package/dist/binder/statement/create-index.d.ts

@@ -0,0 +1,4 @@
+import type { CreateIndexStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindCreateIndex(ctx: BindContext, stmt: CreateIndexStatement): BT.LogicalCreateIndex;

package/dist/binder/statement/create-table.d.ts

@@ -0,0 +1,4 @@
+import type { CreateTableStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindCreateTable(_ctx: BindContext, stmt: CreateTableStatement): BT.LogicalCreateTable;

package/dist/binder/statement/cte.d.ts

@@ -0,0 +1,16 @@
+import type { SelectStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { LogicalOperator } from "../types.js";
+export interface CTECollected {
+    name: string;
+    plan: LogicalOperator;
+    index: number;
+}
+export declare function collectCTEs(ctx: BindContext, cteMap: {
+    map: Record<string, {
+        query: SelectStatement;
+        aliases: string[];
+    }>;
+    recursive: boolean;
+}, scope: BindScope): CTECollected[];

package/dist/binder/statement/delete.d.ts

@@ -0,0 +1,4 @@
+import type { DeleteStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindDelete(ctx: BindContext, stmt: DeleteStatement): BT.LogicalDelete;

package/dist/binder/statement/drop.d.ts

@@ -0,0 +1,3 @@
+import type { DropStatement } from "../../parser/types.js";
+import type * as BT from "../types.js";
+export declare function bindDrop(stmt: DropStatement): BT.LogicalDrop;

package/dist/binder/statement/insert.d.ts

@@ -0,0 +1,4 @@
+import type { InsertStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindInsert(ctx: BindContext, stmt: InsertStatement): BT.LogicalInsert;

package/dist/binder/statement/query-node.d.ts

@@ -0,0 +1,5 @@
+import type { SelectNode, SetOperationNode } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type { LogicalOperator } from "../types.js";
+export declare function bindQueryNode(ctx: BindContext, node: SelectNode | SetOperationNode, scope: BindScope): LogicalOperator;

package/dist/binder/statement/select.d.ts

@@ -0,0 +1,5 @@
+import type { SelectNode } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type * as BT from "../types.js";
+export declare function bindSelect(ctx: BindContext, node: SelectNode, scope: BindScope): BT.LogicalOperator;

package/dist/binder/statement/set-operation.d.ts

@@ -0,0 +1,5 @@
+import type { SetOperationNode } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type * as BT from "../types.js";
+export declare function bindSetOperation(ctx: BindContext, node: SetOperationNode, scope: BindScope): BT.LogicalOperator;

package/dist/binder/statement/update.d.ts

@@ -0,0 +1,4 @@
+import type { UpdateStatement } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type * as BT from "../types.js";
+export declare function bindUpdate(ctx: BindContext, stmt: UpdateStatement): BT.LogicalUpdate;

package/dist/binder/table-ref/base-table.d.ts

@@ -0,0 +1,5 @@
+import type { BaseTableRef } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type * as BT from "../types.js";
+export declare function bindBaseTableRef(ctx: BindContext, ref: BaseTableRef, scope: BindScope): BT.LogicalOperator;

package/dist/binder/table-ref/index.d.ts

@@ -0,0 +1,5 @@
+import type { TableRef } from '../../parser/types.js';
+import type { LogicalOperator } from '../types.js';
+import type { BindContext } from '../core/context.js';
+import type { BindScope } from '../core/scope.js';
+export declare function bindTableRef(ctx: BindContext, ref: TableRef, scope: BindScope): LogicalOperator;

package/dist/binder/table-ref/join.d.ts

@@ -0,0 +1,6 @@
+import type { JoinRef, ParsedExpression } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type * as BT from "../types.js";
+export declare function bindJoinRef(ctx: BindContext, ref: JoinRef, scope: BindScope): BT.LogicalOperator;
+export declare function extractJoinConditions(ctx: BindContext, expr: ParsedExpression, scope: BindScope): BT.JoinCondition[];

package/dist/binder/table-ref/subquery.d.ts

@@ -0,0 +1,5 @@
+import type { SubqueryRef } from "../../parser/types.js";
+import type { BindContext } from "../core/context.js";
+import type { BindScope } from "../core/scope.js";
+import type * as BT from "../types.js";
+export declare function bindSubqueryRef(ctx: BindContext, ref: SubqueryRef, scope: BindScope): BT.LogicalOperator;

package/dist/binder/tests/aggregates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/binder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/cte.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/ddl.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/dml.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/expressions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/join.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/misc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/binder/tests/select.test.d.ts

@@ -0,0 +1 @@
+export {};