taon-type-sql 21.0.21 → 21.0.22

package/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/browser",
-  "version": "21.0.21",
+  "version": "21.0.22",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/browser-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/browser-prod",
-  "version": "21.0.21",
+  "version": "21.0.22",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib/build-info._auto-generated_.d.ts

@@ -21,4 +21,4 @@ export declare const CURRENT_PACKAGE_TAON_VERSION = "v21";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "21.0.21";
+export declare const CURRENT_PACKAGE_VERSION = "21.0.22";

package/lib/build-info._auto-generated_.js

@@ -25,6 +25,6 @@ exports.CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-exports.CURRENT_PACKAGE_VERSION = '21.0.21';
+exports.CURRENT_PACKAGE_VERSION = '21.0.22';
 // THIS FILE IS GENERATED - DO NOT MODIFY
 //# sourceMappingURL=build-info._auto-generated_.js.map

package/lib/package.json

@@ -1,4 +1,4 @@
 {
   "name": "taon-type-sql/lib",
-  "version": "21.0.21"
+  "version": "21.0.22"
 }

package/lib-prod/build-info._auto-generated_.ts

@@ -0,0 +1,27 @@
+// THIS FILE IS GENERATED - DO NOT MODIFY
+/**
+ *  Autogenerated by current cli tool
+ */
+export const BUILD_FRAMEWORK_CLI_NAME = 'tnp';
+/**
+ *  This value can be change in taon.jsonc (appId)
+ */
+export const APP_ID = 'com.domain.example.taon-type-sql';
+/**
+ *  Autogenerated by current cli tool
+ */
+export const BUILD_BASE_HREF = '';
+/**
+ *  This value can be change in taon.jsonc (overrideNpmName)
+ */
+export const PROJECT_NPM_NAME = 'taon-type-sql';
+/**
+ * Taon version from you project taon.json
+ */
+export const CURRENT_PACKAGE_TAON_VERSION = 'v21';
+/**
+ *  Autogenerated by current cli tool. Use *tnp release* to bump version.
+ */
+export const CURRENT_PACKAGE_VERSION = '21.0.22';
+// THIS FILE IS GENERATED - DO NOT MODIFY
+      

package/lib-prod/builder/column/basic-column.ts

@@ -0,0 +1,17 @@
+import QueryTable from "../query-table";
+import QueryColumn from "./query-column";
+import NumberColumn from "./number-column";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+// This file is only needed because the QueryColumn can't implement its count method b. of circular dependencies
+
+export default class BasicColumn<Table extends QueryTable<any, any>, T> extends QueryColumn<Table, T> {
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    count(): NumberColumn<Table> {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}

package/lib-prod/builder/column/boolean-column.ts

@@ -0,0 +1,19 @@
+import QueryTable from "../query-table";
+import NumberColumn from "./number-column";
+import ValueColumn from "./value-column";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+export default class BooleanColumn<Table extends QueryTable<any, any>> extends ValueColumn<Table, boolean> {
+
+    protected _type = 'boolean';
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    count(): NumberColumn<Table> {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+
+}

package/lib-prod/builder/column/comparable-column.ts

@@ -0,0 +1,56 @@
+import QueryColumnCondition from "../condition/query-column-condition";
+import QueryTable from "../query-table";
+import ValueColumn from "./value-column";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+abstract class ComparableColumn<Table extends QueryTable<any, any>, T> extends ValueColumn<Table, T> {
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    lt(value: T) {
+        return new QueryColumnCondition<Table, T>(this, 'lt', value);
+    }
+
+    gt(value: T) {
+        return new QueryColumnCondition<Table, T>(this, 'gt', value);
+    }
+
+    lte(value: T) {
+        return new QueryColumnCondition<Table, T>(this, 'lte', value);
+    }
+
+    gte(value: T) {
+        return new QueryColumnCondition<Table, T>(this, 'gte', value);
+    }
+
+    in(values: T[]) {
+        return new QueryColumnCondition<Table, T>(this, 'in', ...values);
+    }
+
+    notIn(values: T[]) {
+        return new QueryColumnCondition<Table, T>(this, 'not-in', ...values);
+    }
+
+    between(value1: T, value2: T) {
+        return new QueryColumnCondition<Table, T>(this, 'between', value1, value2);
+    }
+
+    notBetween(value1: T, value2: T) {
+        return new QueryColumnCondition<Table, T>(this, 'not-between', value1, value2);
+    }
+
+    // min/max exists for text columns too, not just numeric and date
+
+    min(): this {
+        return new (<any>this.constructor)(this._table, this._name, this._modifiers.concat({ name: 'min' }));
+    }
+
+    max(): this {
+        return new (<any>this.constructor)(this._table, this._name, this._modifiers.concat({ name: 'max' }));
+    }
+}
+
+export default ComparableColumn;

package/lib-prod/builder/column/date-column.ts

@@ -0,0 +1,19 @@
+import QueryTable from "../query-table";
+import ComparableColumn from "./comparable-column";
+import NumberColumn from "./number-column";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+export default class DateColumn<Table extends QueryTable<any, any>> extends ComparableColumn<Table, Date> {
+
+    protected _type = 'date';
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    count(): NumberColumn<Table> {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+
+}

package/lib-prod/builder/column/number-column.ts

@@ -0,0 +1,25 @@
+import QueryTable from "../query-table";
+import ComparableColumn from "./comparable-column";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+export default class NumberColumn<Table extends QueryTable<any, any>> extends ComparableColumn<Table, number> {
+
+    protected _type = 'number';
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    count(): NumberColumn<Table> {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+
+    sum(): NumberColumn<Table> {
+        return new NumberColumn<Table>(this._table, this._name, this._modifiers.concat({ name: 'sum' }));
+    }
+
+    avg(): NumberColumn<Table> {
+        return new NumberColumn<Table>(this._table, this._name, this._modifiers.concat({ name: 'avg' }));
+    }
+}

package/lib-prod/builder/column/query-column.ts

@@ -0,0 +1,34 @@
+import QueryTable from "../query-table";
+import NumberColumn from "./number-column";
+import GenericsHelper from "../helpers/generics-helper";
+import QueryColumnCondition from "../condition/query-column-condition";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+abstract class QueryColumn<Table extends QueryTable<any, any>, T> {
+
+    protected _$type: GenericsHelper<T>;
+    protected _type: string;
+
+    constructor(
+        protected _table: Table,
+        protected _name: ColumnName,
+        protected _modifiers: ColumnModifier[] = []
+    ) {}
+
+    abstract count(): NumberColumn<Table>; // TODO I had to copy-paste the implementation to every child class to avoid a circular dependency
+
+    as(alias: string): this {
+        return new (<any>this.constructor)(this._table, this._name, this._modifiers.concat({ name: 'as', params: alias }));
+    }
+
+    isNull() {
+        return new QueryColumnCondition<Table, T>(this, 'is-null');
+    }
+
+    isNotNull() {
+        return new QueryColumnCondition<Table, T>(this, 'is-not-null');
+    }
+}
+
+export default QueryColumn;

package/lib-prod/builder/column/string-column.ts

@@ -0,0 +1,47 @@
+import QueryTable from "../query-table";
+import ComparableColumn from "./comparable-column";
+import NumberColumn from "./number-column";
+import QueryColumnCondition from "../condition/query-column-condition";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+export default class StringColumn<Table extends QueryTable<any, any>> extends ComparableColumn<Table, string> {
+
+    protected _type = 'string';
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    count(): NumberColumn<Table> {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+
+    lower(): this {
+        return new (<any>this.constructor)(this._table, this._name, this._modifiers.concat({ name: 'lower' }));
+    }
+
+    upper(): this {
+        return new (<any>this.constructor)(this._table, this._name, this._modifiers.concat({ name: 'upper' }));
+    }
+
+    contains(value: string) {
+        return this.like('%' + value + '%');
+    }
+
+    startsWith(value: string) {
+        return this.like(value + '%');
+    }
+
+    endsWith(value: string) {
+        return this.like('%' + value);
+    }
+
+    like(value: string) {
+        return new QueryColumnCondition<Table, string>(this, 'like', value);
+    }
+
+    notLike(value: string) {
+        return new QueryColumnCondition<Table, string>(this, 'not-like', value);
+    }
+}

package/lib-prod/builder/column/value-column.ts

@@ -0,0 +1,39 @@
+import QueryColumnCondition from "../condition/query-column-condition";
+import QueryOrdering from "../other/query-ordering";
+import QueryTable from "../query-table";
+import QueryColumn from "./query-column";
+import QueryCondition from "../condition/query-condition";
+import QueryJoinCondition from "../condition/query-join-condition";
+import {ColumnModifier, ColumnName} from "../helpers/internal-types";
+
+
+abstract class ValueColumn<Table extends QueryTable<any, any>, T> extends QueryColumn<Table, T> {
+
+    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+        super(table, name, modifiers);
+    }
+
+    asc() {
+        return new QueryOrdering<Table>(this, 'ASC');
+    }
+
+    desc() {
+        return new QueryOrdering<Table>(this, 'DESC');
+    }
+
+    eq<Table2 extends QueryTable<any, any>>(value: QueryColumn<Table2, T>): QueryJoinCondition<Table, Table2, T>;
+    eq(value: T): QueryColumnCondition<Table, T>;
+    eq<Table2 extends QueryTable<any, any>>(value: any): QueryCondition<any> {
+        if (value instanceof QueryColumn) {
+            return new QueryJoinCondition<Table, Table2, T>(this, 'eq', value);
+        } else {
+            return new QueryColumnCondition<Table, T>(this, 'eq', value);
+        }
+    }
+
+    ne(value: T) {
+        return new QueryColumnCondition<Table, T>(this, 'ne', value);
+    }
+}
+
+export default ValueColumn;

package/lib-prod/builder/condition/{query-column-condition.d.ts → query-column-condition.ts}

@@ -2,12 +2,27 @@ import QueryColumn from "../column/query-column";
 import QueryTable from "../query-table";
 import QueryCondition from "./query-condition";
 import QueryConditionChain from "./query-condition-chain";
-import { ConditionType } from "../helpers/internal-types";
+import {ConditionType} from "../helpers/internal-types";
+
+
 export default class QueryColumnCondition<Table extends QueryTable<any, any>, T> extends QueryCondition<Table> {
+
     protected _column: QueryColumn<Table, T>;
     protected _type: ConditionType;
     protected _values: T[];
-    constructor(column: QueryColumn<Table, T>, type: ConditionType, ...values: T[]);
-    and<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>;
-    or<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>;
-}
+
+    constructor(column: QueryColumn<Table, T>, type: ConditionType, ...values: T[]) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._values = values;
+    }
+
+    and<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2> {
+        return new QueryConditionChain<Table | Table2>(this, condition, 'and');
+    }
+
+    or<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2> {
+        return new QueryConditionChain<Table | Table2>(this, condition, 'or');
+    }
+}

package/lib-prod/builder/condition/query-condition-chain.ts

@@ -0,0 +1,42 @@
+import QueryTable from "../query-table";
+import QueryCondition from "./query-condition";
+import GenericsHelper from "../helpers/generics-helper";
+import {ConditionChainType} from "../helpers/internal-types";
+
+
+export default class QueryConditionChain<Table extends QueryTable<any, any>> extends QueryCondition<Table> {
+
+    protected _$type: GenericsHelper<Table>;
+
+    protected _sibling: QueryCondition<any>;
+    protected _child: QueryCondition<any>;
+    protected _chainType: ConditionChainType;
+    protected _parenthesis = false;
+    protected _negation = false;
+
+    constructor(sibling: QueryCondition<any>, child: QueryCondition<any>, chainType: ConditionChainType) {
+        super();
+        this._sibling = sibling;
+        this._child = child;
+        this._chainType = chainType;
+    }
+
+    // TODO how to call this
+    $() {
+        this._parenthesis = true;
+        return this;
+    }
+
+    not() {
+        this._negation = true;
+        return this;
+    }
+
+    and<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>  {
+        return new QueryConditionChain<Table | Table2>(this, condition, 'and');
+    }
+
+    or<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>  {
+        return new QueryConditionChain<Table | Table2>(this, condition, 'or');
+    }
+}

package/lib-prod/builder/condition/{query-condition.d.ts → query-condition.ts}

@@ -1,7 +1,13 @@
 import QueryTable from "../query-table";
 import QueryConditionChain from "./query-condition-chain";
-declare abstract class QueryCondition<Table extends QueryTable<any, any>> {
+
+// TODO I had to copy-paste the method implementations to every child class to avoid circular dependencies
+
+abstract class QueryCondition<Table extends QueryTable<any, any>> {
+
     abstract and<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>;
+
     abstract or<Table2 extends QueryTable<any, any>>(condition: QueryCondition<Table2>): QueryConditionChain<Table | Table2>;
 }
-export default QueryCondition;
+
+export default QueryCondition;

package/lib-prod/builder/condition/{query-join-condition.d.ts → query-join-condition.ts}

@@ -2,11 +2,26 @@ import QueryColumn from "../column/query-column";
 import QueryTable from "../query-table";
 import QueryCondition from "./query-condition";
 import QueryConditionChain from "./query-condition-chain";
+
+
 export default class QueryJoinCondition<Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>, T> extends QueryCondition<Table1 | Table2> {
+
     protected _column: QueryColumn<Table1, T>;
     protected _type: string;
     protected _otherColumn: QueryColumn<Table2, T>;
-    constructor(column: QueryColumn<Table1, T>, type: string, otherColumn: QueryColumn<Table2, T>);
-    and<Table3 extends QueryTable<any, any>>(condition: QueryCondition<Table3>): QueryConditionChain<Table1 | Table2 | Table3>;
-    or<Table3 extends QueryTable<any, any>>(condition: QueryCondition<Table3>): QueryConditionChain<Table1 | Table2 | Table3>;
-}
+
+    constructor(column: QueryColumn<Table1, T>, type: string, otherColumn: QueryColumn<Table2, T>) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._otherColumn = otherColumn;
+    }
+
+    and<Table3 extends QueryTable<any, any>>(condition: QueryCondition<Table3>): QueryConditionChain<Table1 | Table2 | Table3>  {
+        return new QueryConditionChain<Table1 | Table2 | Table3>(this, condition, 'and');
+    }
+
+    or<Table3 extends QueryTable<any, any>>(condition: QueryCondition<Table3>): QueryConditionChain<Table1 | Table2 | Table3>  {
+        return new QueryConditionChain<Table1 | Table2 | Table3>(this, condition, 'or');
+    }
+}

package/lib-prod/builder/helpers/generics-helper.ts

@@ -0,0 +1,2 @@
+// TODO In TS generic parameters not used in the class are not enforced, so I have to add dummy fields that use them. Replace with nominal typing
+export default class GenericsHelper<T> {}

package/lib-prod/builder/helpers/{internal-types.d.ts → internal-types.ts}

@@ -1,15 +1,31 @@
+// query:
+
 export type QueryAction = 'select' | 'insert' | 'update' | 'delete';
+
+// columns:
+
 export type ColumnModifierType = 'as' | 'count' | 'min' | 'min' | 'max' | 'sum' | 'avg' | 'lower' | 'upper';
+
 export interface ColumnModifier {
-    name: ColumnModifierType;
-    params?: any;
+    name: ColumnModifierType,
+    params?: any
 }
-export type ColumnName = string | {
-    name: string;
-    alias: string;
-};
-export type ColumnType = 'boolean' | 'number' | 'string' | 'date';
+
+export type ColumnName = string | { name: string, alias: string };
+
+export type ColumnType = 'boolean' | 'number' | 'string' | 'date'; // FIXME use this in the columns, but it causes type errors
+
+// conditions:
+
 export type ConditionChainType = 'or' | 'and';
-export type ConditionType = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'not-in' | 'between' | 'not-between' | 'like' | 'not-like' | 'is-null' | 'is-not-null';
+
+export type ConditionType = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'not-in' | 'between' | 'not-between'
+    | 'like' | 'not-like' | 'is-null' | 'is-not-null';
+
+// joins:
+
 export type JoinType = 'inner' | 'left' | 'right' | 'full';
-export type QueryProcessor = (query: any) => Promise<any>;
+
+// processor:
+
+export type QueryProcessor = (query: any) => Promise<any>;

package/lib-prod/builder/join/joined-tables-chain.ts

@@ -0,0 +1,17 @@
+import QueryTable from "../query-table";
+import QueryJoinCondition from "../condition/query-join-condition";
+import JoinedTables from "./joined-tables";
+import {JoinType} from "../helpers/internal-types";
+
+export default class JoinedTablesChain<Tables extends QueryTable<any, any>> {
+
+    constructor(
+        protected _table: QueryTable<any, any>,
+        protected _modifier: JoinType,
+        protected _parent: JoinedTables<Tables> | QueryTable<any, any>
+    ) {}
+
+    on(condition: QueryJoinCondition<Tables, Tables, any>): JoinedTables<Tables> {
+        return new JoinedTables(condition, this);
+    }
+}

package/lib-prod/builder/join/joined-tables.ts

@@ -0,0 +1,28 @@
+import QueryTable from "../query-table";
+import JoinedTablesChain from "./joined-tables-chain";
+import QueryJoinCondition from "../condition/query-join-condition";
+
+
+export default class JoinedTables<Tables extends QueryTable<any, any>> {
+
+    constructor(
+        protected _condition: QueryJoinCondition<Tables, Tables, any>,
+        protected _parent: JoinedTablesChain<Tables>
+    ) {}
+
+    innerJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<Tables | JoinTable> {
+        return new JoinedTablesChain(table, 'inner', this);
+    }
+
+    leftJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<Tables | JoinTable> {
+        return new JoinedTablesChain(table, 'left', this);
+    }
+
+    rightJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<Tables | JoinTable> {
+        return new JoinedTablesChain(table, 'right', this);
+    }
+
+    fullJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<Tables | JoinTable> {
+        return new JoinedTablesChain(table, 'full', this);
+    }
+}

package/lib-prod/builder/other/{query-ordering.d.ts → query-ordering.ts}

@@ -1,10 +1,26 @@
 import QueryColumn from "../column/query-column";
 import QueryTable from "../query-table";
+
+
 export default class QueryOrdering<Table extends QueryTable<any, any>> {
+
     protected _column: QueryColumn<Table, any>;
     protected _direction: 'ASC' | 'DESC';
     protected _nullsPosition: 'FIRST' | 'LAST';
-    constructor(column: QueryColumn<Table, any>, direction: 'ASC' | 'DESC');
-    nullsFirst(): this;
-    nullsLast(): this;
-}
+
+    constructor(column: QueryColumn<Table, any>, direction: 'ASC' | 'DESC') {
+        this._column = column;
+        this._direction = direction;
+    }
+
+    nullsFirst(): this {
+        this._nullsPosition = 'FIRST';
+        return this;
+    }
+
+    nullsLast(): this {
+        this._nullsPosition = 'LAST';
+        return this;
+    }
+
+}

package/lib-prod/builder/query/select-query.ts

@@ -0,0 +1,68 @@
+import QueryCondition from "../condition/query-condition";
+import QueryOrdering from "../other/query-ordering";
+import QueryTable from "../query-table";
+import QueryColumn from "../column/query-column";
+import { QueryProcessor, QueryAction } from "../helpers/internal-types";
+
+
+export default class SelectQuery<Entity, Table extends QueryTable<Entity, any>> {
+
+    constructor(
+        protected _queryProcessor: QueryProcessor,
+        protected _tables: Table[]
+    ) {}
+
+    protected _distinct = false;
+    protected _offset: number;
+    protected _limit: number;
+    protected _conditions: QueryCondition<Table>[] = [];
+    protected _groupBy: QueryColumn<Table, any>[] = [];
+    protected _having: QueryCondition<Table>[] = [];
+    protected _orderings: (QueryColumn<Table, any> | QueryOrdering<Table>)[] = [];
+    protected _columns: QueryColumn<Table, any>[] = [];
+    protected _action: QueryAction;
+
+    offset(offset: number): this {
+        this._offset = offset;
+        return this;
+    }
+
+    limit(limit: number): this {
+        this._limit = limit;
+        return this;
+    }
+
+    distinct(): this {
+        this._distinct = true;
+        return this;
+    }
+
+    where(...conditions: QueryCondition<Table>[]): this {
+        this._conditions = conditions;
+        return this;
+    }
+
+    groupBy(...columns: QueryColumn<Table, any>[]): this {
+        this._groupBy = columns;
+        return this;
+    }
+
+    having(...conditions: QueryCondition<Table>[]): this {
+        this._having = conditions;
+        return this;
+    }
+
+    orderBy(...orderings: (QueryColumn<Table, any> | QueryOrdering<Table>)[]): this {
+        this._orderings = orderings;
+        return this;
+    }
+
+    select(): Promise<Entity[]>
+    select<T>(column: QueryColumn<Table, T>): Promise<T[]>
+    select(...columns: QueryColumn<Table, any>[]): Promise<any[]>
+    select(...columns: QueryColumn<Table, any>[]): Promise<any[]> {
+        this._columns = columns;
+        this._action = 'select';
+        return this._queryProcessor(this);
+    }
+}