proto.io 0.0.210 → 0.0.212

package/dist/adapters/storage/progres.mjs

@@ -5,9 +5,9 @@ import QueryStream from 'pg-query-stream';
 import { asyncStream, IteratorPool } from '@o2ter/utils-js';
 import Decimal from 'decimal.js';
 import { escapeLiteral, escapeIdentifier } from 'pg/lib/utils';
-import { a as QueryCoditionalSelector, b as QueryFieldSelector, c as QueryExpressionSelector, d as QueryDistanceExpression, e as QueryCoditionalExpression, f as QueryComparisonExpression, g as QueryNotExpression, h as QueryArrayExpression, i as QueryValueExpression, j as QueryKeyExpression, Q as QuerySelector, F as FieldSelectorExpression } from '../../internals/index-DPPLcZx8.mjs';
+import { a as QueryCoditionalSelector, b as QueryFieldSelector, c as QueryExpressionSelector, d as QueryDistanceExpression, e as QueryKeyExpression, f as QueryValueExpression, g as QueryCoditionalExpression, h as QueryComparisonExpression, i as QueryNotExpression, j as QueryArrayExpression, Q as QuerySelector, F as FieldSelectorExpression } from '../../internals/index-DG9HHO_U.mjs';
 import '@o2ter/crypto-js';
-import { r as resolveColumn, a as resolveDataType$1, g as generateId, Q as QueryValidator } from '../../internals/random-ycCeBd0S.mjs';
+import { r as resolveColumn, a as resolveDataType$1, g as generateId, b as accumulatorKeyTypes, Q as QueryValidator } from '../../internals/random-CufRbivU.mjs';
 import { c as PROTO_EVENT } from '../../internals/const-Dkp7Nsv5.mjs';
 import { P as PVK } from '../../internals/private-CNw40LZ7.mjs';
 
@@ -214,12 +214,12 @@ class QueryCompiler {
     _encodeIncludes(query) {
         const names = {};
         const populates = {};
-        const countMatches = [];
+        const groupMatches = {};
         for (const include of query.includes) {
             const { paths: [colname, ...subpath], dataType } = resolveColumn(this.schema, query.className, include);
             names[colname] = dataType;
-            if (isRelation(dataType) && _.includes(query.countMatches, colname))
-                countMatches.push(colname);
+            if (isRelation(dataType) && !_.isNil(query.groupMatches[colname]))
+                groupMatches[colname] = query.groupMatches[colname];
             if (isPointer(dataType) || isRelation(dataType)) {
                 if (_.isEmpty(subpath))
                     throw Error(`Invalid path: ${include}`);
@@ -250,21 +250,26 @@ class QueryCompiler {
         }
         for (const [colname, populate] of _.toPairs(populates)) {
             const _matches = query.matches[colname];
-            const { includes, populates, countMatches } = this._encodeIncludes({
+            const { includes, populates, groupMatches } = this._encodeIncludes({
                 className: populate.className,
                 includes: populate.subpaths,
                 matches: _matches.matches,
-                countMatches: [
-                    ..._.filter(query.countMatches, x => _.startsWith(x, `${colname}.`)).map(x => x.slice(colname.length + 1)),
-                    ..._matches.countMatches ?? [],
-                ],
+                groupMatches: {
+                    ..._.mapKeys(_.pickBy(query.groupMatches, (x, k) => _.startsWith(k, `${colname}.`)), (x, k) => k.slice(colname.length + 1)),
+                    ..._matches.groupMatches ?? {},
+                },
             });
             populate.sort = _encodeSorting(includes, populates, _matches.sort);
             populate.includes = includes;
             populate.populates = populates;
-            populate.countMatches = countMatches;
+            populate.groupMatches = groupMatches;
         }
-        return { className: query.className, includes: names, populates, countMatches: _.uniq(countMatches) };
+        return {
+            className: query.className,
+            includes: names,
+            populates,
+            groupMatches,
+        };
     }
     _baseSelectQuery(query, options) {
         const fetchName = `_fetch_$${query.className.toLowerCase()}`;
@@ -405,7 +410,7 @@ class QueryCompiler {
     }
     _selectIncludes(className, includes) {
         const _includes = _.pickBy(includes, v => _.isString(v) || (v.type !== 'pointer' && v.type !== 'relation'));
-        return _.map(_includes, (dataType, colname) => {
+        return _.flatMap(_includes, (dataType, colname) => {
             if (!_.isString(dataType) && isPrimitive(dataType) && !_.isNil(dataType.default)) {
                 return sql `COALESCE(${{ identifier: className }}.${{ identifier: colname }}, ${{ value: dataType.default }}) AS ${{ identifier: colname }}`;
             }
@@ -426,7 +431,7 @@ class QueryCompiler {
     `)}`;
     }
     _selectPopulateMap(context) {
-        return _.map(context.populates, (populate, field) => this.dialect.selectPopulate(this, context, populate, field, _.includes(context.countMatches, field)));
+        return _.map(context.populates, (populate, field) => this.dialect.selectPopulate(this, context, populate, field));
     }
     insert(options, values) {
         const _values = _.map(values, attr => ({
@@ -564,9 +569,15 @@ class SqlStorage {
         const { query, values } = sql.compile(this.dialect);
         return this._query(query, values);
     }
-    _decodeShapedObject(dataType, value) {
+    _decodeMatchTypes(value, matchType) {
+        if (!_.isPlainObject(value))
+            return;
+        return _.mapValues(value, (v, k) => this.dialect.decodeType(matchType[k], v));
+    }
+    _decodeShapedObject(dataType, value, matchesType) {
         const result = {};
         for (const { path, type } of shapePaths(dataType)) {
+            const matchType = _.get(matchesType, path) ?? {};
             if (_.isString(type)) {
                 const _value = this.dialect.decodeType(type, _.get(value, path));
                 if (!_.isNil(_value))
@@ -575,17 +586,17 @@ class SqlStorage {
             else if (isPointer(type)) {
                 const _value = _.get(value, path);
                 if (_.isPlainObject(_value)) {
-                    const decoded = this._decodeObject(type.target, _value);
+                    const decoded = this._decodeObject(type.target, _value, matchType);
                     if (decoded.objectId)
                         _.set(result, path, decoded);
                 }
             }
             else if (isRelation(type)) {
                 const _value = _.get(value, path);
-                if (_.isString(_value) && _value.match(/^\d+$/g))
-                    _.set(result, path, parseInt(_value));
-                else if (_.isArray(_value))
-                    _.set(result, path, _value.map(x => this._decodeObject(type.target, x)));
+                if (_.isArray(_value))
+                    _.set(result, path, _value.map(x => this._decodeObject(type.target, x, matchType)));
+                else if (_.isPlainObject(_value))
+                    _.set(result, path, this._decodeMatchTypes(_value, matchType));
             }
             else {
                 const _value = this.dialect.decodeType(type.type, _.get(value, path)) ?? type.default;
@@ -595,7 +606,7 @@ class SqlStorage {
         }
         return result;
     }
-    _decodeObject(className, attrs) {
+    _decodeObject(className, attrs, matchesType) {
         const fields = this.schema[className].fields;
         const obj = new TObject(className);
         const _attrs = {};
@@ -603,6 +614,7 @@ class SqlStorage {
             _.set(_attrs, key, value);
         }
         for (const [key, value] of _.toPairs(_attrs)) {
+            const matchType = matchesType[key] ?? {};
             const dataType = fields[key];
             if (!dataType)
                 continue;
@@ -610,20 +622,20 @@ class SqlStorage {
                 obj[PVK].attributes[key] = this.dialect.decodeType(dataType, value);
             }
             else if (isShape(dataType)) {
-                obj[PVK].attributes[key] = this._decodeShapedObject(dataType, value);
+                obj[PVK].attributes[key] = this._decodeShapedObject(dataType, value, matchType);
             }
             else if (isPointer(dataType)) {
                 if (_.isPlainObject(value)) {
-                    const decoded = this._decodeObject(dataType.target, value);
+                    const decoded = this._decodeObject(dataType.target, value, matchType);
                     if (decoded.objectId)
                         obj[PVK].attributes[key] = decoded;
                 }
             }
             else if (isRelation(dataType)) {
-                if (_.isString(value) && value.match(/^\d+$/g))
-                    obj[PVK].attributes[key] = parseInt(value);
-                else if (_.isArray(value))
-                    obj[PVK].attributes[key] = value.map(x => this._decodeObject(dataType.target, x));
+                if (_.isArray(value))
+                    obj[PVK].attributes[key] = value.map(x => this._decodeObject(dataType.target, x, matchType));
+                else if (_.isPlainObject(value))
+                    obj[PVK].attributes[key] = this._decodeMatchTypes(value, matchType);
             }
             else {
                 obj[PVK].attributes[key] = this.dialect.decodeType(dataType.type, value) ?? dataType.default;
@@ -652,6 +664,18 @@ class SqlStorage {
         const count = parseInt(_count);
         return _.isFinite(count) ? count : 0;
     }
+    _matchesType(options) {
+        const types = {};
+        for (const [key, match] of _.entries(options.matches)) {
+            types[key] = this._matchesType(match);
+        }
+        for (const [key, group] of _.entries(options.groupMatches)) {
+            for (const [field, expr] of _.entries(group)) {
+                _.set(types, `${key}.${field}`, accumulatorKeyTypes[expr.type]);
+            }
+        }
+        return types;
+    }
     find(query) {
         const self = this;
         const compiler = self._makeCompiler(false, query.extraFilter);
@@ -659,7 +683,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
@@ -672,7 +696,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
@@ -686,7 +710,7 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(query);
             for await (const { _class, ...object } of objects) {
-                yield self._decodeObject(_class, object);
+                yield self._decodeObject(_class, object, {});
             }
         })();
     }
@@ -701,29 +725,29 @@ class SqlStorage {
         return (async function* () {
             const objects = self.query(_query);
             for await (const object of objects) {
-                yield self._decodeObject(query.className, object);
+                yield self._decodeObject(query.className, object, self._matchesType(query));
             }
         })();
     }
     async insert(options, values) {
         const compiler = this._makeCompiler(true);
         const result = await this.query(compiler.insert(options, values));
-        return _.map(result, x => this._decodeObject(options.className, x));
+        return _.map(result, x => this._decodeObject(options.className, x, this._matchesType(options)));
     }
     async update(query, update) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const updated = await this.query(compiler.update(query, update));
-        return _.map(updated, x => this._decodeObject(query.className, x));
+        return _.map(updated, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
     async upsert(query, update, setOnInsert) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const upserted = await this.query(compiler.upsert(query, update, setOnInsert));
-        return _.map(upserted, x => this._decodeObject(query.className, x));
+        return _.map(upserted, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
     async delete(query) {
         const compiler = this._makeCompiler(true, query.extraFilter);
         const deleted = await this.query(compiler.delete(query));
-        return _.map(deleted, x => this._decodeObject(query.className, x));
+        return _.map(deleted, x => this._decodeObject(query.className, x, this._matchesType(query)));
     }
 }
 
@@ -769,7 +793,15 @@ const _fetchElement = (parent, colname, subpath, dataType) => {
     }
     else if (!_.isEmpty(subpath)) {
         const _subpath = sql `${_.map(subpath, x => sql `${{ quote: x.startsWith('$') ? `$${x}` : x }}`)}`;
-        if (dataType && _isTypeof(dataType, ['array', 'string[]', 'relation'])) {
+        const match = parent.groupMatches?.[colname]?.[subpath[0]];
+        if (dataType && isRelation(dataType) && subpath.length === 1 && match) {
+            return {
+                element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}.${subpath[0]}` }}`,
+                json: false,
+                dataType: accumulatorKeyTypes[match.type],
+            };
+        }
+        else if (dataType && _isTypeof(dataType, ['array', 'string[]', 'relation'])) {
             return {
                 element: sql `jsonb_extract_path(to_jsonb(${element}), ${_subpath})`,
                 json: true,
@@ -829,7 +861,7 @@ const _resolvePopulate = (path, populates) => {
 const fetchElement = (compiler, parent, field) => {
     if (parent.className) {
         const { dataType, colname, subpath } = resolvePaths(compiler, parent.className, _.toPath(field));
-        const { element, json } = _fetchElement(parent, colname, subpath, dataType);
+        const { element, json, dataType: _dataType } = _fetchElement(parent, colname, subpath, dataType);
         if (isPointer(dataType))
             return { element: sql `${{ identifier: parent.name }}.${{ identifier: `${colname}._id` }}`, dataType };
         const populate = isRelation(dataType) && _resolvePopulate(_.toPath(colname), parent.populates);
@@ -837,7 +869,7 @@ const fetchElement = (compiler, parent, field) => {
             return { element, dataType: json ? null : dataType };
         return {
             element,
-            dataType: json ? null : dataType,
+            dataType: json ? null : _dataType ?? dataType,
             relation: {
                 colname,
                 target: dataType.target,
@@ -1177,7 +1209,7 @@ const _encodeJsonValue = (value) => {
         return sql `jsonb_build_object(${_.map(value, (v, k) => sql `${{ value: k }}, ${_encodeJsonValue(v)}`)})`;
     return sql `to_jsonb(${{ value }})`;
 };
-const _encodePopulateInclude = (className, colname, dataType) => {
+const _jsonPopulateInclude = (className, colname, dataType) => {
     switch (_typeof(dataType)) {
         case 'decimal':
             return sql `jsonb_build_object(
@@ -1892,10 +1924,13 @@ const _selectRelationPopulate = (compiler, parent, populate, field, encode) => {
         cond = sql `${sql `(${{ quote: parent.className + '$' }} || ${_local('_id')})`} = ANY(${_foreign(populate.colname)})`;
     }
     return sql `
-    SELECT ${_.compact(_.flatMap(subpaths, ({ path, type }) => [
-        encode && _encodePopulateInclude(populate.name, path, type),
-        !encode && sql `${{ identifier: populate.name }}.${{ identifier: path }}`,
-        !encode && isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }}`,
+    SELECT ${_.compact(_.flatMap(subpaths, ({ path, type }) => encode ? [
+        _jsonPopulateInclude(populate.name, path, type)
+    ] : [
+        ...(populate.groupMatches[path] ? _.map(_.keys(populate.groupMatches[path]), k => sql `${{ identifier: populate.name }}.${{ identifier: `${path}.${k}` }}`) : [
+            sql `${{ identifier: populate.name }}.${{ identifier: path }}`
+        ]),
+        isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }}`,
     ]))}
     FROM ${{ identifier: populate.name }} WHERE ${cond}
     ${!_.isEmpty(populate.sort) ? sql `ORDER BY ${compiler._encodeSort(populate.sort, { className: populate.className, name: populate.name })}` : sql ``}
@@ -1904,33 +1939,68 @@ const _selectRelationPopulate = (compiler, parent, populate, field, encode) => {
     ${compiler.selectLock ? compiler.isUpdate ? sql `FOR UPDATE NOWAIT` : sql `FOR SHARE NOWAIT` : sql ``}
   `;
 };
-const selectPopulate = (compiler, parent, populate, field, countMatches) => {
+const selectPopulate = (compiler, parent, populate, field) => {
     if (populate.type === 'relation') {
-        return {
-            columns: [
-                countMatches ? sql `
-          (
-            SELECT COUNT(*) FROM (
-              ${_selectRelationPopulate(compiler, parent, populate, field, false)}
-            ) ${{ identifier: populate.name }}
-          ) AS ${{ identifier: field }}
-        ` : sql `
-          ARRAY(
-            SELECT to_jsonb(${{ identifier: populate.name }}) FROM (
-              ${_selectRelationPopulate(compiler, parent, populate, field, true)}
-            ) ${{ identifier: populate.name }}
-          ) AS ${{ identifier: field }}
-        `,
-                sql `${{ identifier: parent.name }}.${{ identifier: field }} AS ${{ identifier: `$${field}` }}`
-            ],
-        };
+        const { groupMatches } = parent;
+        const columns = [
+            sql `${{ identifier: parent.name }}.${{ identifier: field }} AS ${{ identifier: `$${field}` }}`,
+        ];
+        if (!_.isEmpty(groupMatches?.[field])) {
+            for (const [key, { type, expr }] of _.entries(groupMatches[field])) {
+                switch (type) {
+                    case '$count':
+                        columns.push(sql `
+              (
+                SELECT COUNT(*) FROM (
+                  ${_selectRelationPopulate(compiler, parent, populate, field, false)}
+                ) ${{ identifier: populate.name }}
+              ) AS ${{ identifier: `${field}.${key}` }}
+            `);
+                        break;
+                    case '$avg':
+                    case '$sum':
+                        {
+                            const op = {
+                                '$avg': 'AVG',
+                                '$sum': 'SUM',
+                            }[type];
+                            if (!expr)
+                                throw Error('Invalid expression');
+                            const exprs = encodeTypedQueryExpression(compiler, populate, expr);
+                            const { sql: value } = (_.includes(['$avg'], type) ? _.find(exprs, e => e.type === 'number') : _.first(exprs)) ?? {};
+                            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}` }}
+              `);
+                        }
+                        break;
+                }
+            }
+        }
+        else {
+            columns.push(sql `
+        ARRAY(
+          SELECT to_jsonb(${{ identifier: populate.name }}) FROM (
+            ${_selectRelationPopulate(compiler, parent, populate, field, true)}
+          ) ${{ identifier: populate.name }}
+        ) AS ${{ identifier: field }}
+      `);
+        }
+        return { columns };
     }
     const _local = (field) => sql `${{ identifier: parent.name }}.${{ identifier: field }}`;
     const _foreign = (field) => sql `${{ identifier: populate.name }}.${{ identifier: field }}`;
     const subpaths = resolveSubpaths(compiler, populate);
     return {
         columns: _.compact(_.flatMap(subpaths, ({ path, type }) => [
-            sql `${{ identifier: populate.name }}.${{ identifier: path }} AS ${{ identifier: `${field}.${path}` }}`,
+            ...populate.groupMatches[path] ? _.map(_.keys(populate.groupMatches[path]), k => sql `${{ identifier: populate.name }}.${{ identifier: `${path}.${k}` }} AS ${{ identifier: `${field}.${path}.${k}` }}`) : [
+                sql `${{ identifier: populate.name }}.${{ identifier: path }} AS ${{ identifier: `${field}.${path}` }}`
+            ],
             isRelation(type) && sql `${{ identifier: populate.name }}.${{ identifier: `$${path}` }} AS ${{ identifier: `$${field}.${path}` }}`,
         ])),
         join: sql `
@@ -2015,9 +2085,8 @@ const encodePopulate = (compiler, parent, remix) => {
         parent.filter && compiler._encodeFilter(parent, parent.filter),
         compiler.extraFilter && compiler._encodeFilter(parent, compiler.extraFilter(parent.className)),
     ]);
-    const _populates = _.map(parent.populates, (populate, field) => selectPopulate(compiler, parent, populate, field, _.includes(parent.countMatches, field)));
+    const _populates = _.map(parent.populates, (populate, field) => selectPopulate(compiler, parent, populate, field));
     const _joins = _.compact(_.map(_populates, ({ join }) => join));
-    const _includes = _.pickBy(parent.includes, v => isPrimitive(v));
     const { joins: _joins2 = [], field: _foreignField = undefined, rows = false, } = parent.foreignField ? encodeForeignField(compiler, {
         className: parent.className,
         name: parent.name,
@@ -2031,7 +2100,7 @@ const encodePopulate = (compiler, parent, remix) => {
         SELECT
         ${{
             literal: [
-                ..._.map(_.keys(_includes), colname => sql `${{ identifier: parent.name }}.${{ identifier: colname }}`),
+                ...compiler._selectIncludes(parent.name, parent.includes),
                 ..._.flatMap(_populates, ({ columns: column }) => column),
                 ..._foreignField ? [sql `${rows ? sql `ARRAY(${_foreignField})` : _foreignField} AS ${{ identifier: parent.colname }}`] : [],
             ], separator: ',\n'
@@ -2084,9 +2153,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         break;
                     return sql `${element} ${nullSafeEqual()} ${{ value: expr.value.objectId }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${nullSafeEqual()} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 return sql `${element} ${nullSafeEqual()} ${encodeValue(expr.value)}`;
             }
         case '$ne':
@@ -2100,9 +2166,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                         break;
                     return sql `${element} ${nullSafeNotEqual()} ${{ value: expr.value.objectId }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${nullSafeNotEqual()} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 return sql `${element} ${nullSafeNotEqual()} ${encodeValue(expr.value)}`;
             }
         case '$gt':
@@ -2146,9 +2209,6 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 else if (!_.isString(dataType) && dataType?.type === 'pointer' && expr.value instanceof TObject && expr.value.objectId) {
                     return sql `${element} ${{ literal: op }} ${{ value: expr.value.objectId }}`;
                 }
-                else if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${{ literal: op }} ${encodeType(colname, 'number', expr.value)}`;
-                }
                 else if (!dataType) {
                     if (expr.value instanceof Decimal || _.isNumber(expr.value)) {
                         return sql `(
@@ -2339,8 +2399,10 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 if (dataType && _isTypeof(dataType, 'string')) {
                     return sql `COALESCE(length(${element}), 0) = ${{ value: expr.value }}`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} = ${{ value: expr.value }}`;
+                if (relation && parent.className && parent.groupMatches?.[colname]) {
+                    const tempName = `_populate_expr_$${compiler.nextIdx()}`;
+                    const populate = _selectRelationPopulate(compiler, { className: parent.className, name: parent.name }, relation.populate, `$${field}`, false);
+                    return sql `(SELECT COUNT(*) FROM (${populate}) AS ${{ identifier: tempName }}) = ${{ value: expr.value }}`;
                 }
                 if (dataType && _isTypeof(dataType, ['array', 'string[]', 'vector', 'relation'])) {
                     return sql `COALESCE(array_length(${element}, 1), 0) = ${{ value: expr.value }}`;
@@ -2363,8 +2425,10 @@ const encodeFieldExpression = (compiler, parent, field, expr) => {
                 if (dataType && _isTypeof(dataType, 'string')) {
                     return sql `COALESCE(length(${element}), 0) ${{ literal: expr.value ? '=' : '<>' }} 0`;
                 }
-                if (relation && _.includes(parent.countMatches, relation.colname)) {
-                    return sql `${element} ${{ literal: expr.value ? '=' : '<>' }} 0`;
+                if (relation && parent.className && parent.groupMatches?.[colname]) {
+                    const tempName = `_populate_expr_$${compiler.nextIdx()}`;
+                    const populate = _selectRelationPopulate(compiler, { className: parent.className, name: parent.name }, relation.populate, `$${field}`, false);
+                    return sql `${{ literal: expr.value ? 'NOT EXISTS' : 'EXISTS' }}(SELECT * FROM (${populate}) AS ${{ identifier: tempName }})`;
                 }
                 if (dataType && _isTypeof(dataType, ['array', 'string[]', 'vector', 'relation'])) {
                     return sql `COALESCE(array_length(${element}, 1), 0) ${{ literal: expr.value ? '=' : '<>' }} 0`;