rawsql-ts 0.5.0-beta → 0.6.0-beta

package/dist/esm/transformers/SelectValueCollector.js

@@ -116,13 +116,13 @@ export class SelectValueCollector {
         const wildSourceNames = wildcards.filter(item => item.value instanceof ColumnReference && item.value.namespaces)
             .map(item => item.value.getNamespace());
         if (query.fromClause) {
-            const fromSourceName = query.fromClause.getAliasSourceName();
+            const fromSourceName = query.fromClause.getSourceAliasName();
             if (fromSourceName && wildSourceNames.includes(fromSourceName)) {
                 this.processFromClause(query.fromClause, false);
             }
             if (query.fromClause.joins) {
                 for (const join of query.fromClause.joins) {
-                    const joinSourceName = join.getAliasSourceName();
+                    const joinSourceName = join.getSourceAliasName();
                     if (joinSourceName && wildSourceNames.includes(joinSourceName)) {
                         this.processJoinClause(join);
                     }
@@ -135,7 +135,7 @@ export class SelectValueCollector {
     }
     processFromClause(clause, joinCascade) {
         if (clause) {
-            const fromSourceName = clause.getAliasSourceName();
+            const fromSourceName = clause.getSourceAliasName();
             this.processSourceExpression(fromSourceName, clause.source);
             if (clause.joins && joinCascade) {
                 for (const join of clause.joins) {
@@ -146,7 +146,7 @@ export class SelectValueCollector {
         return;
     }
     processJoinClause(clause) {
-        const sourceName = clause.getAliasSourceName();
+        const sourceName = clause.getSourceAliasName();
         this.processSourceExpression(sourceName, clause.source);
     }
     processSourceExpression(sourceName, source) {

package/dist/esm/transformers/UpstreamSelectQueryFinder.js

@@ -25,7 +25,7 @@ export class UpstreamSelectQueryFinder {
         const ctes = cteCollector.collect(query);
         const cteMap = new Map();
         for (const cte of ctes) {
-            cteMap.set(cte.getAliasSourceName(), cte);
+            cteMap.set(cte.getSourceAliasName(), cte);
         }
         return this.findUpstream(query, columnNames, cteMap);
     }

package/dist/esm/types/models/Clause.d.ts

@@ -76,7 +76,7 @@ export declare class TableSource extends SqlComponent {
     namespaces: IdentifierString[] | null;
     table: IdentifierString;
     identifier: IdentifierString;
-    constructor(namespaces: string[] | null, table: string);
+    constructor(namespaces: string[] | IdentifierString[] | null, table: string | IdentifierString);
     getSourceName(): string;
 }
 export declare class FunctionSource extends SqlComponent {
@@ -120,14 +120,14 @@ export declare class JoinClause extends SqlComponent {
     condition: JoinConditionComponent | null;
     lateral: boolean;
     constructor(joinType: string, source: SourceExpression, condition: JoinConditionComponent | null, lateral: boolean);
-    getAliasSourceName(): string | null;
+    getSourceAliasName(): string | null;
 }
 export declare class FromClause extends SqlComponent {
     static kind: symbol;
     source: SourceExpression;
     joins: JoinClause[] | null;
     constructor(source: SourceExpression, join: JoinClause[] | null);
-    getAliasSourceName(): string | null;
+    getSourceAliasName(): string | null;
     /**
      * Returns all SourceExpression objects in this FROM clause, including main source and all JOIN sources.
      */
@@ -139,7 +139,7 @@ export declare class CommonTable extends SqlComponent {
     materialized: boolean | null;
     aliasExpression: SourceAliasExpression;
     constructor(query: SelectQuery, aliasExpression: SourceAliasExpression | string, materialized: boolean | null);
-    getAliasSourceName(): string;
+    getSourceAliasName(): string;
 }
 export declare class WithClause extends SqlComponent {
     static kind: symbol;
@@ -186,3 +186,57 @@ export declare class SourceAliasExpression extends SqlComponent {
     columns: IdentifierString[] | null;
     constructor(alias: string, columnAlias: string[] | null);
 }
+export declare class ReturningClause extends SqlComponent {
+    static kind: symbol;
+    columns: IdentifierString[];
+    /**
+     * Constructs a ReturningClause.
+     * @param columns Array of IdentifierString or string representing column names.
+     */
+    constructor(columns: (IdentifierString | string)[]);
+}
+export declare class SetClause extends SqlComponent {
+    static kind: symbol;
+    items: SetClauseItem[];
+    constructor(items: (SetClauseItem | {
+        column: string | IdentifierString;
+        value: ValueComponent;
+    })[]);
+}
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ */
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ * Now supports namespaces for fully qualified column names (e.g. schema.table.column).
+ */
+export declare class SetClauseItem extends SqlComponent {
+    static kind: symbol;
+    namespaces: IdentifierString[] | null;
+    column: IdentifierString;
+    value: ValueComponent;
+    constructor(column: string | IdentifierString | {
+        namespaces: string[] | IdentifierString[] | null;
+        column: string | IdentifierString;
+    }, value: ValueComponent);
+    /**
+     * Returns the fully qualified column name as a string.
+     */
+    getFullName(): string;
+}
+export declare class UpdateClause extends SqlComponent {
+    static kind: symbol;
+    source: SourceExpression;
+    constructor(source: SourceExpression);
+    getSourceAliasName(): string | null;
+}
+/**
+ * Represents the target table (with optional alias/schema) and columns for an INSERT statement.
+ * @param source The target table as a SourceExpression (can include schema, alias, etc.)
+ * @param columns Array of column names (as strings)
+ */
+export declare class InsertClause extends SqlComponent {
+    source: SourceExpression;
+    columns: string[];
+    constructor(source: SourceExpression, columns: string[]);
+}

package/dist/esm/types/models/InsertQuery.d.ts

@@ -1,21 +1,16 @@
 import { SqlComponent } from "./SqlComponent";
-import { IdentifierString } from "./ValueComponent";
 import { SelectQuery } from "./SelectQuery";
+import { InsertClause } from "./Clause";
 export declare class InsertQuery extends SqlComponent {
     static kind: symbol;
-    namespaces: IdentifierString[] | null;
-    table: IdentifierString;
-    columns: IdentifierString[];
+    insertClause: InsertClause;
     selectQuery: SelectQuery | null;
     /**
-     * @param params.table Table name (string or IdentifierString)
-     * @param params.columns Array of column names (string[] or IdentifierString[])
+     * @param params.insertClause InsertClause instance (target table and columns)
      * @param params.selectQuery SELECT/VALUES query (required)
      */
     constructor(params: {
-        namespaces: (string | IdentifierString)[] | null;
-        table: string | IdentifierString;
-        columns: (string | IdentifierString)[];
+        insertClause: InsertClause;
         selectQuery?: SelectQuery | null;
     });
 }

package/dist/esm/types/models/UpdateQuery.d.ts

@@ -0,0 +1,31 @@
+import { SqlComponent } from "./SqlComponent";
+import { IdentifierString, ValueComponent } from "./ValueComponent";
+import { FromClause, ReturningClause, SetClause, WhereClause, UpdateClause } from "./Clause";
+import { WithClause } from "./Clause";
+export declare class UpdateQuery extends SqlComponent {
+    static kind: symbol;
+    withClause: WithClause | null;
+    updateClause: UpdateClause;
+    setClause: SetClause;
+    whereClause: WhereClause | null;
+    fromClause: FromClause | null;
+    returningClause: ReturningClause | null;
+    /**
+     * @param params.source SourceExpression (table or subquery with optional alias)
+     * @param params.setClause SetClause instance or array of {column, value} pairs
+     * @param params.where WHERE clause (optional)
+     * @param params.from FROM clause (optional)
+     * @param params.returning RETURNING clause (optional)
+     */
+    constructor(params: {
+        withClause?: WithClause | null;
+        updateClause: UpdateClause;
+        setClause: SetClause | {
+            column: string | IdentifierString;
+            value: ValueComponent;
+        }[];
+        whereClause?: WhereClause | null;
+        fromClause?: FromClause | null;
+        returning?: ReturningClause | null;
+    });
+}

package/dist/esm/types/models/ValueComponent.d.ts

@@ -16,16 +16,17 @@ export declare class ColumnReference extends SqlComponent {
     static kind: symbol;
     namespaces: IdentifierString[] | null;
     column: IdentifierString;
-    constructor(namespaces: string | string[] | null, column: string);
+    constructor(namespaces: string | string[] | IdentifierString[] | null, column: string | IdentifierString);
     toString(): string;
     getNamespace(): string;
 }
 export declare class FunctionCall extends SqlComponent {
     static kind: symbol;
+    namespaces: IdentifierString[] | null;
     name: RawString;
     argument: ValueComponent | null;
     over: OverExpression | null;
-    constructor(name: string, argument: ValueComponent | null, over: OverExpression | null);
+    constructor(namespaces: string[] | IdentifierString[] | null, name: string | RawString, argument: ValueComponent | null, over: OverExpression | null);
 }
 export type OverExpression = WindowFrameExpression | IdentifierString;
 export declare enum WindowFrameType {
@@ -153,9 +154,11 @@ export declare class StringSpecifierExpression extends SqlComponent {
 }
 export declare class TypeValue extends SqlComponent {
     static kind: symbol;
-    type: RawString;
+    namespaces: IdentifierString[] | null;
+    name: RawString;
     argument: ValueComponent | null;
-    constructor(type: string, argument?: ValueComponent | null);
+    constructor(namespaces: string[] | IdentifierString[] | null, name: string | RawString, argument?: ValueComponent | null);
+    getTypeName(): string;
 }
 export declare class TupleExpression extends SqlComponent {
     static kind: symbol;

package/dist/esm/types/parsers/FullNameParser.d.ts

@@ -0,0 +1,26 @@
+import { Lexeme } from "../models/Lexeme";
+import { IdentifierString } from "../models/ValueComponent";
+/**
+ * Utility class for parsing fully qualified names (e.g. db.schema.table or db.schema.table.column_name)
+ * This can be used for both table and column references.
+ */
+export declare class FullNameParser {
+    /**
+     * Parses a fully qualified name from lexemes, returning namespaces, table, and new index.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        namespaces: string[] | null;
+        name: IdentifierString;
+        newIndex: number;
+    };
+    /**
+     * Parses a fully qualified name from a string (e.g. 'db.schema.table')
+     * Returns { namespaces, name }
+     */
+    static parse(str: string): {
+        namespaces: string[] | null;
+        name: IdentifierString;
+    };
+    private static parseEscapedOrDotSeparatedIdentifiers;
+    private static extractNamespacesAndName;
+}

package/dist/esm/types/parsers/InsertQueryParser.d.ts

@@ -13,5 +13,4 @@ export declare class InsertQueryParser {
         value: InsertQuery;
         newIndex: number;
     };
-    private static parseFullQualifiedName;
 }

package/dist/esm/types/parsers/ReturningClauseParser.d.ts

@@ -0,0 +1,12 @@
+import { Lexeme } from "../models/Lexeme";
+import { ReturningClause } from "../models/Clause";
+export declare class ReturningClauseParser {
+    /**
+     * Parse RETURNING clause from lexemes, starting at the given index.
+     * Returns a ReturningClause instance and the new index after parsing.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: ReturningClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SetClauseParser.d.ts

@@ -0,0 +1,11 @@
+import { Lexeme } from "../models/Lexeme";
+import { SetClause } from "../models/Clause";
+/**
+ * Parse SET clause from lexemes (including 'SET' keyword check).
+ */
+export declare class SetClauseParser {
+    static parseFromLexeme(lexemes: Lexeme[], idx: number): {
+        setClause: SetClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/SourceExpressionParser.d.ts

@@ -1,6 +1,14 @@
 import { SourceExpression } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class SourceExpressionParser {
+    /**
+     * Parse SQL string to SourceExpression (e.g. "table", "table as t", "schema.table t")
+     */
+    static parse(query: string): SourceExpression;
+    static parseTableSourceFromLexemes(lexemes: Lexeme[], index: number): {
+        value: SourceExpression;
+        newIndex: number;
+    };
     static parseFromLexeme(lexemes: Lexeme[], index: number): {
         value: SourceExpression;
         newIndex: number;

package/dist/esm/types/parsers/SourceParser.d.ts

@@ -2,6 +2,20 @@ import { SourceComponent } from "../models/Clause";
 import { Lexeme } from "../models/Lexeme";
 export declare class SourceParser {
     static parse(query: string): SourceComponent;
+    /**
+     * Parses only a TableSource from the given lexemes, regardless of the presence of parentheses after the identifier.
+     * This method is specifically used for cases like INSERT queries (e.g., "insert into table_name (col1, col2)")
+     * where a parenthesis immediately following the table name could otherwise be misinterpreted as a function call.
+     * By using this method, the parser forcibly treats the source as a TableSource.
+     *
+     * @param lexemes The array of lexemes to parse.
+     * @param index The starting index in the lexeme array.
+     * @returns An object containing the parsed TableSource and the new index.
+     */
+    static parseTableSourceFromLexemes(lexemes: Lexeme[], index: number): {
+        value: SourceComponent;
+        newIndex: number;
+    };
     static parseFromLexeme(lexemes: Lexeme[], index: number): {
         value: SourceComponent;
         newIndex: number;

package/dist/esm/types/parsers/UpdateClauseParser.d.ts

@@ -0,0 +1,15 @@
+import { UpdateClause } from "../models/Clause";
+import { Lexeme } from "../models/Lexeme";
+/**
+ * Parses the target of an UPDATE statement (table or source expression with optional alias).
+ */
+export declare class UpdateClauseParser {
+    /**
+     * Parse from lexeme array (returns UpdateClause and new index)
+     * This method parses a table or a table with alias using SourceExpressionParser.
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: UpdateClause;
+        newIndex: number;
+    };
+}

package/dist/esm/types/parsers/UpdateQueryParser.d.ts

@@ -0,0 +1,16 @@
+import { UpdateQuery } from "../models/UpdateQuery";
+import { Lexeme } from "../models/Lexeme";
+export declare class UpdateQueryParser {
+    /**
+     * Parse SQL string to UpdateQuery AST.
+     * @param query SQL string
+     */
+    static parse(query: string): UpdateQuery;
+    /**
+     * Parse from lexeme array (for internal use and tests)
+     */
+    static parseFromLexeme(lexemes: Lexeme[], index: number): {
+        value: UpdateQuery;
+        newIndex: number;
+    };
+}

package/dist/esm/types/transformers/Formatter.d.ts

@@ -104,5 +104,11 @@ export declare class Formatter implements SqlComponentVisitor<string> {
      */
     private visitCreateTableQuery;
     private visitInsertQuery;
+    private visitUpdateQuery;
+    private visitUpdateClause;
+    private visitSetClause;
+    private visitSetClauseItem;
+    private visitReturningClause;
+    private visitInsertClause;
 }
 export {};

package/dist/esm/types/transformers/QueryBuilder.d.ts

@@ -1,3 +1,4 @@
+import { UpdateQuery } from '../models/UpdateQuery';
 import { BinarySelectQuery, SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
 import { CreateTableQuery } from "../models/CreateTableQuery";
 import { InsertQuery } from "../models/InsertQuery";
@@ -51,4 +52,12 @@ export declare class QueryBuilder {
      * @returns An InsertQuery instance
      */
     static buildInsertQuery(selectQuery: SimpleSelectQuery, tableName: string): InsertQuery;
+    /**
+     * Builds an UPDATE query from a SELECT query, table name, and primary key(s).
+     * @param selectQuery The SELECT query providing new values (must select all columns to update and PKs)
+     * @param updateTableExprRaw The table name to update
+     * @param primaryKeys The primary key column name(s)
+     * @returns UpdateQuery instance
+     */
+    static buildUpdateQuery(selectQuery: SimpleSelectQuery, selectSourceName: string, updateTableExprRaw: string, primaryKeys: string | string[]): UpdateQuery;
 }

package/dist/models/Clause.d.ts

@@ -76,7 +76,7 @@ export declare class TableSource extends SqlComponent {
     namespaces: IdentifierString[] | null;
     table: IdentifierString;
     identifier: IdentifierString;
-    constructor(namespaces: string[] | null, table: string);
+    constructor(namespaces: string[] | IdentifierString[] | null, table: string | IdentifierString);
     getSourceName(): string;
 }
 export declare class FunctionSource extends SqlComponent {
@@ -120,14 +120,14 @@ export declare class JoinClause extends SqlComponent {
     condition: JoinConditionComponent | null;
     lateral: boolean;
     constructor(joinType: string, source: SourceExpression, condition: JoinConditionComponent | null, lateral: boolean);
-    getAliasSourceName(): string | null;
+    getSourceAliasName(): string | null;
 }
 export declare class FromClause extends SqlComponent {
     static kind: symbol;
     source: SourceExpression;
     joins: JoinClause[] | null;
     constructor(source: SourceExpression, join: JoinClause[] | null);
-    getAliasSourceName(): string | null;
+    getSourceAliasName(): string | null;
     /**
      * Returns all SourceExpression objects in this FROM clause, including main source and all JOIN sources.
      */
@@ -139,7 +139,7 @@ export declare class CommonTable extends SqlComponent {
     materialized: boolean | null;
     aliasExpression: SourceAliasExpression;
     constructor(query: SelectQuery, aliasExpression: SourceAliasExpression | string, materialized: boolean | null);
-    getAliasSourceName(): string;
+    getSourceAliasName(): string;
 }
 export declare class WithClause extends SqlComponent {
     static kind: symbol;
@@ -186,3 +186,57 @@ export declare class SourceAliasExpression extends SqlComponent {
     columns: IdentifierString[] | null;
     constructor(alias: string, columnAlias: string[] | null);
 }
+export declare class ReturningClause extends SqlComponent {
+    static kind: symbol;
+    columns: IdentifierString[];
+    /**
+     * Constructs a ReturningClause.
+     * @param columns Array of IdentifierString or string representing column names.
+     */
+    constructor(columns: (IdentifierString | string)[]);
+}
+export declare class SetClause extends SqlComponent {
+    static kind: symbol;
+    items: SetClauseItem[];
+    constructor(items: (SetClauseItem | {
+        column: string | IdentifierString;
+        value: ValueComponent;
+    })[]);
+}
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ */
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ * Now supports namespaces for fully qualified column names (e.g. schema.table.column).
+ */
+export declare class SetClauseItem extends SqlComponent {
+    static kind: symbol;
+    namespaces: IdentifierString[] | null;
+    column: IdentifierString;
+    value: ValueComponent;
+    constructor(column: string | IdentifierString | {
+        namespaces: string[] | IdentifierString[] | null;
+        column: string | IdentifierString;
+    }, value: ValueComponent);
+    /**
+     * Returns the fully qualified column name as a string.
+     */
+    getFullName(): string;
+}
+export declare class UpdateClause extends SqlComponent {
+    static kind: symbol;
+    source: SourceExpression;
+    constructor(source: SourceExpression);
+    getSourceAliasName(): string | null;
+}
+/**
+ * Represents the target table (with optional alias/schema) and columns for an INSERT statement.
+ * @param source The target table as a SourceExpression (can include schema, alias, etc.)
+ * @param columns Array of column names (as strings)
+ */
+export declare class InsertClause extends SqlComponent {
+    source: SourceExpression;
+    columns: string[];
+    constructor(source: SourceExpression, columns: string[]);
+}

package/dist/models/Clause.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourceAliasExpression = exports.ForClause = exports.LockMode = exports.FetchSpecification = exports.FetchUnit = exports.FetchType = exports.LimitClause = exports.WithClause = exports.CommonTable = exports.FromClause = exports.JoinClause = exports.JoinUsingClause = exports.JoinOnClause = exports.SourceExpression = exports.SubQuerySource = exports.ParenSource = exports.FunctionSource = exports.TableSource = exports.HavingClause = exports.GroupByClause = exports.OrderByItem = exports.OrderByClause = exports.NullsSortDirection = exports.SortDirection = exports.WindowFrameClause = exports.PartitionByClause = exports.WhereClause = exports.DistinctOn = exports.Distinct = exports.SelectClause = exports.SelectItem = void 0;
+exports.InsertClause = exports.UpdateClause = exports.SetClauseItem = exports.SetClause = exports.ReturningClause = exports.SourceAliasExpression = exports.ForClause = exports.LockMode = exports.FetchSpecification = exports.FetchUnit = exports.FetchType = exports.LimitClause = exports.WithClause = exports.CommonTable = exports.FromClause = exports.JoinClause = exports.JoinUsingClause = exports.JoinOnClause = exports.SourceExpression = exports.SubQuerySource = exports.ParenSource = exports.FunctionSource = exports.TableSource = exports.HavingClause = exports.GroupByClause = exports.OrderByItem = exports.OrderByClause = exports.NullsSortDirection = exports.SortDirection = exports.WindowFrameClause = exports.PartitionByClause = exports.WhereClause = exports.DistinctOn = exports.Distinct = exports.SelectClause = exports.SelectItem = void 0;
 const SqlComponent_1 = require("./SqlComponent");
 const ValueComponent_1 = require("./ValueComponent");
 class SelectItem extends SqlComponent_1.SqlComponent {
@@ -108,9 +108,18 @@ HavingClause.kind = Symbol("HavingClause");
 class TableSource extends SqlComponent_1.SqlComponent {
     constructor(namespaces, table) {
         super();
-        this.namespaces = namespaces !== null ? namespaces.map((namespace) => new ValueComponent_1.IdentifierString(namespace)) : null;
-        ;
-        this.table = new ValueComponent_1.IdentifierString(table);
+        // Accept both string[] and IdentifierString[] for namespaces
+        if (namespaces === null) {
+            this.namespaces = null;
+        }
+        else if (typeof namespaces[0] === "string") {
+            this.namespaces = namespaces.map(ns => new ValueComponent_1.IdentifierString(ns));
+        }
+        else {
+            this.namespaces = namespaces;
+        }
+        // Accept both string and IdentifierString for table
+        this.table = typeof table === "string" ? new ValueComponent_1.IdentifierString(table) : table;
         this.identifier = this.table;
     }
     getSourceName() {
@@ -191,7 +200,7 @@ class JoinClause extends SqlComponent_1.SqlComponent {
         this.condition = condition;
         this.lateral = lateral;
     }
-    getAliasSourceName() {
+    getSourceAliasName() {
         if (this.source.aliasExpression) {
             return this.source.aliasExpression.table.name;
         }
@@ -209,7 +218,7 @@ class FromClause extends SqlComponent_1.SqlComponent {
         this.source = source;
         this.joins = join;
     }
-    getAliasSourceName() {
+    getSourceAliasName() {
         if (this.source.aliasExpression) {
             return this.source.aliasExpression.table.name;
         }
@@ -245,7 +254,7 @@ class CommonTable extends SqlComponent_1.SqlComponent {
             this.aliasExpression = aliasExpression;
         }
     }
-    getAliasSourceName() {
+    getSourceAliasName() {
         return this.aliasExpression.table.name;
     }
 }
@@ -315,4 +324,98 @@ class SourceAliasExpression extends SqlComponent_1.SqlComponent {
 }
 exports.SourceAliasExpression = SourceAliasExpression;
 SourceAliasExpression.kind = Symbol("SourceAliasExpression");
+class ReturningClause extends SqlComponent_1.SqlComponent {
+    /**
+     * Constructs a ReturningClause.
+     * @param columns Array of IdentifierString or string representing column names.
+     */
+    constructor(columns) {
+        super();
+        this.columns = columns.map(col => typeof col === "string" ? new ValueComponent_1.IdentifierString(col) : col);
+    }
+}
+exports.ReturningClause = ReturningClause;
+ReturningClause.kind = Symbol("ReturningClause");
+class SetClause extends SqlComponent_1.SqlComponent {
+    constructor(items) {
+        super();
+        this.items = items.map(item => item instanceof SetClauseItem ? item : new SetClauseItem(item.column, item.value));
+    }
+}
+exports.SetClause = SetClause;
+SetClause.kind = Symbol("SetClause");
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ */
+/**
+ * Represents a single SET clause item in an UPDATE statement.
+ * Now supports namespaces for fully qualified column names (e.g. schema.table.column).
+ */
+class SetClauseItem extends SqlComponent_1.SqlComponent {
+    constructor(column, value) {
+        super();
+        if (typeof column === "object" && column !== null && "column" in column) {
+            // Accepts { namespaces, column }
+            const colObj = column;
+            if (colObj.namespaces == null) {
+                this.namespaces = null;
+            }
+            else if (typeof colObj.namespaces[0] === "string") {
+                this.namespaces = colObj.namespaces.map(ns => new ValueComponent_1.IdentifierString(ns));
+            }
+            else {
+                this.namespaces = colObj.namespaces;
+            }
+            this.column = typeof colObj.column === "string" ? new ValueComponent_1.IdentifierString(colObj.column) : colObj.column;
+        }
+        else {
+            this.namespaces = null;
+            this.column = typeof column === "string" ? new ValueComponent_1.IdentifierString(column) : column;
+        }
+        this.value = value;
+    }
+    /**
+     * Returns the fully qualified column name as a string.
+     */
+    getFullName() {
+        if (this.namespaces && this.namespaces.length > 0) {
+            return this.namespaces.map(ns => ns.name).join(".") + "." + this.column.name;
+        }
+        else {
+            return this.column.name;
+        }
+    }
+}
+exports.SetClauseItem = SetClauseItem;
+SetClauseItem.kind = Symbol("SetClauseItem");
+class UpdateClause extends SqlComponent_1.SqlComponent {
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    getSourceAliasName() {
+        if (this.source.aliasExpression) {
+            return this.source.aliasExpression.table.name;
+        }
+        else if (this.source.datasource instanceof TableSource) {
+            return this.source.datasource.table.name;
+        }
+        return null;
+    }
+}
+exports.UpdateClause = UpdateClause;
+UpdateClause.kind = Symbol("UpdateClause");
+/**
+ * Represents the target table (with optional alias/schema) and columns for an INSERT statement.
+ * @param source The target table as a SourceExpression (can include schema, alias, etc.)
+ * @param columns Array of column names (as strings)
+ */
+class InsertClause extends SqlComponent_1.SqlComponent {
+    constructor(source, columns) {
+        super();
+        this.source = source;
+        this.columns = columns;
+    }
+}
+exports.InsertClause = InsertClause;
 //# sourceMappingURL=Clause.js.map