@entity-access/entity-access 1.0.233 → 1.0.235

package/src/model/EntityQuery.ts

@@ -3,7 +3,7 @@ import Logger from "../common/Logger.js";
 import { AsyncDisposableScope } from "../common/usingAsync.js";
 import { IDbReader } from "../drivers/base/BaseDriver.js";
 import EntityType from "../entity-query/EntityType.js";
-import { CallExpression, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, NewObjectExpression, NumberLiteral, OrderByExpression, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
+import { BinaryExpression, CallExpression, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, NewObjectExpression, NumberLiteral, OrderByExpression, SelectStatement, TableLiteral, UpdateStatement } from "../query/ast/Expressions.js";
 import { QueryExpander } from "../query/expander/QueryExpander.js";
 import EntityContext from "./EntityContext.js";
 import type { EntitySource } from "./EntitySource.js";
@@ -107,67 +107,119 @@ export default class EntityQuery<T = any>
         });
     }
 
-    async update(p, f): Promise<number> {
+    async delete(p, f): Promise<number> {
+        if (p || f) {
+            return this.where(p, f).delete(void 0, void 0);
+        }
 
-        let fields: Expression[];
+        const source = this.selectStatement;
+        
+        const sp = Expression.parameter("d1", this.type);
+        const as = Expression.parameter("s1", this.type);
+        let where: Expression;
+        for (const iterator of this.type.keys) {
+            const compare = Expression.equal(
+                Expression.member(sp, Expression.quotedIdentifier(iterator.columnName)),
+                Expression.member(as, Expression.quotedIdentifier(iterator.columnName))
+            );
+            where = where ? Expression.logicalAnd(where, compare) : compare;
+        }
 
-        let updateQuery = new EntityQuery({ ... this, selectStatement: {
-            ... this.selectStatement,
-            sourceParameter: {
-                ... this.selectStatement.sourceParameter
-            },
-            where: null,
-            joins: null
-        }});
+        const join = JoinExpression.create({
+            source,
+            as,
+            where
+        });
 
-        updateQuery = updateQuery.extend(p, f, (select, body) => {
-            fields = [] as Expression[];
-            switch(body.type) {
-                case "NewObjectExpression":
-                    const noe = body as NewObjectExpression;
-                    for (const iterator of noe.properties) {
-                        const column = this.type.getProperty(iterator.alias.value);
-                        fields.push(Expression.assign(
-                            Expression.quotedIdentifier(column.field.columnName),
-                            iterator.expression
-                        ));
-                    }
-                    break;
-                default:
-                    fields.push(body);
-                    break;
+        let deleteQuery = DeleteStatement.create({
+            table: this.type.fullyQualifiedName,
+            sourceParameter: sp,
+            join
+        })
 
-            }
-            return { ... select, fields };
+        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
+        let query;
+        try {
+            query = this.context.driver.compiler.compileExpression(this, deleteQuery);
+            this.traceQuery?.(query.text);
+            const r = await this.context.connection.executeQuery(query);
+            return r.updated;
+        } catch (error) {
+            session.error(`Failed executing ${query?.text}\r\n${error.stack ?? error}`);
+            throw error;
+        }
+    }
+
+    async update(p?, f?): Promise<number> {
+
+        if (p || f) {
+            return this.extend(p, f, (select, body) => {
+                const fields = [] as Expression[];
+                switch(body.type) {
+                    case "NewObjectExpression":
+                        const noe = body as NewObjectExpression;
+                        for (const iterator of noe.properties) {
+                            fields.push(ExpressionAs.create({
+                                expression: iterator.expression,
+                                alias: Expression.quotedIdentifier(iterator.alias.value)
+                            }));
+                        }
+                        break;
+                    default:
+                        fields.push(body);
+                        break;
+                }
+                return { ... select, fields };
+            }).update();
+        }
+
+        const as = Expression.parameter("s1", this.type);
+        const sp = Expression.parameter("u1", this.type);
+        const join = JoinExpression.create({
+            source: this.selectStatement,
+            as
         });
-        // q.selectStatement.updateStatement = true;
 
+        const set = [] as BinaryExpression[];
+
+        const fieldMap = new Set();
+
+        for (const iterator of this.selectStatement.fields) {
+            if(iterator.type !== "ExpressionAs") {
+                throw new Error(`Invalid expression ${iterator.type}`);
+            }
+            const eAs = iterator as ExpressionAs;
+            const { field } = this.type.getProperty(eAs.alias.value);
+            fieldMap.add(field.columnName);
+            set.push(Expression.assign( Expression.quotedIdentifier(field.columnName), Expression.member(as, Expression.quotedIdentifier(eAs.alias.value))));
+        }
 
-        updateQuery.selectStatement.updateStatement = true;
-        const lm = updateQuery.selectStatement.sourceParameter;
-        const rm = this.selectStatement.sourceParameter;
-        let where = this.selectStatement.where ? { ... this.selectStatement.where }: null;
+        let where = null as Expression;
         for (const iterator of this.type.keys) {
             const compare = Expression.equal(
-                Expression.member(lm, Expression.quotedIdentifier(iterator.columnName)),
-                Expression.member(rm, Expression.quotedIdentifier(iterator.columnName))
+                Expression.member(as, Expression.quotedIdentifier(iterator.columnName)),
+                Expression.member(sp, Expression.quotedIdentifier(iterator.columnName))
             );
             where = where ? Expression.logicalAnd(where, compare) : compare;
+            if (fieldMap.has(iterator.columnName)) {
+                continue;
+            }
+            this.selectStatement.fields.push( Expression.member( this.selectStatement.sourceParameter, Expression.quotedIdentifier(iterator.columnName)));
         }
-        fields = [NumberLiteral.one];
-        const target = {
-            ... this.selectStatement,
-            fields,
+
+        const updateStatement = UpdateStatement.create({
+            set,
+            sourceParameter: sp,
+            table: this.type.fullyQualifiedName,
+            model: this.type,
             where,
-        };
-        updateQuery.selectStatement.where = ExistsExpression.create({
-            target
+            join
         });
 
         const session = this.context.logger?.newSession() ?? Logger.nullLogger;
         let query;
         try {
-            query = this.context.driver.compiler.compileExpression(updateQuery, updateQuery.selectStatement);
+            query = this.context.driver.compiler.compileExpression(this, updateStatement);
             this.traceQuery?.(query.text);
             const r = await this.context.connection.executeQuery(query);
             return r.updated;

package/src/model/IFilterWithParameter.ts

@@ -38,6 +38,13 @@ export interface IBaseQuery<T> {
 
     update<P>(parameters: P, fx: (p: P) => (x:T) => Partial<T>): Promise<number>;
 
+    /**
+     * Warning !! Be careful, this will delete rows from the database and neither soft delete nor any other events will be invoked.
+     * @param parameters parameters to supply
+     * @param fx filter expression
+     */
+    delete<P>(parameters: P, fx: (p: P) => (x: T) => boolean): Promise<number>;
+
     trace<DT>(this: DT, tracer: (text: string) => void): DT;
 
     /**

package/src/query/ast/ExpressionToSql.ts

@@ -90,20 +90,6 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const fields = this.visitArray(e.fields, ",\n\t\t");
         const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins, "\n")}` : [];
 
-        if (e.updateStatement) {
-            const s = e.source;
-            switch(s.type) {
-                case "Identifier":
-                case "TableLiteral":
-                    break;
-                default:
-                    throw new Error(`${s.type} Not supported`);
-            }
-            return prepare `UPDATE ${source}${as} SET
-                ${fields}
-            ${where}${orderBy}${limit}${offset}`;
-        }
-
         return prepare `SELECT
         ${fields}
         FROM ${source}${as}${joins}${where}${orderBy}${limit}${offset}`;
@@ -520,6 +506,19 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
         const table = this.visit(e.table);
 
+        if (e.join) {
+            this.scope.create({ parameter: e.sourceParameter, model: e.sourceParameter.model });
+            const as = e.join.as as ParameterExpression;
+            this.scope.create({ parameter: as, model: as.model });
+            const join = this.visit(e.join.source);
+            const where = this.visit(e.where);
+            const joinName = this.scope.nameOf(as);
+            const asName = this.scope.nameOf(e.sourceParameter);
+            const set = this.visitArray(e.set, ",");
+            return prepare `WITH ${joinName} as (${join}) UPDATE ${table} ${asName} SET ${set} FROM ${joinName} WHERE ${where}`;
+
+        }
+
         const where = this.visit(e.where);
 
         const set = this.visitArray(e.set);
@@ -642,6 +641,17 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
     visitDeleteStatement(e: DeleteStatement): ITextQuery {
         const table = this.visit(e.table);
+        if (e.join) {
+            this.scope.create({ parameter: e.sourceParameter, model: e.sourceParameter.model });
+            const as = e.join.as as ParameterExpression;
+            this.scope.create({ parameter: as, model: as.model });
+            const join = this.visit(e.join.source);
+            const where = this.visit(e.join.where);
+            const joinName = this.scope.nameOf(as);
+            const asName = this.scope.nameOf(e.sourceParameter);
+            return prepare `WITH ${joinName} as (${join}) DELETE FROM ${table} as ${asName} USING ${joinName} WHERE ${where}`;
+        }
+
         const where = this.visit(e.where);
         return prepare `DELETE FROM ${table} WHERE ${where}`;
     }
@@ -699,6 +709,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const target = this.resolveExpression(me.target);
         if (target.type === "ParameterExpression" && me.property.type === "Identifier") {
             const id = me.property as Identifier;
+            if (id.quoted) {
+                return;
+            }
             const pe = target as ParameterExpression;
             const scope = this.scope.get(pe);
             const peModel = scope?.model;
@@ -770,6 +783,10 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
         const resolved = this.resolveExpression(x);
 
+        if (!resolved) {
+            return;
+        }
+
         if (resolved.type === "MemberExpression") {
             x = resolved;
         }

package/src/query/ast/Expressions.ts

@@ -257,8 +257,6 @@ export class SelectStatement extends Expression {
 
     preferLeftJoins: boolean;
 
-    updateStatement: boolean;
-
     source: TableSource | ValuesStatement;
 
     sourceParameter: ParameterExpression;
@@ -409,13 +407,15 @@ export class UpdateStatement extends Expression {
 
     readonly type = "UpdateStatement";
 
-    table: TableLiteral | Identifier;
+    table: TableSource;
+    sourceParameter: ParameterExpression;
+    model: EntityType;
 
     set: BinaryExpression[];
 
     where: Expression;
 
-    joins: JoinExpression[];
+    join: JoinExpression;
 
 }
 
@@ -435,8 +435,12 @@ export class UnionAllStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral | Identifier;
+    table: TableSource;
+    model: EntityType;
     where: Expression;
+
+    sourceParameter: ParameterExpression;
+    join: JoinExpression;
 }
 
 export type ExpressionType =

package/src/tests/db-tests/tests/delete-items.ts

@@ -0,0 +1,42 @@
+import assert from "assert";
+import { Sql } from "../../../index.js";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const first = await context.products.all().first();
+
+    first.name = "First product";
+
+    await context.saveChanges();
+
+    let total = await context.products.all().count();
+
+    let n = await context.products.all()
+        .delete(void 0, (p) => (x) => x.productID === 1);
+
+    assert.equal(n, 1);
+
+    let after = await context.products.all().count();
+
+    assert.equal(total - 1, after);
+
+    total = await context.products.all().count();
+    n = await context.products.all()
+        .limit(1)
+        .delete(void 0, (p) => (x) => true === true);
+
+    assert.equal(n, 1);
+
+    after = await context.products.all().count();
+
+    assert.equal(total - 1, after);
+
+}

package/src/tests/db-tests/tests/update-items.ts

@@ -20,11 +20,25 @@ export default async function(this: TestConfig) {
 
     await context.products
         .where(void 0, (p) => (x) => x.productID > 1)
+        // .trace(console.log)
         .update(void 0, (p) => (x) => ({
             productDescription: "updated"
         }));
 
     // we must verify that productID's description should not have changed...
-    const p1 = await context.products.where(void 0, (p) => (x) => x.productID === 1).first();
+    let p1 = await context.products.where(void 0, (p) => (x) => x.productID === 1).first();
     assert.notStrictEqual("updated", p1.productDescription);
+
+    const n = await context.products
+        .where(void 0, (p) => (x) => true === true)
+        .limit(1)
+        // .trace(console.log)
+        .update(void 0, (p) => (x) => ({
+            productDescription: "x"
+        }));
+
+    assert.equal(n, 1);
+
+    p1 = await context.products.where(void 0, (p) => (x) => x.productID === 1).first();
+    assert.strictEqual("x", p1.productDescription);
 }