@stamhoofd/sql 2.83.5 → 2.84.1

package/src/SQLSelect.ts

@@ -1,22 +1,19 @@
 import { Database, SQLResultNamespacedRow } from '@simonbackx/simple-database';
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression';
+import { Formatter } from '@stamhoofd/utility';
+import { SQLExpression, SQLExpressionOptions, SQLNamedExpression, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression';
 import { SQLAlias, SQLColumnExpression, SQLCount, SQLSelectAs, SQLSum, SQLTableExpression } from './SQLExpressions';
 import { SQLJoin } from './SQLJoin';
 import { Orderable } from './SQLOrderBy';
 import { Whereable } from './SQLWhere';
-import { Formatter } from '@stamhoofd/utility';
 
 class EmptyClass {}
 
-export function parseTable(tableOrExpressiongOrNamespace: SQLExpression | string, table?: string): SQLExpression {
-    if (table !== undefined && typeof tableOrExpressiongOrNamespace === 'string') {
-        return new SQLTableExpression(tableOrExpressiongOrNamespace, table);
-    }
-    else if (typeof tableOrExpressiongOrNamespace === 'string') {
-        return new SQLTableExpression(tableOrExpressiongOrNamespace);
+export function parseTable(tableOrExpression: SQLNamedExpression | string, asNamespace?: string): SQLNamedExpression {
+    if (typeof tableOrExpression === 'string') {
+        return new SQLTableExpression(tableOrExpression, asNamespace);
     }
     else {
-        return tableOrExpressiongOrNamespace;
+        return tableOrExpression;
     }
 }
 
@@ -34,7 +31,7 @@ export type IterableSQLSelectOptions = {
 
 export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Whereable(Orderable(EmptyClass)) implements SQLExpression {
     _columns: SQLExpression[];
-    _from: SQLExpression;
+    _from: SQLNamedExpression;
 
     _limit: number | null = null;
     _offset: number | null = null;
@@ -63,8 +60,8 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
 
     from(namespace: string, table: string): this;
     from(table: string): this;
-    from(expression: SQLExpression): this;
-    from(tableOrExpressiongOrNamespace: SQLExpression | string, table?: string): this {
+    from(expression: SQLNamedExpression): this;
+    from(tableOrExpressiongOrNamespace: SQLNamedExpression | string, table?: string): this {
         this._from = parseTable(tableOrExpressiongOrNamespace, table);
 
         return this;
@@ -102,7 +99,7 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
         // 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;
+        options.defaultNamespace = this._from.getName();
 
         if (parentOptions?.defaultNamespace) {
             options.parentNamespace = parentOptions.defaultNamespace;
@@ -128,8 +125,14 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
 
         // Where
         if (this._where) {
-            query.push('WHERE');
-            query.push(this._where.getSQL(options));
+            const always = this._where.isAlways;
+            if (always === false) {
+                throw new Error('Cannot use SQLSelect with a where that is not always true');
+            }
+            else if (always === null) {
+                query.push('WHERE');
+                query.push(this._where.getSQL(options));
+            }
         }
 
         if (this._groupBy.length > 0) {
@@ -156,6 +159,15 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
         return joinSQLQuery(query, ' ');
     }
 
+    /**
+     * Returns true when it know all results will be included without filtering.
+     * Returns false when it knows no single result will be included.
+     * Null when it does not know.
+     */
+    get isAlways() {
+        return this._where ? this._where.isAlways : true;
+    }
+
     limit(limit: number | null, offset: number | null = null): this {
         this._limit = limit;
         this._offset = offset;
@@ -163,6 +175,10 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
     }
 
     async fetch(): Promise<T[]> {
+        if (this._where && this._where.isAlways === false) {
+            return [];
+        }
+
         const { query, params } = normalizeSQLQuery(this.getSQL());
 
         // when debugging: log all queries

package/src/SQLWhere.ts

@@ -1,6 +1,7 @@
 import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression';
 import { SQLArray, SQLColumnExpression, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from './SQLExpressions';
-import { SQLJoin } from './SQLJoin';
+import { SQLJoin, SQLJoinType } from './SQLJoin';
+import { SQLSelect } from './SQLSelect';
 
 type Constructor<T = {}> = new (...args: any[]) => T;
 
@@ -121,6 +122,18 @@ export abstract class SQLWhere implements SQLExpression {
         return false;
     }
 
+    get isAlways(): boolean | null {
+        return null;
+    }
+
+    get isAlwaysTrue(): boolean {
+        return this.isAlways === true;
+    }
+
+    get isAlwaysFalse(): boolean {
+        return this.isAlways === false;
+    }
+
     abstract getSQL(options?: SQLExpressionOptions): SQLQuery;
     getJoins(): SQLJoin[] {
         return [];
@@ -151,12 +164,17 @@ export class SQLEmptyWhere extends SQLWhere {
     getSQL(options?: SQLExpressionOptions): SQLQuery {
         throw new Error('Empty where');
     }
+
+    get isAlways() {
+        return true;
+    }
 }
 
 export class SQLWhereEqual extends SQLWhere {
     column: SQLExpression;
     sign = SQLWhereSign.Equal;
     value: SQLExpression;
+    nullable = false;
 
     static parseWhere(...parsed: ParseWhereArguments): SQLWhere {
         if (parsed[1] === undefined) {
@@ -199,7 +217,11 @@ export class SQLWhereEqual extends SQLWhere {
     }
 
     get isSingle(): boolean {
-        return true;
+        return this.transformed?.isSingle ?? true;
+    }
+
+    get isAlways(): boolean | null {
+        return this.transformed?.isAlways ?? null;
     }
 
     inverted(): this {
@@ -230,7 +252,55 @@ export class SQLWhereEqual extends SQLWhere {
         return this;
     }
 
+    setNullable(nullable: boolean = true): this {
+        this.nullable = nullable;
+        return this;
+    }
+
+    get transformed() {
+        if (this.value instanceof SQLNull) {
+            // We'll do some transformations to make this query work as expected.
+            // < null = always false
+            // > null = (IS NOT null)
+            // <= null = (IS null)
+            // >= null = always true
+            if (this.sign === SQLWhereSign.Less) {
+                // always false
+                return new SQLWhereOr([]);
+            }
+            if (this.sign === SQLWhereSign.Greater) {
+                // > null = (IS NOT null)
+                return new SQLWhereEqual(this.column, SQLWhereSign.NotEqual, this.value);
+            }
+            if (this.sign === SQLWhereSign.LessEqual) {
+                // (IS null)
+                return new SQLWhereEqual(this.column, SQLWhereSign.Equal, this.value);
+            }
+            if (this.sign === SQLWhereSign.GreaterEqual) {
+                // always true
+                return new SQLWhereAnd([]);
+            }
+        }
+
+        // If the expression is nullable, we'll need to do some handling to make sure the query works as expected.
+        if (this.nullable && !(this.value instanceof SQLNull)) {
+            // <: should also include null values
+            // <=: should also include null values
+            if (this.sign === SQLWhereSign.Less || this.sign === SQLWhereSign.LessEqual) {
+                return new SQLWhereOr([
+                    this.clone().setNullable(false),
+                    new SQLWhereEqual(this.column, SQLWhereSign.Equal, new SQLNull()),
+                ]);
+            }
+        }
+
+        return null;
+    }
+
     getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (this.transformed) {
+            return this.transformed.getSQL(options);
+        }
         if (this.value instanceof SQLArray) {
             if (this.sign !== SQLWhereSign.Equal && this.sign !== SQLWhereSign.NotEqual) {
                 throw new Error('Unsupported sign for array: ' + this.sign);
@@ -250,7 +320,7 @@ export class SQLWhereEqual extends SQLWhere {
 
             return joinSQLQuery([
                 this.column.getSQL(options),
-                ` IS ${(this.sign === SQLWhereSign.NotEqual) ? 'NOT ' : ''} `,
+                ` IS ${(this.sign === SQLWhereSign.NotEqual) ? 'NOT ' : ''}`,
                 this.value.getSQL(options),
             ]);
         }
@@ -275,7 +345,7 @@ export class SQLWhereLike extends SQLWhere {
     }
 
     static escape(str: string) {
-        return str.replace(/([%_])/g, '\\$1');
+        return str.replace(/([%_\\])/g, '\\$1');
     }
 
     clone(): this {
@@ -385,6 +455,24 @@ export class SQLWhereExists extends SQLWhere {
         return this;
     }
 
+    get isAlways(): boolean | null {
+        if (this.subquery instanceof SQLSelect) {
+            const value = this.subquery.isAlways;
+            if (this.notExists) {
+                if (value === true) {
+                    // If the subquery is always true, then NOT EXISTS is always false
+                    return false;
+                }
+                if (value === false) {
+                    // If the subquery is always false, then NOT EXISTS is always true
+                    return true;
+                }
+            }
+            return value;
+        }
+        return null;
+    }
+
     getSQL(options?: SQLExpressionOptions): SQLQuery {
         return joinSQLQuery([
             `${this.notExists ? 'NOT EXISTS' : 'EXISTS'} (`,
@@ -401,22 +489,45 @@ export class SQLWhereJoin extends SQLWhere {
     join: SQLJoin;
     where: SQLWhere;
 
-    constructor(join: SQLJoin, where: SQLWhere) {
+    /**
+     * When this is true, this means we know this relation will always exist.
+     *
+     * This information will be used to optimize the query.
+     */
+    doesRelationAlwaysExist = false;
+
+    constructor(join: SQLJoin, where: SQLWhere, options?: { doesRelationAlwaysExist?: boolean }) {
         super();
         this.join = join;
         this.where = where;
+        this.doesRelationAlwaysExist = options?.doesRelationAlwaysExist ?? false;
     }
 
     get isSingle(): boolean {
         return this.where.isSingle;
     }
 
+    get isAlways(): boolean | null {
+        return this.where.isAlways;
+    }
+
     getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return this.where.getSQL(options);
+        if (this.where.isAlways !== null && (this.doesRelationAlwaysExist || this.join.type === SQLJoinType.Left)) {
+            throw new Error('SQLWhereJoin: should not be included in query if result is determined');
+        }
+
+        return this.where.getSQL({
+            ...options,
+            parentNamespace: options?.defaultNamespace,
+            defaultNamespace: this.join.table.getName(),
+        });
     }
 
     getJoins(): SQLJoin[] {
-        return [this.join];
+        if (this.where.isAlways !== null && (this.doesRelationAlwaysExist || this.join.type === SQLJoinType.Left)) {
+            return [];
+        }
+        return [this.join, ...this.where.getJoins()];
     }
 }
 
@@ -429,9 +540,13 @@ export class SQLWhereAnd extends SQLWhere {
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (this.isAlways === false) {
+            throw new Error('SQLWhereAnd: $and is always false and should be removed from the query');
+        }
+
         return joinSQLQuery(
-            this.children.map((c) => {
-                if (c.isSingle) {
+            this.filteredChildren.map((c) => {
+                if (c.isSingle || this.filteredChildren.length === 1) {
                     return c.getSQL(options);
                 }
                 return joinSQLQuery(['(', c.getSQL(options), ')']);
@@ -440,8 +555,38 @@ export class SQLWhereAnd extends SQLWhere {
         );
     }
 
+    get filteredChildren(): SQLWhere[] {
+        // Children that always return true should not be included in the query (because the result only depends on the other children)
+        return this.children.filter(c => c.isAlways !== true).flatMap(c => c instanceof SQLWhereAnd ? c.filteredChildren : [c]);
+    }
+
     getJoins(): SQLJoin[] {
-        return this.children.flatMap(c => c.getJoins());
+        return this.children.flatMap(c => c.getJoins()); // note: keep all joins
+    }
+
+    get isSingle(): boolean {
+        return this.filteredChildren.length === 1 && this.filteredChildren[0].isSingle;
+    }
+
+    get isAlways(): boolean | null {
+        let allTrue = true;
+        for (const c of this.children) {
+            const v = c.isAlways;
+            if (v === false) {
+                // If any child is always false, the whole AND is false
+                return false;
+            }
+            if (v === null) {
+                allTrue = false;
+            }
+        }
+
+        return allTrue ? true : null;
+    }
+
+    inverted(): SQLWhereOr {
+        // NOT (A AND B) is the same as (NOT A OR NOT B)
+        return new SQLWhereOr(this.children.map(c => new SQLWhereNot(c)));
     }
 }
 
@@ -454,9 +599,14 @@ export class SQLWhereOr extends SQLWhere {
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (this.filteredChildren.length === 0) {
+            // Always false: throw an error (the parent should filter out this query)
+            throw new Error('SQLWhereOr: empty $or is always false and should be removed from the query');
+        }
+
         return joinSQLQuery(
-            this.children.map((c) => {
-                if (c.isSingle) {
+            this.filteredChildren.map((c) => {
+                if (c.isSingle || this.filteredChildren.length === 1) {
                     return c.getSQL(options);
                 }
                 return joinSQLQuery(['(', c.getSQL(options), ')']);
@@ -468,6 +618,36 @@ export class SQLWhereOr extends SQLWhere {
     getJoins(): SQLJoin[] {
         return this.children.flatMap(c => c.getJoins());
     }
+
+    get filteredChildren(): SQLWhere[] {
+        // Children that always return false should not be included in the query (because the result only depends on the other children)
+        return this.children.filter(c => c.isAlways !== false).flatMap(c => c instanceof SQLWhereOr ? c.filteredChildren : [c]);
+    }
+
+    get isSingle(): boolean {
+        return this.filteredChildren.length === 1 && this.filteredChildren[0].isSingle;
+    }
+
+    get isAlways(): boolean | null {
+        let isAllFalse = true;
+        for (const c of this.children) {
+            const v = c.isAlways;
+            if (v === true) {
+                // If any child is always true, the whole OR is true
+                return true;
+            }
+            if (v === null) {
+                isAllFalse = false;
+            }
+        }
+
+        return isAllFalse ? false : null;
+    }
+
+    inverted(): SQLWhereOr {
+        // NOT (A OR B) is the same as (NOT A AND NOT B)
+        return new SQLWhereAnd(this.children.map(c => new SQLWhereNot(c)));
+    }
 }
 
 export class SQLWhereNot extends SQLWhere {
@@ -484,7 +664,7 @@ export class SQLWhereNot extends SQLWhere {
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
         // Optimize query
-        if (this.a instanceof SQLWhereEqual) {
+        if (this.a instanceof SQLWhereEqual || this.a instanceof SQLWhereAnd || this.a instanceof SQLWhereOr || this.a instanceof SQLWhereNot) {
             return this.a.inverted().getSQL(options);
         }
 
@@ -499,4 +679,19 @@ export class SQLWhereNot extends SQLWhere {
     getJoins(): SQLJoin[] {
         return this.a.getJoins();
     }
+
+    get isAlways(): boolean | null {
+        const v = this.a.isAlways;
+        if (v === true) {
+            return false;
+        }
+        if (v === false) {
+            return true;
+        }
+        return null;
+    }
+
+    inverted(): SQLWhere {
+        return this.a; // NOT NOT A is just A
+    }
 }

package/src/filters/SQLFilter.ts

@@ -137,6 +137,14 @@ export function createSQLRelationFilterCompiler(baseSelect: InstanceType<typeof
     };
 }
 
+export function createSQLOneToOneRelationFilterCompiler(baseSelect: InstanceType<typeof SQLSelect> & SQLExpression, definitions: SQLFilterDefinitions): SQLFilterCompiler {
+    return async (filter: StamhoofdFilter) => {
+        const w = await compileToSQLFilter(filter, definitions);
+        const q = baseSelect.clone().where(w);
+        return new SQLWhereExists(q);
+    };
+}
+
 // Already joined, but creates a namespace
 export function createSQLFilterNamespace(definitions: SQLFilterDefinitions): SQLFilterCompiler {
     return (filter: StamhoofdFilter) => {