proto.io 0.0.216 → 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-BBjOdLiT.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' }}`;
@@ -708,7 +708,7 @@ const decodeType = (type, value) => {
 };
 
 //
-//  expressions.ts
+//  types.ts
 //
 //  The MIT License
 //  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
@@ -731,7 +731,8 @@ const decodeType = (type, value) => {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const isArrayExpression = (expr) => {
+const _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
+const isArrayExpr = (expr) => {
     if (expr instanceof validator.QueryArrayExpression)
         return true;
     if (expr instanceof validator.QueryValueExpression)
@@ -745,62 +746,428 @@ const arrayLength = (expr) => {
         return _.isArray(expr.value) ? expr.value.length : 0;
     return 0;
 };
-const mapExpression = (expr, callback) => {
+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 _PrimitiveValue = ['boolean', 'number', 'decimal', 'string', 'date'];
+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 === '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 (!_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 }}` }];
+            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)` },
-            ];
+            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)` },
-                { type: 'number', sql: sql `${{ value: expr.value.toNumber() }}` },
-            ];
+            return { type: 'decimal', sql: sql `CAST(${{ quote: expr.value.toString() }} AS DECIMAL)` };
         if (_.isString(expr.value))
-            return [{ type: 'string', sql: sql `${{ value: expr.value }}` }];
+            return { type: 'string', sql: sql `${{ value: expr.value }}` };
         if (_.isDate(expr.value))
-            return [{ type: 'date', sql: sql `${{ value: 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 }];
+            return { type: 'boolean', sql: value };
     }
     if (expr instanceof validator.QueryDistanceExpression) {
         const value = encodeDistanceQueryExpression(compiler, parent, expr);
-        return [{ type: 'number', sql: value }];
+        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) => {
@@ -826,57 +1193,19 @@ const encodeJsonQueryExpression = (compiler, parent, expr) => {
     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)
+    const typed = encodeTypedQueryExpression(compiler, parent, expr);
+    if (!typed)
         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 };
-        }
+    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 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) {
@@ -898,23 +1227,29 @@ const encodeBooleanExpression = (compiler, parent, expr) => {
             '$lt': sql `<`,
             '$lte': sql `<=`,
         };
-        if (isArrayExpression(expr.left) &&
-            isArrayExpression(expr.right) &&
+        if (isArrayExpr(expr.left) &&
+            isArrayExpr(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);
+            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) {
-            const matched = matchType(_left, _right);
-            if (matched)
-                return sql `${matched[0].sql} ${operatorMap[expr.type]} ${matched[1].sql}`;
+            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);
@@ -926,12 +1261,6 @@ const encodeBooleanExpression = (compiler, parent, expr) => {
     }
     throw Error('Invalid expression');
 };
-const encodeQueryExpression = (compiler, parent, expr) => {
-    if (expr instanceof validator.QueryDistanceExpression) {
-        return encodeDistanceQueryExpression(compiler, parent, expr);
-    }
-    return encodeBooleanExpression(compiler, parent, expr);
-};
 
 //
 //  storage.ts
@@ -1098,13 +1427,18 @@ class SqlStorage {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
         const _matchesType = self._matchesType(compiler, query);
-        const _query = compiler._selectQuery({ ...query, sort: {} }, ({ fetchName }) => ({
-            sort: sql `ORDER BY ${self.dialect.random(opts?.weight ? _.first(encodeTypedQueryExpression(compiler, {
+        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))?.sql : undefined)}`,
-        }));
+            }, 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);
             for await (const object of objects) {
@@ -1983,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 `
@@ -1996,11 +2330,10 @@ const selectPopulate = (compiler, parent, populate, field) => {
                             break;
                     }
                 }
-                else if (expr instanceof validator.QueryExprAccumulator) {
+                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');
                     switch (expr.type) {
@@ -2043,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 `
@@ -2632,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
 //
@@ -2703,7 +3065,8 @@ const PostgresDialect = {
     updateOperation,
     selectPopulate,
     encodeFieldExpression,
-    encodeQueryExpression,
+    encodeBooleanExpression,
+    encodeSortExpression,
     encodePopulate,
     encodeRelation,
     encodeSortKey,