@stamhoofd/sql 2.64.0 → 2.65.1

package/src/SQLExpression.ts

@@ -1,30 +1,30 @@
 export type SQLExpressionOptions = {
-    defaultNamespace?: string
+    defaultNamespace?: string;
+    parentNamespace?: string;
 };
 
-export type NormalizedSQLQuery = {query: string; params: any[]}
-export type SQLQuery = NormalizedSQLQuery|string
+export type NormalizedSQLQuery = { query: string; params: any[] };
+export type SQLQuery = NormalizedSQLQuery | string;
 
-export function joinSQLQuery(queries: (SQLQuery|undefined|null)[], seperator?: string): NormalizedSQLQuery {
-    queries = queries.filter(q => q !== undefined && q !== null)
+export function joinSQLQuery(queries: (SQLQuery | undefined | null)[], seperator?: string): NormalizedSQLQuery {
+    queries = queries.filter(q => q !== undefined && q !== null);
     return {
         query: queries.map(q => typeof q === 'string' ? q : q!.query).join(seperator ?? ''),
-        params: queries.flatMap(q => typeof q === 'string' ? [] : q!.params)
-    }
+        params: queries.flatMap(q => typeof q === 'string' ? [] : q!.params),
+    };
 }
 
 export function normalizeSQLQuery(q: SQLQuery): NormalizedSQLQuery {
     return {
         query: typeof q === 'string' ? q : q.query,
-        params: typeof q === 'string' ? [] : q.params
-    }
+        params: typeof q === 'string' ? [] : q.params,
+    };
 }
 
-
 export interface SQLExpression {
-    getSQL(options?: SQLExpressionOptions): SQLQuery
+    getSQL(options?: SQLExpressionOptions): SQLQuery;
 }
 
 export function isSQLExpression(obj: unknown): obj is SQLExpression {
-    return typeof obj === 'object' && obj !== null && !!(obj as any).getSQL && typeof (obj as any).getSQL === 'function'
+    return typeof obj === 'object' && obj !== null && !!(obj as any).getSQL && typeof (obj as any).getSQL === 'function';
 }

package/src/SQLExpressions.ts

@@ -1,5 +1,6 @@
 import { Database } from '@simonbackx/simple-database';
 import { joinSQLQuery, SQLExpression, SQLExpressionOptions, SQLQuery } from './SQLExpression';
+import { ParseWhereArguments, SQLEmptyWhere } from './SQLWhere';
 
 export type SQLScalarValue = string | number | boolean | Date;
 export type SQLDynamicExpression = SQLScalarValue | SQLScalarValue[] | null | SQLExpression;
@@ -329,23 +330,74 @@ export class SQLWildcardSelectExpression implements SQLExpression {
     }
 }
 
+export class SQLNamespaceExpression implements SQLExpression {
+    namespace: string;
+
+    constructor(namespace: string) {
+        this.namespace = namespace;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return Database.escapeId(this.namespace);
+    }
+}
+
+export const SQLDefaultNamespace: SQLExpression = {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (!options?.defaultNamespace) {
+            throw new Error('No default namespace provided');
+        }
+        return Database.escapeId(options.defaultNamespace);
+    },
+};
+
+/**
+ * Reference the table of the parent query
+ */
+export const SQLParentNamespace: SQLExpression = {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (!options?.parentNamespace) {
+            throw new Error('No parent namespace provided');
+        }
+        return Database.escapeId(options.parentNamespace);
+    },
+};
+
+export type SQLColumnExpressionParams = [
+    namespace: string | SQLExpression,
+    column: string,
+] | [
+    column: string,
+];
+
 export class SQLColumnExpression implements SQLExpression {
-    namespace?: string;
+    namespace: SQLExpression;
     column: string;
 
-    constructor(namespace: string, column: string);
-    constructor(column: string);
-    constructor(namespaceOrColumn: string, column?: string) {
-        if (column === undefined) {
-            this.column = namespaceOrColumn;
+    constructor(...args: SQLColumnExpressionParams) {
+        if (args.length === 1) {
+            this.namespace = SQLDefaultNamespace;
+            this.column = args[0];
             return;
         }
-        this.namespace = namespaceOrColumn;
+
+        const [namespace, column] = args;
+
+        if (typeof namespace === 'string') {
+            this.namespace = new SQLNamespaceExpression(namespace);
+        }
+        else {
+            this.namespace = namespace;
+        }
         this.column = column;
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return Database.escapeId(this.namespace ?? options?.defaultNamespace ?? '') + '.' + Database.escapeId(this.column);
+        return joinSQLQuery([
+            this.namespace.getSQL(options),
+            '.',
+            Database.escapeId(this.column),
+        ]);
     }
 }
 
@@ -371,3 +423,35 @@ export class SQLTableExpression implements SQLExpression {
         return Database.escapeId(this.table) + ' ' + Database.escapeId(this.namespace);
     }
 }
+
+export class SQLIf implements SQLExpression {
+    _if: SQLExpression;
+    _then: SQLExpression = new SQLNull();
+    _else: SQLExpression = new SQLNull();
+
+    constructor(...args: ParseWhereArguments) {
+        this._if = new SQLEmptyWhere().and(...args);
+    }
+
+    then(then: SQLDynamicExpression): SQLIf {
+        this._then = readDynamicSQLExpression(then);
+        return this;
+    }
+
+    else(_else: SQLDynamicExpression): SQLIf {
+        this._else = readDynamicSQLExpression(_else);
+        return this;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'IF(',
+            this._if.getSQL(options),
+            ',',
+            this._then.getSQL(options),
+            ',',
+            this._else.getSQL(options),
+            ')',
+        ]);
+    }
+}

package/src/SQLInsert.ts

@@ -47,9 +47,15 @@ export class SQLInsert implements SQLExpression {
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
-        options = options ?? {};
+        // Create a clone since we are mutating the default namespaces
+        const parentOptions = options;
+        options = options ? { ...options } : {};
         options.defaultNamespace = (this._into as any).namespace ?? (this._into).table ?? undefined;
 
+        if (parentOptions?.defaultNamespace) {
+            options.parentNamespace = parentOptions.defaultNamespace;
+        }
+
         const query: SQLQuery[] = [
             'INSERT INTO',
             this._into.getSQL(options),

package/src/SQLJoin.ts

@@ -1,16 +1,16 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from "./SQLExpression";
-import { SQLWhere, Whereable } from "./SQLWhere";
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression';
+import { SQLWhere, Whereable } from './SQLWhere';
 
 export enum SQLJoinType {
-    Left = "Left",
-    Right = "Right",
-    Inner = "Inner",
-    Outer = "Outer"
+    Left = 'Left',
+    Right = 'Right',
+    Inner = 'Inner',
+    Outer = 'Outer',
 }
 
 class EmptyClass {}
 export class SQLJoin extends Whereable(EmptyClass) implements SQLExpression {
-    type = SQLJoinType.Left
+    type = SQLJoinType.Left;
     table: SQLExpression;
 
     constructor(type: SQLJoinType, table: SQLExpression) {
@@ -28,12 +28,12 @@ export class SQLJoin extends Whereable(EmptyClass) implements SQLExpression {
         }
     }
 
-    getSQL(options?: SQLExpressionOptions | undefined): SQLQuery {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
         return joinSQLQuery([
             this.getJoinPrefix(),
-            this.table?.getSQL(),
+            this.table?.getSQL(options),
             this._where ? 'ON' : undefined,
-            this._where?.getSQL()
-        ], ' ')
+            this._where?.getSQL(options),
+        ], ' ');
     }
 }

package/src/SQLOrderBy.ts

@@ -1,50 +1,54 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from "./SQLExpression";
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression';
+import { SQLColumnExpression } from './SQLExpressions';
 
 type Constructor<T = {}> = new (...args: any[]) => T;
 
 export function Orderable<Sup extends Constructor<{}>>(Base: Sup) {
     return class extends Base {
-        _orderBy: SQLOrderBy|null = null
+        _orderBy: SQLOrderBy | null = null;
 
-        orderBy<T>(this: T, orderBy: SQLOrderBy): T
-        orderBy<T>(this: T, column: SQLExpression, direction?: SQLOrderByDirection) : T
-        orderBy<T>(this: T, columnOrOrderBy: SQLExpression, direction?: SQLOrderByDirection): T {
-            let o = columnOrOrderBy as SQLOrderBy
+        orderBy<T>(this: T, orderBy: SQLOrderBy): T;
+        orderBy<T>(this: T, column: SQLExpression | string, direction?: SQLOrderByDirection): T;
+        orderBy<T>(this: T, columnOrOrderBy: SQLExpression | string, direction?: SQLOrderByDirection): T {
+            let o = columnOrOrderBy as SQLOrderBy;
             if (!(columnOrOrderBy instanceof SQLOrderBy)) {
-                o = new SQLOrderBy({column: columnOrOrderBy, direction: direction ?? 'ASC'})
+                o = new SQLOrderBy({
+                    column: typeof columnOrOrderBy === 'string' ? new SQLColumnExpression(columnOrOrderBy) : columnOrOrderBy,
+                    direction: direction ?? 'ASC',
+                });
             }
 
             const me = this as any; // stupid typescript looses type information if we don't do the this: T dance
 
             if (me._orderBy) {
-                me._orderBy.add(o)
-            } else {
+                me._orderBy.add(o);
+            }
+            else {
                 me._orderBy = o;
             }
 
             return me;
         }
-    }
+    };
 }
 
-
 export type SQLOrderByDirection = 'ASC' | 'DESC';
 export class SQLOrderBy implements SQLExpression {
-    orderBy: {column: SQLExpression, direction: SQLOrderByDirection}[] = [];
+    orderBy: { column: SQLExpression; direction: SQLOrderByDirection }[] = [];
 
-    constructor(...orderBy: {column: SQLExpression, direction: SQLOrderByDirection}[]) {
-        this.orderBy = orderBy
+    constructor(...orderBy: { column: SQLExpression; direction: SQLOrderByDirection }[]) {
+        this.orderBy = orderBy;
     }
 
     static combine(orderBy: SQLOrderBy[]) {
-        return new SQLOrderBy(...orderBy.flatMap(o => o.orderBy))
+        return new SQLOrderBy(...orderBy.flatMap(o => o.orderBy));
     }
 
     add(orderBy: SQLOrderBy) {
-        this.orderBy.push(...orderBy.orderBy)
+        this.orderBy.push(...orderBy.orderBy);
     }
 
-    getSQL(options?: SQLExpressionOptions | undefined): SQLQuery {
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
         if (this.orderBy.length === 0) {
             return '';
         }
@@ -52,14 +56,14 @@ export class SQLOrderBy implements SQLExpression {
         return joinSQLQuery([
             'ORDER BY ',
             joinSQLQuery(
-                this.orderBy.map(o => {
+                this.orderBy.map((o) => {
                     return joinSQLQuery([
                         o.column.getSQL(options),
-                        o.direction
-                    ], ' ')
-                }), 
-                ', '
-            )
-        ])
+                        o.direction,
+                    ], ' ');
+                }),
+                ', ',
+            ),
+        ]);
     }
 }

package/src/SQLSelect.ts

@@ -3,7 +3,7 @@ import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeS
 import { SQLAlias, SQLColumnExpression, SQLCount, SQLSelectAs, SQLSum, SQLTableExpression } from './SQLExpressions';
 import { SQLJoin } from './SQLJoin';
 import { Orderable } from './SQLOrderBy';
-import { Whereable } from './SQLWhere';
+import { SQLWhereSign, Whereable } from './SQLWhere';
 
 class EmptyClass {}
 
@@ -19,7 +19,19 @@ export function parseTable(tableOrExpressiongOrNamespace: SQLExpression | string
     }
 }
 
-export class SQLSelect<T = SQLResultNamespacedRow> extends Whereable(Orderable(EmptyClass)) implements SQLExpression {
+export type IterableSQLSelect<T extends object = SQLResultNamespacedRow> = AsyncIterableIterator<T, undefined> & {
+    isDone: boolean;
+    options: IterableSQLSelectOptions;
+    maxQueries(maxQueries: number): IterableSQLSelect<T>;
+};
+export type IterableSQLSelectOptions = {
+    /**
+     * The loop will cancel after this amount of queries - but you can continue to loop over the results when starting a new for loop.
+     */
+    maxQueries?: number;
+};
+
+export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Whereable(Orderable(EmptyClass)) implements SQLExpression {
     _columns: SQLExpression[];
     _from: SQLExpression;
 
@@ -81,9 +93,15 @@ export class SQLSelect<T = SQLResultNamespacedRow> extends Whereable(Orderable(E
             query.push('/*+ MAX_EXECUTION_TIME(' + this._max_execution_time + ') */');
         }
 
-        options = options ?? {};
+        // Create a clone since we are mutating the default namespaces
+        const parentOptions = options;
+        options = options ? { ...options } : {};
         options.defaultNamespace = (this._from as any).namespace ?? (this._from as any).table ?? undefined;
 
+        if (parentOptions?.defaultNamespace) {
+            options.parentNamespace = parentOptions.defaultNamespace;
+        }
+
         const columns = this._columns.map(c => c.getSQL(options));
         query.push(
             joinSQLQuery(columns, ', '),
@@ -136,7 +154,7 @@ export class SQLSelect<T = SQLResultNamespacedRow> extends Whereable(Orderable(E
         const { query, params } = normalizeSQLQuery(this.getSQL());
 
         // when debugging: log all queries
-        // console.log(query, params);
+        console.log(query, params);
         const [rows] = await Database.select(query, params, { nestTables: true });
 
         // Now map aggregated queries to the correct namespace
@@ -238,4 +256,192 @@ export class SQLSelect<T = SQLResultNamespacedRow> extends Whereable(Orderable(E
         console.warn('Invalid sum SQL response', rows);
         return 0;
     }
+
+    all(options: IterableSQLSelectOptions = {}): T extends { id: string } ? IterableSQLSelect<T> : never {
+        if (this._orderBy) {
+            throw new Error('Cannot use async iterator with custom order by. Results should be ordered by ID');
+        }
+
+        if (this._offset !== null) {
+            throw new Error('Cannot use async iterator with offset');
+        }
+
+        if (!this._limit) {
+            this._limit = 100;
+        }
+
+        const limit = this._limit;
+        this.orderBy('id');
+
+        let next: this | null = this.clone();
+        const base = this;
+
+        let stack: T[] = [];
+        let stackIndex = 0;
+
+        return {
+            queryCount: 0,
+            options,
+            [Symbol.asyncIterator]() {
+                return {
+                    ...this,
+
+                    // Reset the iterator
+                    queryCount: 0,
+                };
+            },
+            get isDone() {
+                return !next && (stackIndex + 1) >= stack.length;
+            },
+            async next(): Promise<IteratorResult<T, undefined>> {
+                stackIndex++;
+
+                if (stackIndex < stack.length) {
+                    return {
+                        done: false,
+                        value: stack[stackIndex],
+                    };
+                }
+
+                if (!next) {
+                    stack = []; // Clean up memory
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+
+                if (this.options.maxQueries !== undefined && this.queryCount >= this.options.maxQueries) {
+                    // Stopping early
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+
+                stack = await next.fetch();
+                next = null;
+                this.queryCount += 1;
+
+                if (stack.length === 0) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                stackIndex = 0;
+
+                if (stack.length >= limit) {
+                    next = base.clone();
+                    const lastResult = stack[stack.length - 1]!;
+                    if (!('id' in lastResult)) {
+                        throw new Error('Cannot use async iterator without ID column');
+                    }
+
+                    const lastId = lastResult.id;
+                    if (typeof lastId !== 'string') {
+                        throw new Error('Cannot use async iterator without string ID column');
+                    }
+
+                    next.andWhere('id', '>', lastId);
+                }
+
+                return {
+                    done: false,
+                    value: stack[stackIndex],
+                };
+            },
+            maxQueries(maxQueries: number) {
+                this.options.maxQueries = maxQueries;
+                return this;
+            },
+        } as IterableSQLSelect<T> as any;
+    }
+
+    allBatched(options: IterableSQLSelectOptions = {}): T extends { id: string } ? IterableSQLSelect<T[]> : never {
+        if (this._orderBy) {
+            throw new Error('Cannot use async iterator with custom order by. Results should be ordered by ID');
+        }
+
+        if (this._offset !== null) {
+            throw new Error('Cannot use async iterator with offset');
+        }
+
+        if (!this._limit) {
+            this._limit = 100;
+        }
+
+        const limit = this._limit;
+        this.orderBy('id');
+
+        let next: this | null = this.clone();
+        const base = this;
+
+        return {
+            queryCount: 0,
+            options,
+            [Symbol.asyncIterator]() {
+                return {
+                    ...this,
+
+                    // Reset the iterator
+                    queryCount: 0,
+                };
+            },
+            get isDone() {
+                return !next;
+            },
+            async next(): Promise<IteratorResult<T[], undefined>> {
+                if (!next) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+
+                if (this.options.maxQueries !== undefined && this.queryCount >= this.options.maxQueries) {
+                    // Stopping early
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+
+                const stack = await next.fetch();
+                next = null;
+                this.queryCount += 1;
+
+                if (stack.length === 0) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+
+                if (stack.length >= limit) {
+                    next = base.clone();
+                    const lastResult = stack[stack.length - 1]!;
+                    if (!('id' in lastResult)) {
+                        throw new Error('Cannot use async iterator without ID column');
+                    }
+
+                    const lastId = lastResult.id;
+                    if (typeof lastId !== 'string') {
+                        throw new Error('Cannot use async iterator without string ID column');
+                    }
+
+                    next.andWhere('id', '>', lastId);
+                }
+
+                return {
+                    done: false,
+                    value: stack,
+                };
+            },
+            maxQueries(maxQueries: number) {
+                this.options.maxQueries = maxQueries;
+                return this;
+            },
+        } as IterableSQLSelect<T[]> as any;
+    }
 }

package/src/SQLUpdate.ts

@@ -34,9 +34,15 @@ export class SQLUpdate extends Whereable(EmptyClass) implements SQLExpression {
             throw new Error('No assignments provided');
         }
 
-        options = options ?? {};
+        // Create a clone since we are mutating the default namespaces
+        const parentOptions = options;
+        options = options ? { ...options } : {};
         options.defaultNamespace = (this._table as any).namespace ?? (this._table).table ?? undefined;
 
+        if (parentOptions?.defaultNamespace) {
+            options.parentNamespace = parentOptions.defaultNamespace;
+        }
+
         const query: SQLQuery[] = [
             'UPDATE ',
             this._table.getSQL(options),