@shaxpir/squilt 1.0.0 → 1.1.0

package/README.md

@@ -73,6 +73,287 @@ query.toSQL(new IndentedQueryRenderer(2));
 // LIMIT 10
 ```
 
+### Delete Queries
+
+Build DELETE statements with optional WHERE clauses:
+
+```typescript
+import { DELETE_FROM, EQ, COLUMN, PARAM, AND, LT } from '@shaxpir/squilt';
+
+// Simple delete
+const deleteAll = DELETE_FROM('temp_files');
+console.log(deleteAll.toSQL());
+// DELETE FROM temp_files
+
+// Delete with conditions
+const deleteOld = DELETE_FROM('logs')
+  .where(AND(
+    EQ(COLUMN('level'), 'debug'),
+    LT(COLUMN('created_at'), PARAM('cutoffDate'))
+  ));
+console.log(deleteOld.toSQL());
+// DELETE FROM logs WHERE ((level = 'debug') AND (created_at < ?))
+```
+
+DELETE queries support subqueries in WHERE clauses:
+
+```typescript
+import { DELETE_FROM, SELECT, FROM, COLUMN, IN, EXISTS, EQ } from '@shaxpir/squilt';
+
+// Delete using IN with subquery
+const bannedUsers = SELECT(FROM('banned_users'), COLUMN('id'));
+const deleteComments = DELETE_FROM('comments')
+  .where(IN(COLUMN('user_id'), bannedUsers));
+console.log(deleteComments.toSQL());
+// DELETE FROM comments WHERE (user_id IN (SELECT id FROM banned_users))
+
+// Delete using EXISTS with correlated subquery
+const deleteOrders = DELETE_FROM('orders')
+  .where(EXISTS(
+    SELECT(FROM('refunds'), COLUMN('*'))
+      .where(EQ(COLUMN('refunds', 'order_id'), COLUMN('orders', 'id')))
+  ));
+console.log(deleteOrders.toSQL());
+// DELETE FROM orders WHERE EXISTS (SELECT * FROM refunds WHERE (refunds.order_id = orders.id))
+```
+
+### Update Queries
+
+Build UPDATE statements with SET clauses and optional WHERE:
+
+```typescript
+import { UPDATE, EQ, COLUMN, PARAM } from '@shaxpir/squilt';
+import { StringLiteral, NumberLiteral } from '@shaxpir/squilt';
+
+// Simple update
+const updateStatus = UPDATE('users')
+  .set('status', new StringLiteral('active'))
+  .set('last_login', PARAM('loginTime'))
+  .where(EQ(COLUMN('id'), PARAM('userId')));
+console.log(updateStatus.toSQL());
+// UPDATE users SET status = 'active', last_login = ? WHERE (id = ?)
+
+// Update multiple columns
+const bulkUpdate = UPDATE('products')
+  .set('price', new NumberLiteral(99))
+  .set('on_sale', new NumberLiteral(1))
+  .set('discount', new NumberLiteral(10))
+  .where(EQ(COLUMN('category'), 'electronics'));
+console.log(bulkUpdate.toSQL());
+// UPDATE products SET price = 99, on_sale = 1, discount = 10 WHERE (category = 'electronics')
+```
+
+### RETURNING Clause (SQLite 3.35+)
+
+Get back affected rows from INSERT, UPDATE, and DELETE statements:
+
+```typescript
+import { INSERT, UPDATE, DELETE_FROM, COLUMN, PARAM, EQ, ALIAS, FN } from '@shaxpir/squilt';
+
+// INSERT with RETURNING
+const createUser = INSERT('users', ['name', 'email'], [PARAM('name'), PARAM('email')])
+  .returning(COLUMN('id'), COLUMN('created_at'));
+console.log(createUser.toSQL());
+// INSERT INTO users (name, email) VALUES (?, ?) RETURNING id, created_at
+
+// UPDATE with RETURNING
+const updateUser = UPDATE('users')
+  .set('status', 'active')
+  .where(EQ(COLUMN('id'), PARAM('userId')))
+  .returning(COLUMN('id'), COLUMN('status'), COLUMN('updated_at'));
+console.log(updateUser.toSQL());
+// UPDATE users SET status = 'active' WHERE (id = ?) RETURNING id, status, updated_at
+
+// DELETE with RETURNING
+const deleteInactive = DELETE_FROM('users')
+  .where(EQ(COLUMN('status'), 'inactive'))
+  .returning(COLUMN('id'), COLUMN('email'));
+console.log(deleteInactive.toSQL());
+// DELETE FROM users WHERE (status = 'inactive') RETURNING id, email
+
+// RETURNING with aliased expressions
+const insertWithAlias = INSERT('orders', ['total'], [PARAM('total')])
+  .returning(
+    COLUMN('id'),
+    ALIAS(FN('DATETIME', COLUMN('created_at')), 'order_time')
+  );
+console.log(insertWithAlias.toSQL());
+// INSERT INTO orders (total) VALUES (?) RETURNING id, DATETIME(created_at) AS order_time
+```
+
+### INSERT ... SELECT
+
+Insert rows from a query result:
+
+```typescript
+import { INSERT_INTO, SELECT, FROM, COLUMN, EQ, LT, PARAM } from '@shaxpir/squilt';
+
+// Basic INSERT ... SELECT
+const archiveOrders = INSERT_INTO('archive_orders')
+  .columns('id', 'user_id', 'total')
+  .fromSelect(
+    SELECT(FROM('orders'), COLUMN('id'), COLUMN('user_id'), COLUMN('total'))
+      .where(LT(COLUMN('created_at'), PARAM('cutoff')))
+  );
+console.log(archiveOrders.toSQL());
+// INSERT INTO archive_orders (id, user_id, total)
+// SELECT id, user_id, total FROM orders WHERE (created_at < ?)
+
+// INSERT OR REPLACE ... SELECT
+const syncData = INSERT_INTO('local_cache')
+  .orReplace()
+  .columns('id', 'data')
+  .fromSelect(
+    SELECT(FROM('remote_data'), COLUMN('id'), COLUMN('data'))
+  );
+console.log(syncData.toSQL());
+// INSERT OR REPLACE INTO local_cache (id, data) SELECT id, data FROM remote_data
+
+// With RETURNING clause
+const copyWithIds = INSERT_INTO('new_table')
+  .columns('name', 'value')
+  .fromSelect(SELECT(FROM('old_table'), COLUMN('name'), COLUMN('value')))
+  .returning(COLUMN('id'));
+console.log(copyWithIds.toSQL());
+// INSERT INTO new_table (name, value) SELECT name, value FROM old_table RETURNING id
+```
+
+### Set Operations: UNION, INTERSECT, EXCEPT
+
+Combine query results with set operations:
+
+```typescript
+import { SELECT, FROM, COLUMN, EQ } from '@shaxpir/squilt';
+
+// UNION - combine results from multiple queries (already supported)
+const allEmails = SELECT(FROM('customers'), COLUMN('email'))
+  .union(SELECT(FROM('subscribers'), COLUMN('email')));
+console.log(allEmails.toSQL());
+// SELECT email FROM customers UNION SELECT email FROM subscribers
+
+// INTERSECT - rows that appear in both queries
+const commonEmails = SELECT(FROM('subscribers'), COLUMN('email'))
+  .intersect(SELECT(FROM('customers'), COLUMN('email')));
+console.log(commonEmails.toSQL());
+// SELECT email FROM subscribers INTERSECT SELECT email FROM customers
+
+// EXCEPT - rows in first query but not in second
+const activeUsers = SELECT(FROM('all_users'), COLUMN('id'))
+  .except(SELECT(FROM('banned_users'), COLUMN('user_id')));
+console.log(activeUsers.toSQL());
+// SELECT id FROM all_users EXCEPT SELECT user_id FROM banned_users
+
+// Combine multiple set operations
+const complexSet = SELECT(FROM('set_a'), COLUMN('id'))
+  .union(SELECT(FROM('set_b'), COLUMN('id')))
+  .intersect(SELECT(FROM('set_c'), COLUMN('id')))
+  .except(SELECT(FROM('set_d'), COLUMN('id')));
+```
+
+### UPSERT (ON CONFLICT) (SQLite 3.24+)
+
+Insert-or-update operations using SQLite's upsert syntax:
+
+```typescript
+import { INSERT, PARAM, COLUMN, EQ } from '@shaxpir/squilt';
+
+// ON CONFLICT DO UPDATE - update existing rows on conflict
+const upsertUser = INSERT('users', ['id', 'name', 'email'], [PARAM('id'), PARAM('name'), PARAM('email')])
+  .onConflict('id')
+  .doUpdate({ name: PARAM('name'), email: PARAM('email') });
+console.log(upsertUser.toSQL());
+// INSERT INTO users (id, name, email) VALUES (?, ?, ?)
+// ON CONFLICT (id) DO UPDATE SET name = ?, email = ?
+
+// ON CONFLICT DO NOTHING - silently ignore conflicts
+const insertIfNotExists = INSERT('events', ['id', 'data'], [PARAM('id'), PARAM('data')])
+  .onConflict('id')
+  .doNothing();
+console.log(insertIfNotExists.toSQL());
+// INSERT INTO events (id, data) VALUES (?, ?) ON CONFLICT (id) DO NOTHING
+
+// Multiple conflict columns
+const upsertRole = INSERT('user_roles', ['user_id', 'role_id', 'assigned_at'], [PARAM('userId'), PARAM('roleId'), PARAM('now')])
+  .onConflict('user_id', 'role_id')
+  .doUpdate({ assigned_at: PARAM('now') });
+console.log(upsertRole.toSQL());
+// INSERT INTO user_roles (user_id, role_id, assigned_at) VALUES (?, ?, ?)
+// ON CONFLICT (user_id, role_id) DO UPDATE SET assigned_at = ?
+
+// With WHERE clause on conflict (conditional upsert)
+const conditionalUpsert = INSERT('users', ['id', 'name'], [PARAM('id'), PARAM('name')])
+  .onConflict('id')
+  .onConflictWhere(EQ(COLUMN('active'), true))
+  .doUpdate({ name: PARAM('name') });
+console.log(conditionalUpsert.toSQL());
+// INSERT INTO users (id, name) VALUES (?, ?)
+// ON CONFLICT (id) WHERE (active = 1) DO UPDATE SET name = ?
+
+// With RETURNING clause
+const upsertWithReturn = INSERT('counters', ['counter_key', 'value'], [PARAM('key'), PARAM('value')])
+  .onConflict('counter_key')
+  .doUpdate({ value: PARAM('value') })
+  .returning(COLUMN('counter_key'), COLUMN('value'));
+console.log(upsertWithReturn.toSQL());
+// INSERT INTO counters (counter_key, value) VALUES (?, ?)
+// ON CONFLICT (counter_key) DO UPDATE SET value = ?
+// RETURNING counter_key, value
+```
+
+### DROP TABLE and DROP INDEX
+
+Remove tables and indexes from the database:
+
+```typescript
+import { DROP_TABLE, DROP_INDEX } from '@shaxpir/squilt';
+
+// Simple DROP TABLE
+const dropUsers = DROP_TABLE('users');
+console.log(dropUsers.toSQL());
+// DROP TABLE users
+
+// DROP TABLE IF EXISTS
+const dropCache = DROP_TABLE('cache').ifExists();
+console.log(dropCache.toSQL());
+// DROP TABLE IF EXISTS cache
+
+// Simple DROP INDEX
+const dropIndex = DROP_INDEX('idx_users_email');
+console.log(dropIndex.toSQL());
+// DROP INDEX idx_users_email
+
+// DROP INDEX IF EXISTS
+const dropOldIndex = DROP_INDEX('idx_old').ifExists();
+console.log(dropOldIndex.toSQL());
+// DROP INDEX IF EXISTS idx_old
+```
+
+### Range Queries with BETWEEN
+
+Use BETWEEN for range comparisons:
+
+```typescript
+import { SELECT, FROM, COLUMN, BETWEEN, NOT_BETWEEN, PARAM, AND } from '@shaxpir/squilt';
+
+// Price range query
+const priceFilter = SELECT(FROM('products'), COLUMN('*'))
+  .where(BETWEEN(COLUMN('price'), 10, 100));
+console.log(priceFilter.toSQL());
+// SELECT * FROM products WHERE (price BETWEEN 10 AND 100)
+
+// Date range with parameters
+const dateFilter = SELECT(FROM('orders'), COLUMN('*'))
+  .where(BETWEEN(COLUMN('created_at'), PARAM('startDate'), PARAM('endDate')));
+console.log(dateFilter.toSQL());
+// SELECT * FROM orders WHERE (created_at BETWEEN ? AND ?)
+
+// Exclude a range with NOT BETWEEN
+const excludeRange = SELECT(FROM('employees'), COLUMN('*'))
+  .where(NOT_BETWEEN(COLUMN('salary'), 50000, 100000));
+console.log(excludeRange.toSQL());
+// SELECT * FROM employees WHERE (salary NOT BETWEEN 50000 AND 100000)
+```
+
 ### Parameterized Queries
 
 Use named parameters for safe value binding:
@@ -109,14 +390,21 @@ const params = query.accept(new ParamCollectingVisitor({ userId: 42 }));
 | `SELECT_DISTINCT(...args)` | Create a SELECT DISTINCT query |
 | `FROM(table)` | Create a FROM clause |
 | `COLUMN(name)` or `COLUMN(table, name)` | Reference a column |
+| `ALIAS(expr, name)` | Create an aliased expression |
 | `EQ`, `NOT_EQ`, `GT`, `LT`, `GTE`, `LTE` | Comparison operators |
+| `BETWEEN`, `NOT_BETWEEN` | Range operators |
 | `AND`, `OR`, `NOT` | Logical operators |
 | `LIKE`, `IN`, `NOT_IN` | Pattern matching |
 | `JOIN`, `LEFT_JOIN`, `CROSS_JOIN` | Join clauses |
 | `FN(name, ...args)` | Function calls |
 | `CASE([...cases])` | CASE expressions |
 | `WITH(name, query)` | Common Table Expressions |
-| `INSERT`, `INSERT_OR_REPLACE` | Insert statements |
+| `UNION`, `INTERSECT`, `EXCEPT` | Set operations |
+| `INSERT`, `INSERT_INTO`, `INSERT_OR_REPLACE` | Insert statements |
+| `UPDATE(table)` | Update statements |
+| `DELETE_FROM(table)` | Delete statements |
+| `DROP_TABLE(table)` | Drop table statements |
+| `DROP_INDEX(index)` | Drop index statements |
 
 ### Renderers
 

package/dist/ast/AlterTableQuery.d.ts

@@ -0,0 +1,32 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { SqlTreeNode } from "./Abstractions";
+import { ColumnType, ColumnConstraints, ColumnDefinition } from "./CreateTableQuery";
+export type AlterTableOperation = {
+    type: 'ADD_COLUMN';
+    column: ColumnDefinition;
+} | {
+    type: 'RENAME_COLUMN';
+    oldName: string;
+    newName: string;
+} | {
+    type: 'DROP_COLUMN';
+    columnName: string;
+} | {
+    type: 'RENAME_TABLE';
+    newTableName: string;
+};
+export declare class AlterTableQuery implements SqlTreeNode {
+    private _tableName;
+    private _operation;
+    constructor(tableName: string);
+    static create(tableName: string): AlterTableQuery;
+    addColumn(name: string, type: ColumnType, constraints?: ColumnConstraints): AlterTableQuery;
+    renameColumn(oldName: string, newName: string): AlterTableQuery;
+    dropColumn(columnName: string): AlterTableQuery;
+    renameTo(newTableName: string): AlterTableQuery;
+    get tableName(): string;
+    get operation(): AlterTableOperation | null;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/AlterTableQuery.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents an ALTER TABLE statement
+class AlterTableQuery {
+    constructor(tableName) {
+        this._operation = null;
+        this._tableName = tableName;
+    }
+    static create(tableName) {
+        return new AlterTableQuery(tableName);
+    }
+    addColumn(name, type, constraints = {}) {
+        this._operation = {
+            type: 'ADD_COLUMN',
+            column: { name, type, constraints }
+        };
+        return this;
+    }
+    renameColumn(oldName, newName) {
+        this._operation = {
+            type: 'RENAME_COLUMN',
+            oldName,
+            newName
+        };
+        return this;
+    }
+    dropColumn(columnName) {
+        this._operation = {
+            type: 'DROP_COLUMN',
+            columnName
+        };
+        return this;
+    }
+    renameTo(newTableName) {
+        this._operation = {
+            type: 'RENAME_TABLE',
+            newTableName
+        };
+        return this;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+    get operation() {
+        return this._operation;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitAlterTableQuery(this);
+    }
+}
+exports.AlterTableQuery = AlterTableQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/BetweenExpression.d.ts

@@ -0,0 +1,10 @@
+import { AliasableExpression, Expression } from "./Abstractions";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+export declare class BetweenExpression extends AliasableExpression {
+    readonly operand: Expression;
+    readonly low: Expression;
+    readonly high: Expression;
+    readonly not: boolean;
+    constructor(operand: Expression, low: Expression, high: Expression, not?: boolean);
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/BetweenExpression.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetweenExpression = void 0;
+const Abstractions_1 = require("./Abstractions");
+class BetweenExpression extends Abstractions_1.AliasableExpression {
+    constructor(operand, low, high, not = false) {
+        super();
+        this.operand = operand;
+        this.low = low;
+        this.high = high;
+        this.not = not;
+    }
+    accept(visitor) {
+        return visitor.visitBetweenExpression(this);
+    }
+}
+exports.BetweenExpression = BetweenExpression;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmV0d2VlbkV4cHJlc3Npb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN0L0JldHdlZW5FeHByZXNzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGlEQUFpRTtBQUdqRSxNQUFhLGlCQUFrQixTQUFRLGtDQUFtQjtJQU14RCxZQUFZLE9BQW1CLEVBQUUsR0FBZSxFQUFFLElBQWdCLEVBQUUsTUFBZSxLQUFLO1FBQ3RGLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7UUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNqQixDQUFDO0lBRU0sTUFBTSxDQUFJLE9BQThCO1FBQzdDLE9BQU8sT0FBTyxDQUFDLHNCQUFzQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzlDLENBQUM7Q0FDRjtBQWpCRCw4Q0FpQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBbGlhc2FibGVFeHByZXNzaW9uLCBFeHByZXNzaW9uIH0gZnJvbSBcIi4vQWJzdHJhY3Rpb25zXCI7XG5pbXBvcnQgeyBTcWxUcmVlTm9kZVZpc2l0b3IgfSBmcm9tIFwiLi4vdmlzaXRvci9TcWxUcmVlTm9kZVZpc2l0b3JcIjtcblxuZXhwb3J0IGNsYXNzIEJldHdlZW5FeHByZXNzaW9uIGV4dGVuZHMgQWxpYXNhYmxlRXhwcmVzc2lvbiB7XG4gIHB1YmxpYyByZWFkb25seSBvcGVyYW5kOiBFeHByZXNzaW9uO1xuICBwdWJsaWMgcmVhZG9ubHkgbG93OiBFeHByZXNzaW9uO1xuICBwdWJsaWMgcmVhZG9ubHkgaGlnaDogRXhwcmVzc2lvbjtcbiAgcHVibGljIHJlYWRvbmx5IG5vdDogYm9vbGVhbjtcblxuICBjb25zdHJ1Y3RvcihvcGVyYW5kOiBFeHByZXNzaW9uLCBsb3c6IEV4cHJlc3Npb24sIGhpZ2g6IEV4cHJlc3Npb24sIG5vdDogYm9vbGVhbiA9IGZhbHNlKSB7XG4gICAgc3VwZXIoKTtcbiAgICB0aGlzLm9wZXJhbmQgPSBvcGVyYW5kO1xuICAgIHRoaXMubG93ID0gbG93O1xuICAgIHRoaXMuaGlnaCA9IGhpZ2g7XG4gICAgdGhpcy5ub3QgPSBub3Q7XG4gIH1cblxuICBwdWJsaWMgYWNjZXB0PFQ+KHZpc2l0b3I6IFNxbFRyZWVOb2RlVmlzaXRvcjxUPik6IFQge1xuICAgIHJldHVybiB2aXNpdG9yLnZpc2l0QmV0d2VlbkV4cHJlc3Npb24odGhpcyk7XG4gIH1cbn1cbiJdfQ==

package/dist/ast/CastExpression.d.ts

@@ -0,0 +1,13 @@
+import { AliasableExpression, Expression } from "./Abstractions";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+/**
+ * Represents a CAST expression: CAST(expression AS type)
+ */
+export declare class CastExpression extends AliasableExpression {
+    private _expression;
+    private _targetType;
+    constructor(expression: Expression, targetType: string);
+    get expression(): Expression;
+    get targetType(): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CastExpression.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CastExpression = void 0;
+const Abstractions_1 = require("./Abstractions");
+/**
+ * Represents a CAST expression: CAST(expression AS type)
+ */
+class CastExpression extends Abstractions_1.AliasableExpression {
+    constructor(expression, targetType) {
+        super();
+        this._expression = expression;
+        this._targetType = targetType;
+    }
+    get expression() {
+        return this._expression;
+    }
+    get targetType() {
+        return this._targetType;
+    }
+    accept(visitor) {
+        return visitor.visitCastExpression(this);
+    }
+}
+exports.CastExpression = CastExpression;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FzdEV4cHJlc3Npb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXN0L0Nhc3RFeHByZXNzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLGlEQUFpRTtBQUdqRTs7R0FFRztBQUNILE1BQWEsY0FBZSxTQUFRLGtDQUFtQjtJQUlyRCxZQUFZLFVBQXNCLEVBQUUsVUFBa0I7UUFDcEQsS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztRQUM5QixJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztJQUNoQyxDQUFDO0lBRUQsSUFBVyxVQUFVO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0lBRUQsSUFBVyxVQUFVO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0lBRU0sTUFBTSxDQUFJLE9BQThCO1FBQzdDLE9BQU8sT0FBTyxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNDLENBQUM7Q0FDRjtBQXJCRCx3Q0FxQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBbGlhc2FibGVFeHByZXNzaW9uLCBFeHByZXNzaW9uIH0gZnJvbSBcIi4vQWJzdHJhY3Rpb25zXCI7XG5pbXBvcnQgeyBTcWxUcmVlTm9kZVZpc2l0b3IgfSBmcm9tIFwiLi4vdmlzaXRvci9TcWxUcmVlTm9kZVZpc2l0b3JcIjtcblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgQ0FTVCBleHByZXNzaW9uOiBDQVNUKGV4cHJlc3Npb24gQVMgdHlwZSlcbiAqL1xuZXhwb3J0IGNsYXNzIENhc3RFeHByZXNzaW9uIGV4dGVuZHMgQWxpYXNhYmxlRXhwcmVzc2lvbiB7XG4gIHByaXZhdGUgX2V4cHJlc3Npb246IEV4cHJlc3Npb247XG4gIHByaXZhdGUgX3RhcmdldFR5cGU6IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihleHByZXNzaW9uOiBFeHByZXNzaW9uLCB0YXJnZXRUeXBlOiBzdHJpbmcpIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMuX2V4cHJlc3Npb24gPSBleHByZXNzaW9uO1xuICAgIHRoaXMuX3RhcmdldFR5cGUgPSB0YXJnZXRUeXBlO1xuICB9XG5cbiAgcHVibGljIGdldCBleHByZXNzaW9uKCk6IEV4cHJlc3Npb24ge1xuICAgIHJldHVybiB0aGlzLl9leHByZXNzaW9uO1xuICB9XG5cbiAgcHVibGljIGdldCB0YXJnZXRUeXBlKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuX3RhcmdldFR5cGU7XG4gIH1cblxuICBwdWJsaWMgYWNjZXB0PFQ+KHZpc2l0b3I6IFNxbFRyZWVOb2RlVmlzaXRvcjxUPik6IFQge1xuICAgIHJldHVybiB2aXNpdG9yLnZpc2l0Q2FzdEV4cHJlc3Npb24odGhpcyk7XG4gIH1cbn1cbiJdfQ==

package/dist/ast/CollateExpression.d.ts

@@ -0,0 +1,18 @@
+import { AliasableExpression, Expression } from "./Abstractions";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+/**
+ * Represents a COLLATE expression: expression COLLATE collation_name
+ *
+ * SQLite built-in collations:
+ * - BINARY: Compares using memcmp()
+ * - NOCASE: Case-insensitive ASCII comparison
+ * - RTRIM: Like BINARY but ignores trailing spaces
+ */
+export declare class CollateExpression extends AliasableExpression {
+    private _expression;
+    private _collation;
+    constructor(expression: Expression, collation: string);
+    get expression(): Expression;
+    get collation(): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CollateExpression.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollateExpression = void 0;
+const Abstractions_1 = require("./Abstractions");
+/**
+ * Represents a COLLATE expression: expression COLLATE collation_name
+ *
+ * SQLite built-in collations:
+ * - BINARY: Compares using memcmp()
+ * - NOCASE: Case-insensitive ASCII comparison
+ * - RTRIM: Like BINARY but ignores trailing spaces
+ */
+class CollateExpression extends Abstractions_1.AliasableExpression {
+    constructor(expression, collation) {
+        super();
+        this._expression = expression;
+        this._collation = collation;
+    }
+    get expression() {
+        return this._expression;
+    }
+    get collation() {
+        return this._collation;
+    }
+    accept(visitor) {
+        return visitor.visitCollateExpression(this);
+    }
+}
+exports.CollateExpression = CollateExpression;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/CreateIndexQuery.d.ts

@@ -0,0 +1,25 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { Expression, SqlTreeNode } from "./Abstractions";
+export declare class CreateIndexQuery implements SqlTreeNode {
+    private _indexName;
+    private _tableName;
+    private _columns;
+    private _unique;
+    private _ifNotExists;
+    private _where;
+    constructor(indexName: string);
+    static create(indexName: string): CreateIndexQuery;
+    on(tableName: string, columns: string | string[]): CreateIndexQuery;
+    unique(): CreateIndexQuery;
+    ifNotExists(): CreateIndexQuery;
+    where(expression: Expression): CreateIndexQuery;
+    get indexName(): string;
+    get tableName(): string;
+    get columns(): string[];
+    get isUnique(): boolean;
+    get hasIfNotExists(): boolean;
+    get whereExpression(): Expression | null;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CreateIndexQuery.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateIndexQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a CREATE INDEX statement
+class CreateIndexQuery {
+    constructor(indexName) {
+        this._tableName = '';
+        this._columns = [];
+        this._unique = false;
+        this._ifNotExists = false;
+        this._where = null;
+        this._indexName = indexName;
+    }
+    static create(indexName) {
+        return new CreateIndexQuery(indexName);
+    }
+    on(tableName, columns) {
+        this._tableName = tableName;
+        this._columns = Array.isArray(columns) ? columns : [columns];
+        return this;
+    }
+    unique() {
+        this._unique = true;
+        return this;
+    }
+    ifNotExists() {
+        this._ifNotExists = true;
+        return this;
+    }
+    where(expression) {
+        this._where = expression;
+        return this;
+    }
+    get indexName() {
+        return this._indexName;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get isUnique() {
+        return this._unique;
+    }
+    get hasIfNotExists() {
+        return this._ifNotExists;
+    }
+    get whereExpression() {
+        return this._where;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitCreateIndexQuery(this);
+    }
+}
+exports.CreateIndexQuery = CreateIndexQuery;
+//# sourceMappingURL=data:application/json;base64,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