@sqb/builder 4.25.0 → 4.26.1

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "4.25.0",
+  "version": "4.26.1",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {
     "debug": "^4.4.3",
+    "fast-tokenizer": "^1.9.0",
     "putil-flattentext": "^2.1.1",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.13.0",

package/query/delete-query.d.ts

@@ -7,7 +7,7 @@ import { Query } from './query.js';
 export declare class DeleteQuery extends Query {
     _table: TableName | RawStatement;
     _where?: LogicalOperator;
-    constructor(tableName: string | RawStatement);
+    constructor(tableName: string | TableName | RawStatement);
     get _type(): SerializationType;
     /**
      * Defines "where" part of query

package/query/delete-query.js

@@ -8,12 +8,18 @@ export class DeleteQuery extends Query {
     _where;
     constructor(tableName) {
         super();
-        if (!tableName ||
-            !(typeof tableName === 'string' || isRawStatement(tableName))) {
+        if (!(tableName &&
+            (tableName instanceof TableName ||
+                typeof tableName === 'string' ||
+                isRawStatement(tableName)))) {
             throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
         }
         this._table =
-            typeof tableName === 'string' ? new TableName(tableName) : tableName;
+            tableName instanceof TableName
+                ? tableName
+                : typeof tableName === 'string'
+                    ? new TableName(tableName)
+                    : tableName;
     }
     get _type() {
         return SerializationType.DELETE_QUERY;
@@ -33,8 +39,6 @@ export class DeleteQuery extends Query {
         const o = {
             table: this._table._serialize(ctx),
             where: this._serializeWhere(ctx),
-            indexHint: this._indexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
-            noIndexHint: this._noIndexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
         };
         return ctx.serialize(this._type, o, () => this.__defaultSerialize(ctx, o));
     }

package/query/insert-query.js

@@ -32,8 +32,6 @@ export class InsertQuery extends ReturningQuery {
             columns: this.__serializeColumns(ctx),
             values: this.__serializeValues(ctx),
             returning: this.__serializeReturning(ctx),
-            indexHint: this._indexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
-            noIndexHint: this._noIndexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
         };
         let out = 'insert into ' +
             o.table +

package/query/query.d.ts

@@ -13,8 +13,6 @@ export interface QueryIndexHintArgs {
 }
 export declare abstract class Query extends Serializable {
     protected _comment: QueryCommentArgs[];
-    protected _indexHint: QueryIndexHintArgs[];
-    protected _noIndexHint: QueryIndexHintArgs[];
     protected _params?: Record<string, any>;
     constructor();
     /**
@@ -24,8 +22,4 @@ export declare abstract class Query extends Serializable {
     values(obj: any): this;
     comment(args: QueryCommentArgs): this;
     comment(text: string, dialect?: string[]): this;
-    indexHint(args: QueryIndexHintArgs): this;
-    indexHint(index: string | string[], dialect?: string[]): this;
-    noIndexHint(args: QueryIndexHintArgs): this;
-    noIndexHint(index: string | string[], dialect?: string[]): this;
 }

package/query/query.js

@@ -5,8 +5,6 @@ import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
 export class Query extends Serializable {
     _comment = [];
-    _indexHint = [];
-    _noIndexHint = [];
     _params;
     constructor() {
         super();
@@ -60,33 +58,5 @@ export class Query extends Serializable {
             });
         return this;
     }
-    indexHint(arg0, dialect) {
-        if (typeof arg0 === 'object' && !Array.isArray(arg0))
-            this._indexHint.push({
-                index: Array.isArray(arg0.index) ? arg0.index : [arg0.index],
-                dialect: Array.isArray(arg0.dialect) ? arg0.dialect : undefined,
-            });
-        else {
-            this._indexHint.push({
-                index: Array.isArray(arg0) ? arg0 : [arg0],
-                dialect: Array.isArray(dialect) ? dialect : undefined,
-            });
-        }
-        return this;
-    }
-    noIndexHint(arg0, dialect) {
-        if (typeof arg0 === 'object' && !Array.isArray(arg0))
-            this._noIndexHint.push({
-                index: Array.isArray(arg0.index) ? arg0.index : [arg0.index],
-                dialect: Array.isArray(arg0.dialect) ? arg0.dialect : undefined,
-            });
-        else {
-            this._noIndexHint.push({
-                index: Array.isArray(arg0) ? arg0 : [arg0],
-                dialect: Array.isArray(dialect) ? dialect : undefined,
-            });
-        }
-        return this;
-    }
 }
 merge(Query.prototype, EventEmitter.prototype, { descriptor: true });

package/query/select-query.d.ts

@@ -6,6 +6,7 @@ import { JoinStatement } from '../sql-objects/join-statement.js';
 import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
 import { OrderColumn } from '../sql-objects/order-column.js';
 import { RawStatement } from '../sql-objects/raw-statement.js';
+import { TableName } from '../sql-objects/table-name.js';
 import { Query } from './query.js';
 import type { UnionQuery } from './union-query.js';
 export declare class SelectQuery extends Query {
@@ -28,7 +29,7 @@ export declare class SelectQuery extends Query {
     /**
      * Defines "from" part of  query.
      */
-    from(...table: (string | RawStatement | SelectQuery | UnionQuery)[]): this;
+    from(...table: (string | TableName | RawStatement | SelectQuery | UnionQuery)[]): this;
     /**
      * Adds "join" statements to query
      */

package/query/select-query.js

@@ -1,3 +1,4 @@
+import { splitString } from 'fast-tokenizer';
 import { coerceToInt } from 'putil-varhelpers';
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
@@ -6,7 +7,7 @@ import { GroupColumn } from '../sql-objects/group-column.js';
 import { OpAnd } from '../sql-objects/operators/op-and.js';
 import { OrderColumn } from '../sql-objects/order-column.js';
 import { TableName } from '../sql-objects/table-name.js';
-import { isJoinStatement, isSerializable } from '../typeguards.js';
+import { isJoinStatement } from '../typeguards.js';
 import { Query } from './query.js';
 export class SelectQuery extends Query {
     _tables;
@@ -38,8 +39,22 @@ export class SelectQuery extends Query {
                 continue;
             if (Array.isArray(arg))
                 self.addColumn(...arg);
-            else
-                this._columns.push(isSerializable(arg) ? arg : new FieldExpression(arg));
+            else {
+                if (typeof arg === 'string') {
+                    const items = splitString(arg, {
+                        brackets: true,
+                        delimiters: ',',
+                        quotes: true,
+                        keepQuotes: true,
+                        keepBrackets: true,
+                    });
+                    items.forEach(item => {
+                        this._columns.push(new FieldExpression(item));
+                    });
+                }
+                else
+                    this._columns.push(arg);
+            }
         }
         return this;
     }
@@ -51,7 +66,11 @@ export class SelectQuery extends Query {
         for (const arg of table) {
             if (!arg)
                 continue;
-            this._tables.push(typeof arg === 'string' ? new TableName(arg) : arg);
+            this._tables.push(arg instanceof TableName
+                ? arg
+                : typeof arg === 'string'
+                    ? new TableName(arg)
+                    : arg);
         }
         return this;
     }
@@ -142,6 +161,7 @@ export class SelectQuery extends Query {
      */
     _serialize(ctx) {
         const o = {
+            query: this,
             columns: this.__serializeSelectColumns(ctx),
             from: this.__serializeFrom(ctx),
             join: this.__serializeJoins(ctx),
@@ -150,13 +170,14 @@ export class SelectQuery extends Query {
             orderBy: this.__serializeOrderColumns(ctx),
             limit: this._limit,
             offset: this._offset,
-            indexHint: this._indexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
-            noIndexHint: this._noIndexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
+            optimizerHint: '',
         };
         return ctx.serialize(this._type, o, () => {
             let out = 'select';
             if (this._distinct)
                 out += ' distinct';
+            if (o.optimizerHint)
+                out += ' ' + o.optimizerHint;
             // columns part
             /* istanbul ignore else */
             if (o.columns) {
@@ -221,15 +242,21 @@ export class SelectQuery extends Query {
                     if (t instanceof SelectQuery) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in "from"');
-                        arr.push('\n\t(' + s + ') ' + t._alias);
+                        arr.push({
+                            source: t,
+                            text: '\n\t(' + s + ') ' + t._alias,
+                        });
                     }
                     else
-                        arr.push(s);
+                        arr.push({
+                            source: t,
+                            text: s,
+                        });
                 }
             }
         }
         return ctx.serialize(SerializationType.SELECT_QUERY_FROM, arr, () => {
-            const s = arr.join(',');
+            const s = arr.map(x => x.text).join(',');
             return s ? 'from' + (s.substring(0, 1) !== '\n' ? ' ' : '') + s : '';
         });
     }

package/query/update-query.d.ts

@@ -8,7 +8,7 @@ export declare class UpdateQuery extends ReturningQuery {
     _table: TableName | RawStatement;
     _input: any;
     _where?: LogicalOperator;
-    constructor(tableName: string | RawStatement, input: any);
+    constructor(tableName: string | TableName | RawStatement, input: any);
     get _type(): SerializationType;
     /**
      * Defines "where" part of query

package/query/update-query.js

@@ -10,8 +10,10 @@ export class UpdateQuery extends ReturningQuery {
     _where;
     constructor(tableName, input) {
         super();
-        if (!tableName ||
-            !(typeof tableName === 'string' || isRawStatement(tableName))) {
+        if (!(tableName &&
+            (tableName instanceof TableName ||
+                typeof tableName === 'string' ||
+                isRawStatement(tableName)))) {
             throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
         }
         if (!input ||
@@ -19,7 +21,11 @@ export class UpdateQuery extends ReturningQuery {
             throw new TypeError('Object or Raw instance required as second argument (input) for UpdateQuery');
         }
         this._table =
-            typeof tableName === 'string' ? new TableName(tableName) : tableName;
+            tableName instanceof TableName
+                ? tableName
+                : typeof tableName === 'string'
+                    ? new TableName(tableName)
+                    : tableName;
         this._input = input;
     }
     get _type() {
@@ -42,8 +48,6 @@ export class UpdateQuery extends ReturningQuery {
             values: this.__serializeValues(ctx),
             where: this.__serializeWhere(ctx),
             returning: this.__serializeReturning(ctx),
-            indexHint: this._indexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
-            noIndexHint: this._noIndexHint.filter(x => !ctx.dialect || !x.dialect?.length || x.dialect.includes(ctx.dialect)),
         };
         let out = 'update ' + o.table + ' set \n\t' + o.values + '\b';
         if (o.where)

package/sql-objects/table-name.d.ts

@@ -1,11 +1,22 @@
 import { SerializationType } from '../enums.js';
 import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
+export interface OptimizerHintArgs {
+    hint: string;
+    dialect?: string[];
+}
+export interface TableNameArgs {
+    schema?: string;
+    table: string;
+    alias?: string;
+    optimizerHint?: string | string[] | OptimizerHintArgs | OptimizerHintArgs[];
+}
 export declare class TableName extends Serializable {
     schema?: string;
     table?: string;
     alias?: string;
-    constructor(tableName: string);
+    optimizerHint?: OptimizerHintArgs[];
+    constructor(tableName: string | TableNameArgs);
     get _type(): SerializationType;
     _serialize(ctx: SerializeContext): string;
 }

package/sql-objects/table-name.js

@@ -4,17 +4,40 @@ export class TableName extends Serializable {
     schema;
     table;
     alias;
+    optimizerHint;
     constructor(tableName) {
         super();
-        const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
-        if (!m)
-            throw new TypeError(`(${tableName}) does not match table name format`);
-        if (m[1])
-            this.schema = m[1];
-        if (m[2])
-            this.table = m[2];
-        if (m[3])
-            this.alias = m[3];
+        if (typeof tableName === 'string') {
+            const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
+            if (!m)
+                throw new TypeError(`(${tableName}) does not match table name format`);
+            if (m[1])
+                this.schema = m[1];
+            if (m[2])
+                this.table = m[2];
+            if (m[3])
+                this.alias = m[3];
+        }
+        else {
+            this.schema = tableName.schema;
+            this.table = tableName.table;
+            this.alias = tableName.alias;
+            if (tableName.optimizerHint) {
+                const arg0 = tableName.optimizerHint;
+                this.optimizerHint = [];
+                if (typeof arg0 === 'object' && !Array.isArray(arg0)) {
+                    this.optimizerHint.push({
+                        hint: String(arg0.hint),
+                        dialect: Array.isArray(arg0.dialect) ? arg0.dialect : undefined,
+                    });
+                }
+                else {
+                    this.optimizerHint.push({
+                        hint: String(arg0),
+                    });
+                }
+            }
+        }
     }
     get _type() {
         return SerializationType.TABLE_NAME;
@@ -24,6 +47,7 @@ export class TableName extends Serializable {
             schema: this.schema,
             table: this.table,
             alias: this.alias,
+            optimizerHint: this.optimizerHint,
         }, () => (this.schema ? this.schema + '.' : '') +
             this.table +
             (this.alias ? ' ' + this.alias : ''));

package/sqlobject.initializers.d.ts

@@ -18,14 +18,16 @@ import { ParamExpression } from './sql-objects/param-expression.js';
 import { RawStatement } from './sql-objects/raw-statement.js';
 import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
 import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
+import { TableName as TableNameClass, TableNameArgs } from './sql-objects/table-name.js';
 import { UpperStatement } from './sql-objects/upper-statement.js';
 export declare function Raw(text: string): RawStatement;
 export declare function Select(...column: (string | string[] | Serializable)[]): SelectQuery;
 export declare function Insert(tableName: string | RawStatement, input: any): InsertQuery;
-export declare function Update(tableName: string | RawStatement, input: any): UpdateQuery;
-export declare function Delete(tableName: string | RawStatement): DeleteQuery;
+export declare function Update(tableName: string | TableNameClass | RawStatement, input: any): UpdateQuery;
+export declare function Delete(tableName: string | TableNameClass | RawStatement): DeleteQuery;
 export declare function Union(...queries: Query[]): UnionQuery;
 export declare function UnionAll(...queries: Query[]): UnionQuery;
+export declare function TableName(tableName: string | TableNameArgs): TableNameClass;
 export declare function Join(table: string | SelectQuery | RawStatement): JoinStatement;
 export declare function InnerJoin(table: string | SelectQuery | RawStatement): JoinStatement;
 export declare function LeftJoin(table: string | SelectQuery | RawStatement): JoinStatement;

package/sqlobject.initializers.js

@@ -16,6 +16,7 @@ import { ParamExpression } from './sql-objects/param-expression.js';
 import { RawStatement } from './sql-objects/raw-statement.js';
 import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
 import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
+import { TableName as TableNameClass, } from './sql-objects/table-name.js';
 import { UpperStatement } from './sql-objects/upper-statement.js';
 export function Raw(text) {
     return new RawStatement(text);
@@ -38,6 +39,9 @@ export function Union(...queries) {
 export function UnionAll(...queries) {
     return new UnionQuery(queries, 'all');
 }
+export function TableName(tableName) {
+    return new TableNameClass(tableName);
+}
 export function Join(table) {
     return new JoinStatement(JoinType.INNER, table);
 }