namirasoft-node-clickhouse 1.4.4 → 1.4.5

package/package.json

@@ -8,7 +8,7 @@
     "framework": "npm",
     "application": "package",
     "private": false,
-    "version": "1.4.4",
+    "version": "1.4.5",
     "author": "Amir Abolhasani",
     "license": "MIT",
     "main": "./dist/index.js",

package/src/BaseClickhouseDatabase.ts

@@ -1,118 +1,118 @@
-import { Logger } from "namirasoft-log";
-import { BaseDatabase, BaseFilterItemBuilder_JoinTable } from "namirasoft-node";
-import { createClient } from '@clickhouse/client';
-import { NodeClickHouseClient } from '@clickhouse/client/dist/client';
-import { BaseClickhouseTable } from "./BaseClickhouseTable";
-import { FilterItem, SortItem } from "namirasoft-core";
-import { FindOptions } from "./FindOptions";
-import { BaseFilterItemBuilderClickhouse } from "./BaseFilterItemBuilderClickhouse";
-
-export abstract class BaseClickhouseDatabase extends BaseDatabase
-{
-    public client!: NodeClickHouseClient;
-    private name: string;
-    constructor(isHTTPS: boolean, host: string, port: number, name: string, user: string, pass: string, params?: { [name: string]: string })
-    {
-        super();
-        let parameters = Object.keys(params ?? {}).map(key => `${key}=>${params?.[key]}`).join("&");
-        if (!process.env.NAMIRASOFT_MUTE)
-        {
-            this.client = createClient({
-                url: `http${isHTTPS ? "s" : ""}://${user}:${pass}@${host}:${port}/${name}${parameters.length > 0 ? ("?" + parameters) : ""}`,
-            })
-        }
-        this.name = name;
-    }
-    override async connect()
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-        {
-            await this.client.ping();
-            Logger.main?.success(`Database Clickhouse was connected to ${this.name}`);
-        }
-    }
-    override async sync(force: boolean)
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-            if (force)
-            {
-                // There is no such a feature
-            }
-    }
-    getQuery(table: string, option: FindOptions): string
-    {
-        let columns = (option.columns ?? []).filter(c => c);
-        let where = (option.where ?? []).filter(w => w);
-        let order = (option.order ?? []).filter(o => o);
-
-        let parts = ["SELECT"];
-        if (columns.length == 0)
-            parts.push("*");
-        parts.push(columns.join(", "));
-        parts.push("FROM");
-        parts.push(table);
-        if (where.length > 0)
-        {
-            parts.push("WHERE");
-            parts.push(where.join(" AND "));
-        }
-        if (order.length > 0)
-        {
-            parts.push("SORT");
-            parts.push(order.join(", "));
-        }
-        if (option.limit)
-        {
-            parts.push(`LIMIT ${option.limit}`);
-            if (option.offset)
-                parts.push(`OFFSET ${option.offset}`);
-        }
-        return parts.join(" ");
-    }
-    async select<T>(query: string): Promise<T[]>
-    {
-        let res = await this.client.query({
-            query,
-            format: "JSON"
-        });
-        let ans = await res.json<T>();
-        return ans.data;
-    }
-    async getFiltersConditions(table_main: BaseClickhouseTable<BaseClickhouseDatabase>, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<string[]> }, filters?: FilterItem[] | undefined): Promise<string[][]>
-    {
-        let builder = new BaseFilterItemBuilderClickhouse(this);
-        return await builder.build(table_main, table_joins, filters);
-    }
-    getAdvancedSearchConditions(columns: string[], search: string): string[]
-    {
-        const conditions: string[] = [];
-
-        if (search && search.split)
-        {
-            const toks = search.split(' ').filter(Boolean);
-
-            for (const tok of toks)
-            {
-                const safeTok = tok.trim().replace(/'/g, "\\'"); // escape single quotes
-                const cs = columns.map(column => `ifNull(${column}, '')`);
-                const concatExpr = `concat(${cs.join(', ')})`;
-                const condition = `positionCaseInsensitiveUTF8(${concatExpr}, '${safeTok}') > 0`;
-                conditions.push(condition);
-            }
-        }
-
-        return conditions;
-    }
-    override getSortOptions(sorts?: SortItem[] | undefined): string[]
-    {
-        let ans: string[] = sorts?.filter(s => s).map(s =>
-        {
-            return `s.column.name ${s.ascending ? "ASC" : "DESC"}`;
-        }) ?? [];
-
-        if (!ans || ans.length == 0)
-            ans = ["created_at DESC"];
-
-        return ans;
-    }
+import { Logger } from "namirasoft-log";
+import { BaseDatabase, BaseFilterItemBuilder_JoinTable } from "namirasoft-node";
+import { createClient } from '@clickhouse/client';
+import { NodeClickHouseClient } from '@clickhouse/client/dist/client';
+import { BaseClickhouseTable } from "./BaseClickhouseTable";
+import { FilterItem, SortItem } from "namirasoft-core";
+import { FindOptions } from "./FindOptions";
+import { BaseFilterItemBuilderClickhouse } from "./BaseFilterItemBuilderClickhouse";
+
+export abstract class BaseClickhouseDatabase extends BaseDatabase
+{
+    public client!: NodeClickHouseClient;
+    private name: string;
+    constructor(isHTTPS: boolean, host: string, port: number, name: string, user: string, pass: string, params?: { [name: string]: string })
+    {
+        super();
+        let parameters = Object.keys(params ?? {}).map(key => `${key}=>${params?.[key]}`).join("&");
+        if (!process.env.NAMIRASOFT_MUTE)
+        {
+            this.client = createClient({
+                url: `http${isHTTPS ? "s" : ""}://${user}:${pass}@${host}:${port}/${name}${parameters.length > 0 ? ("?" + parameters) : ""}`,
+            })
+        }
+        this.name = name;
+    }
+    override async connect()
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+        {
+            await this.client.ping();
+            Logger.main?.success(`Database Clickhouse was connected to ${this.name}`);
+        }
+    }
+    override async sync(force: boolean)
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+            if (force)
+            {
+                // There is no such a feature
+            }
+    }
+    getQuery(table: string, option: FindOptions): string
+    {
+        let columns = (option.columns ?? []).filter(c => c);
+        let where = (option.where ?? []).filter(w => w);
+        let order = (option.order ?? []).filter(o => o);
+
+        let parts = ["SELECT"];
+        if (columns.length == 0)
+            parts.push("*");
+        parts.push(columns.join(", "));
+        parts.push("FROM");
+        parts.push(`${this.name}.${table}`);
+        if (where.length > 0)
+        {
+            parts.push("WHERE");
+            parts.push(where.join(" AND "));
+        }
+        if (order.length > 0)
+        {
+            parts.push("ORDER BY");
+            parts.push(order.join(", "));
+        }
+        if (option.limit)
+        {
+            parts.push(`LIMIT ${option.limit}`);
+            if (option.offset)
+                parts.push(`OFFSET ${option.offset}`);
+        }
+        return parts.join(" ");
+    }
+    async select<T>(query: string): Promise<T[]>
+    {
+        let res = await this.client.query({
+            query,
+            format: "JSON"
+        });
+        let ans = await res.json<T>();
+        return ans.data;
+    }
+    async getFiltersConditions(table_main: BaseClickhouseTable<BaseClickhouseDatabase>, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<string[]> }, filters?: FilterItem[] | undefined): Promise<string[][]>
+    {
+        let builder = new BaseFilterItemBuilderClickhouse(this);
+        return await builder.build(table_main, table_joins, filters);
+    }
+    getAdvancedSearchConditions(columns: string[], search: string): string[]
+    {
+        const conditions: string[] = [];
+
+        if (search && search.split)
+        {
+            const toks = search.split(' ').filter(Boolean);
+
+            for (const tok of toks)
+            {
+                const safeTok = tok.trim().replace(/'/g, "\\'"); // escape single quotes
+                const cs = columns.map(column => `ifNull(${column}, '')`);
+                const concatExpr = `concat(${cs.join(', ')})`;
+                const condition = `positionCaseInsensitiveUTF8(${concatExpr}, '${safeTok}') > 0`;
+                conditions.push(condition);
+            }
+        }
+
+        return conditions;
+    }
+    override getSortOptions(sorts?: SortItem[] | undefined): string[]
+    {
+        let ans: string[] = sorts?.filter(s => s).map(s =>
+        {
+            return `s.column.name ${s.ascending ? "ASC" : "DESC"}`;
+        }) ?? [];
+
+        if (!ans || ans.length == 0)
+            ans = ["created_at DESC"];
+
+        return ans;
+    }
 }

package/src/BaseClickhouseModelSchema.ts

@@ -1,5 +1,5 @@
-import { BaseClickhouseModelSchemaColumnOptions } from "./BaseClickhouseModelSchemaColumnOptions";
-
-export type BaseClickhouseModelSchema<TAttributes = any> = {
-    [name in keyof TAttributes]: BaseClickhouseModelSchemaColumnOptions;
+import { BaseClickhouseModelSchemaColumnOptions } from "./BaseClickhouseModelSchemaColumnOptions";
+
+export type BaseClickhouseModelSchema<TAttributes = any> = {
+    [name in keyof TAttributes]: BaseClickhouseModelSchemaColumnOptions;
 }

package/src/BaseClickhouseModelSchemaColumnOptions.ts

@@ -1,7 +1,7 @@
-import { BaseTableColumnOptions } from "namirasoft-node";
-
-export interface BaseClickhouseModelSchemaColumnOptions extends BaseTableColumnOptions
-{
-    type: any;
-    required: boolean;
+import { BaseTableColumnOptions } from "namirasoft-node";
+
+export interface BaseClickhouseModelSchemaColumnOptions extends BaseTableColumnOptions
+{
+    type: any;
+    required: boolean;
 };

package/src/BaseClickhouseTable.ts

@@ -1,177 +1,177 @@
-import { BaseClickhouseDatabase } from "./BaseClickhouseDatabase";
-import { BaseTable } from "namirasoft-node";
-import { BaseMetaColumn, BaseMetaTable, SortItem } from "namirasoft-core";
-import { AnySchema, ArraySchema, BaseTypeSchema, BoolSchema, DateTimeSchema, DoubleSchema, StringSchema, TypeSchema, VariableSchema } from "namirasoft-schema";
-import { BaseClickhouseModelSchemaColumnOptions } from "./BaseClickhouseModelSchemaColumnOptions";
-import { BaseClickhouseModelSchema } from "./BaseClickhouseModelSchema";
-import { FindOptions } from "./FindOptions";
-
-export abstract class BaseClickhouseTable<D extends BaseClickhouseDatabase> extends BaseTable<D, BaseClickhouseModelSchemaColumnOptions>
-{
-    name!: string;
-    schema!: BaseClickhouseModelSchema;
-    constructor(database: D, name: string, schema: BaseClickhouseModelSchema)
-    {
-        super(database);
-        this.name = name;
-        this.schema = schema;
-    }
-    override getName(): string
-    {
-        return this.name;
-    }
-    override getSecureColumns(): string[]
-    {
-        let columns = super.getSecureColumns();
-        return ["_id", "__v", "deleted_at", "deletedAt", ...columns]
-    }
-    override getReadOnlyColumns(): string[]
-    {
-        let columns = super.getReadOnlyColumns();
-        return ["id", "created_at", "updated_at", "createdAt", "updatedAt", ...columns];
-    }
-    private getModelAllSchemas()
-    {
-        let otherAttributes: BaseClickhouseModelSchema = {
-            _id: { type: String, required: true },
-            __v: { type: String, required: true },
-        };
-        return { ... this.schema, ...otherAttributes };
-    }
-    public override getColumnOption(name: string)
-    {
-        let schema = this.getModelAllSchemas();
-        return schema[name] as BaseClickhouseModelSchemaColumnOptions;
-    }
-    public override forEachColumn(handler: (name: string, column: BaseClickhouseModelSchemaColumnOptions) => void)
-    {
-        let schema = this.getModelAllSchemas();
-        let keys = Object.keys(schema);
-        for (let i = 0; i < keys.length; i++)
-            handler(keys[i], this.getColumnOption(keys[i]));
-    }
-    public override getColumn(name: string): BaseMetaColumn
-    {
-        let option = this.getColumnOption(name);
-        let table_name = this.getName();
-        let table = new BaseMetaTable(null, table_name, table_name);
-        let type = option.type;
-        try
-        {
-            if (typeof (type) == "function")
-                type = type.name;
-        } catch (error)
-        {
-        }
-        let column = new BaseMetaColumn(table, name, name, type, option.required);
-        return column;
-    }
-    protected override getTypeSchema(option: BaseClickhouseModelSchemaColumnOptions): BaseTypeSchema
-    {
-        let required = option.required;
-        /* VariableType */
-        if (option.type === Boolean)
-            return new BoolSchema(required);
-        // else if (type instanceof Number)
-        //     return new TinyIntSchema(required);
-        // else if (type instanceof DataTypes.SMALLINT)
-        //     return new SmallIntSchema(required);
-        // else if (type instanceof DataTypes.MEDIUMINT)
-        //     return new MediumIntSchema(required);
-        // else if (type instanceof DataTypes.INTEGER)
-        //     return new IntegerSchema(required);
-        // else if (type instanceof DataTypes.BIGINT)
-        //     return new BigIntSchema(required);
-        // else if (this.isFloat(type))
-        //     return new FloatSchema(required, type.options.decimals);
-        else if (option.type === Number)
-            return new DoubleSchema(required, null);
-        // else if (this.isDecimal(type))
-        //     return new DecimalSchema(required, type.options.scale);
-        // else if (this.isReal(type))
-        //     return new RealSchema(required, type.options.decimals);
-        // else if (this.isChar(type))
-        //     return new StringSchema(required, type.options.length, type.options.length);
-        else if (option.type === String)
-            return new StringSchema(required, null, null);
-        // else if (type instanceof DataTypes.TEXT)
-        //     return new StringSchema(required, null, null);
-        else if (option.type === Date)
-            return new DateTimeSchema(required);
-        // else if (type instanceof DataTypes.DATEONLY)
-        //     return new DateSchema(required);
-        // else if (type instanceof DataTypes.TIME)
-        //     return new TimeSchema(required);
-        // else if (type instanceof DataTypes.DURATION)
-        //     return new DurationSchema(required);
-        // else if (this.isEnum(type))
-        // {
-        //     let name = NamingConvention.lower_case_underscore.convert(this.model.modelName + "_" + element.field, NamingConvention.Pascal_Case);
-        //     return new EnumSchema(name, required, type.options.values);
-        // }
-        // else if (type instanceof DataTypes.JSON)
-        //     return new AnySchema(required);
-        else if (option.type === Object)
-        {
-            let tags_type = option.tags?.type;
-            if (tags_type)
-            {
-                if (tags_type === "BaseTypeSchema")
-                    return new TypeSchema(required);
-                if (tags_type === "BaseVariableSchema")
-                    return new VariableSchema(required);
-                if (tags_type === "BaseTypeSchema[]")
-                    return new ArraySchema(required, [new TypeSchema(required)]);
-                if (tags_type === "BaseVariableSchema[]")
-                    return new ArraySchema(required, [new VariableSchema(required)]);
-            }
-            return new AnySchema(required);
-        }
-        throw new Error("Unsupported datatype for schema: " + option);
-    }
-
-    static formatDate(date: Date): string
-    {
-        return date.toISOString().replace('T', ' ').substring(0, 19); // "YYYY-MM-DD HH:mm:ss"
-    }
-    async _getOrNull<M>(option: FindOptions): Promise<M | null>
-    {
-        let query = this.database.getQuery(this.name, option);
-        let ans = await this.database.select<M>(query);
-        if (ans.length > 0)
-            return ans[0];
-        return null;
-    }
-    async _get<M>(options: FindOptions): Promise<M>
-    {
-        let value = await this._getOrNull<M>(options);
-        if (value != null)
-            return value;
-        throw this.getNotFoundError(options.where);
-    }
-    async _list<M>(where: string[], pagination: { dont: true } | { page: number, size: number }, sorts: { dont: true } | SortItem[], options: FindOptions): Promise<{ rows: M[], count: number }>
-    {
-        let order: string[] = [];
-        if (!('dont' in pagination))
-        {
-            let p = this.database.paginate(pagination.page, pagination.size);
-            options.offset = p.offset;
-            options.limit = p.limit;
-        }
-        if (!('dont' in sorts))
-            order = this.database.getSortOptions(sorts);
-
-        if (!options.where)
-            options.where = [];
-        options.where.push(...where);
-        if (!options.order)
-            options.order = [];
-        options.order.push(...order);
-
-        let query_rows = this.database.getQuery(this.name, options);
-        let query_count = this.database.getQuery(this.name, { columns: ["Count(*) as total"], where: options.where });
-        let res_rows = await this.database.select<M>(query_rows);
-        let res_count = await this.database.select<{ total: number }>(query_count);
-        return { rows: res_rows, count: res_count[0].total };
-    }
+import { BaseClickhouseDatabase } from "./BaseClickhouseDatabase";
+import { BaseTable } from "namirasoft-node";
+import { BaseMetaColumn, BaseMetaTable, SortItem } from "namirasoft-core";
+import { AnySchema, ArraySchema, BaseTypeSchema, BoolSchema, DateTimeSchema, DoubleSchema, StringSchema, TypeSchema, VariableSchema } from "namirasoft-schema";
+import { BaseClickhouseModelSchemaColumnOptions } from "./BaseClickhouseModelSchemaColumnOptions";
+import { BaseClickhouseModelSchema } from "./BaseClickhouseModelSchema";
+import { FindOptions } from "./FindOptions";
+
+export abstract class BaseClickhouseTable<D extends BaseClickhouseDatabase> extends BaseTable<D, BaseClickhouseModelSchemaColumnOptions>
+{
+    name!: string;
+    schema!: BaseClickhouseModelSchema;
+    constructor(database: D, name: string, schema: BaseClickhouseModelSchema)
+    {
+        super(database);
+        this.name = name;
+        this.schema = schema;
+    }
+    override getName(): string
+    {
+        return this.name;
+    }
+    override getSecureColumns(): string[]
+    {
+        let columns = super.getSecureColumns();
+        return ["_id", "__v", "deleted_at", "deletedAt", ...columns]
+    }
+    override getReadOnlyColumns(): string[]
+    {
+        let columns = super.getReadOnlyColumns();
+        return ["id", "created_at", "updated_at", "createdAt", "updatedAt", ...columns];
+    }
+    private getModelAllSchemas()
+    {
+        let otherAttributes: BaseClickhouseModelSchema = {
+            _id: { type: String, required: true },
+            __v: { type: String, required: true },
+        };
+        return { ... this.schema, ...otherAttributes };
+    }
+    public override getColumnOption(name: string)
+    {
+        let schema = this.getModelAllSchemas();
+        return schema[name] as BaseClickhouseModelSchemaColumnOptions;
+    }
+    public override forEachColumn(handler: (name: string, column: BaseClickhouseModelSchemaColumnOptions) => void)
+    {
+        let schema = this.getModelAllSchemas();
+        let keys = Object.keys(schema);
+        for (let i = 0; i < keys.length; i++)
+            handler(keys[i], this.getColumnOption(keys[i]));
+    }
+    public override getColumn(name: string): BaseMetaColumn
+    {
+        let option = this.getColumnOption(name);
+        let table_name = this.getName();
+        let table = new BaseMetaTable(null, table_name, table_name);
+        let type = option.type;
+        try
+        {
+            if (typeof (type) == "function")
+                type = type.name;
+        } catch (error)
+        {
+        }
+        let column = new BaseMetaColumn(table, name, name, type, option.required);
+        return column;
+    }
+    protected override getTypeSchema(option: BaseClickhouseModelSchemaColumnOptions): BaseTypeSchema
+    {
+        let required = option.required;
+        /* VariableType */
+        if (option.type === Boolean)
+            return new BoolSchema(required);
+        // else if (type instanceof Number)
+        //     return new TinyIntSchema(required);
+        // else if (type instanceof DataTypes.SMALLINT)
+        //     return new SmallIntSchema(required);
+        // else if (type instanceof DataTypes.MEDIUMINT)
+        //     return new MediumIntSchema(required);
+        // else if (type instanceof DataTypes.INTEGER)
+        //     return new IntegerSchema(required);
+        // else if (type instanceof DataTypes.BIGINT)
+        //     return new BigIntSchema(required);
+        // else if (this.isFloat(type))
+        //     return new FloatSchema(required, type.options.decimals);
+        else if (option.type === Number)
+            return new DoubleSchema(required, null);
+        // else if (this.isDecimal(type))
+        //     return new DecimalSchema(required, type.options.scale);
+        // else if (this.isReal(type))
+        //     return new RealSchema(required, type.options.decimals);
+        // else if (this.isChar(type))
+        //     return new StringSchema(required, type.options.length, type.options.length);
+        else if (option.type === String)
+            return new StringSchema(required, null, null);
+        // else if (type instanceof DataTypes.TEXT)
+        //     return new StringSchema(required, null, null);
+        else if (option.type === Date)
+            return new DateTimeSchema(required);
+        // else if (type instanceof DataTypes.DATEONLY)
+        //     return new DateSchema(required);
+        // else if (type instanceof DataTypes.TIME)
+        //     return new TimeSchema(required);
+        // else if (type instanceof DataTypes.DURATION)
+        //     return new DurationSchema(required);
+        // else if (this.isEnum(type))
+        // {
+        //     let name = NamingConvention.lower_case_underscore.convert(this.model.modelName + "_" + element.field, NamingConvention.Pascal_Case);
+        //     return new EnumSchema(name, required, type.options.values);
+        // }
+        // else if (type instanceof DataTypes.JSON)
+        //     return new AnySchema(required);
+        else if (option.type === Object)
+        {
+            let tags_type = option.tags?.type;
+            if (tags_type)
+            {
+                if (tags_type === "BaseTypeSchema")
+                    return new TypeSchema(required);
+                if (tags_type === "BaseVariableSchema")
+                    return new VariableSchema(required);
+                if (tags_type === "BaseTypeSchema[]")
+                    return new ArraySchema(required, [new TypeSchema(required)]);
+                if (tags_type === "BaseVariableSchema[]")
+                    return new ArraySchema(required, [new VariableSchema(required)]);
+            }
+            return new AnySchema(required);
+        }
+        throw new Error("Unsupported datatype for schema: " + option);
+    }
+
+    static formatDate(date: Date): string
+    {
+        return date.toISOString().replace('T', ' ').substring(0, 19); // "YYYY-MM-DD HH:mm:ss"
+    }
+    async _getOrNull<M>(option: FindOptions): Promise<M | null>
+    {
+        let query = this.database.getQuery(this.name, option);
+        let ans = await this.database.select<M>(query);
+        if (ans.length > 0)
+            return ans[0];
+        return null;
+    }
+    async _get<M>(options: FindOptions): Promise<M>
+    {
+        let value = await this._getOrNull<M>(options);
+        if (value != null)
+            return value;
+        throw this.getNotFoundError(options.where);
+    }
+    async _list<M>(where: string[], pagination: { dont: true } | { page: number, size: number }, sorts: { dont: true } | SortItem[], options: FindOptions): Promise<{ rows: M[], count: number }>
+    {
+        let order: string[] = [];
+        if (!('dont' in pagination))
+        {
+            let p = this.database.paginate(pagination.page, pagination.size);
+            options.offset = p.offset;
+            options.limit = p.limit;
+        }
+        if (!('dont' in sorts))
+            order = this.database.getSortOptions(sorts);
+
+        if (!options.where)
+            options.where = [];
+        options.where.push(...where);
+        if (!options.order)
+            options.order = [];
+        options.order.push(...order);
+
+        let query_rows = this.database.getQuery(this.name, options);
+        let query_count = this.database.getQuery(this.name, { columns: ["Count(*) as total"], where: options.where });
+        let res_rows = await this.database.select<M>(query_rows);
+        let res_count = await this.database.select<{ total: number }>(query_count);
+        return { rows: res_rows, count: res_count[0].total };
+    }
 }

package/src/BaseFilterItemBuilderClickhouse.ts

@@ -1,108 +1,108 @@
-import { BaseFilterItemBuilder_JoinTable, BaseFilterItemBuilderDatabase } from "namirasoft-node";
-import { BaseClickhouseDatabase } from "./BaseClickhouseDatabase";
-
-export class BaseFilterItemBuilderClickhouse extends BaseFilterItemBuilderDatabase<string[]>
-{
-    override async getAdvancedSearchConditions(columns: string[], search: string)
-    {
-        let database = this.database as BaseClickhouseDatabase;
-        return [database.getAdvancedSearchConditions(columns, search)];
-    }
-    override getIn(column_name: string, not: boolean, values: string[])
-    {
-        const escapedValues = values.map(v => `'${v.replace(/'/g, `\\'`)}'`).join(', ');
-        const condition = `${column_name} ${not ? 'NOT IN' : 'IN'} (${escapedValues})`;
-        return { condition: [condition] };
-    }
-    override getLike(column_name: string, not: boolean, value: string)
-    {
-        const escapedValue = value.replace(/'/g, `\\'`);
-
-        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '%${escapedValue}%')`;
-
-        return { condition: [condition] };
-    }
-    override getRegex(column_name: string, not: boolean, value: string)
-    {
-        const escapedValue = value.replace(/'/g, `\\'`);
-
-        const condition = `${not ? 'NOT ' : ''}match(${column_name}, '${escapedValue}')`;
-
-        return { condition: [condition] };
-    }
-    override getEmpty(column_name: string, not: boolean)
-    {
-        let condition = '';
-
-        if (!not)
-            condition = `(${column_name} IS NULL OR ${column_name} = '')`;
-        else
-            condition = `(${column_name} IS NOT NULL AND ${column_name} != '')`;
-
-        return { condition: [condition] };
-    }
-    override getExists(column_name: string, not: boolean)
-    {
-        let condition = `(${column_name} IS NOT NULL AND ${column_name} != '')`;
-        if (not)
-            condition = `NOT (${condition})`;
-        if (!not)
-            return { condition: [condition] };
-        return { condition: [condition], independant: { not } };
-    }
-    override getIncludes(column_name: string, not: boolean, values: string[])
-    {
-        const escapedValues = values.map(v => `'${v.replace(/'/g, `\\'`)}'`).join(', ');
-        const condition = `${column_name} ${not ? 'NOT IN' : 'IN'} (${escapedValues})`;
-        if (!not)
-            return { condition: [condition] };
-        return { condition: [condition], independant: { not } };
-    }
-    override getStartsWith(column_name: string, not: boolean, value: string)
-    {
-        const escapedValue = value.replace(/'/g, `\\'`);
-        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '${escapedValue}%')`;
-        return { condition: [condition] };
-    }
-    override getEndsWith(column_name: string, not: boolean, value: string)
-    {
-        const escapedValue = value.replace(/'/g, `\\'`);
-        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '%${escapedValue}')`;
-        return { condition: [condition] };
-    }
-    override getLT(column_name: string, value: any)
-    {
-        const condition = `${column_name} < ${this.escapeValue(value)}`;
-        return { condition: [condition] };
-    }
-    override getLTE(column_name: string, value: any)
-    {
-        const condition = `${column_name} <= ${this.escapeValue(value)}`;
-        return { condition: [condition] };
-    }
-    override getGT(column_name: string, value: any)
-    {
-        const condition = `${column_name} > ${this.escapeValue(value)}`;
-        return { condition: [condition] };
-    }
-    override getGTE(column_name: string, value: any)
-    {
-        const condition = `${column_name} >= ${this.escapeValue(value)}`;
-        return { condition: [condition] };
-    }
-    override async getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<string[]>, conditions: string[][]) 
-    {
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.flat().join(' AND ')}` : '';
-        const select = `SELECT ${join.secondary.column} FROM ${table_name} ${whereClause}`;
-        const condition = `${join.main.column} ${not ? 'NOT IN' : 'IN'} (${select})`;
-        return [condition];
-    }
-    override escapeValue(value: any): string
-    {
-        if (typeof value === 'string')
-            return `'${value.replace(/'/g, `\\'`)}'`;
-        if (value instanceof Date)
-            return `'${value.toISOString()}'`;
-        return value.toString();
-    }
+import { BaseFilterItemBuilder_JoinTable, BaseFilterItemBuilderDatabase } from "namirasoft-node";
+import { BaseClickhouseDatabase } from "./BaseClickhouseDatabase";
+
+export class BaseFilterItemBuilderClickhouse extends BaseFilterItemBuilderDatabase<string[]>
+{
+    override escapeValue(value: any): string
+    {
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, `\\'`)}'`;
+        if (value instanceof Date)
+            return `'${value.toISOString()}'`;
+        return value.toString();
+    }
+    override async getAdvancedSearchConditions(columns: string[], search: string)
+    {
+        let database = this.database as BaseClickhouseDatabase;
+        return [database.getAdvancedSearchConditions(columns, search)];
+    }
+    override getIn(column_name: string, not: boolean, values: string[])
+    {
+        const escapedValues = values.map(v => `'${v.replace(/'/g, `\\'`)}'`).join(', ');
+        const condition = `${column_name} ${not ? 'NOT IN' : 'IN'} (${escapedValues})`;
+        return { condition: [condition] };
+    }
+    override getLike(column_name: string, not: boolean, value: string)
+    {
+        const escapedValue = value.replace(/'/g, `\\'`);
+
+        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '%${escapedValue}%')`;
+
+        return { condition: [condition] };
+    }
+    override getRegex(column_name: string, not: boolean, value: string)
+    {
+        const escapedValue = value.replace(/'/g, `\\'`);
+
+        const condition = `${not ? 'NOT ' : ''}match(${column_name}, '${escapedValue}')`;
+
+        return { condition: [condition] };
+    }
+    override getEmpty(column_name: string, not: boolean)
+    {
+        let condition = '';
+
+        if (!not)
+            condition = `(${column_name} IS NULL OR ${column_name} = '')`;
+        else
+            condition = `(${column_name} IS NOT NULL AND ${column_name} != '')`;
+
+        return { condition: [condition] };
+    }
+    override getExists(column_name: string, not: boolean)
+    {
+        let condition = `(${column_name} IS NOT NULL AND ${column_name} != '')`;
+        if (not)
+            condition = `NOT (${condition})`;
+        if (!not)
+            return { condition: [condition] };
+        return { condition: [condition], independant: { not } };
+    }
+    override getIncludes(column_name: string, not: boolean, values: string[])
+    {
+        const escapedValues = values.map(v => `'${v.replace(/'/g, `\\'`)}'`).join(', ');
+        const condition = `${column_name} ${not ? 'NOT IN' : 'IN'} (${escapedValues})`;
+        if (!not)
+            return { condition: [condition] };
+        return { condition: [condition], independant: { not } };
+    }
+    override getStartsWith(column_name: string, not: boolean, value: string)
+    {
+        const escapedValue = value.replace(/'/g, `\\'`);
+        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '${escapedValue}%')`;
+        return { condition: [condition] };
+    }
+    override getEndsWith(column_name: string, not: boolean, value: string)
+    {
+        const escapedValue = value.replace(/'/g, `\\'`);
+        const condition = `${not ? 'NOT ' : ''}(${column_name} LIKE '%${escapedValue}')`;
+        return { condition: [condition] };
+    }
+    override getLT(column_name: string, value: any)
+    {
+        const condition = `${column_name} < ${this.escapeValue(value)}`;
+        return { condition: [condition] };
+    }
+    override getLTE(column_name: string, value: any)
+    {
+        const condition = `${column_name} <= ${this.escapeValue(value)}`;
+        return { condition: [condition] };
+    }
+    override getGT(column_name: string, value: any)
+    {
+        const condition = `${column_name} > ${this.escapeValue(value)}`;
+        return { condition: [condition] };
+    }
+    override getGTE(column_name: string, value: any)
+    {
+        const condition = `${column_name} >= ${this.escapeValue(value)}`;
+        return { condition: [condition] };
+    }
+    override async getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<string[]>, conditions: string[][]) 
+    {
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.flat().join(' AND ')}` : '';
+        const select = `SELECT ${join.secondary.column} FROM ${table_name} ${whereClause}`;
+        const condition = `${join.main.column} ${not ? 'NOT IN' : 'IN'} (${select})`;
+        return [condition];
+    }
 }

package/src/FindOptions.ts

@@ -1,8 +1,8 @@
-export interface FindOptions
-{
-    columns?: string[];
-    where?: string[];
-    order?: string[];
-    limit?: number;
-    offset?: number;
+export interface FindOptions
+{
+    columns?: string[];
+    where?: string[];
+    order?: string[];
+    limit?: number;
+    offset?: number;
 }

package/src/index.ts

@@ -1,5 +1,5 @@
-export * from "./BaseClickhouseDatabase";
-export * from "./BaseClickhouseModelSchema";
-export * from "./BaseClickhouseModelSchemaColumnOptions";
-export * from "./BaseClickhouseTable";
+export * from "./BaseClickhouseDatabase";
+export * from "./BaseClickhouseModelSchema";
+export * from "./BaseClickhouseModelSchemaColumnOptions";
+export * from "./BaseClickhouseTable";
 export * from "./BaseFilterItemBuilderClickhouse"