ace-front-end 1.0.0

package/ace-app-bolts-ui/src/models/expr/mixins.ts

@@ -0,0 +1,1946 @@
+import {
+    type BooleanResultExpression,
+    type CollectionExpression,
+    type CollectionExpressionProperties,
+    type CollectionPath,
+    type Comparable,
+    type ComparableResultExpression,
+    type DateOperations,
+    type DateResultExpression,
+    type DateTimeResultExpression,
+    type EntityExpressionProperties,
+    type EntityResultExpression,
+    type EnumExpressionProperties,
+    type EnumResultExpression,
+    type JavaType,
+    javaTypes,
+    type ListResultExpression,
+    type MapExpressionProperties,
+    type MapResultExpression,
+    type NumberExpressionProperties,
+    type NumberResultExpression,
+    type PathExpression,
+    type QEntity,
+    type QEntityConstructor,
+    type ScalarResultExpression,
+    type StringResultExpression,
+    type TimeOperations,
+    type TimeResultExpression,
+    type TupleExpressionProperties,
+    type TupleResultExpression,
+} from "./Interfaces";
+import {
+    AvgFunctionBase,
+    CountFunctionBase,
+    MaxBooleanFunctionBase,
+    MaxDateFunctionBase,
+    MaxDateTimeFunctionBase,
+    MaxEnumFunctionBase,
+    MaxNumberFunctionBase,
+    MaxStringFunctionBase,
+    MaxTimeFunctionBase,
+    MinDateFunctionBase,
+    MinDateTimeFunctionBase,
+    MinEnumFunctionBase,
+    MinNumberFunctionBase,
+    MinStringFunctionBase,
+    MinTimeFunctionBase,
+    SizeFunctionBase,
+    SumFunctionBase,
+} from "./impls/agg";
+import {
+    AnyBooleanFunctionBase,
+    AnyDateFunctionBase,
+    AnyDateTimeFunctionBase,
+    AnyEntityFunctionBase,
+    AnyEnumFunctionBase,
+    AnyNumberFunctionBase,
+    AnyStringFunctionBase,
+    AnyTimeFunctionBase,
+} from "./impls/any";
+import { Expression } from "./impls/base";
+import {
+    AndOrBooleanExpressionBase,
+    BetweenBooleanExpressionBase,
+    CollectionContainsExpressionBase,
+    CompareCollectionExpressionBase,
+    CompareExpressionBase,
+    CompareSubQueryExpressionBase,
+    ExistsExpressionBase,
+    IsEmptyExpressionBase,
+    IsNullExpressionBase,
+    MapContainsExpressionBase,
+    NotBooleanExpressionBase,
+    StringCompareExpressionBase,
+    SubQueryCompareExpressionBase,
+    SubQueryContainsExpressionBase,
+} from "./impls/bool";
+import {
+    BooleanListPathBase,
+    BooleanPathBase,
+    BooleanSetPathBase,
+    CollectionPathExpressionBase,
+    DateListPathBase,
+    DatePathBase,
+    DateSetPathBase,
+    DateTimeListPathBase,
+    DateTimePathBase,
+    DateTimeSetPathBase,
+    EntityListPathBase,
+    EntityPathBase,
+    EntitySetPathBase,
+    EnumListPathBase,
+    EnumPathBase,
+    EnumSetPathBase,
+    MapPathBase,
+    NumberListPathBase,
+    NumberPathBase,
+    NumberSetPathBase,
+    StringListPathBase,
+    StringPathBase,
+    StringSetPathBase,
+    TimeListPathBase,
+    TimePathBase,
+    TimeSetPathBase,
+} from "./impls/path";
+import { TupleExpressionBase } from "./impls/collection";
+import {
+    BooleanConstBase,
+    DateConstBase,
+    DateTimeConstBase,
+    EnumConstBase,
+    NumberConstBase,
+    StringConstBase,
+    TimeConstBase,
+} from "./impls/constant";
+import {
+    CurrentDateFunctionBase,
+    CurrentDateTimeFunctionBase,
+    CurrentTimeFunctionBase,
+    DateTransformFunctionBase,
+    TimeTransformFunctionBase,
+} from "./impls/dateTime";
+import {
+    CoalesceBooleanFunctionBase,
+    CoalesceDateFunctionBase,
+    CoalesceDateTimeFunctionBase,
+    CoalesceEntityFunctionBase,
+    CoalesceEnumFunctionBase,
+    CoalesceNumberFunctionBase,
+    CoalesceStringFunctionBase,
+    CoalesceTimeFunctionBase,
+    NullIfBooleanFunctionBase,
+    NullIfDateFunctionBase,
+    NullIfDateTimeFunctionBase,
+    NullIfEntityFunctionBase,
+    NullIfEnumFunctionBase,
+    NullIfNumberFunctionBase,
+    NullIfStringFunctionBase,
+    NullIfTimeFunctionBase,
+} from "./impls/nullfun";
+import {
+    AbsFunctionBase,
+    ArithmeticExpressionBase,
+    CastToNumFunctionBase,
+    CeilFunctionBase,
+    FloorFunctionBase,
+    NegateFunctionBase,
+    RoundFunctionBase,
+    SqrtFunctionBase,
+} from "./impls/num";
+import {
+    ConcatStringFunctionBase,
+    IndexOfStringFunctionBase,
+    LengthOfStringFunctionBase,
+    StringTransformFunctionBase,
+    SubstringFunctionBase,
+    ToStringFunctionBase,
+} from "./impls/strfun";
+import {
+    BooleanCaseExpressionBase,
+    DateCaseExpressionBase,
+    DateTimeCaseExpressionBase,
+    EntityCaseExpressionBase,
+    EnumCaseExpressionBase,
+    NumberCaseExpressionBase,
+    StringCaseExpressionBase,
+    TimeCaseExpressionBase,
+} from "./impls/when";
+import moment from "moment";
+import type { WithQueryEntityFunction } from "../orgService/dsl";
+import type { Instance } from "element-plus";
+
+interface ExpressionConstructor {
+    new (...args: any[]): Expression;
+}
+
+interface CollectionExpressionConstructor {
+    new (...args: any[]): Expression & CollectionExpressionProperties;
+}
+
+interface CollectionPathExpressionConstructor {
+    new (...args: any[]): CollectionPathExpressionBase;
+}
+
+interface EntityExpressionConstructor {
+    new (...args: any[]): Expression & EntityExpressionProperties;
+}
+
+interface EnumExpressionConstructor {
+    new (...args: any[]): Expression & EnumExpressionProperties;
+}
+
+interface NumberExpressionConstructor {
+    new (...args: any[]): Expression & NumberExpressionProperties;
+}
+
+interface TupleExpressionConstructor {
+    new (...args: any[]): Expression & TupleExpressionProperties;
+}
+
+interface MapExpressionConstructor {
+    new (...args: any[]): Expression & MapExpressionProperties;
+}
+
+export interface EntityPathConstructor {
+    new (...args: any[]): Expression & EntityExpressionProperties & PathExpression;
+}
+
+export interface IEntityPath extends PathExpression {
+    boolPath(path: string): BooleanResultExpression;
+
+    stringPath(path: string): StringResultExpression;
+
+    datePath(path: string): DateResultExpression;
+
+    dateTimePath(path: string): DateTimeResultExpression;
+
+    timePath(path: string): TimeResultExpression;
+
+    enumPath(path: string): EnumResultExpression;
+
+    numberPath(path: string): NumberResultExpression;
+
+    mapPath(path: string, keyType: string, valueType: string): MapResultExpression;
+
+    booleanListPath(path: string): InstanceType<typeof BooleanListPath>;
+
+    stringListPath(path: string): InstanceType<typeof StringListPath>;
+
+    dateListPath(path: string): InstanceType<typeof DateListPath>;
+
+    dateTimeListPath(path: string): InstanceType<typeof DateTimeListPath>;
+
+    timeListPath(path: string): InstanceType<typeof TimeListPath>;
+
+    enumListPath(path: string): InstanceType<typeof EnumListPath>;
+
+    numberListPath(path: string): InstanceType<typeof NumberListPath>;
+
+    entityListPath(path: string): InstanceType<typeof EntityListPath>;
+
+    boolSetPath(path: string): InstanceType<typeof BooleanSetPath>;
+
+    stringSetPath(path: string): InstanceType<typeof StringSetPath>;
+
+    dateSetPath(path: string): InstanceType<typeof DateSetPath>;
+
+    dateTimeSetPath(path: string): InstanceType<typeof DateTimeSetPath>;
+
+    timeSetPath(path: string): InstanceType<typeof TimeSetPath>;
+
+    enumSetPath(path: string): InstanceType<typeof EnumSetPath>;
+
+    numberSetPath(path: string): InstanceType<typeof NumberSetPath>;
+}
+
+export interface EntityPathConstructor2 {
+    new (...args: any[]): Expression & EntityExpressionProperties & PathExpression & IEntityPath;
+}
+
+function resolveConstExpression(value: Comparable): ComparableResultExpression {
+    if (typeof value === "boolean") {
+        return new BooleanConst(value);
+    } else if (typeof value === "number") {
+        if (Math.round(value) === value) {
+            return new NumberConst(value.toString(), javaTypes.long);
+        } else {
+            return new NumberConst(value.toString(), javaTypes.decimal);
+        }
+    } else if (value instanceof Date) {
+        const dt = value as Date;
+        const bs = moment(dt).format("YYYY-MM-DD HH:mm:ss");
+        return new DateTimeConst(bs);
+    } else {
+        return new StringConst(value as string);
+    }
+}
+
+function withComparableOperations<T extends ExpressionConstructor>(Base: T) {
+    return class extends Base implements ComparableResultExpression {
+        /**
+         * 获取记录数
+         */
+        count(): NumberResultExpression;
+        /**
+         * 获取去除重复值后的记录数
+         * @param distinct 是否去重
+         */
+        count(distinct: boolean): NumberResultExpression;
+        /**
+         * 获取去除重复值后的记录数
+         * @param distinct 是否去重
+         */
+        count(distinct?: boolean): NumberResultExpression {
+            return new CountFunction(this, distinct ?? false);
+        }
+
+        /**
+         * 等于
+         * @param right 等号右侧表达式
+         */
+        eq(right: ComparableResultExpression): BooleanResultExpression;
+        /**
+         * 等于
+         * @param constValue 等号右侧常量值
+         */
+        eq<T extends Comparable>(constValue: T): BooleanResultExpression;
+        /**
+         * 等于
+         * @param right 等号右侧的表达式
+         */
+        eq(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "EQUAL",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "EQUAL",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        /**
+         * 小于
+         * @param right 小于号右侧的表达式
+         */
+        lt(right: ComparableResultExpression): BooleanResultExpression;
+        /**
+         * 小于
+         * @param constValue 小于号右侧的常量值
+         */
+        lt<T extends Comparable>(constValue: T): BooleanResultExpression;
+        /**
+         * 小于
+         * @param right 小于号右侧的表达式或常量值
+         */
+        lt(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "LESS_THAN",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "LESS_THAN",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        /**
+         * 大于
+         * @param right 大于号右侧的表达式
+         */
+        gt(right: ComparableResultExpression): BooleanResultExpression;
+        /**
+         * 大于
+         * @param constValue 大于号右侧的常量值
+         */
+        gt<T extends Comparable>(constValue: T): BooleanResultExpression;
+        /**
+         * 大于
+         * @param right 大于号右侧表达式或常量值
+         */
+        gt(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "GREAT_THAN",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "GREAT_THAN",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        ne(right: ComparableResultExpression): BooleanResultExpression;
+        ne<T extends Comparable>(constValue: T): BooleanResultExpression;
+        ne(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "NOT_EQUAL",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "NOT_EQUAL",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        loe(right: ComparableResultExpression): BooleanResultExpression;
+        loe<T extends Comparable>(constValue: T): BooleanResultExpression;
+        loe(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "LESS_THAN_OR_EQUAL",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "LESS_THAN_OR_EQUAL",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        goe(right: ComparableResultExpression): BooleanResultExpression;
+        goe<T extends Comparable>(constValue: T): BooleanResultExpression;
+        goe(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new CompareExpression(
+                    "GREAT_THAN_OR_EQUAL",
+                    this,
+                    right as any as ComparableResultExpression,
+                );
+            } else {
+                return new CompareExpression(
+                    "GREAT_THAN_OR_EQUAL",
+                    this,
+                    resolveConstExpression(right as Comparable),
+                );
+            }
+        }
+
+        between<T extends ComparableResultExpression>(low: T, high: T): BooleanResultExpression;
+        between<T extends Comparable>(low: T, high: T): BooleanResultExpression;
+        between<T extends Comparable>(
+            low: ComparableResultExpression,
+            high: T,
+        ): BooleanResultExpression;
+        between<T extends Comparable>(
+            low: T,
+            high: ComparableResultExpression,
+        ): BooleanResultExpression;
+        between(low: unknown, high: unknown): BooleanResultExpression {
+            let lowExpr: ComparableResultExpression;
+            let highExpr: ComparableResultExpression;
+            if (low instanceof Expression) {
+                lowExpr = low as any as ComparableResultExpression;
+            } else {
+                lowExpr = resolveConstExpression(low as Comparable);
+            }
+            if (high instanceof Expression) {
+                highExpr = high as any as ComparableResultExpression;
+            } else {
+                highExpr = resolveConstExpression(high as Comparable);
+            }
+            return new BetweenBooleanExpression(this, lowExpr, highExpr);
+        }
+
+        isNull(): BooleanResultExpression {
+            return new IsNullExpression(false, this);
+        }
+
+        isNotNull(): BooleanResultExpression {
+            return new IsNullExpression(true, this);
+        }
+    };
+}
+
+function withScalarOperations<T extends ExpressionConstructor>(Base: T) {
+    return class extends withComparableOperations(Base) implements ScalarResultExpression {
+        coalesce(right: BooleanResultExpression): BooleanResultExpression;
+        coalesce(right: StringResultExpression): StringResultExpression;
+        coalesce(right: NumberResultExpression): NumberResultExpression;
+        coalesce(right: EnumResultExpression): EnumResultExpression;
+        coalesce(right: DateResultExpression): DateResultExpression;
+        coalesce(right: DateTimeResultExpression): DateTimeResultExpression;
+        coalesce(right: TimeResultExpression): TimeResultExpression;
+        coalesce(right: EntityResultExpression): EntityResultExpression;
+        coalesce(right: boolean): BooleanResultExpression;
+        coalesce(right: string): StringResultExpression;
+        coalesce(right: number): NumberResultExpression;
+        coalesce(
+            right: unknown,
+        ):
+            | NumberResultExpression
+            | BooleanResultExpression
+            | StringResultExpression
+            | EnumResultExpression
+            | DateResultExpression
+            | DateTimeResultExpression
+            | TimeResultExpression
+            | EntityResultExpression {
+            if (right instanceof Expression) {
+                switch (right.resultType) {
+                    case javaTypes.bool:
+                        return new CoalesceBooleanFunction(
+                            this,
+                            right as any as BooleanResultExpression,
+                        );
+                    case javaTypes.byte:
+                    case javaTypes.long:
+                    case javaTypes.int:
+                    case javaTypes.short:
+                    case javaTypes.float:
+                    case javaTypes.double:
+                    case javaTypes.decimal:
+                    case javaTypes.bigInt:
+                        return new CoalesceNumberFunction(
+                            this,
+                            right as any as NumberResultExpression,
+                        );
+                    case javaTypes.dateTime:
+                        return new CoalesceDateTimeFunction(
+                            this,
+                            right as any as DateTimeResultExpression,
+                        );
+                    case javaTypes.date:
+                        return new CoalesceDateFunction(this, right as any as DateResultExpression);
+                    case javaTypes.time:
+                        return new CoalesceTimeFunction(this, right as any as TimeResultExpression);
+                    case javaTypes.object:
+                        return new CoalesceEntityFunction(
+                            this,
+                            right as any as EntityResultExpression,
+                        );
+                    case javaTypes.enum:
+                        return new CoalesceEnumFunction(this, right as any as EnumResultExpression);
+                    case javaTypes.string:
+                        return new CoalesceStringFunction(
+                            this,
+                            right as any as StringResultExpression,
+                        );
+                    default:
+                        throw new Error(
+                            `Cannot coalesce ${right.resultType} with ${this.resultType}`,
+                        );
+                }
+            } else {
+                const constExpression = resolveConstExpression(right as any as Comparable);
+                switch (constExpression.resultType) {
+                    case javaTypes.bool:
+                        return new CoalesceBooleanFunction(
+                            this,
+                            constExpression as BooleanResultExpression,
+                        );
+                    case javaTypes.byte:
+                    case javaTypes.long:
+                    case javaTypes.int:
+                    case javaTypes.short:
+                    case javaTypes.float:
+                    case javaTypes.double:
+                    case javaTypes.decimal:
+                    case javaTypes.bigInt:
+                        return new CoalesceNumberFunction(
+                            this,
+                            constExpression as NumberResultExpression,
+                        );
+                    case javaTypes.string:
+                        return new CoalesceStringFunction(
+                            this,
+                            constExpression as StringResultExpression,
+                        );
+                    default:
+                        throw new Error(
+                            `Cannot coalesce ${constExpression.resultType} with ${this.resultType}`,
+                        );
+                }
+            }
+        }
+
+        nullIf(right: BooleanResultExpression): BooleanResultExpression;
+        nullIf(right: StringResultExpression): StringResultExpression;
+        nullIf(right: NumberResultExpression): NumberResultExpression;
+        nullIf(right: EnumResultExpression): EnumResultExpression;
+        nullIf(right: DateResultExpression): DateResultExpression;
+        nullIf(right: DateTimeResultExpression): DateTimeResultExpression;
+        nullIf(right: TimeResultExpression): TimeResultExpression;
+        nullIf(right: EntityResultExpression): EntityResultExpression;
+        nullIf(right: boolean): BooleanResultExpression;
+        nullIf(right: string): StringResultExpression;
+        nullIf(right: number): NumberResultExpression;
+        nullIf(
+            right: unknown,
+        ):
+            | NumberResultExpression
+            | BooleanResultExpression
+            | StringResultExpression
+            | EnumResultExpression
+            | DateResultExpression
+            | DateTimeResultExpression
+            | TimeResultExpression
+            | EntityResultExpression {
+            if (right instanceof Expression) {
+                switch (right.resultType) {
+                    case javaTypes.bool:
+                        return new NullIfBooleanFunction(
+                            this,
+                            right as any as BooleanResultExpression,
+                        );
+                    case javaTypes.byte:
+                    case javaTypes.long:
+                    case javaTypes.int:
+                    case javaTypes.short:
+                    case javaTypes.float:
+                    case javaTypes.double:
+                    case javaTypes.decimal:
+                    case javaTypes.bigInt:
+                        return new NullIfNumberFunction(
+                            this,
+                            right as any as NumberResultExpression,
+                        );
+                    case javaTypes.dateTime:
+                        return new NullIfDateTimeFunction(
+                            this,
+                            right as any as DateTimeResultExpression,
+                        );
+                    case javaTypes.date:
+                        return new NullIfDateFunction(this, right as any as DateResultExpression);
+                    case javaTypes.time:
+                        return new NullIfTimeFunction(this, right as any as TimeResultExpression);
+                    case javaTypes.object:
+                        return new NullIfEntityFunction(
+                            this,
+                            right as any as EntityResultExpression,
+                        );
+                    case javaTypes.enum:
+                        return new NullIfEnumFunction(this, right as any as EnumResultExpression);
+                    case javaTypes.string:
+                        return new NullIfStringFunction(
+                            this,
+                            right as any as StringResultExpression,
+                        );
+                    default:
+                        throw new Error(
+                            `Cannot nullIf ${right.resultType} with ${this.resultType}`,
+                        );
+                }
+            } else {
+                const constExpression = resolveConstExpression(right as any as Comparable);
+                switch (constExpression.resultType) {
+                    case javaTypes.bool:
+                        return new NullIfBooleanFunction(
+                            this,
+                            constExpression as BooleanResultExpression,
+                        );
+                    case javaTypes.byte:
+                    case javaTypes.long:
+                    case javaTypes.int:
+                    case javaTypes.short:
+                    case javaTypes.float:
+                    case javaTypes.double:
+                    case javaTypes.decimal:
+                    case javaTypes.bigInt:
+                        return new NullIfNumberFunction(
+                            this,
+                            constExpression as NumberResultExpression,
+                        );
+                    case javaTypes.string:
+                        return new NullIfStringFunction(
+                            this,
+                            constExpression as StringResultExpression,
+                        );
+                    default:
+                        throw new Error(
+                            `Cannot nullIf ${constExpression.resultType} with ${this.resultType}`,
+                        );
+                }
+            }
+        }
+
+        str(): StringResultExpression {
+            return new ToStringFunction(this);
+        }
+
+        castToNum(numberType: JavaType): NumberResultExpression {
+            throw new CastToNumFunction(this, numberType);
+        }
+    };
+}
+
+export function withBooleanOperations<T extends ExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements BooleanResultExpression {
+        and(right: BooleanResultExpression): BooleanResultExpression;
+        and(right: boolean): BooleanResultExpression;
+        and(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new AndOrBooleanExpression(
+                    "AND",
+                    this,
+                    right as any as BooleanResultExpression,
+                );
+            } else {
+                return new AndOrBooleanExpression("AND", this, new BooleanConst(right as boolean));
+            }
+        }
+
+        or(right: BooleanResultExpression): BooleanResultExpression;
+        or(right: boolean): BooleanResultExpression;
+        or(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new AndOrBooleanExpression(
+                    "OR",
+                    this,
+                    right as any as BooleanResultExpression,
+                );
+            } else {
+                return new AndOrBooleanExpression("OR", this, new BooleanConst(right as boolean));
+            }
+        }
+
+        min(): BooleanResultExpression {
+            return new MinBooleanFunction(this);
+        }
+
+        max(): BooleanResultExpression {
+            throw new MaxBooleanFunction(this);
+        }
+
+        not(): BooleanResultExpression {
+            throw new NotBooleanExpression(this);
+        }
+    };
+}
+
+function withCollectionResult<T extends CollectionExpressionConstructor>(Base: T) {
+    return class extends Base implements CollectionExpression {
+        size(): NumberResultExpression {
+            throw new SizeFunction(this);
+        }
+
+        contains(value: ComparableResultExpression): BooleanResultExpression {
+            return new CollectionContainsExpression(this, value);
+        }
+    };
+}
+
+function withCollectionPath<T extends CollectionPathExpressionConstructor>(Base: T) {
+    return class extends withCollectionResult(Base) implements CollectionPath {};
+}
+
+function withDateOperations<T extends ExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements DateOperations {
+        dayOfWeek(): NumberResultExpression {
+            return new DateTransformFunction("DAY_OF_WEEK", this);
+        }
+
+        dayOfMonth(): NumberResultExpression {
+            return new DateTransformFunction("DAY_OF_MONTH", this);
+        }
+
+        dayOfYear(): NumberResultExpression {
+            return new DateTransformFunction("DAY_OF_YEAR", this);
+        }
+
+        month(): NumberResultExpression {
+            return new DateTransformFunction("MONTH", this);
+        }
+
+        year(): NumberResultExpression {
+            return new DateTransformFunction("YEAR", this);
+        }
+
+        week(): NumberResultExpression {
+            return new DateTransformFunction("WEEK", this);
+        }
+
+        yearMonth(): NumberResultExpression {
+            return new DateTransformFunction("YEAR_MONTH", this);
+        }
+
+        yearWeek(): NumberResultExpression {
+            return new DateTransformFunction("YEAR_WEEK", this);
+        }
+    };
+}
+
+function withTimeOperations<T extends ExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements TimeOperations {
+        hour(): NumberResultExpression {
+            return new TimeTransformFunction("HOUR", this);
+        }
+
+        minute(): NumberResultExpression {
+            return new TimeTransformFunction("MINUTE", this);
+        }
+
+        second(): NumberResultExpression {
+            return new TimeTransformFunction("SECOND", this);
+        }
+
+        milliSecond(): NumberResultExpression {
+            return new TimeTransformFunction("MILLISECOND", this);
+        }
+
+        min(): TimeResultExpression {
+            return new MinTimeFunction(this);
+        }
+
+        max(): TimeResultExpression {
+            return new MaxTimeFunction(this);
+        }
+    };
+}
+
+function withDateResult<T extends ExpressionConstructor>(Base: T) {
+    return class extends withDateOperations(Base) implements DateResultExpression {
+        min(): DateResultExpression {
+            return new MinDateFunction(this);
+        }
+
+        max(): DateResultExpression {
+            return new MaxDateFunction(this);
+        }
+    };
+}
+
+function withTimeResult<T extends ExpressionConstructor>(Base: T) {
+    return class extends withTimeOperations(Base) implements TimeResultExpression {
+        min(): TimeResultExpression {
+            return new MinTimeFunction(this);
+        }
+
+        max(): TimeResultExpression {
+            return new MaxTimeFunction(this);
+        }
+    };
+}
+
+function withDateTimeResult<T extends ExpressionConstructor>(Base: T) {
+    return class
+        extends withDateOperations(withTimeOperations(Base))
+        implements DateTimeResultExpression
+    {
+        min(): DateTimeResultExpression {
+            return new MinDateTimeFunction(this);
+        }
+
+        max(): DateTimeResultExpression {
+            return new MaxDateTimeFunction(this);
+        }
+    };
+}
+
+function withEntityResult<T extends EntityExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements EntityResultExpression {};
+}
+
+function withEnumResult<T extends EnumExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements EnumResultExpression {
+        min(): EnumResultExpression {
+            return new MinEnumFunction(this);
+        }
+
+        max(): EnumResultExpression {
+            return new MaxEnumFunction(this);
+        }
+    };
+}
+
+function withEntityPath<T extends EntityPathConstructor>(Base: T) {
+    return class extends withEntityResult(Base) implements PathExpression {
+        boolPath(path: string) {
+            return new BooleanPath(path, this.entityType__, this, this.alias__);
+        }
+
+        stringPath(path: string) {
+            return new StringPath(path, this.entityType__, this, this.alias__);
+        }
+
+        datePath(path: string) {
+            return new DatePath(path, this.entityType__, this, this.alias__);
+        }
+
+        dateTimePath(path: string) {
+            return new DateTimePath(path, this.entityType__, this, this.alias__);
+        }
+
+        timePath(path: string) {
+            return new TimePath(path, this.entityType__, this, this.alias__);
+        }
+
+        enumPath(path: string) {
+            return new EnumPath(path, this.entityType__, this, this.alias__);
+        }
+
+        numberPath(path: string) {
+            return new NumberPath(path, this.entityType__, this, this.alias__);
+        }
+
+        entityPath(path: string) {
+            return new EntityPath(path, this.entityType__, this, this.alias__);
+        }
+
+        booleanListPath(path: string) {
+            return new BooleanListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        stringListPath(path: string) {
+            return new StringListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        dateListPath(path: string) {
+            return new DateListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        dateTimeListPath(path: string) {
+            return new DateTimeListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        timeListPath(path: string) {
+            return new TimeListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        enumListPath(path: string) {
+            return new EnumListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        numberListPath(path: string) {
+            return new NumberListPath(path, this.entityType__, this, this.alias__);
+        }
+
+        entityListPath(path: string) {
+            return new EntityListPath(path, this.entityType__, this, undefined, this.alias__);
+        }
+
+        boolSetPath(path: string) {
+            return new BooleanSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        stringSetPath(path: string) {
+            return new StringSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        dateSetPath(path: string) {
+            return new DateSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        dateTimeSetPath(path: string) {
+            return new DateTimeSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        timeSetPath(path: string) {
+            return new TimeSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        enumSetPath(path: string) {
+            return new EnumSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        numberSetPath(path: string) {
+            return new NumberSetPath(path, this.entityType__, this, this.alias__);
+        }
+
+        entitySetPath(path: string) {
+            return new EntitySetPath(path, this.entityType__, this, undefined, this.alias__);
+        }
+
+        mapPath(path: string, keyType: string, valueType: string) {
+            return new MapPath(path, this.entityType__, keyType, valueType, this, this.alias__);
+        }
+    };
+}
+
+function withMapResult<T extends MapExpressionConstructor>(Base: T) {
+    return class extends Base implements MapResultExpression {
+        get<T extends ScalarResultExpression>(key: ScalarResultExpression): T {
+            switch (this.valueType__) {
+                case javaTypes.bool:
+                    return new MapGetBooleanFunction(this, key) as unknown as T;
+                case javaTypes.byte:
+                case javaTypes.long:
+                case javaTypes.int:
+                case javaTypes.short:
+                case javaTypes.float:
+                case javaTypes.double:
+                case javaTypes.decimal:
+                case javaTypes.bigInt:
+                    return new MapGetNumberFunction(this, key) as unknown as T;
+                case javaTypes.dateTime:
+                    return new MapGetDateTimeFunction(this, key) as unknown as T;
+                case javaTypes.date:
+                    return new MapGetDateFunction(this, key) as unknown as T;
+                case javaTypes.time:
+                    return new MapGetTimeFunction(this, key) as unknown as T;
+                case javaTypes.object:
+                    return new MapGetEntityFunction(this, key) as unknown as T;
+                case javaTypes.enum:
+                    return new MapGetEnumFunction(this, key) as unknown as T;
+                case javaTypes.string:
+                    return new MapGetStringFunction(this, key) as unknown as T;
+                default:
+                    throw new Error(`Cannot mapGet ${this.valueType__} with ${key}`);
+            }
+        }
+
+        contains(
+            key: ScalarResultExpression,
+            value: ComparableResultExpression,
+        ): BooleanResultExpression;
+        contains(key: Comparable, value: Comparable): BooleanResultExpression;
+        contains(key: unknown, value: unknown): BooleanResultExpression {
+            let keyExpr, valueExpr;
+            if (key instanceof Expression) {
+                keyExpr = key as unknown as ScalarResultExpression;
+            } else {
+                keyExpr = resolveConstExpression(key as Comparable);
+            }
+            if (value instanceof Expression) {
+                valueExpr = value as unknown as ComparableResultExpression;
+            } else {
+                valueExpr = resolveConstExpression(value as Comparable);
+            }
+            return new MapContainsExpression(this, keyExpr as ScalarResultExpression, valueExpr);
+        }
+
+        containsKey(key: ScalarResultExpression): BooleanResultExpression;
+        containsKey(key: Comparable): BooleanResultExpression;
+        containsKey(key: unknown): BooleanResultExpression {
+            let keyExpr;
+            if (key instanceof Expression) {
+                keyExpr = key as unknown as ScalarResultExpression;
+            } else {
+                keyExpr = resolveConstExpression(key as Comparable);
+            }
+            return new MapContainsExpression(this, keyExpr as ScalarResultExpression);
+        }
+
+        containsValue(value: ComparableResultExpression): BooleanResultExpression;
+        containsValue(value: Comparable): BooleanResultExpression;
+        containsValue(value: unknown): BooleanResultExpression {
+            let valueExpr;
+            if (value instanceof Expression) {
+                valueExpr = value as unknown as ComparableResultExpression;
+            } else {
+                valueExpr = resolveConstExpression(value as Comparable);
+            }
+            return new MapContainsExpression(this, undefined, valueExpr);
+        }
+    };
+}
+
+function withNumberResult<T extends NumberExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements NumberResultExpression {
+        add(right: NumberResultExpression): NumberResultExpression;
+        add(right: number): NumberResultExpression;
+        add(right: unknown): NumberResultExpression {
+            if (right instanceof Expression) {
+                return new ArithmeticExpression(
+                    this,
+                    right as unknown as NumberResultExpression,
+                    "ADD",
+                );
+            } else {
+                return new ArithmeticExpression(
+                    this,
+                    resolveConstExpression(right as Comparable) as NumberResultExpression,
+                    "ADD",
+                );
+            }
+        }
+
+        minus(right: NumberResultExpression): NumberResultExpression;
+        minus(right: number): NumberResultExpression;
+        minus(right: unknown): NumberResultExpression {
+            if (right instanceof Expression) {
+                return new ArithmeticExpression(
+                    this,
+                    right as unknown as NumberResultExpression,
+                    "MINUS",
+                );
+            } else {
+                return new ArithmeticExpression(
+                    this,
+                    resolveConstExpression(right as Comparable) as NumberResultExpression,
+                    "MINUS",
+                );
+            }
+        }
+
+        multiply(right: number): NumberResultExpression;
+        multiply(right: NumberResultExpression): NumberResultExpression;
+        multiply(right: unknown): NumberResultExpression {
+            if (right instanceof Expression) {
+                return new ArithmeticExpression(
+                    this,
+                    right as unknown as NumberResultExpression,
+                    "MULTIPLY",
+                );
+            } else {
+                return new ArithmeticExpression(
+                    this,
+                    resolveConstExpression(right as Comparable) as NumberResultExpression,
+                    "MULTIPLY",
+                );
+            }
+        }
+
+        divide(right: NumberResultExpression): NumberResultExpression;
+        divide(right: number): NumberResultExpression;
+        divide(right: unknown): NumberResultExpression {
+            if (right instanceof Expression) {
+                return new ArithmeticExpression(
+                    this,
+                    right as unknown as NumberResultExpression,
+                    "DIVIDE",
+                );
+            } else {
+                return new ArithmeticExpression(
+                    this,
+                    resolveConstExpression(right as Comparable) as NumberResultExpression,
+                    "DIVIDE",
+                );
+            }
+        }
+
+        mod(right: NumberResultExpression): NumberResultExpression;
+        mod(right: number): NumberResultExpression;
+        mod(right: unknown): NumberResultExpression {
+            if (right instanceof Expression) {
+                return new ArithmeticExpression(
+                    this,
+                    right as unknown as NumberResultExpression,
+                    "MOD",
+                );
+            } else {
+                return new ArithmeticExpression(
+                    this,
+                    resolveConstExpression(right as Comparable) as NumberResultExpression,
+                    "MOD",
+                );
+            }
+        }
+
+        avg(): NumberResultExpression {
+            return new AvgFunction(this);
+        }
+
+        sum(): NumberResultExpression {
+            return new SumFunction(this);
+        }
+
+        min(): NumberResultExpression {
+            return new MinNumberFunction(this);
+        }
+
+        max(): NumberResultExpression {
+            return new MaxNumberFunction(this);
+        }
+    };
+}
+
+function withStringResult<T extends ExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements StringResultExpression {
+        concat(right: StringResultExpression): StringResultExpression;
+        concat(right: string): StringResultExpression;
+        concat(right: unknown): StringResultExpression {
+            if (right instanceof Expression) {
+                return new ConcatStringFunction(this, right as unknown as StringResultExpression);
+            } else {
+                return new ConcatStringFunction(this, new StringConst(right as string));
+            }
+        }
+
+        trim(): StringResultExpression {
+            return new StringTransformFunction(this, "TRIM");
+        }
+
+        lowerCase(): StringResultExpression {
+            return new StringTransformFunction(this, "LOWER");
+        }
+
+        upperCase(): StringResultExpression {
+            return new StringTransformFunction(this, "UPPER");
+        }
+
+        like(right: StringResultExpression): BooleanResultExpression;
+        like(right: string): BooleanResultExpression;
+        like(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "LIKE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression("LIKE", this, new StringConst(right as string));
+            }
+        }
+
+        contains(right: StringResultExpression): BooleanResultExpression;
+        contains(right: string): BooleanResultExpression;
+        contains(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "CONTAIN",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "CONTAIN",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        startWith(right: string): BooleanResultExpression;
+        startWith(right: StringResultExpression): BooleanResultExpression;
+        startWith(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "START_WITH",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "START_WITH",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        endWith(right: StringResultExpression): BooleanResultExpression;
+        endWith(right: string): BooleanResultExpression;
+        endWith(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "END_WITH",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "END_WITH",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        match(right: string): BooleanResultExpression;
+        match(right: StringResultExpression): BooleanResultExpression;
+        match(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "MATCH",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression("MATCH", this, new StringConst(right as string));
+            }
+        }
+
+        likeIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        likeIgnoreCase(right: string): BooleanResultExpression;
+        likeIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "LIKE_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "LIKE_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        containIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        containIgnoreCase(right: string): BooleanResultExpression;
+        containIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "CONTAIN_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "CONTAIN_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        startWithIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        startWithIgnoreCase(right: string): BooleanResultExpression;
+        startWithIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "START_WITH_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "START_WITH_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        endWithIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        endWithIgnoreCase(right: string): BooleanResultExpression;
+        endWithIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "END_WITH_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "END_WITH_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        notLike(right: StringResultExpression): BooleanResultExpression;
+        notLike(right: string): BooleanResultExpression;
+        notLike(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "NOT_LIKE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "NOT_LIKE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        eqIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        eqIgnoreCase(right: string): BooleanResultExpression;
+        eqIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "EQUAL_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "EQUAL_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        neIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+        neIgnoreCase(right: string): BooleanResultExpression;
+        neIgnoreCase(right: unknown): BooleanResultExpression {
+            if (right instanceof Expression) {
+                return new StringCompareExpression(
+                    "NOT_EQUAL_IGNORE_CASE",
+                    this,
+                    right as unknown as StringResultExpression,
+                );
+            } else {
+                return new StringCompareExpression(
+                    "NOT_EQUAL_IGNORE_CASE",
+                    this,
+                    new StringConst(right as string),
+                );
+            }
+        }
+
+        indexOf(sub: StringResultExpression): NumberResultExpression;
+        indexOf(
+            sub: StringResultExpression,
+            startFrom: NumberResultExpression,
+        ): NumberResultExpression;
+        indexOf(sub: StringResultExpression, startFrom: number): NumberResultExpression;
+        indexOf(sub: string, startFrom: NumberResultExpression): NumberResultExpression;
+        indexOf(sub: string): NumberResultExpression;
+        indexOf(sub: string, startFrom: number): NumberResultExpression;
+        indexOf(sub: unknown, startFrom?: unknown): NumberResultExpression {
+            let subExpr, startFromExpr;
+            if (typeof sub === "string") {
+                subExpr = new StringConst(sub);
+            } else {
+                subExpr = sub as StringResultExpression;
+            }
+            if (startFrom) {
+                if (typeof startFrom === "number") {
+                    startFromExpr = resolveConstExpression(startFrom) as NumberResultExpression;
+                } else {
+                    startFromExpr = startFrom as NumberResultExpression;
+                }
+            }
+            return new IndexOfStringFunction(this, subExpr, startFromExpr);
+        }
+
+        length(): NumberResultExpression {
+            return new LengthOfStringFunction(this);
+        }
+
+        subString(beginIndex: NumberResultExpression): StringResultExpression;
+        subString(beginIndex: number): string;
+        subString(
+            beginIndex: NumberResultExpression,
+            endIndex: NumberResultExpression,
+        ): StringResultExpression;
+        subString(beginIndex: number, endIndex: NumberResultExpression): StringResultExpression;
+        subString(beginIndex: NumberResultExpression, endIndex: number): StringResultExpression;
+        subString(beginIndex: number, endIndex: number): StringResultExpression;
+        subString(beginIndex: unknown, endIndex?: unknown): string | StringResultExpression {
+            let beginIndexExpr, endIndexExpr;
+            if (typeof beginIndex === "number") {
+                beginIndexExpr = resolveConstExpression(beginIndex) as NumberResultExpression;
+            } else {
+                beginIndexExpr = beginIndex as NumberResultExpression;
+            }
+            if (endIndex) {
+                if (typeof endIndex === "number") {
+                    endIndexExpr = resolveConstExpression(endIndex) as NumberResultExpression;
+                } else {
+                    endIndexExpr = endIndex as NumberResultExpression;
+                }
+            }
+            return new SubstringFunction(this, beginIndexExpr, endIndexExpr);
+        }
+
+        isEmpty(not: boolean): BooleanResultExpression {
+            return new IsEmptyExpression(not, this);
+        }
+
+        min(): StringResultExpression {
+            return new MinStringFunction(this);
+        }
+
+        max(): StringResultExpression {
+            throw new MaxStringFunction(this);
+        }
+    };
+}
+
+function withTupleResult<T extends TupleExpressionConstructor>(Base: T) {
+    return class extends withScalarOperations(Base) implements TupleResultExpression {};
+}
+
+//#region agg
+export const AvgFunction = withNumberResult(AvgFunctionBase);
+
+export const CountFunction = withNumberResult(CountFunctionBase);
+
+export const MaxBooleanFunction = withBooleanOperations(MaxBooleanFunctionBase);
+
+export const MaxDateFunction = withDateResult(MaxDateFunctionBase);
+
+export const MaxDateTimeFunction = withDateTimeResult(MaxDateTimeFunctionBase);
+
+export const MaxEnumFunction = withEnumResult(MaxEnumFunctionBase);
+
+export const MaxNumberFunction = withNumberResult(MaxNumberFunctionBase);
+
+export const MaxStringFunction = withStringResult(MaxStringFunctionBase);
+
+export const MaxTimeFunction = withTimeResult(MaxTimeFunctionBase);
+
+export const MinBooleanFunction = withBooleanOperations(MaxBooleanFunctionBase);
+
+export const MinDateFunction = withDateResult(MinDateFunctionBase);
+
+export const MinDateTimeFunction = withDateTimeResult(MinDateTimeFunctionBase);
+
+export const MinEnumFunction = withEnumResult(MinEnumFunctionBase);
+
+export const MinNumberFunction = withNumberResult(MinNumberFunctionBase);
+
+export const MinStringFunction = withStringResult(MinStringFunctionBase);
+
+export const MinTimeFunction = withTimeResult(MinTimeFunctionBase);
+
+export const SizeFunction = withNumberResult(SizeFunctionBase);
+
+export const SumFunction = class extends withNumberResult(SumFunctionBase) {};
+//#endregion
+
+//#region any
+export const AnyBooleanFunction = withBooleanOperations(AnyBooleanFunctionBase);
+
+export const AnyDateFunction = withDateResult(AnyDateFunctionBase);
+
+export const AnyDateTimeFunction = withDateTimeResult(AnyDateTimeFunctionBase);
+
+export const AnyEntityFunction = withEntityResult(withEntityPath(AnyEntityFunctionBase));
+
+export const AnyEnumFunction = withEnumResult(AnyEnumFunctionBase);
+
+export const AnyNumberFunction = withNumberResult(AnyNumberFunctionBase);
+
+export const AnyStringFunction = withStringResult(AnyStringFunctionBase);
+
+export const AnyTimeFunction = withTimeResult(AnyTimeFunctionBase);
+//#endregion
+
+//#region boolean functions
+export const AndOrBooleanExpression = withBooleanOperations(AndOrBooleanExpressionBase);
+export const BetweenBooleanExpression = withBooleanOperations(BetweenBooleanExpressionBase);
+export const CollectionContainsExpression = withBooleanOperations(CollectionContainsExpressionBase);
+export const CompareCollectionExpression = withBooleanOperations(CompareCollectionExpressionBase);
+export const CompareExpression = withBooleanOperations(CompareExpressionBase);
+export const CompareSubQueryExpression = withBooleanOperations(CompareSubQueryExpressionBase);
+export const ExistsExpression = withBooleanOperations(ExistsExpressionBase);
+export const IsEmptyExpression = withBooleanOperations(IsEmptyExpressionBase);
+export const IsNullExpression = withBooleanOperations(IsNullExpressionBase);
+export const MapContainsExpression = withBooleanOperations(MapContainsExpressionBase);
+export const NotBooleanExpression = withBooleanOperations(NotBooleanExpressionBase);
+export const StringCompareExpression = withBooleanOperations(StringCompareExpressionBase);
+export const SubQueryCompareExpression = withBooleanOperations(SubQueryCompareExpressionBase);
+export const SubQueryContainsExpression = withBooleanOperations(SubQueryContainsExpressionBase);
+//#endregion
+//#region collection
+export const TupleExpression = withTupleResult(TupleExpressionBase);
+//#endregion
+//#region
+export const BooleanConst = withBooleanOperations(BooleanConstBase);
+export const DateConst = withDateResult(DateConstBase);
+export const DateTimeConst = withDateTimeResult(DateTimeConstBase);
+export const NumberConst = withNumberResult(NumberConstBase);
+export const StringConst = withStringResult(StringConstBase);
+export const TimeConst = withTimeResult(TimeConstBase);
+export const EnumConst = withEnumResult(EnumConstBase);
+//#endregion
+
+//#region dateTime
+export const CurrentDateFunction = withDateResult(CurrentDateFunctionBase);
+export const CurrentDateTimeFunction = withDateTimeResult(CurrentDateTimeFunctionBase);
+export const CurrentTimeFunction = withTimeResult(CurrentTimeFunctionBase);
+export const DateTransformFunction = withNumberResult(DateTransformFunctionBase);
+export const TimeTransformFunction = withNumberResult(TimeTransformFunctionBase);
+//#endregion
+
+//#region mapGet
+abstract class MapGetFunction extends Expression {
+    readonly mapPath: MapResultExpression;
+    readonly key: ScalarResultExpression;
+
+    constructor(mapPath: MapResultExpression, key: ScalarResultExpression, resultType: JavaType) {
+        super(resultType);
+        this.mapPath = mapPath;
+        this.key = key;
+    }
+
+    validate(): void {
+        if (this.mapPath == null || this.key == null) {
+            throw new Error("MapGetFunction的mapPath和key 参数不能为空");
+        }
+    }
+}
+
+export const MapGetBooleanFunction = withBooleanOperations(
+    class extends MapGetFunction {
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.bool);
+        }
+    },
+);
+
+export const MapGetDateFunction = withDateResult(
+    class extends MapGetFunction {
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.date);
+        }
+    },
+);
+
+export const MapGetDateTimeFunction = withDateTimeResult(
+    class extends MapGetFunction {
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.dateTime);
+        }
+    },
+);
+
+export const MapGetNumberFunction = withNumberResult(
+    class extends MapGetFunction implements NumberExpressionProperties {
+        readonly numberType__: JavaType = javaTypes.number;
+
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.number);
+        }
+    },
+);
+
+export const MapGetStringFunction = withStringResult(
+    class extends MapGetFunction {
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.string);
+        }
+    },
+);
+
+export const MapGetTimeFunction = withTimeResult(
+    class extends MapGetFunction {
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.time);
+        }
+    },
+);
+
+export const MapGetEnumFunction = withEnumResult(
+    class extends MapGetFunction implements EnumExpressionProperties {
+        readonly enumType__: string = javaTypes.enum;
+
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.enum);
+        }
+    },
+);
+
+export const MapGetEntityFunction = withEntityResult(
+    class extends MapGetFunction implements EntityExpressionProperties {
+        readonly entityType__: string = javaTypes.object;
+
+        constructor(mapPath: MapResultExpression, key: ScalarResultExpression) {
+            super(mapPath, key, javaTypes.object);
+        }
+    },
+);
+
+//#endregion
+
+//#region nullfun
+export const CoalesceBooleanFunction = withBooleanOperations(CoalesceBooleanFunctionBase);
+
+export const CoalesceDateFunction = withDateResult(CoalesceDateFunctionBase);
+
+export const CoalesceDateTimeFunction = withDateTimeResult(CoalesceDateTimeFunctionBase);
+
+export const CoalesceNumberFunction = withNumberResult(CoalesceNumberFunctionBase);
+
+export const CoalesceStringFunction = withStringResult(CoalesceStringFunctionBase);
+
+export const CoalesceTimeFunction = withTimeResult(CoalesceTimeFunctionBase);
+
+export const CoalesceEnumFunction = withEnumResult(CoalesceEnumFunctionBase);
+
+export const CoalesceEntityFunction = withEntityResult(CoalesceEntityFunctionBase);
+
+export const NullIfBooleanFunction = withBooleanOperations(NullIfBooleanFunctionBase);
+
+export const NullIfDateFunction = withDateResult(NullIfDateFunctionBase);
+
+export const NullIfDateTimeFunction = withDateTimeResult(NullIfDateTimeFunctionBase);
+
+export const NullIfNumberFunction = withNumberResult(NullIfNumberFunctionBase);
+
+export const NullIfStringFunction = withStringResult(NullIfStringFunctionBase);
+
+export const NullIfTimeFunction = withTimeResult(NullIfTimeFunctionBase);
+
+export const NullIfEnumFunction = withEnumResult(NullIfEnumFunctionBase);
+
+export const NullIfEntityFunction = withEntityResult(NullIfEntityFunctionBase);
+
+//#endregion
+
+//#region path
+export class BooleanListPath extends withCollectionPath(BooleanListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyBooleanFunction(this);
+    }
+}
+
+export const BooleanPath = withBooleanOperations(BooleanPathBase);
+
+export class BooleanSetPath extends withCollectionPath(BooleanSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyBooleanFunction(this);
+    }
+}
+
+export class DateListPath extends withCollectionPath(DateListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyDateFunction(this);
+    }
+}
+
+export const DatePath = withDateResult(DatePathBase);
+
+export class DateSetPath extends withCollectionPath(DateSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyDateFunction(this);
+    }
+}
+
+export class DateTimeListPath extends withCollectionPath(DateTimeListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyDateTimeFunction(this);
+    }
+}
+
+export const DateTimePath = withDateTimeResult(DateTimePathBase);
+
+export class DateTimeSetPath extends withCollectionPath(DateTimeSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyDateTimeFunction(this);
+    }
+}
+
+export class EntityListPath<T extends QEntity> extends withCollectionPath(EntityListPathBase) {
+    private readonly withQueryEntity?: WithQueryEntityFunction;
+
+    /**
+     * 构造实体集合路径
+     * @param path 属性名
+     * @param fromEntity 所属的Java实体类型
+     * @param parent 上级路径对象
+     * @param withFun 用于生成QueryEntity的mixin方法
+     * @param alias 别名
+     */
+    constructor(
+        path: string,
+        fromEntity: string,
+        parent?: PathExpression,
+        withFun?: WithQueryEntityFunction,
+        alias?: string,
+    ) {
+        super(path, fromEntity, parent, alias);
+        this.withQueryEntity = withFun;
+    }
+
+    /**
+     * 集合中的任何元素，此方法适用与无指定QEntiy类型的动态查询构造
+     */
+    anyQ(): InstanceType<typeof AnyEntityFunction> {
+        return new AnyEntityFunction("", "", this);
+    }
+
+    /**
+     * 类型化的any方法，返回指定的QEntity类型
+     */
+    any(): T & ScalarResultExpression {
+        if (this.withQueryEntity) {
+            return new (this.withQueryEntity(AnyEntityFunction))(this) as T &
+                ScalarResultExpression;
+        } else {
+            throw new Error("any()方法要求必须使用withQueryEntityFunction参数不能为空");
+        }
+    }
+}
+
+export const EntityPath = withEntityPath(EntityPathBase);
+
+export class EntitySetPath<T extends QEntity> extends withCollectionPath(EntitySetPathBase) {
+    private readonly withQueryEntity?: WithQueryEntityFunction;
+
+    /**
+     * 构造实体集合路径
+     * @param path 属性名
+     * @param fromEntity 所属的Java实体类型
+     * @param parent 上级路径对象
+     * @param withFun 用于生成QueryEntity的mixin方法
+     * @param alias 别名
+     */
+    constructor(
+        path: string,
+        fromEntity: string,
+        parent?: PathExpression,
+        withFun?: WithQueryEntityFunction,
+        alias?: string,
+    ) {
+        super(path, fromEntity, parent, alias);
+        this.withQueryEntity = withFun;
+    }
+
+    /**
+     * 集合中的任何元素，此方法适用与无指定QEntiy类型的动态查询构造
+     */
+    anyQ() {
+        return new AnyEntityFunction("", "", this);
+    }
+
+    /**
+     * 类型化的any方法，返回指定的QEntity类型
+     */
+    any(): T & ScalarResultExpression {
+        if (this.withQueryEntity) {
+            return new (this.withQueryEntity(AnyEntityFunction))(this) as T &
+                ScalarResultExpression;
+        } else {
+            throw new Error("any()方法要求必须使用withQueryEntityFunction参数不能为空");
+        }
+    }
+}
+
+export class EnumListPath extends withCollectionPath(EnumListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyEnumFunction(this);
+    }
+}
+
+export const EnumPath = withEnumResult(EnumPathBase);
+
+export class EnumSetPath extends withCollectionPath(EnumSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyEnumFunction(this);
+    }
+}
+
+export const MapPath = withMapResult(MapPathBase);
+
+export class NumberListPath extends withCollectionPath(NumberListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyNumberFunction(this, this.elementType__ as JavaType);
+    }
+}
+
+export const NumberPath = withNumberResult(NumberPathBase);
+
+export class NumberSetPath extends withCollectionPath(NumberSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyNumberFunction(this, this.elementType__ as JavaType);
+    }
+}
+
+export class StringListPath extends withCollectionPath(StringListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyStringFunction(this);
+    }
+}
+
+export const StringPath = withStringResult(StringPathBase);
+
+export class StringSetPath extends withCollectionPath(StringSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyStringFunction(this);
+    }
+}
+
+export class TimeListPath extends withCollectionPath(TimeListPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyTimeFunction(this);
+    }
+}
+
+export const TimePath = withTimeOperations(TimePathBase);
+
+export class TimeSetPath extends withCollectionPath(TimeSetPathBase) {
+    /**
+     * 集合中的任何元素
+     */
+    any() {
+        return new AnyTimeFunction(this);
+    }
+}
+
+//#endregion
+
+//#region num
+export const AbsFunction = withNumberResult(AbsFunctionBase);
+export const ArithmeticExpression = withNumberResult(ArithmeticExpressionBase);
+export const CastToNumFunction = withNumberResult(CastToNumFunctionBase);
+export const CeilFunction = withNumberResult(CeilFunctionBase);
+export const FloorFunction = withNumberResult(FloorFunctionBase);
+export const NegateFunction = withNumberResult(NegateFunctionBase);
+export const RoundFunction = withNumberResult(RoundFunctionBase);
+export const SqrtFunction = withNumberResult(SqrtFunctionBase);
+//#endregion
+
+//#region str function
+export const ConcatStringFunction = withStringResult(ConcatStringFunctionBase);
+export const IndexOfStringFunction = withNumberResult(IndexOfStringFunctionBase);
+export const LengthOfStringFunction = withNumberResult(LengthOfStringFunctionBase);
+export const StringTransformFunction = withStringResult(StringTransformFunctionBase);
+export const SubstringFunction = withStringResult(SubstringFunctionBase);
+export const ToStringFunction = withStringResult(ToStringFunctionBase);
+//#endregion
+
+//#region when
+export const BooleanCaseExpression = withBooleanOperations(BooleanCaseExpressionBase);
+export const DateCaseExpression = withDateResult(DateCaseExpressionBase);
+export const DateTimeCaseExpression = withDateTimeResult(DateTimeCaseExpressionBase);
+export const TimeCaseExpression = withTimeResult(TimeCaseExpressionBase);
+export const StringCaseExpression = withStringResult(StringCaseExpressionBase);
+export const EnumCaseExpression = withEnumResult(EnumCaseExpressionBase);
+export const EntityCaseExpression = withEntityResult(EntityCaseExpressionBase);
+export const NumberCaseExpression = withNumberResult(NumberCaseExpressionBase);
+
+//#endregion