oak-db 3.3.10 → 3.3.12

package/lib/MySQL/types/Configuration.d.ts

@@ -1,12 +1,12 @@
-export type MySQLConfiguration = {
-    host: string;
-    user: string;
-    password: string;
-    database: string;
-    charset: 'utf8mb4_general_ci';
-    connectionLimit: number;
-    port?: number;
-};
-export type Configuration = {
-    mysql: MySQLConfiguration;
-};
+export type MySQLConfiguration = {
+    host: string;
+    user: string;
+    password: string;
+    database: string;
+    charset: 'utf8mb4_general_ci';
+    connectionLimit: number;
+    port?: number;
+};
+export type Configuration = {
+    mysql: MySQLConfiguration;
+};

package/lib/MySQL/types/Configuration.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/PostgreSQL/connector.d.ts

@@ -0,0 +1,31 @@
+import { Pool, PoolClient, QueryResult, QueryResultRow } from 'pg';
+import { TxnOption } from 'oak-domain/lib/types';
+import { PostgreSQLConfiguration } from './types/Configuration';
+export declare class PostgreSQLConnector {
+    pool: Pool;
+    configuration: PostgreSQLConfiguration;
+    txnDict: Record<string, PoolClient>;
+    constructor(configuration: PostgreSQLConfiguration);
+    connect(): void;
+    disconnect(): Promise<void>;
+    startTransaction(option?: TxnOption): Promise<string>;
+    /**
+     * 映射隔离级别到 PostgreSQL 语法
+     */
+    private mapIsolationLevel;
+    exec(sql: string, txn?: string): Promise<[QueryResultRow[], QueryResult]>;
+    commitTransaction(txn: string): Promise<void>;
+    rollbackTransaction(txn: string): Promise<void>;
+    /**
+     * 执行多条 SQL 语句（用于初始化等场景）
+     */
+    execBatch(sqls: string[], txn?: string): Promise<void>;
+    /**
+     * 获取连接池状态
+     */
+    getPoolStatus(): {
+        total: number;
+        idle: number;
+        waiting: number;
+    };
+}

package/lib/PostgreSQL/connector.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLConnector = void 0;
+const tslib_1 = require("tslib");
+const pg_1 = require("pg");
+const uuid_1 = require("uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+class PostgreSQLConnector {
+    pool;
+    configuration;
+    txnDict;
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.txnDict = {};
+        this.pool = new pg_1.Pool(configuration);
+        // 错误处理
+        this.pool.on('error', (err) => {
+            console.error('PostgreSQL pool error:', err);
+        });
+    }
+    connect() {
+        // pg Pool 是惰性连接，不需要显式连接
+        // 但可以在这里进行连接测试
+    }
+    async disconnect() {
+        // 先获取所有事务ID的快照
+        const txnIds = Object.keys(this.txnDict);
+        for (const txnId of txnIds) {
+            try {
+                await this.rollbackTransaction(txnId);
+            }
+            catch (e) {
+                console.error(`Failed to rollback transaction ${txnId}:`, e);
+            }
+        }
+        await this.pool.end();
+    }
+    async startTransaction(option) {
+        const startInner = async () => {
+            const connection = await this.pool.connect();
+            // 添加：检测连接是否已被其他事务占用
+            for (const txn2 in this.txnDict) {
+                if (this.txnDict[txn2] === connection) {
+                    return new Promise((resolve) => {
+                        this.pool.on('release', () => resolve(startInner()));
+                    });
+                }
+            }
+            try {
+                let beginStmt = 'BEGIN';
+                if (option?.isolationLevel) {
+                    // PostgreSQL 隔离级别: 
+                    // READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE
+                    // 注意: PostgreSQL 的 READ UNCOMMITTED 行为等同于 READ COMMITTED
+                    const level = this.mapIsolationLevel(option.isolationLevel);
+                    beginStmt = `BEGIN ISOLATION LEVEL ${level}`;
+                }
+                await connection.query(beginStmt);
+                const id = (0, uuid_1.v4)();
+                this.txnDict[id] = connection;
+                return id;
+            }
+            catch (error) {
+                // 如果启动事务失败，释放连接
+                connection.release();
+                throw error;
+            }
+        };
+        return startInner();
+    }
+    /**
+     * 映射隔离级别到 PostgreSQL 语法
+     */
+    mapIsolationLevel(level) {
+        const levelUpper = level.toUpperCase().replace(/[-_]/g, ' '); // 同时处理 - 和 _
+        const validLevels = [
+            'READ UNCOMMITTED',
+            'READ COMMITTED',
+            'REPEATABLE READ',
+            'SERIALIZABLE'
+        ];
+        if (validLevels.includes(levelUpper)) {
+            return levelUpper;
+        }
+        // 默认使用 READ COMMITTED
+        console.warn(`Unknown isolation level "${level}", using READ COMMITTED`);
+        return 'READ COMMITTED';
+    }
+    async exec(sql, txn) {
+        if (process.env.NODE_ENV === 'development') {
+            // console.log(`SQL: ${sql}; \n`);
+        }
+        try {
+            let result;
+            if (txn) {
+                const connection = this.txnDict[txn];
+                (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+                result = await connection.query(sql);
+            }
+            else {
+                result = await this.pool.query(sql);
+            }
+            // 返回格式与 mysql2 兼容: [rows, fields/result]
+            return [result.rows, result];
+        }
+        catch (error) {
+            // 增强错误信息
+            const enhancedError = new Error(`PostgreSQL query failed: ${error.message}\nSQL: ${sql.slice(0, 500)}${sql.length > 500 ? '...' : ''}`);
+            enhancedError.originalError = error;
+            enhancedError.sql = sql;
+            throw enhancedError;
+        }
+    }
+    async commitTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+        try {
+            await connection.query('COMMIT');
+        }
+        finally {
+            delete this.txnDict[txn];
+            connection.release();
+        }
+    }
+    async rollbackTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+        try {
+            await connection.query('ROLLBACK');
+        }
+        finally {
+            delete this.txnDict[txn];
+            connection.release();
+        }
+    }
+    /**
+     * 执行多条 SQL 语句（用于初始化等场景）
+     */
+    async execBatch(sqls, txn) {
+        for (const sql of sqls) {
+            if (sql.trim()) {
+                await this.exec(sql, txn);
+            }
+        }
+    }
+    /**
+     * 获取连接池状态
+     */
+    getPoolStatus() {
+        return {
+            total: this.pool.totalCount,
+            idle: this.pool.idleCount,
+            waiting: this.pool.waitingCount
+        };
+    }
+}
+exports.PostgreSQLConnector = PostgreSQLConnector;

package/lib/PostgreSQL/store.d.ts

@@ -0,0 +1,38 @@
+import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult } from 'oak-domain/lib/types';
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { CascadeStore } from 'oak-domain/lib/store/CascadeStore';
+import { PostgreSQLConfiguration } from './types/Configuration';
+import { PostgreSQLConnector } from './connector';
+import { PostgreSQLTranslator, PostgreSQLSelectOption, PostgreSQLOperateOption } from './translator';
+import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
+import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
+import { CreateEntityOption } from '../types/Translator';
+import { DbStore } from '../types/dbStore';
+export declare class PostgreSQLStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements DbStore<ED, Cxt> {
+    protected countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
+    protected aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
+    protected selectAbjointRow<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: SyncContext<ED>, option: OP): Partial<ED[T]['Schema']>[];
+    protected updateAbjointRow<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: SyncContext<ED>, option: OP): number;
+    exec(script: string, txnId?: string): Promise<void>;
+    connector: PostgreSQLConnector;
+    translator: PostgreSQLTranslator<ED>;
+    constructor(storageSchema: StorageSchema<ED>, configuration: PostgreSQLConfiguration);
+    checkRelationAsync<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, operation: Omit<ED[T]['Operation'] | ED[T]['Selection'], 'id'>, context: Cxt): Promise<void>;
+    protected aggregateAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected supportManyToOneJoin(): boolean;
+    protected supportMultipleCreate(): boolean;
+    private formResult;
+    protected selectAbjointRowAsync<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: AsyncContext<ED>, option?: PostgreSQLSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: PostgreSQLOperateOption): Promise<number>;
+    operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OperateOption): Promise<OperationResult<ED>>;
+    select<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: SelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected countAbjointRowAsync<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: AsyncContext<ED>, option: SelectOption): Promise<number>;
+    count<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: SelectOption): Promise<number>;
+    begin(option?: TxnOption): Promise<string>;
+    commit(txnId: string): Promise<void>;
+    rollback(txnId: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    initialize(option: CreateEntityOption): Promise<void>;
+}

package/lib/PostgreSQL/store.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLStore = void 0;
+const tslib_1 = require("tslib");
+const CascadeStore_1 = require("oak-domain/lib/store/CascadeStore");
+const connector_1 = require("./connector");
+const translator_1 = require("./translator");
+const lodash_1 = require("lodash");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const relation_1 = require("oak-domain/lib/store/relation");
+function convertGeoTextToObject(geoText) {
+    if (geoText.startsWith('POINT')) {
+        const coord = geoText.match(/(-?\d+\.?\d*)/g);
+        (0, assert_1.default)(coord && coord.length === 2);
+        return {
+            type: 'point',
+            coordinate: coord.map(ele => parseFloat(ele)),
+        };
+    }
+    else if (geoText.startsWith('LINESTRING')) {
+        const coordsMatch = geoText.match(/\(([^)]+)\)/);
+        if (coordsMatch) {
+            const points = coordsMatch[1].split(',').map(p => {
+                const [x, y] = p.trim().split(/\s+/).map(parseFloat);
+                return [x, y];
+            });
+            return {
+                type: 'path',
+                coordinate: points,
+            };
+        }
+    }
+    else if (geoText.startsWith('POLYGON')) {
+        const ringsMatch = geoText.match(/\(\(([^)]+)\)\)/g);
+        if (ringsMatch) {
+            const rings = ringsMatch.map(ring => {
+                const coordStr = ring.replace(/[()]/g, '');
+                return coordStr.split(',').map(p => {
+                    const [x, y] = p.trim().split(/\s+/).map(parseFloat);
+                    return [x, y];
+                });
+            });
+            return {
+                type: 'polygon',
+                coordinate: rings,
+            };
+        }
+    }
+    throw new Error(`Unsupported geometry type: ${geoText.slice(0, 50)}`);
+}
+class PostgreSQLStore extends CascadeStore_1.CascadeStore {
+    countAbjointRow(entity, selection, context, option) {
+        throw new Error('PostgreSQL store 不支持同步取数据');
+    }
+    aggregateAbjointRowSync(entity, aggregation, context, option) {
+        throw new Error('PostgreSQL store 不支持同步取数据');
+    }
+    selectAbjointRow(entity, selection, context, option) {
+        throw new Error('PostgreSQL store 不支持同步取数据');
+    }
+    updateAbjointRow(entity, operation, context, option) {
+        throw new Error('PostgreSQL store 不支持同步更新数据');
+    }
+    async exec(script, txnId) {
+        await this.connector.exec(script, txnId);
+    }
+    connector;
+    translator;
+    constructor(storageSchema, configuration) {
+        super(storageSchema);
+        this.connector = new connector_1.PostgreSQLConnector(configuration);
+        this.translator = new translator_1.PostgreSQLTranslator(storageSchema);
+    }
+    checkRelationAsync(entity, operation, context) {
+        throw new Error('Method not implemented.');
+    }
+    async aggregateAbjointRowAsync(entity, aggregation, context, option) {
+        const sql = this.translator.translateAggregate(entity, aggregation, option);
+        const result = await this.connector.exec(sql, context.getCurrentTxnId());
+        return this.formResult(entity, result[0]);
+    }
+    aggregate(entity, aggregation, context, option) {
+        return this.aggregateAsync(entity, aggregation, context, option);
+    }
+    supportManyToOneJoin() {
+        return true;
+    }
+    supportMultipleCreate() {
+        return true;
+    }
+    formResult(entity, result) {
+        const schema = this.getSchema();
+        function resolveAttribute(entity2, r, attr, value) {
+            const { attributes, view } = schema[entity2];
+            if (!view) {
+                const i = attr.indexOf(".");
+                if (i !== -1) {
+                    const attrHead = attr.slice(0, i);
+                    const attrTail = attr.slice(i + 1);
+                    const rel = (0, relation_1.judgeRelation)(schema, entity2, attrHead);
+                    if (rel === 1) {
+                        (0, lodash_1.set)(r, attr, value);
+                    }
+                    else {
+                        if (!r[attrHead]) {
+                            r[attrHead] = {};
+                        }
+                        if (rel === 0) {
+                            resolveAttribute(entity2, r[attrHead], attrTail, value);
+                        }
+                        else if (rel === 2) {
+                            resolveAttribute(attrHead, r[attrHead], attrTail, value);
+                        }
+                        else {
+                            (0, assert_1.default)(typeof rel === 'string');
+                            resolveAttribute(rel, r[attrHead], attrTail, value);
+                        }
+                    }
+                }
+                else if (attributes[attr]) {
+                    const { type } = attributes[attr];
+                    switch (type) {
+                        case 'date':
+                        case 'time': {
+                            if (value instanceof Date) {
+                                r[attr] = value.valueOf();
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'geometry': {
+                            if (typeof value === 'string') {
+                                r[attr] = convertGeoTextToObject(value);
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'object':
+                        case 'array': {
+                            // PostgreSQL jsonb 直接返回对象，不需要 parse
+                            if (typeof value === 'string') {
+                                r[attr] = JSON.parse(value);
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'function': {
+                            if (typeof value === 'string') {
+                                r[attr] = `return ${Buffer.from(value, 'base64').toString()}`;
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        case 'bool':
+                        case 'boolean': {
+                            // PostgreSQL 直接返回 boolean 类型
+                            r[attr] = value;
+                            break;
+                        }
+                        case 'decimal': {
+                            // PostgreSQL numeric 类型可能返回字符串
+                            if (typeof value === 'string') {
+                                r[attr] = parseFloat(value);
+                            }
+                            else {
+                                (0, assert_1.default)(value === null || typeof value === 'number');
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        // TODO: 这里和mysql统一行为，ref类型的字符串去除前后空格
+                        case "char":
+                        case "ref": {
+                            if (value) {
+                                (0, assert_1.default)(typeof value === 'string');
+                                r[attr] = value.trim();
+                            }
+                            else {
+                                r[attr] = value;
+                            }
+                            break;
+                        }
+                        default: {
+                            r[attr] = value;
+                        }
+                    }
+                }
+                else {
+                    // TODO: 这里和mysql统一行为，id字段为char类型时，去除后面的空格
+                    if (value && typeof value === 'string') {
+                        if (attr === 'id') {
+                            r[attr] = value.trim();
+                        }
+                        else if (attr.startsWith("#count")) {
+                            // PostgreSQL count 返回字符串
+                            r[attr] = parseInt(value, 10);
+                        }
+                        else {
+                            r[attr] = value;
+                        }
+                    }
+                    else {
+                        r[attr] = value;
+                    }
+                }
+            }
+            else {
+                (0, lodash_1.assign)(r, { [attr]: value });
+            }
+        }
+        function removeNullObjects(r, e) {
+            for (let attr in r) {
+                const rel = (0, relation_1.judgeRelation)(schema, e, attr);
+                if (rel === 2) {
+                    if (r[attr].id === null) {
+                        (0, assert_1.default)(schema[e].toModi || r.entity !== attr);
+                        delete r[attr];
+                        continue;
+                    }
+                    removeNullObjects(r[attr], attr);
+                }
+                else if (typeof rel === 'string') {
+                    if (r[attr].id === null) {
+                        (0, assert_1.default)(schema[e].toModi || r[`${attr}Id`] === null, `对象${String(e)}取数据时，发现其外键找不到目标对象，rowId是${r.id}，其外键${attr}Id值为${r[`${attr}Id`]}`);
+                        delete r[attr];
+                        continue;
+                    }
+                    removeNullObjects(r[attr], rel);
+                }
+            }
+        }
+        function formSingleRow(r) {
+            let result2 = {};
+            for (let attr in r) {
+                const value = r[attr];
+                resolveAttribute(entity, result2, attr, value);
+            }
+            removeNullObjects(result2, entity);
+            return result2;
+        }
+        if (result instanceof Array) {
+            return result.map(r => formSingleRow(r));
+        }
+        return formSingleRow(result);
+    }
+    async selectAbjointRowAsync(entity, selection, context, option) {
+        const sql = this.translator.translateSelect(entity, selection, option);
+        const result = await this.connector.exec(sql, context.getCurrentTxnId());
+        return this.formResult(entity, result[0]);
+    }
+    async updateAbjointRowAsync(entity, operation, context, option) {
+        const { translator, connector } = this;
+        const { action } = operation;
+        const txn = context.getCurrentTxnId();
+        switch (action) {
+            case 'create': {
+                const { data } = operation;
+                const sql = translator.translateInsert(entity, data instanceof Array ? data : [data]);
+                const result = await connector.exec(sql, txn);
+                // PostgreSQL QueryResult.rowCount
+                return result[1].rowCount || 0;
+            }
+            case 'remove': {
+                const sql = translator.translateRemove(entity, operation, option);
+                const result = await connector.exec(sql, txn);
+                return result[1].rowCount || 0;
+            }
+            default: {
+                (0, assert_1.default)(!['select', 'download', 'stat'].includes(action));
+                const sql = translator.translateUpdate(entity, operation, option);
+                const result = await connector.exec(sql, txn);
+                return result[1].rowCount || 0;
+            }
+        }
+    }
+    async operate(entity, operation, context, option) {
+        const { action } = operation;
+        (0, assert_1.default)(!['select', 'download', 'stat'].includes(action), '不支持使用 select operation');
+        return await super.operateAsync(entity, operation, context, option);
+    }
+    async select(entity, selection, context, option) {
+        return await super.selectAsync(entity, selection, context, option);
+    }
+    async countAbjointRowAsync(entity, selection, context, option) {
+        const sql = this.translator.translateCount(entity, selection, option);
+        const result = await this.connector.exec(sql, context.getCurrentTxnId());
+        // PostgreSQL 返回的 count 是 string 类型（bigint）
+        const cnt = result[0][0]?.cnt;
+        return typeof cnt === 'string' ? parseInt(cnt, 10) : (cnt || 0);
+    }
+    async count(entity, selection, context, option) {
+        return this.countAsync(entity, selection, context, option);
+    }
+    async begin(option) {
+        return await this.connector.startTransaction(option);
+    }
+    async commit(txnId) {
+        await this.connector.commitTransaction(txnId);
+    }
+    async rollback(txnId) {
+        await this.connector.rollbackTransaction(txnId);
+    }
+    async connect() {
+        await this.connector.connect();
+    }
+    async disconnect() {
+        await this.connector.disconnect();
+    }
+    async initialize(option) {
+        const schema = this.getSchema();
+        // 可选：先创建 PostGIS 扩展
+        // await this.connector.exec('CREATE EXTENSION IF NOT EXISTS postgis;');
+        for (const entity in schema) {
+            const sqls = this.translator.translateCreateEntity(entity, option);
+            for (const sql of sqls) {
+                await this.connector.exec(sql);
+            }
+        }
+    }
+}
+exports.PostgreSQLStore = PostgreSQLStore;

package/lib/PostgreSQL/translator.d.ts

@@ -0,0 +1,83 @@
+import { EntityDict, Q_FullTextValue, RefOrExpression, Ref, StorageSchema } from "oak-domain/lib/types";
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { DataType } from "oak-domain/lib/types/schema/DataTypes";
+import { SqlOperateOption, SqlSelectOption, SqlTranslator } from "../sqlTranslator";
+import { CreateEntityOption } from '../types/Translator';
+export interface PostgreSQLSelectOption extends SqlSelectOption {
+}
+export interface PostgreSQLOperateOption extends SqlOperateOption {
+}
+export declare class PostgreSQLTranslator<ED extends EntityDict & BaseEntityDict> extends SqlTranslator<ED> {
+    private getEnumTypeName;
+    /**
+     * 将 MySQL 风格的 JSON 路径转换为 PostgreSQL 路径数组格式
+     * 例如: ".foo.bar[0].baz" -> '{foo,bar,0,baz}'
+     */
+    private convertJsonPath;
+    /**
+     * 生成 PostgreSQL JSON 访问表达式
+     * @param column 列名（包含别名）
+     * @param path JSON 路径
+     * @param asText 是否返回文本（使用 #>> 而不是 #>）
+     */
+    private buildJsonAccessor;
+    protected getDefaultSelectFilter(alias: string, option?: PostgreSQLSelectOption): string;
+    private makeUpSchema;
+    constructor(schema: StorageSchema<ED>);
+    static supportedDataTypes: DataType[];
+    static spatialTypes: DataType[];
+    static withLengthDataTypes: DataType[];
+    static withPrecisionDataTypes: DataType[];
+    static withScaleDataTypes: DataType[];
+    static dataTypeDefaults: Record<string, any>;
+    maxAliasLength: number;
+    private populateDataTypeDef;
+    /**
+     * PostgreSQL 字符串值转义
+     * 防御SQL注入
+     */
+    escapeStringValue(value: string): string;
+    /**
+     * LIKE 模式转义
+     * 转义 LIKE 语句中的特殊字符
+     */
+    escapeLikePattern(value: string): string;
+    /**
+     * PostgreSQL 标识符转义
+     * 用于表名、列名等
+     */
+    escapeIdentifier(identifier: string): string;
+    /**
+     * tsquery 搜索词转义
+     */
+    escapeTsQueryValue(value: string): string;
+    quoteIdentifier(identifier: string): string;
+    protected translateAttrProjection(dataType: DataType, alias: string, attr: string): string;
+    protected translateObjectPredicate(predicate: Record<string, any>, alias: string, attr: string): string;
+    protected translateObjectProjection(projection: Record<string, any>, alias: string, attr: string, prefix: string): string;
+    protected translateAttrValue(dataType: DataType | Ref, value: any): string;
+    protected translateFullTextSearch<T extends keyof ED>(value: Q_FullTextValue, entity: T, alias: string): string;
+    translateCreateEntity<T extends keyof ED>(entity: T, options?: CreateEntityOption): string[];
+    private translateFnName;
+    private translateAttrInExpression;
+    protected translateExpression<T extends keyof ED>(entity: T, alias: string, expression: RefOrExpression<keyof ED[T]["OpSchema"]>, refDict: Record<string, [string, keyof ED]>): string;
+    protected populateSelectStmt<T extends keyof ED>(projectionText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, groupByText?: string, indexFrom?: number, count?: number, option?: PostgreSQLSelectOption): string;
+    translateUpdate<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Update'], option?: OP): string;
+    translateRemove<T extends keyof ED, OP extends SqlOperateOption>(entity: T, operation: ED[T]['Remove'], option?: OP): string;
+    /**
+     * PostgreSQL专用的结构化JOIN分析
+     * 返回结构化的JOIN信息，而不是拼接好的FROM字符串
+     */
+    private analyzeJoinStructured;
+    /**
+     * 构建JOIN条件（用于UPDATE/DELETE的WHERE子句）
+     */
+    private buildJoinConditions;
+    /**
+     * 生成 PostgreSQL UPSERT 语句
+     * INSERT ... ON CONFLICT (key) DO UPDATE SET ...
+     */
+    translateUpsert<T extends keyof ED>(entity: T, data: ED[T]['CreateMulti']['data'], conflictKeys: string[], updateAttrs?: string[]): string;
+    protected populateUpdateStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: PostgreSQLOperateOption): string;
+    protected populateRemoveStmt(updateText: string, fromText: string, aliasDict: Record<string, string>, filterText: string, sorterText?: string, indexFrom?: number, count?: number, option?: PostgreSQLOperateOption): string;
+}