ace-front-end 1.0.0

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

@@ -0,0 +1,1081 @@
+export interface TypeResultExpression {
+    resultType: JavaType;
+
+    validate(): void;
+
+    ascend(): void;
+
+    descend(): void;
+
+    isDesc(): boolean;
+}
+
+export type Comparable = string | number | boolean | Date;
+
+/**
+ * 结果值为可比较类型的表达式
+ */
+export interface ComparableResultExpression extends TypeResultExpression {
+    /**
+     * 创建针对当前表达式的计数count表达式
+     */
+    count(): NumberResultExpression;
+
+    /**
+     * 创建针对当前表达式的计数count表达式
+     * @param distinct 是否去重
+     */
+    count(distinct: boolean): NumberResultExpression;
+
+    /**
+     * 创建等于比较表达式
+     * @param right 等号右侧比较值
+     */
+    eq(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建等于比较表达式
+     * @param right 等号右侧比较值
+     */
+    eq<T extends Comparable>(constValue: T): BooleanResultExpression;
+
+    /**
+     * 创建小于表达式
+     * @param right 小于号右侧的比较值
+     */
+    lt(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建小于表达式
+     * @param right 小于号右侧的比较值
+     */
+    lt<T extends Comparable>(right: T): BooleanResultExpression;
+
+    /**
+     * 创建大于表达式
+     * @param right 大于号右侧的比较值
+     */
+    gt(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建大于表达式
+     * @param right 大于号右侧的比较值
+     */
+    gt<T extends Comparable>(right: T): BooleanResultExpression;
+
+    /**
+     * 创建不等于比较表达式
+     * @param right 不等号右侧比较值
+     */
+    ne(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建不等于比较表达式
+     * @param right 不等号右侧比较值
+     */
+    ne<T extends Comparable>(right: T): BooleanResultExpression;
+
+    /**
+     * 创建小于等于表达式
+     * @param right 大于等于号右侧的比较值
+     */
+    loe(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建小于等于表达式
+     * @param right 大于等于号右侧的比较值
+     */
+    loe<T extends Comparable>(right: T): BooleanResultExpression;
+
+    /**
+     * 创建大于等于表达式
+     * @param right 大于等于号右侧的比较值
+     */
+    goe(right: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建大于等于表达式
+     * @param right 大于等于号右侧的比较值
+     */
+    goe<T extends Comparable>(right: T): BooleanResultExpression;
+
+    /**
+     * 创建between比较表达式
+     * @param low 最小值
+     * @param high 最大值
+     */
+    between<T extends ComparableResultExpression>(low: T, high: T): BooleanResultExpression;
+
+    /**
+     * 创建between比较表达式
+     * @param low 最小值
+     * @param high 最大值
+     */
+    between<T extends Comparable>(low: T, high: T): BooleanResultExpression;
+
+    /**
+     * 创建between比较表达式
+     * @param low 最小值
+     * @param high 最大值
+     */
+    between<T extends Comparable>(
+        low: ComparableResultExpression,
+        high: T
+    ): BooleanResultExpression;
+
+    /**
+     * 创建between比较表达式
+     * @param low 最小值
+     * @param high 最大值
+     */
+    between<T extends Comparable>(
+        low: T,
+        high: ComparableResultExpression
+    ): BooleanResultExpression;
+
+    /**
+     * 创建isNull判断是否为空表达式
+     * @param not 是否取反，true表示判断非空
+     */
+    isNull(not: boolean): BooleanResultExpression;
+}
+
+export type EnumKeys<TE> = keyof TE;
+
+export type DateType = string;
+
+function isDateType(value: string): value is DateType {
+    const dateRegExp = /^\d{4}-\d{2}-\d{2}$/;
+    return dateRegExp.test(value);
+}
+
+/**
+ * 字符串转换为DateType，检查格式是否正确，格式要求为"yyyy-MM-dd"
+ */
+export function toDate(value: string): DateType {
+    if (isDateType(value)) {
+        return value as DateType; // 类型转换
+    }
+    throw new Error("Invalid date format, expected yyyy-MM-dd");
+}
+
+export type DateTimeType = string;
+
+function isDateTimeType(value: string): value is DateType {
+    const dateRegExp = /^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}$/;
+    return dateRegExp.test(value);
+}
+
+/**
+ * 字符串转换为DateTimeType，检查格式是否正确，格式要求为"yyyy-MM-dd HH:mm:ss"
+ */
+export function toDateTime(value: string): DateTimeType {
+    if (isDateTimeType(value)) {
+        return value as DateTimeType; // 类型转换
+    }
+    throw new Error("Invalid dateTime format, expected yyyy-MM-dd HH:mm:ss");
+}
+
+export type TimeType = string;
+
+function isTimeType(value: string): value is DateType {
+    const dateRegExp = /^\d{2}:\d{2}:\d{2}$/;
+    return dateRegExp.test(value);
+}
+
+/**
+ * 字符串转换为TimeType，检查格式是否正确，格式要求为"HH:mm:ss"
+ */
+export function toTime(value: string): DateTimeType {
+    if (isTimeType(value)) {
+        return value as DateTimeType; // 类型转换
+    }
+    throw new Error("Invalid dateTime format, expected HH:mm:ss");
+}
+
+/**
+ * java类
+ */
+export type JavaType = (typeof javaTypes)[keyof typeof javaTypes];
+/**
+ * Java类型名
+ */
+export const javaTypes = {
+    bool: "java.lang.Boolean",
+    string: "java.lang.String",
+    dateTime: "java.time.LocalDateTime",
+    date: "java.time.LocalDate",
+    time: "java.time.LocalTime",
+    long: "java.lang.Long",
+    int: "java.lang.Integer",
+    short: "java.lang.Short",
+    float: "java.lang.Float",
+    double: "java.lang.Double",
+    byte: "java.lang.Byte",
+    decimal: "java.math.BigDecimal",
+    bigInt: "java.math.BigInteger",
+    list: "java.util.List",
+    set: "java.util.Set",
+    map: "java.util.Map",
+    object: "java.lang.Object",
+    enum: "java.lang.Enum",
+    number: "java.lang.Number",
+    tuple: "com.csicit.ace.api.expr.Tuple",
+} as const;
+
+export type BooleanOperator = "AND" | "OR";
+
+export type CollectionCompareOperator =
+    | "IN"
+    | "NOT_IN"
+    | "EQUAL_ALL"
+    | "NOT_EQUAL_ALL"
+    | "EQUAL_ANY"
+    | "NOT_EQUAL_ANY"
+    | "GREAT_THAN_ALL"
+    | "GREAT_THAN_ANY"
+    | "LESS_THAN_ALL"
+    | "LESS_THAN_ANY"
+    | "GREAT_THAN_OR_EQUAL_ALL"
+    | "GREAT_THAN_OR_EQUAL_ANY"
+    | "LESS_THAN_OR_EQUAL_ALL"
+    | "LESS_THAN_OR_EQUAL_ANY";
+
+export type CompareOperator =
+    | "EQUAL"
+    | "NOT_EQUAL"
+    | "GREAT_THAN"
+    | "LESS_THAN"
+    | "GREAT_THAN_OR_EQUAL"
+    | "LESS_THAN_OR_EQUAL";
+
+export type DateTransformOperator =
+    | "DAY_OF_WEEK"
+    | "DAY_OF_MONTH"
+    | "DAY_OF_YEAR"
+    | "MONTH"
+    | "YEAR"
+    | "WEEK"
+    | "YEAR_MONTH"
+    | "YEAR_WEEK";
+
+export type TimeTransformOperator = "HOUR" | "MINUTE" | "SECOND" | "MILLISECOND";
+
+export type JoinType = "INNER" | "LEFT" | "RIGHT";
+
+export type ArithmeticOperator = "ADD" | "MINUS" | "MULTIPLY" | "DIVIDE" | "MOD";
+
+export type StringTransformOperator = "TRIM" | "UPPER" | "LOWER";
+
+export type StringCompareOperator =
+    | "CONTAIN"
+    | "CONTAIN_IGNORE_CASE"
+    | "START_WITH"
+    | "START_WITH_IGNORE_CASE"
+    | "END_WITH"
+    | "END_WITH_IGNORE_CASE"
+    | "EQUAL_IGNORE_CASE"
+    | "NOT_EQUAL_IGNORE_CASE"
+    | "MATCH"
+    | "LIKE"
+    | "LIKE_IGNORE_CASE"
+    | "NOT_LIKE";
+
+/**
+ * 表示结果值为标量的表达式
+ */
+export interface ScalarResultExpression extends ComparableResultExpression {
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: BooleanResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: StringResultExpression): StringResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: EnumResultExpression): EnumResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: DateResultExpression): DateResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: DateTimeResultExpression): DateTimeResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: TimeResultExpression): TimeResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: EntityResultExpression): EntityResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: boolean): BooleanResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: string): StringResultExpression;
+
+    /**
+     * 创建coalesce函数表达式，该表达式自作向右取遇到的第一个非空结果值
+     * @param right 右侧表达式
+     */
+    coalesce(right: number): NumberResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: BooleanResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: StringResultExpression): StringResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: EnumResultExpression): EnumResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: DateResultExpression): DateResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: DateTimeResultExpression): DateTimeResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: TimeResultExpression): TimeResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: EntityResultExpression): EntityResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: boolean): BooleanResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: string): StringResultExpression;
+
+    /**
+     * 创建nulIf函数表达式，该函数将当前表达式结果值与右侧表达式结果值比较，如果相等返回空值，否则返回当前表达式结果值(左侧值)
+     */
+    nullIf(right: number): NumberResultExpression;
+
+    /**
+     * 创建作用为转换为字符串的函数表达式
+     */
+    str(): StringResultExpression;
+
+    /**
+     * 创建作用为转换为数值的函数表达式
+     */
+    castToNum(numberType: JavaType): NumberResultExpression;
+}
+
+/**
+ * 表示结果为布尔类型的表达式
+ */
+export interface BooleanResultExpression extends ScalarResultExpression {
+    /**
+     * 创建and逻辑表达式
+     * @param right and右侧布尔表达式
+     */
+    and(right: BooleanResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建and逻辑表达式
+     * @param right and右侧布尔表达式
+     */
+    and(right: boolean): BooleanResultExpression;
+
+    /**
+     * 创建or逻辑表达式
+     * @param right or右侧布尔表达式
+     */
+    or(right: BooleanResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建or逻辑表达式
+     * @param right or右侧布尔表达式
+     */
+    or(right: boolean): BooleanResultExpression;
+
+    /**
+     * 创建取最小值的表达式
+     */
+    min(): BooleanResultExpression;
+
+    /**
+     * 创建取最大值的表达式
+     */
+    max(): BooleanResultExpression;
+
+    /**
+     * 创建逻辑取反的表达式
+     */
+    not(): BooleanResultExpression;
+}
+
+export interface CollectionExpressionProperties extends TypeResultExpression {
+    elementType__: JavaType | string;
+}
+
+export interface CollectionOperations {
+    size(): NumberResultExpression;
+
+    contains(value: ComparableResultExpression): BooleanResultExpression;
+}
+
+export interface CollectionExpression
+    extends CollectionExpressionProperties,
+            CollectionOperations {
+}
+
+export interface PathExpression extends TypeResultExpression {
+    path__: string;
+    alias__?: string;
+    fromEntity__: string;
+    superPath__?: PathExpression;
+}
+
+export interface CollectionPath extends CollectionExpression, PathExpression {
+}
+
+export interface TemporalResultExpression extends ScalarResultExpression {
+}
+
+export interface DateTemporalResultExpression extends TemporalResultExpression {
+}
+
+export interface TimeTemporalResultExpression extends TemporalResultExpression {
+}
+
+export interface DateOperations {
+    /**
+     * 创建获取当前日期表达式结果值是周几的表达式
+     */
+    dayOfWeek(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日期表达式结果值是几号的表达式
+     */
+    dayOfMonth(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日志表达式结果值是年中第几天的表达式
+     */
+    dayOfYear(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日期表达式结果值的所属月份的表达式
+     */
+    month(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日期表达式结果值的所属年份的表达式
+     */
+    year(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日期表达式结果值是当年中的第几周的表达式
+     */
+    week(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日期表达式结果值中年月部分的表达式，返回结果如: 202310，表示2023年10月
+     */
+    yearMonth(): NumberResultExpression;
+
+    /**
+     * 创建获取当前日志表达式结果值中年周部分的表达式，返回结果如：202320，表示2023年第20周
+     */
+    yearWeek(): NumberResultExpression;
+}
+
+export interface TimeOperations {
+    /**
+     * 创建获取当期时间表达式结果值的小时部分
+     */
+    hour(): NumberResultExpression;
+
+    /**
+     * 创建获取当期时间表达式结果值的分钟部分
+     */
+    minute(): NumberResultExpression;
+
+    /**
+     * 创建获取当期时间表达式结果值的秒数部分
+     */
+    second(): NumberResultExpression;
+
+    /**
+     * 创建获取当期时间表达式结果值的毫秒数部分
+     */
+    milliSecond(): NumberResultExpression;
+}
+
+export interface DateResultExpression extends DateTemporalResultExpression, DateOperations {
+    /**
+     * 创建获取最小值表达式
+     */
+    min(): DateResultExpression;
+
+    /**
+     * 创建获取最大值表达式
+     */
+    max(): DateResultExpression;
+}
+
+export interface DateTimeResultExpression
+    extends DateTemporalResultExpression,
+            TimeTemporalResultExpression,
+            DateOperations,
+            TimeOperations {
+    /**
+     * 创建获取最小值表达式
+     */
+    min(): DateTimeResultExpression;
+
+    /**
+     * 创建获取最大值表达式
+     */
+    max(): DateTimeResultExpression;
+}
+
+export interface TimeResultExpression extends TimeTemporalResultExpression, TimeOperations {
+    /**
+     * 创建获取最小值表达式
+     */
+    min(): TimeResultExpression;
+
+    /**
+     * 创建获取最大值表达式
+     */
+    max(): TimeResultExpression;
+}
+
+export interface EntityExpressionProperties {
+    entityType__: string;
+}
+
+export interface EntityResultExpression
+    extends ScalarResultExpression,
+            EntityExpressionProperties {
+}
+
+export interface EnumExpressionProperties {
+    enumType__: string;
+}
+
+export interface EnumResultExpression extends ScalarResultExpression, EnumExpressionProperties {
+    /**
+     * 创建获取最小值表达式
+     */
+    min(): EnumResultExpression;
+
+    /**
+     * 创建获取最大值表达式
+     */
+    max(): EnumResultExpression;
+}
+
+export interface ListResultExpression extends CollectionExpression {
+}
+
+export interface MapExpressionProperties {
+    keyType__: string;
+    valueType__: string;
+}
+
+export interface MapResultExpression extends TypeResultExpression, MapExpressionProperties {
+    /**
+     * 创建判断Map中是否包含指定键值的表达式
+     * @param key 键
+     * @param value 值
+     */
+    contains(
+        key: ScalarResultExpression,
+        value: ComparableResultExpression
+    ): BooleanResultExpression;
+
+    /**
+     * 创建判断Map中是否包含指定键值的表达式
+     * @param key 键
+     * @param value 值
+     */
+    contains(key: Comparable, value: Comparable): BooleanResultExpression;
+
+    /**
+     * 创建判断Map中是否包含指定键的表达式
+     * @param key 键
+     */
+    containsKey(key: ScalarResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断Map中是否包含指定键的表达式
+     * @param key 键
+     */
+    containsKey(key: Comparable): BooleanResultExpression;
+
+    /**
+     * 创建判断Map中是否包含指定值的表达式
+     * @param value 值
+     */
+    containsValue(value: ComparableResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断Map中是否包含指定值的表达式
+     * @param value 值
+     */
+    containsValue(value: Comparable): BooleanResultExpression;
+
+    /**
+     * 创建获取Map中指定键对应值的表达式
+     * @param key 键
+     */
+    get<T extends ScalarResultExpression>(key: ScalarResultExpression): T;
+}
+
+export interface NumberExpressionProperties {
+    numberType__: JavaType;
+}
+
+/**
+ * 表示结果为数值类型的表达式
+ */
+export interface NumberResultExpression extends ScalarResultExpression, NumberExpressionProperties {
+    /**
+     * 创建数值相加的表达式
+     * @param right 加号右侧的值
+     */
+    add(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建数值相加的表达式
+     * @param right 加号右侧的值
+     */
+    add(right: number): NumberResultExpression;
+
+    /**
+     * 创建数值相减的表达式
+     * @param right 减号右侧的值
+     */
+    minus(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建数值相减的表达式
+     * @param right 减号右侧的值
+     */
+    minus(right: number): NumberResultExpression;
+
+    /**
+     * 创建数值相乘的表达式
+     * @param right 乘号右侧的值
+     */
+    multiply(right: number): NumberResultExpression;
+
+    /**
+     * 创建数值相乘的表达式
+     * @param right 乘号右侧的值
+     */
+    multiply(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建数值相除的表达式
+     * @param right 除号右侧的值
+     */
+    divide(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建数值相除的表达式
+     * @param right 除号右侧的值
+     */
+    divide(right: number): NumberResultExpression;
+
+    /**
+     * 创建数值取余的表达式
+     * @param right 被除数值
+     */
+    mod(right: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建数值取余的表达式
+     * @param right 被除数值
+     */
+    mod(right: number): NumberResultExpression;
+
+    /**
+     * 创建取平均值的函数表达式
+     */
+    avg(): NumberResultExpression;
+
+    /**
+     * 创建求和函数表达式
+     */
+    sum(): NumberResultExpression;
+
+    /**
+     * 创建最小值函数表达式
+     */
+    min(): NumberResultExpression;
+
+    /**
+     * 创建最大值函数表达式
+     */
+    max(): NumberResultExpression;
+}
+
+export interface SetResultExpression extends CollectionExpression {
+}
+
+/**
+ * 表示结果值是字符串的表达式
+ */
+export interface StringResultExpression extends ScalarResultExpression {
+    /**
+     * 创建拼接字符串函数表达式
+     * @param right 要拼接的字符串
+     */
+    concat(right: StringResultExpression): StringResultExpression;
+
+    /**
+     * 创建拼接字符串函数表达式
+     * @param right 要拼接的字符串
+     */
+    concat(right: string): StringResultExpression;
+
+    /**
+     * 创建trim函数表达式，去除字符串前后的空格
+     */
+    trim(): StringResultExpression;
+
+    /**
+     * 创建转换为小写形式的函数表达式
+     */
+    lowerCase(): StringResultExpression;
+
+    /**
+     * 创建转换为大写形式的函数表达式
+     */
+    upperCase(): StringResultExpression;
+
+    /**
+     * 创建like模糊匹配表达式
+     * @param right 要匹配的值，按照sql标准，其中可以使用`%`或`_`作为通配符，其中`%`匹配多个字符，`_`匹配单个字符
+     */
+    like(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建like模糊匹配表达式
+     * @param right 要匹配的值，按照sql标准，其中可以使用`%`或`_`作为通配符，其中`%`匹配多个字符，`_`匹配单个字符
+     */
+    like(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否包含指定子串的表达式
+     * @param right 指定的子串
+     */
+    contains(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否包含指定子串的表达式
+     * @param right 指定的子串
+     */
+    contains(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串开头的表达式
+     * @param right 指定子串
+     */
+    startWith(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串开头的表达式
+     * @param right 指定子串
+     */
+    startWith(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串结尾的表达式
+     * @param right 指定子串
+     */
+    endWith(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串结尾的表达式
+     * @param right 指定子串
+     */
+    endWith(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否匹配指定正则表达式的表达式
+     * @param right 指定正则表达式
+     * @summary 因为不是所有数据库都支持正则匹配，所以应尽量避免使用方法
+     */
+    match(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否匹配指定正则表达式的表达式
+     * @param right 指定正则表达式
+     * @summary 因为不是所有数据库都支持正则匹配，所以应尽量避免使用方法
+     */
+    match(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否匹配指定模式字符串（忽略大小写）的表达式
+     * @param right 指定模式字符串
+     */
+    likeIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否匹配指定模式字符串（忽略大小写）的表达式
+     * @param right 指定模式字符串
+     */
+    likeIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否包含指定子串（忽略大小写）的表达式
+     * @param right 指定的子串
+     */
+    containIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否包含指定子串（忽略大小写）的表达式
+     * @param right 指定的子串
+     */
+    containIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串开头（忽略大小写）的表达式
+     * @param right 指定子串
+     */
+    startWithIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串开头（忽略大小写）的表达式
+     * @param right 指定子串
+     */
+    startWithIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串结尾（忽略大小写）的表达式
+     * @param right 指定子串
+     */
+    endWithIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否以指定子串结尾（忽略大小写）的表达式
+     * @param right 指定子串
+     */
+    endWithIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否不匹配指定模式的表达式
+     * @param right 指定模式字符串
+     */
+    notLike(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否不匹配指定模式的表达式
+     * @param right 指定模式字符串
+     */
+    notLike(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否等于指定字符串（忽略大小写）的表达式
+     * @param right 指定字符串
+     */
+    eqIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否等于指定字符串（忽略大小写）的表达式
+     * @param right 指定字符串
+     */
+    eqIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否不等于指定字符串（忽略大小写）的表达式
+     * @param right 指定字符串
+     */
+    neIgnoreCase(right: StringResultExpression): BooleanResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否不等于指定字符串（忽略大小写）的表达式
+     * @param right 指定字符串
+     */
+    neIgnoreCase(right: string): BooleanResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     */
+    indexOf(sub: StringResultExpression): NumberResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     * @param startFrom 从指定位置开始检索
+     */
+    indexOf(sub: StringResultExpression, startFrom: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     * @param startFrom 从指定位置开始检索
+     */
+    indexOf(sub: StringResultExpression, startFrom: number): NumberResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     * @param startFrom 从指定位置开始检索
+     */
+    indexOf(sub: string, startFrom: NumberResultExpression): NumberResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     */
+    indexOf(sub: string): NumberResultExpression;
+
+    /**
+     * 创建获取指定子串在当前字符串表达式结果值中起始位置的表达式
+     * @param sub 指定字符串
+     * @param startFrom 从指定位置开始检索
+     */
+    indexOf(sub: string, startFrom: number): NumberResultExpression;
+
+    /**
+     * 创建获取当前字符串表达式结果值长度的表达式
+     */
+    length(): NumberResultExpression;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     */
+    subString(beginIndex: NumberResultExpression): StringResultExpression;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     */
+    subString(beginIndex: number): string;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     * @param endIndex  结束截取位置
+     */
+    subString(
+        beginIndex: NumberResultExpression,
+        endIndex: NumberResultExpression
+    ): StringResultExpression;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     * @param endIndex  结束截取位置
+     */
+    subString(beginIndex: number, endIndex: NumberResultExpression): StringResultExpression;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     * @param endIndex  结束截取位置
+     */
+    subString(beginIndex: NumberResultExpression, endIndex: number): StringResultExpression;
+
+    /**
+     * 创建从当前字符串表达式结果值中截取子串的表达式
+     * @param beginIndex 开始截取位置
+     * @param endIndex  结束截取位置
+     */
+    subString(beginIndex: number, endIndex: number): StringResultExpression;
+
+    /**
+     * 创建判断当前字符串表达式结果值是否为空的表达式
+     * @param not 是否取反
+     */
+    isEmpty(not: boolean): BooleanResultExpression;
+
+    /**
+     * 创建获取最小值表达式
+     */
+    min(): StringResultExpression;
+
+    /**
+     * 创建获取最大值表达式
+     */
+    max(): StringResultExpression;
+}
+
+export interface TupleExpressionProperties {
+    elementTypes: string[];
+}
+
+export interface TupleResultExpression extends ScalarResultExpression, TupleExpressionProperties {
+}
+
+export interface Case<T extends ScalarResultExpression> {
+    key: BooleanResultExpression;
+    value: T;
+}
+
+export interface QEntity {
+    [p: string]: any;
+}
+
+export interface QEntityConstructor {
+    new (parent?: PathExpression, path?: string): QEntity;
+}
+
+export type SortDescriptor = {
+    field: string;
+    order: "asc" | "desc" | "" | null;
+};