proto.io 0.0.215 → 0.0.217

package/dist/adapters/storage/progres.js

@@ -9,7 +9,7 @@ var QueryStream = require('pg-query-stream');
 var utilsJs = require('@o2ter/utils-js');
 var Decimal = require('decimal.js');
 var utils = require('pg/lib/utils');
-var validator = require('../../internals/validator-m6wY35c6.js');
+var validator = require('../../internals/validator-mcBCJP4P.js');
 require('@o2ter/crypto-js');
 var _const = require('../../internals/const-C3I6cfav.js');
 var random$1 = require('../../internals/random-nkOQ9U6S.js');
@@ -413,7 +413,7 @@ class QueryCompiler {
             return this.dialect.encodeFieldExpression(this, parent, filter.field, filter.expr);
         }
         if (filter instanceof validator.QueryExpressionSelector) {
-            return this.dialect.encodeQueryExpression(this, parent, filter.expr);
+            return this.dialect.encodeBooleanExpression(this, parent, filter.expr);
         }
     }
     _selectIncludes(className, includes) {
@@ -428,7 +428,7 @@ class QueryCompiler {
     _encodeSort(sort, parent) {
         if (_.isArray(sort)) {
             return sql `${_.map(sort, ({ expr, order }) => {
-                const _expr = this.dialect.encodeQueryExpression(this, parent, expr);
+                const _expr = this.dialect.encodeSortExpression(this, parent, expr);
                 if (!_expr)
                     throw Error('Invalid expression');
                 return sql `${_expr} ${{ literal: order === 1 ? 'ASC' : 'DESC' }}`;
@@ -540,6 +540,728 @@ class QueryCompiler {
     }
 }
 
+//
+//  encode.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const _encodeJsonValue = (value) => {
+    if (_.isArray(value))
+        return sql `jsonb_build_array(${_.map(value, x => _encodeJsonValue(x))})`;
+    if (_.isPlainObject(value))
+        return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
+    return sql `to_jsonb(${{ value }})`;
+};
+const _jsonPopulateInclude = (className, colname, dataType) => {
+    switch (index._typeof(dataType)) {
+        case 'decimal':
+            return sql `jsonb_build_object(
+            '$decimal', CAST(${{ identifier: className }}.${{ identifier: colname }} AS TEXT)
+          ) AS ${{ identifier: colname }}`;
+        case 'date':
+            return sql `jsonb_build_object(
+            '$date', to_char(${{ identifier: className }}.${{ identifier: colname }} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+          ) AS ${{ identifier: colname }}`;
+        default:
+            return sql `${{ identifier: className }}.${{ identifier: colname }}`;
+    }
+};
+const encodeType = (colname, dataType, value) => {
+    if (_.isNil(value))
+        return sql `NULL`;
+    switch (_.isString(dataType) ? dataType : dataType.type) {
+        case 'boolean':
+            if (_.isBoolean(value))
+                return sql `${{ value }}`;
+            break;
+        case 'number':
+            if (_.isNumber(value) && _.isFinite(value))
+                return sql `${{ value }}`;
+            if (value instanceof Decimal)
+                return sql `${{ value: value.toNumber() }}`;
+            break;
+        case 'decimal':
+            if (_.isNumber(value) && _.isFinite(value))
+                return sql `CAST(${{ quote: (new Decimal(value)).toString() }} AS DECIMAL)`;
+            if (value instanceof Decimal)
+                return sql `CAST(${{ quote: value.toString() }} AS DECIMAL)`;
+            break;
+        case 'string':
+            if (_.isString(value))
+                return sql `${{ value }}`;
+            break;
+        case 'string[]':
+            if (_.isArray(value) && _.every(value, x => _.isString(x)))
+                return sql `ARRAY[${_.map(value, x => sql `${{ value: x }}`)}]::TEXT[]`;
+            break;
+        case 'date':
+            if (_.isDate(value))
+                return sql `${{ value }}`;
+            break;
+        case 'object':
+            if (_.isPlainObject(value))
+                return sql `${{ value: index._encodeValue(value) }}`;
+            break;
+        case 'vector':
+            if (!_.isArray(value) || value.length !== index.dimensionOf(dataType))
+                break;
+            if (!_.every(value, x => _.isFinite(x)))
+                break;
+            return sql `${{ value }}::DOUBLE PRECISION[]`;
+        case 'array':
+            if (!_.isArray(value))
+                break;
+            return sql `ARRAY[${_.map(value, x => _encodeJsonValue(index._encodeValue(x)))}]::JSONB[]`;
+        case 'pointer':
+            if (value instanceof index.TObject && value.objectId)
+                return sql `${{ value: `${value.className}$${value.objectId}` }}`;
+            break;
+        case 'relation':
+            if (_.isArray(value) && _.every(value, x => x instanceof index.TObject && x.objectId)) {
+                return sql `${{ value: _.uniq(_.map(value, (x) => `${x.className}$${x.objectId}`)) }}`;
+            }
+            break;
+    }
+    throw Error('Invalid data type');
+};
+const decodeType = (type, value) => {
+    switch (type) {
+        case 'boolean':
+            if (_.isBoolean(value))
+                return value;
+            if (value === 'true')
+                return true;
+            if (value === 'false')
+                return false;
+            break;
+        case 'number':
+            if (_.isNumber(value))
+                return value;
+            if (_.isString(value)) {
+                const float = parseFloat(value);
+                return _.isNaN(float) ? null : float;
+            }
+            break;
+        case 'decimal':
+            if (_.isString(value) || _.isNumber(value))
+                return new Decimal(value);
+            if (value instanceof Decimal)
+                return value;
+            if (_.isPlainObject(value) && _.isString(value.$decimal))
+                return new Decimal(value.$decimal);
+            break;
+        case 'string':
+            if (_.isString(value))
+                return value;
+            break;
+        case 'string[]':
+            if (_.isArray(value) && _.every(value, x => _.isString(x)))
+                return value;
+            break;
+        case 'date':
+            if (_.isDate(value))
+                return value;
+            if (_.isString(value)) {
+                const date = new Date(value);
+                if (isFinite(date.valueOf()))
+                    return date;
+            }
+            if (_.isPlainObject(value) && _.isString(value.$date))
+                return new Date(value.$date);
+            break;
+        case 'object':
+            if (_.isPlainObject(value))
+                return index._decodeValue(value);
+            break;
+        case 'array':
+            if (_.isArray(value))
+                return index._decodeValue(value);
+            break;
+        case 'vector':
+            if (!_.isArray(value))
+                break;
+            if (_.every(value, x => _.isNumber(x))) {
+                return value;
+            }
+            break;
+    }
+    return null;
+};
+
+//
+//  types.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
+const isArrayExpr = (expr) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return true;
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value);
+    return false;
+};
+const arrayLength = (expr) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return expr.exprs.length;
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value) ? expr.value.length : 0;
+    return 0;
+};
+const mapExpr = (expr, callback) => {
+    if (expr instanceof validator.QueryArrayExpression)
+        return _.map(expr.exprs, x => callback(x));
+    if (expr instanceof validator.QueryValueExpression)
+        return _.isArray(expr.value) ? _.map(expr.value, x => callback(new validator.QueryValueExpression(x))) : [];
+    return [];
+};
+const zipExpr = (lhs, rhs) => {
+    const result = [];
+    for (const [l, r] of _.zip(lhs, rhs)) {
+        if (!l || !r)
+            return;
+        if (l.type === r.type)
+            result.push([l, r]);
+        else if (l.type === 'number' && r.type === 'decimal')
+            result.push([l, { type: 'decimal', sql: sql `CAST((${r.sql}) AS DECIMAL)` }]);
+        else if (l.type === 'decimal' && r.type === 'number')
+            result.push([{ type: 'decimal', sql: sql `CAST((${l.sql}) AS DECIMAL)` }, r]);
+        else
+            return;
+    }
+    return result;
+};
+const typeCastExpr = (expr, type) => {
+    if (!expr)
+        return;
+    if (expr.type === type)
+        return expr;
+    if (expr.type === 'number' && type === 'decimal')
+        return { type, sql: sql `CAST((${expr.sql}) AS DECIMAL)` };
+    if (expr.type === 'decimal' && type === 'number')
+        return { type, sql: sql `CAST((${expr.sql}) AS DOUBLE PRECISION)` };
+};
+
+//
+//  vector.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const encodeVectorExpression = (compiler, parent, exprs) => {
+    if (exprs.length === 1) {
+        const [expr] = exprs;
+        if (expr instanceof validator.QueryKeyExpression) {
+            const { element, dataType } = fetchElement(compiler, parent, expr.key);
+            if (!dataType || !index.isVector(dataType))
+                throw Error('Invalid expression');
+            return { sql: element, dimension: dataType.dimension };
+        }
+        if (expr instanceof validator.QueryValueExpression) {
+            if (!_.isArray(expr.value) || !_.every(expr.value, x => _.isFinite(x)))
+                throw Error('Invalid expression');
+            return { sql: sql `${{ value: expr.value }}::DOUBLE PRECISION[]`, dimension: expr.value.length };
+        }
+    }
+    const result = _.compact(_.map(exprs, x => typeCastExpr(encodeTypedQueryExpression(compiler, parent, x), 'number')?.sql));
+    if (result.length !== exprs.length)
+        throw Error('Invalid expression');
+    return { sql: sql `ARRAY[${_.map(result, x => sql `COALESCE(${x}, 0)`)}]`, dimension: result.length };
+};
+const encodeDistanceQueryExpression = (compiler, parent, expr) => {
+    const { sql: left, dimension: d1 } = encodeVectorExpression(compiler, parent, expr.left);
+    const { sql: right, dimension: d2 } = encodeVectorExpression(compiler, parent, expr.right);
+    if (d1 !== d2)
+        throw Error('Invalid expression');
+    const operatorMap = {
+        '$distance': sql `<->`,
+        '$innerProduct': sql `<#>`,
+        '$negInnerProduct': sql `<#>`,
+        '$cosineDistance': sql `<=>`,
+        '$rectilinearDistance': sql `<+>`,
+    };
+    const _expr = sql `
+    CAST(
+      ${left} AS VECTOR(${{ literal: `${d1}` }})
+    )
+    ${operatorMap[expr.type]} 
+    CAST(
+      ${right} AS VECTOR(${{ literal: `${d2}` }})
+    )
+  `;
+    return expr.type === '$innerProduct' ? sql `-1 * (${_expr})` : _expr;
+};
+
+//
+//  index.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const encodeTypedQueryExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryKeyExpression) {
+        const { element, dataType } = fetchElement(compiler, parent, expr.key);
+        const _dataType = dataType ? index._typeof(dataType) : null;
+        if (!_dataType || !_PrimitiveValue.includes(_dataType))
+            return;
+        return { type: _dataType, sql: element };
+    }
+    if (expr instanceof validator.QueryValueExpression) {
+        if (_.isBoolean(expr.value))
+            return { type: 'boolean', sql: sql `${{ value: expr.value }}` };
+        if (_.isNumber(expr.value))
+            return { type: 'number', sql: sql `${{ value: expr.value }}` };
+        if (expr.value instanceof Decimal)
+            return { type: 'decimal', sql: sql `CAST(${{ quote: expr.value.toString() }} AS DECIMAL)` };
+        if (_.isString(expr.value))
+            return { type: 'string', sql: sql `${{ value: expr.value }}` };
+        if (_.isDate(expr.value))
+            return { type: 'date', sql: sql `${{ value: expr.value }}` };
+    }
+    if (expr instanceof validator.QueryCoditionalExpression ||
+        expr instanceof validator.QueryComparisonExpression ||
+        expr instanceof validator.QueryNotExpression) {
+        const value = encodeBooleanExpression(compiler, parent, expr);
+        if (value)
+            return { type: 'boolean', sql: value };
+    }
+    if (expr instanceof validator.QueryDistanceExpression) {
+        const value = encodeDistanceQueryExpression(compiler, parent, expr);
+        return { type: 'number', sql: value };
+    }
+    if (expr instanceof validator.QueryZeroParamExpression) {
+        switch (expr.type) {
+            case '$rand': return { type: 'number', sql: sql `RANDOM()` };
+            case '$now': return { type: 'date', sql: sql `CAST(NOW() AS TIMESTAMP(3) WITH TIME ZONE)` };
+        }
+    }
+    if (expr instanceof validator.QueryUnaryExpression) {
+        const value = encodeTypedQueryExpression(compiler, parent, expr.expr);
+        if (!value)
+            return;
+        switch (expr.type) {
+            case '$abs':
+            case '$neg':
+            case '$sqrt':
+            case '$cbrt':
+            case '$ceil':
+            case '$floor':
+            case '$round':
+            case '$exp':
+            case '$ln':
+            case '$log10':
+            case '$sin':
+            case '$cos':
+            case '$tan':
+            case '$asin':
+            case '$acos':
+            case '$atan':
+            case '$asinh':
+            case '$acosh':
+            case '$atanh':
+            case '$sinh':
+            case '$cosh':
+            case '$tanh':
+            case '$degrees':
+            case '$radians':
+            case '$sign':
+                {
+                    const op = {
+                        '$abs': 'ABS',
+                        '$neg': '-',
+                        '$sqrt': 'SQRT',
+                        '$cbrt': 'CBRT',
+                        '$ceil': 'CEIL',
+                        '$floor': 'FLOOR',
+                        '$round': 'ROUND',
+                        '$exp': 'EXP',
+                        '$ln': 'LN',
+                        '$log10': 'LOG10',
+                        '$sin': 'SIN',
+                        '$cos': 'COS',
+                        '$tan': 'TAN',
+                        '$asin': 'ASIN',
+                        '$acos': 'ACOS',
+                        '$atan': 'ATAN',
+                        '$asinh': 'ASINH',
+                        '$acosh': 'ACOSH',
+                        '$atanh': 'ATANH',
+                        '$sinh': 'SINH',
+                        '$cosh': 'COSH',
+                        '$tanh': 'TANH',
+                        '$degrees': 'DEGREES',
+                        '$radians': 'RADIANS',
+                        '$sign': 'SIGN',
+                    }[expr.type];
+                    if (!_.includes(['number', 'decimal'], value.type))
+                        return;
+                    return { type: 'number', sql: sql `${{ literal: op }}(${value.sql})` };
+                }
+            case '$log2':
+                if (!_.includes(['number', 'decimal'], value.type))
+                    return;
+                return { type: value.type, sql: sql `(LOG(${value.sql}) / LOG(2))` };
+            case '$size':
+                if (!_.includes(['string', 'string[]', 'array'], value.type))
+                    return;
+                return { type: 'number', sql: sql `LENGTH(${value.sql})` };
+            case '$lower':
+            case '$upper':
+                {
+                    const op = {
+                        '$lower': 'LOWER',
+                        '$upper': 'UPPER',
+                    }[expr.type];
+                    if (value.type !== 'string')
+                        return;
+                    return { type: 'string', sql: sql `${{ literal: op }}(${value.sql})` };
+                }
+        }
+    }
+    if (expr instanceof validator.QueryBinaryExpression) {
+        const left = encodeTypedQueryExpression(compiler, parent, expr.left);
+        const right = encodeTypedQueryExpression(compiler, parent, expr.right);
+        if (!left || !right)
+            return;
+        switch (expr.type) {
+            case '$divide':
+            case '$subtract':
+                {
+                    const op = {
+                        '$divide': '/',
+                        '$subtract': '-',
+                    }[expr.type];
+                    if (left.type === right.type) {
+                        return { type: left.type, sql: sql `(${left.sql}) ${{ literal: op }} (${right.sql})` };
+                    }
+                    if (left.type === 'decimal' && right.type === 'number') {
+                        return { type: 'decimal', sql: sql `CAST((${left.sql}) AS DECIMAL) ${{ literal: op }} (${right.sql})` };
+                    }
+                    if (left.type === 'number' && right.type === 'decimal') {
+                        return { type: 'decimal', sql: sql `(${left.sql}) ${{ literal: op }} CAST((${right.sql}) AS DECIMAL)` };
+                    }
+                }
+                break;
+            case '$log':
+                {
+                    if (left.type === right.type) {
+                        return { type: left.type, sql: sql `(LOG(${left.sql}) / LOG(${right.sql}))` };
+                    }
+                    if (left.type === 'decimal' && right.type === 'number') {
+                        return { type: 'decimal', sql: sql `(LOG(${left.sql}) / LOG(CAST((${right.sql}) AS DECIMAL)))` };
+                    }
+                    if (left.type === 'number' && right.type === 'decimal') {
+                        return { type: 'decimal', sql: sql `(LOG(CAST((${left.sql}) AS DECIMAL) / LOG(${right.sql}))` };
+                    }
+                }
+                break;
+            case '$pow':
+            case '$atan2':
+                {
+                    const op = {
+                        '$pow': 'POWER',
+                        '$atan2': 'ATAN2',
+                    }[expr.type];
+                    if (left.type === right.type) {
+                        return { type: left.type, sql: sql `${{ literal: op }}((${left.sql}), (${right.sql}))` };
+                    }
+                    if (left.type === 'decimal' && right.type === 'number') {
+                        return { type: 'decimal', sql: sql `${{ literal: op }}((${left.sql}), CAST((${right.sql}) AS DECIMAL))` };
+                    }
+                    if (left.type === 'number' && right.type === 'decimal') {
+                        return { type: 'decimal', sql: sql `${{ literal: op }}(CAST((${left.sql}) AS DECIMAL), (${right.sql}))` };
+                    }
+                }
+                break;
+            case '$trim':
+            case '$ltrim':
+            case '$rtrim':
+                {
+                    const op = {
+                        '$trim': 'TRIM',
+                        '$ltrim': 'LTRIM',
+                        '$rtrim': 'RTRIM',
+                    }[expr.type];
+                    if (left?.type !== 'string' || right?.type !== 'string')
+                        return;
+                    return { type: 'string', sql: sql `${{ literal: op }}(${left.sql}, ${right.sql})` };
+                }
+            case '$first':
+            case '$last':
+                {
+                    if (!_.includes(['number', 'decimal'], right.type))
+                        return;
+                    if (left?.type === 'string') {
+                        const op = {
+                            '$first': 'LEFT',
+                            '$last': 'RIGHT',
+                        }[expr.type];
+                        return { type: 'string', sql: sql `${{ literal: op }}(${left.sql}, ${right.sql})` };
+                    }
+                }
+                break;
+            case '$ldrop':
+            case '$rdrop':
+                {
+                    if (!_.includes(['number', 'decimal'], right.type))
+                        return;
+                    if (left?.type === 'string') {
+                        const op = {
+                            '$ldrop': 'RIGHT',
+                            '$rdrop': 'LEFT',
+                        }[expr.type];
+                        return { type: 'string', sql: sql `${{ literal: op }}(${left.sql}, -(${right.sql}))` };
+                    }
+                }
+                break;
+        }
+    }
+    if (expr instanceof validator.QueryListExpression) {
+        const values = _.compact(_.map(expr.exprs, x => encodeTypedQueryExpression(compiler, parent, x)));
+        if (values.length !== expr.exprs.length)
+            return;
+        switch (expr.type) {
+            case '$add':
+            case '$multiply':
+                {
+                    const op = {
+                        '$add': '+',
+                        '$multiply': '*',
+                    }[expr.type];
+                    if (_.every(values, x => x.type === 'number')) {
+                        return { type: 'number', sql: sql `${{ literal: _.map(values, x => x.sql), separator: ` ${op} ` }}` };
+                    }
+                    if (_.every(values, x => x.type === 'number' || x.type === 'decimal')) {
+                        return { type: 'decimal', sql: sql `${{ literal: _.map(values, x => x.type === 'decimal' ? x.sql : sql `CAST((${x.sql}) AS DECIMAL)`), separator: ` ${op} ` }}` };
+                    }
+                }
+                break;
+            case '$ifNull':
+                {
+                    const type = values[0].type;
+                    if (_.every(values, x => x.type === type)) {
+                        return { type, sql: sql `COALESCE(${{ literal: _.map(values, x => x.sql) }})` };
+                    }
+                }
+                break;
+            case '$concat':
+                {
+                    if (_.every(values, x => x.type === 'string')) {
+                        return { type: 'string', sql: sql `CONCAT(${{ literal: _.map(values, x => x.sql) }})` };
+                    }
+                }
+                break;
+        }
+    }
+    if (expr instanceof validator.QueryTernaryExpression) {
+        const first = encodeTypedQueryExpression(compiler, parent, expr.first);
+        const second = encodeTypedQueryExpression(compiler, parent, expr.second);
+        const last = encodeTypedQueryExpression(compiler, parent, expr.last);
+        if (!first || !second || !last)
+            return;
+        switch (expr.type) {
+            case '$lpad':
+            case '$rpad':
+                {
+                    const op = {
+                        '$lpad': 'LPAD',
+                        '$rpad': 'RPAD',
+                    }[expr.type];
+                    if (first?.type !== 'string' || last?.type !== 'string')
+                        return;
+                    if (!_.includes(['number', 'decimal'], second.type))
+                        return;
+                    return { type: 'string', sql: sql `${{ literal: op }}(${first.sql}, ${second.sql}, ${last.sql})` };
+                }
+        }
+    }
+    if (expr instanceof validator.QueryCondExpression) {
+        const branches = _.flatMap(_.map(expr.branch, x => ({
+            case: encodeTypedQueryExpression(compiler, parent, x.case),
+            then: encodeTypedQueryExpression(compiler, parent, x.then),
+        })), x => x.case && x.then ? ({ case: x.case, then: x.then }) : []);
+        if (branches.length !== expr.branch.length)
+            return;
+        const defaultCase = encodeTypedQueryExpression(compiler, parent, expr.default);
+        if (!defaultCase)
+            return;
+        if (!_.every(branches, x => x.case.type === 'boolean' && x.then.type === defaultCase.type))
+            return;
+        return {
+            type: defaultCase.type,
+            sql: sql `CASE ${{
+                literal: _.map(branches, x => sql `WHEN (${x.case.sql}) THEN (${x.then.sql})`),
+                separator: ' '
+            }} ELSE (${defaultCase.sql}) END`,
+        };
+    }
+};
+const encodeJsonQueryExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryKeyExpression) {
+        const { element, dataType } = fetchElement(compiler, parent, expr.key);
+        if (dataType && index.isPrimitive(dataType)) {
+            switch (index._typeof(dataType)) {
+                case 'boolean': return sql `to_jsonb(${element})`;
+                case 'number': return sql `to_jsonb(${element})`;
+                case 'decimal': return sql `jsonb_build_object('$decimal', CAST(${element} AS TEXT))`;
+                case 'string': return sql `to_jsonb(${element})`;
+                case 'string[]': return sql `to_jsonb(${element})`;
+                case 'date': return sql `jsonb_build_object(
+          '$date', to_char(${element} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+        )`;
+            }
+        }
+        return sql `${element}`;
+    }
+    if (expr instanceof validator.QueryValueExpression) {
+        return _encodeJsonValue(index._encodeValue(expr.value));
+    }
+    if (expr instanceof validator.QueryArrayExpression) {
+        return sql `jsonb_build_array(${_.map(expr.exprs, x => encodeJsonQueryExpression(compiler, parent, x))})`;
+    }
+    const typed = encodeTypedQueryExpression(compiler, parent, expr);
+    if (!typed)
+        throw Error('Invalid expression');
+    switch (typed.type) {
+        case 'boolean': return sql `to_jsonb(${typed.sql})`;
+        case 'number': return sql `to_jsonb(${typed.sql})`;
+        case 'decimal': return sql `jsonb_build_object('$decimal', CAST(${typed.sql} AS TEXT))`;
+        case 'string': return sql `to_jsonb(${typed.sql})`;
+        case 'date': return sql `jsonb_build_object(
+      '$date', to_char(${typed.sql} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
+    )`;
+        default: throw Error('Invalid expression');
+    }
+};
+const encodeBooleanExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryCoditionalExpression) {
+        const queries = _.compact(_.map(expr.exprs, x => encodeBooleanExpression(compiler, parent, x)));
+        if (_.isEmpty(queries))
+            return;
+        switch (expr.type) {
+            case '$and': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' AND ' }})`;
+            case '$nor': return sql `(${{ literal: _.map(queries, x => sql `NOT (${x})`), separator: ' AND ' }})`;
+            case '$or': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' OR ' }})`;
+        }
+    }
+    if (expr instanceof validator.QueryComparisonExpression) {
+        const operatorMap = {
+            '$eq': nullSafeEqual(),
+            '$ne': nullSafeNotEqual(),
+            '$gt': sql `>`,
+            '$gte': sql `>=`,
+            '$lt': sql `<`,
+            '$lte': sql `<=`,
+        };
+        if (isArrayExpr(expr.left) &&
+            isArrayExpr(expr.right) &&
+            arrayLength(expr.left) === arrayLength(expr.right)) {
+            const _left = mapExpr(expr.left, x => encodeTypedQueryExpression(compiler, parent, x));
+            const _right = mapExpr(expr.right, x => encodeTypedQueryExpression(compiler, parent, x));
+            const zipped = zipExpr(_left, _right) ?? [];
+            if (_left.length === zipped.length) {
+                const [l, r] = _.unzip(zipped);
+                return sql `(${_.map(l, x => x.sql)}) ${operatorMap[expr.type]} (${_.map(r, x => x.sql)})`;
+            }
+        }
+        const _left = encodeTypedQueryExpression(compiler, parent, expr.left);
+        const _right = encodeTypedQueryExpression(compiler, parent, expr.right);
+        if (_left && _right) {
+            if (_left.type === _right.type) {
+                return sql `(${_left.sql}) ${operatorMap[expr.type]} (${_right.sql})`;
+            }
+            if (_left.type === 'decimal' && _right.type === 'number') {
+                return sql `CAST((${_left.sql}) AS DOUBLE PRECISION) ${operatorMap[expr.type]} (${_right.sql})`;
+            }
+            if (_left.type === 'number' && _right.type === 'decimal') {
+                return sql `(${_left.sql}) ${operatorMap[expr.type]} CAST((${_right.sql}) AS DOUBLE PRECISION)`;
+            }
+        }
+        const _left2 = encodeJsonQueryExpression(compiler, parent, expr.left);
+        const _right2 = encodeJsonQueryExpression(compiler, parent, expr.right);
+        return sql `${_left2} ${operatorMap[expr.type]} ${_right2}`;
+    }
+    if (expr instanceof validator.QueryNotExpression) {
+        const _expr = encodeBooleanExpression(compiler, parent, expr.expr);
+        return _expr ? sql `NOT (${_expr})` : undefined;
+    }
+    throw Error('Invalid expression');
+};
+
 //
 //  storage.ts
 //
@@ -705,8 +1427,17 @@ class SqlStorage {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
         const _matchesType = self._matchesType(compiler, query);
-        const _query = compiler._selectQuery({ ...query, sort: {} }, {
-            sort: sql `ORDER BY ${self.dialect.random(opts ?? {})}`,
+        const _query = compiler._selectQuery({ ...query, sort: {} }, ({ fetchName }) => {
+            if (!opts?.weight)
+                return { sort: sql `ORDER BY ${self.dialect.random()}` };
+            const weight = encodeTypedQueryExpression(compiler, {
+                name: fetchName,
+                className: query.className,
+                groupMatches: query.groupMatches,
+            }, opts.weight);
+            if (!weight)
+                throw Error('Invalid expression');
+            return { sort: sql `ORDER BY ${self.dialect.random(weight.sql)}` };
         });
         return (async function* () {
             const objects = self.query(_query);
@@ -951,8 +1682,8 @@ const encodeSortKey = (compiler, parent, key) => {
     const { element } = fetchElement(compiler, parent, key);
     return element;
 };
-const random = (opts) => {
-    return opts.weight ? sql `-ln(random()) / ${{ identifier: opts.weight }}` : sql `random()`;
+const random = (weight) => {
+    return weight ? sql `-ln(random()) / ${weight}` : sql `random()`;
 };
 
 //
@@ -1169,201 +1900,34 @@ class PostgresDriver extends PostgresClientDriver {
         this.database = database;
     }
     async shutdown() {
-        await this._release_pubsub();
-        await this.database.end();
-    }
-    _init_pubsub() {
-        if (this.pubsub || this.database.ending || this.database.ended)
-            return;
-        this.pubsub = new PostgresPubSub(this.database.connect());
-    }
-    async _release_pubsub() {
-        const pubsub = this.pubsub;
-        this.pubsub = undefined;
-        await pubsub?.shutdown();
-    }
-    subscribe(channel, callback) {
-        this._init_pubsub();
-        if (!this.pubsub)
-            return () => void 0;
-        const release = this.pubsub.subscribe(({ channel: _channel, payload }) => {
-            if (_channel === channel)
-                callback(payload);
-        });
-        return () => {
-            release();
-            if (this.pubsub?.isEmpty())
-                this._release_pubsub();
-        };
-    }
-}
-
-//
-//  encode.ts
-//
-//  The MIT License
-//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
-//
-//  Permission is hereby granted, free of charge, to any person obtaining a copy
-//  of this software and associated documentation files (the "Software"), to deal
-//  in the Software without restriction, including without limitation the rights
-//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//  copies of the Software, and to permit persons to whom the Software is
-//  furnished to do so, subject to the following conditions:
-//
-//  The above copyright notice and this permission notice shall be included in
-//  all copies or substantial portions of the Software.
-//
-//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-//  THE SOFTWARE.
-//
-const _encodeJsonValue = (value) => {
-    if (_.isArray(value))
-        return sql `jsonb_build_array(${_.map(value, x => _encodeJsonValue(x))})`;
-    if (_.isPlainObject(value))
-        return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
-    return sql `to_jsonb(${{ value }})`;
-};
-const _jsonPopulateInclude = (className, colname, dataType) => {
-    switch (index._typeof(dataType)) {
-        case 'decimal':
-            return sql `jsonb_build_object(
-            '$decimal', CAST(${{ identifier: className }}.${{ identifier: colname }} AS TEXT)
-          ) AS ${{ identifier: colname }}`;
-        case 'date':
-            return sql `jsonb_build_object(
-            '$date', to_char(${{ identifier: className }}.${{ identifier: colname }} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
-          ) AS ${{ identifier: colname }}`;
-        default:
-            return sql `${{ identifier: className }}.${{ identifier: colname }}`;
-    }
-};
-const encodeType = (colname, dataType, value) => {
-    if (_.isNil(value))
-        return sql `NULL`;
-    switch (_.isString(dataType) ? dataType : dataType.type) {
-        case 'boolean':
-            if (_.isBoolean(value))
-                return sql `${{ value }}`;
-            break;
-        case 'number':
-            if (_.isNumber(value) && _.isFinite(value))
-                return sql `${{ value }}`;
-            if (value instanceof Decimal)
-                return sql `${{ value: value.toNumber() }}`;
-            break;
-        case 'decimal':
-            if (_.isNumber(value) && _.isFinite(value))
-                return sql `CAST(${{ quote: (new Decimal(value)).toString() }} AS DECIMAL)`;
-            if (value instanceof Decimal)
-                return sql `CAST(${{ quote: value.toString() }} AS DECIMAL)`;
-            break;
-        case 'string':
-            if (_.isString(value))
-                return sql `${{ value }}`;
-            break;
-        case 'string[]':
-            if (_.isArray(value) && _.every(value, x => _.isString(x)))
-                return sql `ARRAY[${_.map(value, x => sql `${{ value: x }}`)}]::TEXT[]`;
-            break;
-        case 'date':
-            if (_.isDate(value))
-                return sql `${{ value }}`;
-            break;
-        case 'object':
-            if (_.isPlainObject(value))
-                return sql `${{ value: index._encodeValue(value) }}`;
-            break;
-        case 'vector':
-            if (!_.isArray(value) || value.length !== index.dimensionOf(dataType))
-                break;
-            if (!_.every(value, x => _.isFinite(x)))
-                break;
-            return sql `${{ value }}::DOUBLE PRECISION[]`;
-        case 'array':
-            if (!_.isArray(value))
-                break;
-            return sql `ARRAY[${_.map(value, x => _encodeJsonValue(index._encodeValue(x)))}]::JSONB[]`;
-        case 'pointer':
-            if (value instanceof index.TObject && value.objectId)
-                return sql `${{ value: `${value.className}$${value.objectId}` }}`;
-            break;
-        case 'relation':
-            if (_.isArray(value) && _.every(value, x => x instanceof index.TObject && x.objectId)) {
-                return sql `${{ value: _.uniq(_.map(value, (x) => `${x.className}$${x.objectId}`)) }}`;
-            }
-            break;
-    }
-    throw Error('Invalid data type');
-};
-const decodeType = (type, value) => {
-    switch (type) {
-        case 'boolean':
-            if (_.isBoolean(value))
-                return value;
-            if (value === 'true')
-                return true;
-            if (value === 'false')
-                return false;
-            break;
-        case 'number':
-            if (_.isNumber(value))
-                return value;
-            if (_.isString(value)) {
-                const float = parseFloat(value);
-                return _.isNaN(float) ? null : float;
-            }
-            break;
-        case 'decimal':
-            if (_.isString(value) || _.isNumber(value))
-                return new Decimal(value);
-            if (value instanceof Decimal)
-                return value;
-            if (_.isPlainObject(value) && _.isString(value.$decimal))
-                return new Decimal(value.$decimal);
-            break;
-        case 'string':
-            if (_.isString(value))
-                return value;
-            break;
-        case 'string[]':
-            if (_.isArray(value) && _.every(value, x => _.isString(x)))
-                return value;
-            break;
-        case 'date':
-            if (_.isDate(value))
-                return value;
-            if (_.isString(value)) {
-                const date = new Date(value);
-                if (isFinite(date.valueOf()))
-                    return date;
-            }
-            if (_.isPlainObject(value) && _.isString(value.$date))
-                return new Date(value.$date);
-            break;
-        case 'object':
-            if (_.isPlainObject(value))
-                return index._decodeValue(value);
-            break;
-        case 'array':
-            if (_.isArray(value))
-                return index._decodeValue(value);
-            break;
-        case 'vector':
-            if (!_.isArray(value))
-                break;
-            if (_.every(value, x => _.isNumber(x))) {
-                return value;
-            }
-            break;
+        await this._release_pubsub();
+        await this.database.end();
     }
-    return null;
-};
+    _init_pubsub() {
+        if (this.pubsub || this.database.ending || this.database.ended)
+            return;
+        this.pubsub = new PostgresPubSub(this.database.connect());
+    }
+    async _release_pubsub() {
+        const pubsub = this.pubsub;
+        this.pubsub = undefined;
+        await pubsub?.shutdown();
+    }
+    subscribe(channel, callback) {
+        this._init_pubsub();
+        if (!this.pubsub)
+            return () => void 0;
+        const release = this.pubsub.subscribe(({ channel: _channel, payload }) => {
+            if (_channel === channel)
+                callback(payload);
+        });
+        return () => {
+            release();
+            if (this.pubsub?.isEmpty())
+                this._release_pubsub();
+        };
+    }
+}
 
 //
 //  update.ts
@@ -1651,232 +2215,6 @@ const updateOperation = (paths, dataType, operation) => {
     throw Error('Invalid update operation');
 };
 
-//
-//  expressions.ts
-//
-//  The MIT License
-//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
-//
-//  Permission is hereby granted, free of charge, to any person obtaining a copy
-//  of this software and associated documentation files (the "Software"), to deal
-//  in the Software without restriction, including without limitation the rights
-//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//  copies of the Software, and to permit persons to whom the Software is
-//  furnished to do so, subject to the following conditions:
-//
-//  The above copyright notice and this permission notice shall be included in
-//  all copies or substantial portions of the Software.
-//
-//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-//  THE SOFTWARE.
-//
-const isArrayExpression = (expr) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return true;
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value);
-    return false;
-};
-const arrayLength = (expr) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return expr.exprs.length;
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value) ? expr.value.length : 0;
-    return 0;
-};
-const mapExpression = (expr, callback) => {
-    if (expr instanceof validator.QueryArrayExpression)
-        return _.map(expr.exprs, x => callback(x));
-    if (expr instanceof validator.QueryValueExpression)
-        return _.isArray(expr.value) ? _.map(expr.value, x => callback(new validator.QueryValueExpression(x))) : [];
-    return [];
-};
-const _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
-const encodeTypedQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryKeyExpression) {
-        const { element, dataType } = fetchElement(compiler, parent, expr.key);
-        const _dataType = dataType ? index._typeof(dataType) : null;
-        if (_dataType === 'number') {
-            return [
-                { type: 'number', sql: element },
-                { type: 'decimal', sql: sql `CAST((${element}) AS DECIMAL)` },
-            ];
-        }
-        else if (_dataType === 'decimal') {
-            return [
-                { type: 'decimal', sql: element },
-                { type: 'number', sql: element },
-            ];
-        }
-        else if (_dataType && _PrimitiveValue.includes(_dataType)) {
-            return [{ type: _dataType, sql: element }];
-        }
-    }
-    if (expr instanceof validator.QueryValueExpression) {
-        if (_.isBoolean(expr.value))
-            return [{ type: 'boolean', sql: sql `${{ value: expr.value }}` }];
-        if (_.isNumber(expr.value))
-            return [
-                { type: 'number', sql: sql `${{ value: expr.value }}` },
-                { type: 'decimal', sql: sql `CAST(${{ quote: (new Decimal(expr.value)).toString() }} AS DECIMAL)` },
-            ];
-        if (expr.value instanceof Decimal)
-            return [
-                { type: 'decimal', sql: sql `CAST(${{ quote: expr.value.toString() }} AS DECIMAL)` },
-                { type: 'number', sql: sql `${{ value: expr.value.toNumber() }}` },
-            ];
-        if (_.isString(expr.value))
-            return [{ type: 'string', sql: sql `${{ value: expr.value }}` }];
-        if (_.isDate(expr.value))
-            return [{ type: 'date', sql: sql `${{ value: expr.value }}` }];
-    }
-    if (expr instanceof validator.QueryCoditionalExpression ||
-        expr instanceof validator.QueryComparisonExpression ||
-        expr instanceof validator.QueryNotExpression) {
-        const value = encodeBooleanExpression(compiler, parent, expr);
-        if (value)
-            return [{ type: 'boolean', sql: value }];
-    }
-    if (expr instanceof validator.QueryDistanceExpression) {
-        const value = encodeDistanceQueryExpression(compiler, parent, expr);
-        return [{ type: 'number', sql: value }];
-    }
-};
-const encodeJsonQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryKeyExpression) {
-        const { element, dataType } = fetchElement(compiler, parent, expr.key);
-        if (dataType && index.isPrimitive(dataType)) {
-            switch (index._typeof(dataType)) {
-                case 'boolean': return sql `to_jsonb(${element})`;
-                case 'number': return sql `to_jsonb(${element})`;
-                case 'decimal': return sql `jsonb_build_object('$decimal', CAST(${element} AS TEXT))`;
-                case 'string': return sql `to_jsonb(${element})`;
-                case 'string[]': return sql `to_jsonb(${element})`;
-                case 'date': return sql `jsonb_build_object(
-          '$date', to_char(${element} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')
-        )`;
-            }
-        }
-        return sql `${element}`;
-    }
-    if (expr instanceof validator.QueryValueExpression) {
-        return _encodeJsonValue(index._encodeValue(expr.value));
-    }
-    if (expr instanceof validator.QueryArrayExpression) {
-        return sql `jsonb_build_array(${_.map(expr.exprs, x => encodeJsonQueryExpression(compiler, parent, x))})`;
-    }
-    const value = encodeQueryExpression(compiler, parent, expr);
-    if (!value)
-        throw Error('Invalid expression');
-    return sql `to_jsonb(${value})`;
-};
-const encodeVectorExpression = (compiler, parent, exprs) => {
-    if (exprs.length === 1) {
-        const [expr] = exprs;
-        if (expr instanceof validator.QueryKeyExpression) {
-            const { element, dataType } = fetchElement(compiler, parent, expr.key);
-            if (!dataType || !index.isVector(dataType))
-                throw Error('Invalid expression');
-            return { sql: element, dimension: dataType.dimension };
-        }
-        if (expr instanceof validator.QueryValueExpression) {
-            if (!_.isArray(expr.value) || !_.every(expr.value, x => _.isFinite(x)))
-                throw Error('Invalid expression');
-            return { sql: sql `${{ value: expr.value }}::DOUBLE PRECISION[]`, dimension: expr.value.length };
-        }
-    }
-    const result = _.map(exprs, x => _.find(encodeTypedQueryExpression(compiler, parent, x), e => e.type === 'number')?.sql);
-    if (_.some(result, x => _.isNil(x)))
-        throw Error('Invalid expression');
-    return { sql: sql `ARRAY[${_.map(result, x => sql `COALESCE(${x}, 0)`)}]`, dimension: result.length };
-};
-const encodeDistanceQueryExpression = (compiler, parent, expr) => {
-    const { sql: left, dimension: d1 } = encodeVectorExpression(compiler, parent, expr.left);
-    const { sql: right, dimension: d2 } = encodeVectorExpression(compiler, parent, expr.right);
-    if (d1 !== d2)
-        throw Error('Invalid expression');
-    const operatorMap = {
-        '$distance': sql `<->`,
-        '$innerProduct': sql `<#>`,
-        '$negInnerProduct': sql `<#>`,
-        '$cosineDistance': sql `<=>`,
-        '$rectilinearDistance': sql `<+>`,
-    };
-    const _expr = sql `
-    CAST(
-      ${left} AS VECTOR(${{ literal: `${d1}` }})
-    )
-    ${operatorMap[expr.type]} 
-    CAST(
-      ${right} AS VECTOR(${{ literal: `${d2}` }})
-    )
-  `;
-    return expr.type === '$innerProduct' ? sql `-1 * (${_expr})` : _expr;
-};
-const matchType = (first, second) => {
-    const found = _.find(first, l => _.some(second, r => l.type === r.type));
-    return found ? [found, _.find(second, r => r.type === found.type)] : undefined;
-};
-const encodeBooleanExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryCoditionalExpression) {
-        const queries = _.compact(_.map(expr.exprs, x => encodeBooleanExpression(compiler, parent, x)));
-        if (_.isEmpty(queries))
-            return;
-        switch (expr.type) {
-            case '$and': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' AND ' }})`;
-            case '$nor': return sql `(${{ literal: _.map(queries, x => sql `NOT (${x})`), separator: ' AND ' }})`;
-            case '$or': return sql `(${{ literal: _.map(queries, x => sql `(${x})`), separator: ' OR ' }})`;
-        }
-    }
-    if (expr instanceof validator.QueryComparisonExpression) {
-        const operatorMap = {
-            '$eq': nullSafeEqual(),
-            '$ne': nullSafeNotEqual(),
-            '$gt': sql `>`,
-            '$gte': sql `>=`,
-            '$lt': sql `<`,
-            '$lte': sql `<=`,
-        };
-        if (isArrayExpression(expr.left) &&
-            isArrayExpression(expr.right) &&
-            arrayLength(expr.left) === arrayLength(expr.right)) {
-            const _left = mapExpression(expr.left, x => encodeTypedQueryExpression(compiler, parent, x));
-            const _right = mapExpression(expr.right, x => encodeTypedQueryExpression(compiler, parent, x));
-            const mapped = _.compact(_.map(_.zip(_left, _right), ([l, r]) => matchType(l, r)));
-            if (mapped.length === _left.length) {
-                const [l, r] = _.unzip(mapped);
-                return sql `(${_.map(l, x => x.sql)}) ${operatorMap[expr.type]} (${_.map(r, x => x.sql)})`;
-            }
-        }
-        const _left = encodeTypedQueryExpression(compiler, parent, expr.left);
-        const _right = encodeTypedQueryExpression(compiler, parent, expr.right);
-        if (_left && _right) {
-            const matched = matchType(_left, _right);
-            if (matched)
-                return sql `${matched[0].sql} ${operatorMap[expr.type]} ${matched[1].sql}`;
-        }
-        const _left2 = encodeJsonQueryExpression(compiler, parent, expr.left);
-        const _right2 = encodeJsonQueryExpression(compiler, parent, expr.right);
-        return sql `${_left2} ${operatorMap[expr.type]} ${_right2}`;
-    }
-    if (expr instanceof validator.QueryNotExpression) {
-        const _expr = encodeBooleanExpression(compiler, parent, expr.expr);
-        return _expr ? sql `NOT (${_expr})` : undefined;
-    }
-    throw Error('Invalid expression');
-};
-const encodeQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryDistanceExpression) {
-        return encodeDistanceQueryExpression(compiler, parent, expr);
-    }
-    return encodeBooleanExpression(compiler, parent, expr);
-};
-
 //
 //  populate.ts
 //
@@ -1979,7 +2317,7 @@ const selectPopulate = (compiler, parent, populate, field) => {
         ];
         if (!_.isEmpty(groupMatches?.[field])) {
             for (const [key, expr] of _.entries(groupMatches[field])) {
-                if (expr instanceof validator.QueryNoParamAccumulator) {
+                if (expr instanceof validator.QueryZeroParamAccumulator) {
                     switch (expr.type) {
                         case '$count':
                             columns.push(sql `
@@ -1992,30 +2330,44 @@ const selectPopulate = (compiler, parent, populate, field) => {
                             break;
                     }
                 }
-                else if (expr instanceof validator.QueryExprAccumulator) {
-                    const op = {
-                        '$max': 'MAX',
-                        '$min': 'MIN',
-                        '$avg': 'AVG',
-                        '$sum': 'SUM',
-                        '$stdDevPop': 'STDDEV_POP',
-                        '$stdDevSamp': 'STDDEV_SAMP',
-                        '$varPop': 'VAR_POP',
-                        '$varSamp': 'VAR_SAMP',
-                    }[expr.type];
+                else if (expr instanceof validator.QueryUnaryAccumulator) {
                     if (!expr.expr)
                         throw Error('Invalid expression');
-                    const exprs = encodeTypedQueryExpression(compiler, populate, expr.expr);
-                    const value = _.first(exprs)?.sql;
+                    const { sql: value } = encodeTypedQueryExpression(compiler, populate, expr.expr) ?? {};
                     if (!value)
                         throw Error('Invalid expression');
-                    columns.push(sql `
-            (
-              SELECT ${{ literal: op }}(${value}) FROM (
-                ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-              ) ${{ identifier: populate.name }}
-            ) AS ${{ identifier: `${field}.${key}` }}
-          `);
+                    switch (expr.type) {
+                        case '$most':
+                            columns.push(sql `
+                (
+                  SELECT MODE() WITHIN GROUP (ORDER BY (${value})) FROM (
+                    ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                  ) ${{ identifier: populate.name }}
+                ) AS ${{ identifier: `${field}.${key}` }}
+              `);
+                            break;
+                        default:
+                            {
+                                const op = {
+                                    '$max': 'MAX',
+                                    '$min': 'MIN',
+                                    '$avg': 'AVG',
+                                    '$sum': 'SUM',
+                                    '$stdDevPop': 'STDDEV_POP',
+                                    '$stdDevSamp': 'STDDEV_SAMP',
+                                    '$varPop': 'VAR_POP',
+                                    '$varSamp': 'VAR_SAMP',
+                                }[expr.type];
+                                columns.push(sql `
+                  (
+                    SELECT ${{ literal: op }}(${value}) FROM (
+                      ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                    ) ${{ identifier: populate.name }}
+                  ) AS ${{ identifier: `${field}.${key}` }}
+                `);
+                            }
+                            break;
+                    }
                 }
                 else if (expr instanceof validator.QueryPercentileAccumulator) {
                     const op = {
@@ -2024,8 +2376,7 @@ const selectPopulate = (compiler, parent, populate, field) => {
                     }[expr.mode];
                     if (!expr.input)
                         throw Error('Invalid expression');
-                    const exprs = encodeTypedQueryExpression(compiler, populate, expr.input);
-                    const value = _.first(exprs)?.sql;
+                    const { sql: value } = encodeTypedQueryExpression(compiler, populate, expr.input) ?? {};
                     if (!value)
                         throw Error('Invalid expression');
                     columns.push(sql `
@@ -2613,6 +2964,36 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
     throw Error('Invalid expression');
 };
 
+//
+//  index.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+const encodeSortExpression = (compiler, parent, expr) => {
+    if (expr instanceof validator.QueryDistanceExpression) {
+        return encodeDistanceQueryExpression(compiler, parent, expr);
+    }
+};
+
 //
 //  relation.ts
 //
@@ -2684,7 +3065,8 @@ const PostgresDialect = {
     updateOperation,
     selectPopulate,
     encodeFieldExpression,
-    encodeQueryExpression,
+    encodeBooleanExpression,
+    encodeSortExpression,
     encodePopulate,
     encodeRelation,
     encodeSortKey,