@sqb/builder 4.24.1 → 4.26.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "4.24.1",
+  "version": "4.26.0",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {

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;

package/query/query.d.ts

@@ -3,9 +3,16 @@ import { Serializable } from '../serializable.js';
 import { GenerateOptions, GenerateResult } from '../types.js';
 export declare interface Query extends EventEmitter {
 }
+export interface QueryCommentArgs {
+    comment: string;
+    dialect?: string[];
+}
+export interface QueryIndexHintArgs {
+    index: string[];
+    dialect?: string[];
+}
 export declare abstract class Query extends Serializable {
-    protected _comment?: string;
-    protected _commentDialect?: string[];
+    protected _comment: QueryCommentArgs[];
     protected _params?: Record<string, any>;
     constructor();
     /**
@@ -13,5 +20,6 @@ export declare abstract class Query extends Serializable {
      */
     generate(options?: GenerateOptions): GenerateResult;
     values(obj: any): this;
+    comment(args: QueryCommentArgs): this;
     comment(text: string, dialect?: string[]): this;
 }

package/query/query.js

@@ -4,8 +4,7 @@ import merge from 'putil-merge';
 import { Serializable } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
 export class Query extends Serializable {
-    _comment;
-    _commentDialect;
+    _comment = [];
     _params;
     constructor() {
         super();
@@ -22,12 +21,16 @@ export class Query extends Serializable {
         /* generate output */
         let sql = this._serialize(ctx);
         sql = flattenText(sql, { noWrap: !ctx.prettyPrint });
-        if (this._comment &&
-            (!ctx.dialect ||
-                !this._commentDialect ||
-                this._commentDialect.includes(ctx.dialect))) {
-            const lines = '-- ' + this._comment.split('\n').join('\n-- ') + '\n';
-            sql = lines + sql;
+        if (this._comment.length) {
+            const comment = this._comment
+                .filter(x => !ctx.dialect ||
+                !x.dialect?.length ||
+                x.dialect.includes(ctx.dialect))
+                .map(x => x.comment.replace(/\n/g, '\n  '))
+                .join('\n');
+            if (comment) {
+                sql = `/*${comment}*/\n${sql}`;
+            }
         }
         return {
             sql,
@@ -42,9 +45,17 @@ export class Query extends Serializable {
         this._params = obj;
         return this;
     }
-    comment(text, dialect) {
-        this._comment = text;
-        this._commentDialect = dialect;
+    comment(arg0, dialect) {
+        if (typeof arg0 === 'string')
+            this._comment.push({
+                comment: arg0,
+                dialect: Array.isArray(dialect) ? dialect : undefined,
+            });
+        else if (typeof arg0 === 'object' && typeof arg0.comment === 'string')
+            this._comment.push({
+                comment: arg0.comment,
+                dialect: Array.isArray(arg0.dialect) ? arg0.dialect : undefined,
+            });
         return this;
     }
 }

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

@@ -51,7 +51,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 +146,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,11 +155,14 @@ export class SelectQuery extends Query {
             orderBy: this.__serializeOrderColumns(ctx),
             limit: this._limit,
             offset: this._offset,
+            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) {
@@ -219,15 +227,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() {

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);
 }