semanticdb-core 1.0.53 → 1.1.1

package/dist/common/date.js

@@ -24,7 +24,7 @@ function getSupportedTimeWindows() {
     return ['second', 'minute', 'hour', 'weekday', 'day', 'week', 'month', 'quarter', 'year'];
 }
 function isStandardDateForm(dateValue) {
-    return typeof dateValue === 'object' && '$gte' in dateValue && '$lte' in dateValue;
+    return typeof dateValue === 'object' && dateValue !== null && '$gte' in dateValue && '$lte' in dateValue;
 }
 /**
  * year + offset形态
@@ -32,7 +32,7 @@ function isStandardDateForm(dateValue) {
  * @return {Boolean}
  */
 function isRelativeDateForm(dateValue) {
-    if (typeof dateValue !== 'object')
+    if (typeof dateValue !== 'object' || dateValue === null)
         return false;
     const complexOperators = ['$gte', '$gt', '$lte', '$lt', '$or', '$ne'];
     for (const complexOperator of complexOperators) {

package/dist/index.d.ts

@@ -9,5 +9,6 @@ export { getDrilldownDimensions } from './schema/schema.utils/getDrilldownDimens
 export * from './logicform/logicform';
 export * from './logicform/logicform.utils';
 export * from './logicform/types/query';
+export * from './logicform/nameForPredNode';
 export * from './custom-function/utils';
 export * from './result/index';

package/dist/index.js

@@ -27,5 +27,6 @@ Object.defineProperty(exports, "getDrilldownDimensions", { enumerable: true, get
 __exportStar(require("./logicform/logicform"), exports);
 __exportStar(require("./logicform/logicform.utils"), exports);
 __exportStar(require("./logicform/types/query"), exports);
+__exportStar(require("./logicform/nameForPredNode"), exports);
 __exportStar(require("./custom-function/utils"), exports);
 __exportStar(require("./result/index"), exports);

package/dist/logicform/nameForPredNode.d.ts

@@ -0,0 +1,20 @@
+import { SchemaType } from '../schema/schema';
+import { PredItemType } from './logicform';
+import { QueryType } from './types/query';
+export interface ctx {
+    schemas: Record<string, SchemaType>;
+    customFunctions: Record<string, any>;
+    locale?: string;
+}
+/**
+ * 给Query起名
+ */
+export declare const nameForQuery: (query: QueryType, schema: SchemaType, schemas: Record<string, SchemaType>) => string;
+/**
+ * 给pred node起名, normalize阶段用到
+ * @param predNode - PredItemType
+ * @param s - schema object
+ * @param ctx - 上下文对象
+ * @returns 名称字符串
+ */
+export declare const nameForPredNode: (predNode: PredItemType, s: SchemaType, ctx: ctx) => string | null;

package/dist/logicform/nameForPredNode.js

@@ -0,0 +1,907 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameForPredNode = exports.nameForQuery = void 0;
+const moment_1 = __importDefault(require("moment"));
+const schema_utils_1 = require("../schema/schema.utils");
+const utils_1 = require("../custom-function/utils");
+const date_1 = require("../common/date");
+// ============== 辅助函数 ==============
+const getPropertyName = (property) => {
+    var _a;
+    if ((_a = property === null || property === void 0 ? void 0 : property.ui) === null || _a === void 0 ? void 0 : _a.title) {
+        return property.ui.title;
+    }
+    return property.name;
+};
+const twToChinese = (tw) => {
+    const map = {
+        year: '年',
+        quarter: '季度',
+        month: '月',
+        week: '周',
+        day: '日',
+        hour: '点',
+        minute: '分',
+        second: '秒',
+    };
+    return map[tw];
+};
+/**
+ * 中文转其他语言的简化实现
+ */
+const zhCNToOthers = (cnText, locale = 'zh-CN') => {
+    if (locale.toLowerCase() === 'zh-cn') {
+        return cnText;
+    }
+    if (locale.startsWith('en')) {
+        const map = {
+            '同比': 'YoY%',
+            '环比': 'MoM%',
+            '周环比': 'WoW%',
+            '季度环比': 'QoQ%',
+            '同比差值': 'YoY Diff',
+            '环比差值': 'MoM Diff',
+            '同期': 'YoY',
+            '环期': 'MoM',
+            '周环期': 'WoW',
+            '占比': '%',
+            '数量': '#',
+            '累计': 'Cumulative ',
+            '年': 'Year',
+            '季度': 'Quarter',
+            '月': 'Month',
+            '周': 'Week',
+            '星期': 'Weekday',
+            '日': 'Day',
+            '小时': 'Hour',
+            '分钟': 'Minute',
+            '秒': 'Second',
+            '均': ' Avg',
+            '每小时': 'Hourly ',
+            '每小时段': 'By Hour ',
+            '分星期': 'By Weekday ',
+            '日均': 'Daily Avg ',
+            '月均': 'Monthly Avg ',
+            '周均': 'Weekly Avg ',
+            '上期': 'Previous Period ',
+            '按农历': ' (Lunar)',
+            '按星期': ' (By Weekday)',
+            '段': ' Range',
+        };
+        return map[cnText] || cnText;
+    }
+    return cnText;
+};
+/**
+ * 将相对日期转为中文问句
+ */
+const relativeDateToQuestion = (value) => {
+    let toAdd = '';
+    const tws = (0, date_1.getSupportedTimeWindows)().reverse();
+    for (const tw of tws) {
+        if (tw in value) {
+            const chinese = twToChinese(tw);
+            if (chinese) {
+                if (typeof value[tw] === 'object') {
+                    if (value[tw].$gte && value[tw].$lte) {
+                        toAdd += `${value[tw].$gte}-${value[tw].$lte}${chinese}`;
+                    }
+                    else if (value[tw].$in) {
+                        toAdd += `${value[tw].$in.join(',')}${chinese}`;
+                    }
+                }
+                else {
+                    toAdd += `${value[tw]}${chinese}`;
+                }
+            }
+        }
+    }
+    if (value.$offset) {
+        if (value.$offset.year === 0) {
+            toAdd += '今年';
+        }
+        else if (value.$offset.year === -1) {
+            toAdd += '去年';
+        }
+        else if (value.$offset.year) {
+            toAdd += `${-value.$offset.year}年前`;
+        }
+        if (value.$offset.quarter === 0) {
+            toAdd += '本季度';
+        }
+        else if (value.$offset.quarter === -1) {
+            toAdd += '上季度';
+        }
+        else if (value.$offset.quarter) {
+            toAdd += `${-value.$offset.quarter}季度前`;
+        }
+        if (value.$offset.month === 0) {
+            toAdd += '本月';
+        }
+        else if (value.$offset.month === -1) {
+            toAdd += '上月';
+        }
+        else if (value.$offset.month) {
+            toAdd += `${-value.$offset.month}个月前`;
+        }
+        if (value.$offset.week === -1) {
+            toAdd += `上周`;
+        }
+        else if (value.$offset.week) {
+            toAdd += `${-value.$offset.week}周前`;
+        }
+        else if (value.$offset.week === 0) {
+            toAdd += '本周';
+        }
+        if (value.weekday) {
+            const weekdayMap = {
+                1: '周一',
+                2: '周二',
+                3: '周三',
+                4: '周四',
+                5: '周五',
+                6: '周六',
+                7: '周日',
+            };
+            toAdd += weekdayMap[value.weekday] || '';
+        }
+        if (value.$offset.day === 0) {
+            toAdd += '今天';
+        }
+        else if (value.$offset.day === -1) {
+            toAdd += '昨天';
+        }
+        else if (value.$offset.day) {
+            toAdd += `${-value.$offset.day}天前`;
+        }
+    }
+    return toAdd;
+};
+// moment的帮助函数
+const momentGetOneIndexedMonthByLevel = (date, level) => {
+    if (level === 'month') {
+        return date.get(level) + 1;
+    }
+    if (level === 'day') {
+        return date.get('date');
+    }
+    return date.get(level);
+};
+/**
+ * 将标准日期格式转为问句
+ */
+const normalizedDateFormToQuestion = (date) => {
+    const start = (0, moment_1.default)(date.$gte);
+    const end = (0, moment_1.default)(date.$lte);
+    const formatter = 'YYYYMMDDHHmmss';
+    const levels = ['year', 'quarter', 'month', 'date'];
+    const processLevel = (levelIndex, baseRelativeForm = {}) => {
+        const level = levels[levelIndex];
+        if (!level)
+            return null;
+        if (start.get(level) === end.get(level)) {
+            if (start.format(formatter) === (0, moment_1.default)(start).startOf(level).format(formatter) &&
+                end.format(formatter) === (0, moment_1.default)(end).endOf(level).format(formatter)) {
+                const levelKey = level === 'date' ? 'day' : level;
+                const relativeDateForm = Object.assign(Object.assign({}, baseRelativeForm), { [levelKey]: momentGetOneIndexedMonthByLevel(start, level) });
+                if (relativeDateForm.month) {
+                    delete relativeDateForm.quarter;
+                }
+                if (relativeDateForm.day) {
+                    delete relativeDateForm.week;
+                }
+                return relativeDateToQuestion(relativeDateForm);
+            }
+            if (levelIndex >= levels.length) {
+                return null;
+            }
+            const newBaseRelativeForm = Object.assign(Object.assign({}, baseRelativeForm), { [level]: momentGetOneIndexedMonthByLevel(start, level) });
+            const innerQuestion = processLevel(levelIndex + 1, newBaseRelativeForm);
+            if (innerQuestion)
+                return innerQuestion;
+            // XTD
+            if (!innerQuestion) {
+                if (start.isSame((0, moment_1.default)(start).startOf(level)) && end.isSame((0, moment_1.default)().endOf('day'))) {
+                    switch (level) {
+                        case 'year':
+                            return 'YTD';
+                        case 'quarter':
+                            return 'QTD';
+                        case 'month':
+                            return 'MTD';
+                    }
+                }
+            }
+            return null;
+        }
+        return null;
+    };
+    const ret = processLevel(0, {});
+    if (ret)
+        return ret;
+    let startString = start.format('YYYY-MM-DD HH:mm:ss');
+    let endString = end.format('YYYY-MM-DD HH:mm:ss');
+    if (startString.endsWith(' 00:00:00') && endString.endsWith(' 23:59:59')) {
+        startString = startString.substring(0, 10);
+        endString = endString.substring(0, 10);
+    }
+    return `${startString}～${endString}`;
+};
+/**
+ * 将相对日期格式标准化
+ */
+const normaliseRelativeDateForm = (value, config = {}) => {
+    if (config.startOfWeek === 'sunday') {
+        moment_1.default.locale('en');
+    }
+    let startDate = (0, moment_1.default)();
+    let endDate = (0, moment_1.default)();
+    const tws = (0, date_1.getSupportedTimeWindows)();
+    let granuality;
+    const others = {};
+    if (value.$calendar) {
+        others.$calendar = value.$calendar;
+    }
+    // 处理 $in 连续值
+    for (const [k, v] of Object.entries(value)) {
+        if (typeof v === 'object' && v && v.$in) {
+            let isContinuous = false;
+            const sorted = [...v.$in].sort((a, b) => a - b);
+            if (sorted[sorted.length - 1] - sorted[0] === sorted.length - 1) {
+                isContinuous = true;
+            }
+            if (isContinuous) {
+                value[k] = {
+                    $gte: sorted[0],
+                    $lte: sorted[sorted.length - 1],
+                };
+            }
+        }
+    }
+    let hasHitComplexDate = false;
+    if ('hour' in value && 'minute' in value && !('second' in value)) {
+        value.second = 0;
+    }
+    if (!('year' in value) && !('$offset' in value)) {
+        hasHitComplexDate = true;
+        if ('hour' in value && 'minute' in value && 'second' in value) {
+            others.$time = (0, moment_1.default)()
+                .hour(value.hour)
+                .minute(value.minute)
+                .second(value.second)
+                .format('HH:mm:ss');
+        }
+    }
+    if (('year' in value || ('$offset' in value && 'year' in value.$offset)) &&
+        'day' in value &&
+        Object.keys(value).length === 2) {
+        hasHitComplexDate = true;
+    }
+    for (let index = tws.length - 1; index >= 0; index--) {
+        const tw = tws[index];
+        const valueInGran = value[tw];
+        if (tw in value) {
+            let twToSet = tw;
+            if (twToSet === 'day') {
+                twToSet = 'date';
+            }
+            else if (twToSet === 'weekday') {
+                twToSet = 'day';
+            }
+            if (!hasHitComplexDate && typeof valueInGran === 'number') {
+                granuality = tw;
+                if (twToSet === 'month') {
+                    startDate.set(twToSet, valueInGran - 1);
+                    endDate.set(twToSet, valueInGran - 1);
+                }
+                else if (twToSet === 'week') {
+                    if (!value.month && !('$offset' in value && 'month' in value.$offset)) {
+                        const twoDigitValue = `${valueInGran}`.padStart(2, '0');
+                        startDate = (0, moment_1.default)(`${startDate.year()}${twoDigitValue}`, 'ggggww').startOf('week');
+                        endDate = (0, moment_1.default)(startDate).endOf('week');
+                    }
+                    else {
+                        startDate.startOf('month').startOf('week');
+                        endDate.startOf('month').endOf('week');
+                    }
+                }
+                else {
+                    if ('period' in value && 'hour' in value && value.period === 'pm' && value.hour < 12) {
+                        startDate.set(twToSet, valueInGran + 12);
+                        endDate.set(twToSet, valueInGran + 12);
+                    }
+                    else {
+                        startDate.set(twToSet, valueInGran);
+                        endDate.set(twToSet, valueInGran);
+                    }
+                }
+            }
+            else if (!hasHitComplexDate &&
+                valueInGran.$gte &&
+                valueInGran.$lte &&
+                Object.keys(valueInGran).length === 2) {
+                granuality = tw;
+                if (twToSet === 'month') {
+                    startDate.set(twToSet, valueInGran.$gte - 1);
+                    endDate.set(twToSet, valueInGran.$lte - 1);
+                }
+                else {
+                    startDate.set(twToSet, valueInGran.$gte);
+                    endDate.set(twToSet, valueInGran.$lte);
+                }
+                hasHitComplexDate = true;
+            }
+            else {
+                others[`$${tw}`] = valueInGran;
+                hasHitComplexDate = true;
+                if (tw === 'year') {
+                    granuality = 'year';
+                    if (typeof valueInGran === 'object' && valueInGran.$in) {
+                        const startYear = Math.min(...valueInGran.$in);
+                        const endYear = Math.max(...valueInGran.$in);
+                        startDate.set('year', startYear);
+                        endDate.set('year', endYear);
+                    }
+                    else if (typeof valueInGran === 'number') {
+                        startDate.set('year', valueInGran);
+                        endDate.set('year', valueInGran);
+                    }
+                }
+            }
+        }
+        if ('$offset' in value && tw in value.$offset) {
+            if (!granuality || tws.indexOf(tw) < tws.indexOf(granuality)) {
+                granuality = tw;
+            }
+            startDate.add(value.$offset[tw], tw);
+            endDate.add(value.$offset[tw], tw);
+        }
+    }
+    const getMomentGran = (gran) => {
+        let momentGran = gran;
+        if (gran === 'weekday')
+            momentGran = 'day';
+        return momentGran || 'day';
+    };
+    const momentGran = getMomentGran(granuality);
+    const normed = Object.assign({ $gte: startDate.startOf(momentGran).toDate(), $lte: endDate.endOf(momentGran).toDate(), $options: Object.assign({}, value) }, others);
+    if (!granuality) {
+        delete normed.$gte;
+        delete normed.$lte;
+    }
+    if (normed.$options) {
+        delete normed.$options.$calendar;
+    }
+    moment_1.default.locale('zh-cn');
+    return normed;
+};
+// ============== nameForValue ==============
+const nameForValue = (property, value, prefix) => {
+    let toAdd = '';
+    let propertyNameUsed = false;
+    if (property.primal_type === 'boolean') {
+        let negativePrefix = '';
+        if (value === true) {
+            negativePrefix = '';
+        }
+        else if (value === false) {
+            negativePrefix = '非';
+        }
+        else if (typeof value === 'object' && '$ne' in value) {
+            if (value.$ne)
+                negativePrefix = '非';
+        }
+        let booleanPredName = property.name;
+        if (booleanPredName.startsWith('是否')) {
+            booleanPredName = booleanPredName.slice(2);
+        }
+        else if (booleanPredName.startsWith('是不是')) {
+            booleanPredName = booleanPredName.slice(3);
+        }
+        toAdd = `${negativePrefix}${booleanPredName}`;
+        propertyNameUsed = true;
+    }
+    else if (property.primal_type === 'date') {
+        if ((0, date_1.isRelativeDateForm)(value) || typeof value === 'string') {
+            let postfix = '';
+            if (prefix === '大于等于') {
+                postfix = '以后';
+            }
+            else if (prefix === '小于等于') {
+                postfix = '以前';
+            }
+            if ((0, date_1.isRelativeDateForm)(value)) {
+                toAdd = relativeDateToQuestion(value);
+            }
+            else {
+                toAdd = value;
+                if ((0, moment_1.default)(toAdd).format('MMDDmmss') === '01010000') {
+                    toAdd = (0, moment_1.default)(toAdd).format('YYYY年');
+                }
+                else if ((0, moment_1.default)(toAdd).format('HHmmss') === '000000') {
+                    toAdd = (0, moment_1.default)(toAdd).format('YYYY年MM月DD日');
+                }
+            }
+            toAdd = `${toAdd}${postfix}`;
+        }
+        else if (typeof value === 'object' && value.$options && typeof value.$options === 'string') {
+            toAdd = value.$options;
+        }
+        else {
+            let low = value.$gte || value.$gt;
+            let high = value.$lte || value.$lt;
+            if (low && high) {
+                if ((0, date_1.isRelativeDateForm)(low)) {
+                    if (value.$gte) {
+                        low = normaliseRelativeDateForm(low).$gte;
+                    }
+                    else {
+                        low = normaliseRelativeDateForm(low).$lte;
+                    }
+                }
+                if ((0, date_1.isRelativeDateForm)(high)) {
+                    if (value.$lte) {
+                        high = normaliseRelativeDateForm(high).$lte;
+                    }
+                    else {
+                        high = normaliseRelativeDateForm(high).$gte;
+                    }
+                }
+            }
+            toAdd = normalizedDateFormToQuestion({
+                $gte: low,
+                $lte: high,
+            });
+            // $month, $year, etc...
+            const tws = (0, date_1.getSupportedTimeWindows)().reverse();
+            for (const tw of tws) {
+                if (`$${tw}` in value || tw in value) {
+                    const data = value[`$${tw}`] || value[tw];
+                    if (typeof data === 'object') {
+                        if (data.$in) {
+                            toAdd += `，${data.$in.join('，')}${twToChinese(tw)}`;
+                        }
+                        if (data.$gte && data.$lte) {
+                            toAdd += `，${data.$gte}~${data.$lte}${twToChinese(tw)}`;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else if (property.primal_type === 'object' && typeof value === 'boolean') {
+        if (value) {
+            toAdd = property.name;
+        }
+        else {
+            toAdd = `无${property.name}`;
+        }
+        propertyNameUsed = true;
+    }
+    else if (typeof value === 'object' && '$exists' in value) {
+        if (value.$exists) {
+            toAdd = `有${property.name}`;
+        }
+        else {
+            toAdd = `无${property.name}`;
+        }
+        propertyNameUsed = true;
+    }
+    else if (property.primal_type === 'object' && typeof value === 'object' && value.name) {
+        toAdd = value.name;
+    }
+    else if (typeof value !== 'object') {
+        toAdd += `${value}`;
+    }
+    else {
+        console.error(`[nameForQuery]未考虑到的情况: ${JSON.stringify(value)} `);
+    }
+    return { toAdd, propertyNameUsed };
+};
+// ============== nameForQuery ==============
+/**
+ * 给Query起名
+ */
+const nameForQuery = (query, schema, schemas) => {
+    const names = [];
+    for (const [pred, value] of Object.entries(query)) {
+        const property = (0, schema_utils_1.findPropertyByName)(schema._id, pred, schemas);
+        if (!property)
+            continue;
+        // skip agg_key
+        if (schema.agg_key && schema.agg_key.key === property.name)
+            continue;
+        const shouldNotAddPropertyName = property.primal_type === 'date' ||
+            property.is_categorical ||
+            property.is_name ||
+            property.primal_type === 'object';
+        let toAdd = '';
+        let propertyNameUsed = false;
+        if (typeof value === 'object' && value !== null) {
+            if ('schema' in value && 'query' in value) {
+                toAdd += (0, exports.nameForQuery)(value.query, schemas[value.schema], schemas);
+            }
+            else if (property.primal_type === 'date' &&
+                ((0, date_1.isStandardDateForm)(value) || (0, date_1.isRelativeDateForm)(value))) {
+                const res = nameForValue(property, value);
+                toAdd = res.toAdd;
+                propertyNameUsed = res.propertyNameUsed;
+            }
+            else {
+                Object.entries(value).forEach(([k, v]) => {
+                    let shouldRunNameForValue = true;
+                    if ('$gte' === k) {
+                        toAdd += '大于等于';
+                    }
+                    else if ('$gt' === k) {
+                        toAdd += '大于';
+                    }
+                    else if ('$ne' === k) {
+                        toAdd += '不等于';
+                    }
+                    else if ('$eq' === k) {
+                        toAdd += '为';
+                    }
+                    else if ('$lte' === k) {
+                        toAdd += '小于等于';
+                    }
+                    else if ('$lt' === k) {
+                        toAdd += '小于';
+                    }
+                    else if ('$exists' === k) {
+                        toAdd += `${v ? (property.primal_type === 'object' ? '' : '有') : '无'}${property.name}`;
+                        propertyNameUsed = true;
+                        shouldRunNameForValue = false;
+                    }
+                    else if ('$regex' === k) {
+                        propertyNameUsed = true;
+                        shouldRunNameForValue = false;
+                    }
+                    else if ('$in' === k) {
+                        toAdd = v
+                            .map((vv) => {
+                            return (0, exports.nameForQuery)({
+                                [pred]: vv,
+                            }, schema, schemas);
+                        })
+                            .join('或');
+                        propertyNameUsed = true;
+                        shouldRunNameForValue = false;
+                    }
+                    else if ('$nin' === k) {
+                        toAdd =
+                            '非' +
+                                v
+                                    .map((vv) => {
+                                    return (0, exports.nameForQuery)({
+                                        [pred]: vv,
+                                    }, schema, schemas);
+                                })
+                                    .join('且');
+                        propertyNameUsed = true;
+                        shouldRunNameForValue = false;
+                    }
+                    if (shouldRunNameForValue) {
+                        const res = nameForValue(property, v, toAdd);
+                        if (property.primal_type === 'date') {
+                            toAdd = '';
+                        }
+                        toAdd += res.toAdd;
+                        propertyNameUsed = res.propertyNameUsed;
+                    }
+                });
+            }
+        }
+        else {
+            if (!shouldNotAddPropertyName) {
+                toAdd = '为';
+            }
+            const res = nameForValue(property, value, toAdd);
+            toAdd = toAdd + res.toAdd;
+            propertyNameUsed = res.propertyNameUsed;
+        }
+        if (!shouldNotAddPropertyName && !propertyNameUsed) {
+            toAdd = `${property.name}${toAdd}`;
+        }
+        names.push(toAdd);
+    }
+    let name = '';
+    for (let i = 0; i < names.length; i++) {
+        const element = names[i];
+        if (i > 0) {
+            const prev = names[i - 1];
+            if (prev.match('\\d$') && element.match('^\\d')) {
+                name += `,${element}`;
+                continue;
+            }
+            if (prev.match('[a-zA-Z]$') && element.match('^[a-zA-Z]')) {
+                name += ` ${element}`;
+                continue;
+            }
+        }
+        name += element;
+    }
+    return name;
+};
+exports.nameForQuery = nameForQuery;
+// ============== nameForPredNode ==============
+/**
+ * 给pred node起名, normalize阶段用到
+ * @param predNode - PredItemType
+ * @param s - schema object
+ * @param ctx - 上下文对象
+ * @returns 名称字符串
+ */
+const nameForPredNode = (predNode, s, ctx) => {
+    var _a, _b, _c, _d;
+    const { schemas, customFunctions, locale = 'zh-CN' } = ctx;
+    if (typeof predNode !== 'object')
+        return null;
+    const schema = predNode.schema ? schemas[predNode.schema] : s;
+    let name = '';
+    // query
+    if (predNode.query) {
+        name += (0, exports.nameForQuery)(predNode.query, schema, schemas);
+    }
+    // operator
+    let useAggKey = false;
+    if (predNode.query && schema.agg_key && schema.agg_key.key in predNode.query) {
+        let keyName;
+        if (typeof predNode.query[schema.agg_key.key] === 'object' &&
+            predNode.query[schema.agg_key.key].query) {
+            keyName = Object.values(predNode.query[schema.agg_key.key].query)[0];
+        }
+        else {
+            keyName = predNode.query[schema.agg_key.key];
+        }
+        useAggKey = true;
+        let onlyValue = keyName;
+        while (typeof onlyValue === 'object') {
+            onlyValue = Object.values(onlyValue)[0];
+        }
+        name += onlyValue;
+    }
+    let defaultNameCalled = false;
+    if (predNode.operator) {
+        const func = (0, utils_1.findOneCustomFunction)(predNode.schema || schema._id, predNode.operator, customFunctions);
+        if (!func) {
+            throw new Error(`未注册的函数：${predNode.operator}`);
+        }
+        let basePredName = null;
+        let baseProperty = null;
+        if (typeof predNode.pred === 'object') {
+            basePredName = (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+        }
+        else if (predNode.pred) {
+            baseProperty = (0, schema_utils_1.findPropertyByName)(schema._id, predNode.pred, schemas);
+            if (baseProperty) {
+                basePredName = getPropertyName(baseProperty);
+            }
+            else {
+                basePredName = predNode.pred;
+            }
+        }
+        if (predNode.by) {
+            const addNameForByItem = (byItem) => {
+                if ([
+                    '$year',
+                    '$quarter',
+                    '$month',
+                    '$week',
+                    '$weekday',
+                    '$day',
+                    '$hour',
+                    '$minute',
+                    '$second',
+                ].includes(byItem)) {
+                    const dateLevelString = byItem.substring(1);
+                    switch (dateLevelString) {
+                        case 'year':
+                            name += zhCNToOthers('年', locale);
+                            break;
+                        case 'quarter':
+                            name += zhCNToOthers('季度', locale);
+                            break;
+                        case 'month':
+                            name += zhCNToOthers('月', locale);
+                            break;
+                        case 'week':
+                            name += zhCNToOthers('周', locale);
+                            break;
+                        case 'weekday':
+                            name += zhCNToOthers('星期', locale);
+                            break;
+                        case 'day':
+                            name += zhCNToOthers('日', locale);
+                            break;
+                        case 'hour':
+                            name += zhCNToOthers('小时', locale);
+                            break;
+                        case 'minute':
+                            name += zhCNToOthers('分钟', locale);
+                            break;
+                        case 'second':
+                            name += zhCNToOthers('秒', locale);
+                            break;
+                        default:
+                            throw new Error(`[nameForPred]不支持的日期级别：${dateLevelString}`);
+                    }
+                }
+                else {
+                    name += byItem;
+                }
+            };
+            if (typeof predNode.by === 'string') {
+                addNameForByItem(predNode.by);
+            }
+            else if (Array.isArray(predNode.by)) {
+                predNode.by.forEach((byItem) => addNameForByItem(byItem));
+            }
+            name += zhCNToOthers('均', locale);
+        }
+        if (func && func.defaultName) {
+            if (func.name === '$sql') {
+                name += func.defaultName(Object.assign(Object.assign({}, predNode), { schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+            }
+            else if (func.name === '$count_recent' || func.name === '$count_repeat' || func.name === '$sql') {
+                name = func.defaultName(Object.assign(Object.assign({}, predNode), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+            }
+            else if (!(useAggKey && predNode.pred === ((_a = schema.agg_key) === null || _a === void 0 ? void 0 : _a.value))) {
+                name += func.defaultName(Object.assign(Object.assign(Object.assign({}, predNode), (baseProperty || {})), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+            }
+            defaultNameCalled = true;
+        }
+        else {
+            switch (predNode.operator) {
+                case '$hour':
+                    name += `${zhCNToOthers('每小时', locale)}${basePredName}`;
+                    break;
+                case '$toHour':
+                    name += `${zhCNToOthers('每小时段', locale)}${basePredName}`;
+                    break;
+                case '$weekday':
+                    name += `${zhCNToOthers('分星期', locale)}${basePredName}`;
+                    break;
+                case '$day':
+                    name += `${zhCNToOthers('日', locale)}${basePredName}`;
+                    break;
+                case '$year':
+                    name += `${zhCNToOthers('年', locale)}${basePredName}`;
+                    break;
+                case '$week':
+                    name += `${zhCNToOthers('周', locale)}${basePredName}`;
+                    break;
+                case '$month':
+                    name += `${zhCNToOthers('月', locale)}${basePredName}`;
+                    break;
+                case '$quarter':
+                    name += `${zhCNToOthers('季度', locale)}${basePredName}`;
+                    break;
+                case '$yoy':
+                case '$mom':
+                case '$wow':
+                case '$qoq':
+                case '$yoyd':
+                case '$momd':
+                case '$sply':
+                case '$splm':
+                case '$splw': {
+                    const map = {
+                        $yoy: '同比',
+                        $mom: '环比',
+                        $wow: '周环比',
+                        $qoq: '季度环比',
+                        $yoyd: '同比差值',
+                        $momd: '环比差值',
+                        $sply: '同期',
+                        $splm: '环期',
+                        $splw: '周环期',
+                    };
+                    if (map[predNode.operator] === '环期') {
+                        name += `${zhCNToOthers('上期', locale)}${basePredName}`;
+                    }
+                    else if (map[predNode.operator] === '同期') {
+                        name += `${zhCNToOthers(map[predNode.operator], locale)}${basePredName}`;
+                    }
+                    else {
+                        name += `${basePredName}${zhCNToOthers(map[predNode.operator], locale)}`;
+                    }
+                    if (predNode.params) {
+                        if ((_b = predNode.params[0]) === null || _b === void 0 ? void 0 : _b.time) {
+                            const timestampProp = (0, schema_utils_1.findTimestampLikeProperty)(schema);
+                            if (timestampProp) {
+                                name += (0, exports.nameForQuery)({
+                                    [timestampProp.name]: predNode.params[0].time,
+                                }, schema, schemas);
+                            }
+                        }
+                        if (((_c = predNode.params[0]) === null || _c === void 0 ? void 0 : _c.by) === 'lunar') {
+                            name += zhCNToOthers('按农历', locale);
+                        }
+                        else if (((_d = predNode.params[0]) === null || _d === void 0 ? void 0 : _d.by) === 'weekday') {
+                            name += zhCNToOthers('按星期', locale);
+                        }
+                    }
+                    break;
+                }
+                case '$percentage':
+                    if (predNode.pred) {
+                        if (typeof predNode.pred === 'object') {
+                            name += (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+                        }
+                        else {
+                            name += predNode.pred;
+                        }
+                    }
+                    name += zhCNToOthers('占比', locale);
+                    break;
+                case '$uniq':
+                    if (predNode.pred) {
+                        if (typeof predNode.pred === 'object') {
+                            name += (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+                        }
+                        else {
+                            name += predNode.pred;
+                        }
+                    }
+                    name += zhCNToOthers('数量', locale);
+                    break;
+                case '$dailyavg':
+                    if (locale.startsWith('en')) {
+                        name += `${basePredName} daily avg`;
+                    }
+                    else {
+                        name += `${zhCNToOthers('日均', locale)}${basePredName}`;
+                    }
+                    break;
+                case '$monthlyavg':
+                    if (locale.startsWith('en')) {
+                        name += `${basePredName} monthly avg`;
+                    }
+                    else {
+                        name += `${zhCNToOthers('月均', locale)}${basePredName}`;
+                    }
+                    break;
+                case '$weeklyavg':
+                    if (locale.startsWith('en')) {
+                        name += `${basePredName} weekly avg`;
+                    }
+                    else {
+                        name += `${zhCNToOthers('周均', locale)}${basePredName}`;
+                    }
+                    break;
+                case '$piecewise':
+                    name += `${basePredName}${zhCNToOthers('段', locale)}`;
+                    break;
+                default:
+                    name += predNode.operator;
+                    break;
+            }
+        }
+    }
+    else if (predNode.pred) {
+        if (predNode.pred === '*') {
+            return null;
+        }
+        name += predNode.pred;
+    }
+    // level
+    if (!defaultNameCalled && predNode.level) {
+        name += `(${predNode.level})`;
+    }
+    // accumulate
+    if (predNode.accumulate) {
+        if (locale.startsWith('en')) {
+            // do nothing
+        }
+        else {
+            name = `${zhCNToOthers('累计', locale)}${name}`;
+        }
+    }
+    // feat: name 不能有下划线
+    return name.replace(/_/g, '');
+};
+exports.nameForPredNode = nameForPredNode;

package/dist/schema/schema.utils.d.ts

@@ -1,5 +1,6 @@
 import { PropertyType } from './property';
 import { SchemaType } from './schema';
+import { LogicformType } from '../logicform/logicform';
 export declare const findPropertyByType: (type: string, schema: SchemaType) => PropertyType | undefined;
 /**
  * Find a property by name within a specific schema
@@ -15,6 +16,12 @@ export declare const findPropertyByName: (schemaID: string, propertyName: string
  * @returns The property marked as display name (is_name=true or ui.name=true) or undefined if not found
  */
 export declare const findDisplayNameProperty: (schema: SchemaType) => PropertyType | undefined;
+/**
+ * 找到schema中的timestamp属性
+ * @param schema - The runtime schema to search in
+ * @returns The property with type 'timestamp' or undefined if not found
+ */
+export declare const findTimestampLikeProperty: (schema: SchemaType) => PropertyType | undefined;
 /**
  * 以fromSchema为基础，找到toSchema中对应的property
  * @param propertyName
@@ -22,3 +29,24 @@ export declare const findDisplayNameProperty: (schema: SchemaType) => PropertyTy
  * @param toSchema
  */
 export declare const findPropertyForOtherSchema: (propertyName: string, fromSchemaID: string, toSchemaID: string, schemasDict: Record<string, SchemaType>) => PropertyType | undefined;
+/**
+ * 获取hierarchy指定层级的累加代码长度
+ * @param schema - The schema with hierarchy
+ * @param name - The hierarchy level name to get accumulated code length for
+ * @returns The accumulated code length up to and including the specified level
+ * @throws Error if the level name is not found in the hierarchy
+ */
+export declare const getHierarchyCodeLength: (schema: SchemaType, name: string) => number;
+/**
+ * 获取从fromNode到toNode的引用链
+ * @param fromNode - 起始节点的logicform
+ * @param toNode - 目标节点的logicform
+ * @param schemas - Schema字典
+ * @returns 引用链数组或包含错误信息的对象
+ */
+export declare const getRefChain: (fromNode: LogicformType, toNode: LogicformType, schemas: Record<string, SchemaType>) => {
+    property: PropertyType;
+    schema?: SchemaType;
+}[] | {
+    error: string;
+} | null;

package/dist/schema/schema.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findPropertyForOtherSchema = exports.findDisplayNameProperty = exports.findPropertyByName = exports.findPropertyByType = void 0;
+exports.getRefChain = exports.getHierarchyCodeLength = exports.findPropertyForOtherSchema = exports.findTimestampLikeProperty = exports.findDisplayNameProperty = exports.findPropertyByName = exports.findPropertyByType = void 0;
 const findPropertyByType = (type, schema) => {
     return schema.properties.find((property) => property.type === type);
 };
@@ -65,6 +65,15 @@ const findDisplayNameProperty = (schema) => {
     return undefined;
 };
 exports.findDisplayNameProperty = findDisplayNameProperty;
+/**
+ * 找到schema中的timestamp属性
+ * @param schema - The runtime schema to search in
+ * @returns The property with type 'timestamp' or undefined if not found
+ */
+const findTimestampLikeProperty = (schema) => {
+    return schema.properties.find((property) => property.type === 'timestamp');
+};
+exports.findTimestampLikeProperty = findTimestampLikeProperty;
 /**
  * 以fromSchema为基础，找到toSchema中对应的property
  * @param propertyName
@@ -98,3 +107,123 @@ const findPropertyForOtherSchema = (propertyName, fromSchemaID, toSchemaID, sche
     return undefined;
 };
 exports.findPropertyForOtherSchema = findPropertyForOtherSchema;
+/**
+ * 获取hierarchy指定层级的累加代码长度
+ * @param schema - The schema with hierarchy
+ * @param name - The hierarchy level name to get accumulated code length for
+ * @returns The accumulated code length up to and including the specified level
+ * @throws Error if the level name is not found in the hierarchy
+ */
+const getHierarchyCodeLength = (schema, name) => {
+    if (!schema.hierarchy) {
+        throw new Error(`${schema.name}中没有hierarchy`);
+    }
+    let codeLength = 0;
+    let nameFound = false;
+    for (const hierarchyItem of schema.hierarchy) {
+        codeLength += hierarchyItem.code_length;
+        if (hierarchyItem.name === name) {
+            nameFound = true;
+            break;
+        }
+    }
+    if (!nameFound)
+        throw new Error(`${schema.name}中没有此level：${name}`);
+    return codeLength;
+};
+exports.getHierarchyCodeLength = getHierarchyCodeLength;
+/**
+ * 获取从fromNode到toNode的引用链
+ * @param fromNode - 起始节点的logicform
+ * @param toNode - 目标节点的logicform
+ * @param schemas - Schema字典
+ * @returns 引用链数组或包含错误信息的对象
+ */
+const getRefChain = (fromNode, toNode, schemas) => {
+    const getError = (p) => {
+        // granularity check
+        if (p.granularity && schemas[fromNode.schema].hierarchy) {
+            let levelLength;
+            if (fromNode.entity_id) {
+                levelLength = fromNode.entity_id.length;
+            }
+            else if (fromNode.groupby && fromNode.groupby.find((gi) => gi.level)) {
+                const levelGI = fromNode.groupby.find((gi) => gi.level);
+                if (levelGI === null || levelGI === void 0 ? void 0 : levelGI.level) {
+                    levelLength = (0, exports.getHierarchyCodeLength)(schemas[fromNode.schema], levelGI.level);
+                }
+            }
+            if (levelLength && p.granularity) {
+                // granularity check
+                const maxCodeLength = (0, exports.getHierarchyCodeLength)(schemas[fromNode.schema], p.granularity);
+                if (maxCodeLength && maxCodeLength < levelLength) {
+                    return `**${schemas[toNode.schema].name}**中，**${p.name}**要求为${p.granularity}以上。暂无法回答此问题。请联系技术支持。`;
+                }
+            }
+        }
+        return null;
+    };
+    let error = null;
+    // 优先拿直接能找到的，找不到再用一个dfs来找
+    const directFound = schemas[toNode.schema].properties.find((p) => {
+        if (!p.ref)
+            return false;
+        if (p.is_supplementary)
+            return false;
+        if (getError(p))
+            return false;
+        if (p.ref !== fromNode.schema)
+            return false;
+        const constraintsWithRole = p.constraints;
+        const fromNodeWithRole = fromNode;
+        if ((constraintsWithRole === null || constraintsWithRole === void 0 ? void 0 : constraintsWithRole.role) &&
+            (fromNodeWithRole === null || fromNodeWithRole === void 0 ? void 0 : fromNodeWithRole._role) &&
+            !Object.keys(constraintsWithRole.role).every((k) => constraintsWithRole.role[k] === fromNodeWithRole._role[k])) {
+            return false;
+        }
+        return true;
+    });
+    if (directFound) {
+        return [{ property: directFound }];
+    }
+    // 一个dfs
+    const fromTo = (from, to, chain = []) => {
+        // max depth
+        if (chain.length > 10)
+            return null;
+        const schema = schemas[from];
+        for (const property of schema.properties) {
+            if (property.type === 'object' && !property.is_supplementary && property.ref && schemas[property.ref]) {
+                if (chain.length > 0) {
+                    const lastItem = chain[chain.length - 1];
+                    if (lastItem.schema._id === schema._id && lastItem.property.name === property.name) {
+                        continue;
+                    }
+                }
+                const newChain = [...chain, { property, schema: schemas[property.ref] }];
+                if (property.ref === to) {
+                    // sanity check
+                    const errorMsg = getError(property);
+                    if (errorMsg) {
+                        error = errorMsg;
+                        continue;
+                    }
+                    return newChain;
+                }
+                else {
+                    const nestedChain = fromTo(property.ref, to, newChain);
+                    if (nestedChain) {
+                        return nestedChain;
+                    }
+                }
+            }
+        }
+        return null;
+    };
+    const chain = fromTo(toNode.schema, fromNode.schema);
+    if (!chain && error) {
+        return { error };
+    }
+    return chain;
+};
+exports.getRefChain = getRefChain;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semanticdb-core",
-  "version": "1.0.53",
+  "version": "1.1.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [