(improvement)(headless) transfer term nature modelId to viewId before providing it to chat and put the modelId of metadata into the dict word instead of viewId (#739)

Co-authored-by: jolunoluo

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/ModelDetail.java

@@ -19,13 +19,13 @@ public class ModelDetail {
 
     private String tableQuery;
 
-    private List<Identify> identifiers;
+    private List<Identify> identifiers = Lists.newArrayList();
 
-    private List<Dim> dimensions;
+    private List<Dim> dimensions = Lists.newArrayList();
 
-    private List<Measure> measures;
+    private List<Measure> measures = Lists.newArrayList();
 
-    private List<Field> fields;
+    private List<Field> fields = Lists.newArrayList();
 
     public String getSqlQuery() {
         if (StringUtils.isNotBlank(sqlQuery) && sqlQuery.endsWith(";")) {

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/Param.java

@@ -3,6 +3,7 @@ package com.tencent.supersonic.headless.api.pojo;
 import lombok.Data;
 
 import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
 
 @Data
 public class Param {
@@ -10,7 +11,7 @@ public class Param {
     @NotBlank(message = "Invald parameter name")
     private String name;
 
-    @NotBlank(message = "Invalid parameter value")
+    @NotNull(message = "Invalid parameter value")
     private String value;
 
     public Param() {
@@ -21,14 +22,4 @@ public class Param {
         this.value = value;
     }
 
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder("{");
-        sb.append("\"name\":\"")
-                .append(name).append('\"');
-        sb.append(",\"value\":\"")
-                .append(value).append('\"');
-        sb.append('}');
-        return sb.toString();
-    }
 }

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/SchemaElement.java

@@ -1,7 +1,6 @@
 package com.tencent.supersonic.headless.api.pojo;
 
 import com.google.common.base.Objects;
-import com.google.common.collect.Lists;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -19,6 +18,7 @@ import java.util.List;
 public class SchemaElement implements Serializable {
 
     private Long view;
+    private Long model;
     private Long id;
     private String name;
     private String bizName;
@@ -52,7 +52,4 @@ public class SchemaElement implements Serializable {
         return Objects.hashCode(view, id, name, bizName, type);
     }
 
-    public List<String> getModelNames() {
-        return Lists.newArrayList(name);
-    }
 }

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/response/MetricResp.java

@@ -30,6 +30,8 @@ public class MetricResp extends SchemaItem {
 
     private Long domainId;
 
+    private String modelBizName;
+
     private String modelName;
 
     //ATOMIC DERIVED

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/SearchService.java

@@ -6,8 +6,15 @@ import com.hankcs.hanlp.corpus.tag.Nature;
 import com.hankcs.hanlp.dictionary.CoreDictionary;
 import com.hankcs.hanlp.seg.common.Term;
 import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import com.tencent.supersonic.headless.api.pojo.request.DimensionValueReq;
+import com.tencent.supersonic.headless.core.knowledge.helper.NatureHelper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.util.CollectionUtils;
+
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -17,11 +24,6 @@ import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
-import com.tencent.supersonic.headless.api.pojo.request.DimensionValueReq;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.util.CollectionUtils;
-
 @Slf4j
 public class SearchService {
 
@@ -39,14 +41,14 @@ public class SearchService {
      * @param key
      * @return
      */
-    public static List<HanlpMapResult> prefixSearch(String key, int limit, Set<Long> detectModelIds) {
-        return prefixSearch(key, limit, trie, detectModelIds);
+    public static List<HanlpMapResult> prefixSearch(String key, int limit, Map<Long, List<Long>> modelIdToViewIds) {
+        return prefixSearch(key, limit, trie, modelIdToViewIds);
     }
 
     public static List<HanlpMapResult> prefixSearch(String key, int limit, BinTrie<List<String>> binTrie,
-                                                    Set<Long> detectModelIds) {
-        Set<Map.Entry<String, List<String>>> result = prefixSearchLimit(key, limit, binTrie, detectModelIds);
-        return result.stream().map(
+                                                    Map<Long, List<Long>> modelIdToViewIds) {
+        Set<Map.Entry<String, List<String>>> result = prefixSearchLimit(key, limit, binTrie, modelIdToViewIds.keySet());
+        List<HanlpMapResult> hanlpMapResults = result.stream().map(
                         entry -> {
                             String name = entry.getKey().replace("#", " ");
                             return new HanlpMapResult(name, entry.getValue(), key);
@@ -54,6 +56,13 @@ public class SearchService {
                 ).sorted((a, b) -> -(b.getName().length() - a.getName().length()))
                 .limit(SEARCH_SIZE)
                 .collect(Collectors.toList());
+        for (HanlpMapResult hanlpMapResult : hanlpMapResults) {
+            List<String> natures = hanlpMapResult.getNatures().stream()
+                    .map(nature -> NatureHelper.changeModel2View(nature, modelIdToViewIds))
+                    .flatMap(Collection::stream).collect(Collectors.toList());
+            hanlpMapResult.setNatures(natures);
+        }
+        return hanlpMapResults;
     }
 
     /***

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/DimensionWordBuilder.java

@@ -38,11 +38,11 @@ public class DimensionWordBuilder extends BaseWordBuilder {
     private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
         DictWord dictWord = new DictWord();
         dictWord.setWord(word);
-        Long viewId = schemaElement.getView();
-        String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+        Long modelId = schemaElement.getModel();
+        String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
                 + DictWordType.DIMENSION.getType();
         if (isSuffix) {
-            nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+            nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
                     + DictWordType.SUFFIX.getType() + DictWordType.DIMENSION.getType();
         }
         dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/EntityWordBuilder.java

@@ -27,8 +27,8 @@ public class EntityWordBuilder extends BaseWordBuilder {
             return result;
         }
 
-        Long view = schemaElement.getView();
-        String nature = DictWordType.NATURE_SPILT + view + DictWordType.NATURE_SPILT + schemaElement.getId()
+        Long modelId = schemaElement.getModel();
+        String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
                 + DictWordType.ENTITY.getType();
 
         if (!CollectionUtils.isEmpty(schemaElement.getAlias())) {

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/MetricWordBuilder.java

@@ -38,11 +38,11 @@ public class MetricWordBuilder extends BaseWordBuilder {
     private DictWord getOnwWordNature(String word, SchemaElement schemaElement, boolean isSuffix) {
         DictWord dictWord = new DictWord();
         dictWord.setWord(word);
-        Long viewId = schemaElement.getView();
-        String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+        Long modelId = schemaElement.getModel();
+        String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
                 + DictWordType.METRIC.getType();
         if (isSuffix) {
-            nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId()
+            nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId()
                     + DictWordType.SUFFIX.getType() + DictWordType.METRIC.getType();
         }
         dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/builder/ValueWordBuilder.java

@@ -27,8 +27,8 @@ public class ValueWordBuilder extends BaseWordBuilder {
 
             schemaElement.getAlias().stream().forEach(value -> {
                 DictWord dictWord = new DictWord();
-                Long viewId = schemaElement.getView();
-                String nature = DictWordType.NATURE_SPILT + viewId + DictWordType.NATURE_SPILT + schemaElement.getId();
+                Long modelId = schemaElement.getModel();
+                String nature = DictWordType.NATURE_SPILT + modelId + DictWordType.NATURE_SPILT + schemaElement.getId();
                 dictWord.setNatureWithFrequency(String.format("%s " + DEFAULT_FREQUENCY, nature));
                 dictWord.setWord(value);
                 result.add(dictWord);

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/HanlpHelper.java

@@ -1,34 +1,36 @@
 package com.tencent.supersonic.headless.core.knowledge.helper;
 
-import static com.hankcs.hanlp.HanLP.Config.CustomDictionaryPath;
-
+import com.google.common.collect.Lists;
 import com.hankcs.hanlp.HanLP;
 import com.hankcs.hanlp.corpus.tag.Nature;
 import com.hankcs.hanlp.dictionary.CoreDictionary;
 import com.hankcs.hanlp.dictionary.DynamicCustomDictionary;
 import com.hankcs.hanlp.seg.Segment;
+import com.hankcs.hanlp.seg.common.Term;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
 import com.tencent.supersonic.headless.api.pojo.response.S2Term;
 import com.tencent.supersonic.headless.core.knowledge.DictWord;
 import com.tencent.supersonic.headless.core.knowledge.HadoopFileIOAdapter;
 import com.tencent.supersonic.headless.core.knowledge.MapResult;
 import com.tencent.supersonic.headless.core.knowledge.MultiCustomDictionary;
 import com.tencent.supersonic.headless.core.knowledge.SearchService;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ResourceUtils;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
-import com.hankcs.hanlp.seg.common.Term;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.BeanUtils;
-import org.springframework.util.CollectionUtils;
-import org.springframework.util.ResourceUtils;
+import static com.hankcs.hanlp.HanLP.Config.CustomDictionaryPath;
 
 /**
  * HanLP helper
@@ -212,18 +214,25 @@ public class HanlpHelper {
         }
     }
 
-    public static List<com.tencent.supersonic.headless.api.pojo.response.S2Term> getTerms(String text) {
+    public static List<S2Term> getTerms(String text, Map<Long, List<Long>> modelIdToViewIds) {
         return getSegment().seg(text.toLowerCase()).stream()
                 .filter(term -> term.getNature().startsWith(DictWordType.NATURE_SPILT))
-                .map(term -> transform2ApiTerm(term))
+                .map(term -> transform2ApiTerm(term, modelIdToViewIds))
+                .flatMap(Collection::stream)
                 .collect(Collectors.toList());
     }
 
-    public static S2Term transform2ApiTerm(Term term) {
-        S2Term knowledgeTerm = new S2Term();
-        BeanUtils.copyProperties(term, knowledgeTerm);
-        knowledgeTerm.setFrequency(term.getFrequency());
-        return knowledgeTerm;
+    public static List<S2Term> transform2ApiTerm(Term term, Map<Long, List<Long>> modelIdToViewIds) {
+        List<S2Term> s2Terms = Lists.newArrayList();
+        List<String> natures = NatureHelper.changeModel2View(String.valueOf(term.getNature()), modelIdToViewIds);
+        for (String nature : natures) {
+            S2Term s2Term = new S2Term();
+            BeanUtils.copyProperties(term, s2Term);
+            s2Term.setNature(Nature.create(nature));
+            s2Term.setFrequency(term.getFrequency());
+            s2Terms.add(s2Term);
+        }
+        return s2Terms;
     }
 
 }

headless/core/src/main/java/com/tencent/supersonic/headless/core/knowledge/helper/NatureHelper.java

@@ -1,12 +1,14 @@
 package com.tencent.supersonic.headless.core.knowledge.helper;
 
+import com.google.common.collect.Lists;
 import com.hankcs.hanlp.corpus.tag.Nature;
+import com.tencent.supersonic.common.pojo.enums.DictWordType;
 import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
 import com.tencent.supersonic.headless.api.pojo.response.S2Term;
 import com.tencent.supersonic.headless.core.knowledge.ViewInfoStat;
-import com.tencent.supersonic.common.pojo.enums.DictWordType;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
+import org.springframework.util.CollectionUtils;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -81,6 +83,43 @@ public class NatureHelper {
         return null;
     }
 
+    private static Long getModelId(String nature) {
+        try {
+            String[] split = nature.split(DictWordType.NATURE_SPILT);
+            if (split.length <= 1) {
+                return null;
+            }
+            return Long.valueOf(split[1]);
+        } catch (NumberFormatException e) {
+            log.error("", e);
+        }
+        return null;
+    }
+
+    private static Nature changeModel2View(String nature, Long viewId) {
+        try {
+            String[] split = nature.split(DictWordType.NATURE_SPILT);
+            if (split.length <= 1) {
+                return null;
+            }
+            split[1] = String.valueOf(viewId);
+            return Nature.create(StringUtils.join(split, DictWordType.NATURE_SPILT));
+        } catch (NumberFormatException e) {
+            log.error("", e);
+        }
+        return null;
+    }
+
+    public static List<String> changeModel2View(String nature, Map<Long, List<Long>> modelIdToViewIds) {
+        Long modelId = getModelId(nature);
+        List<Long> viewIds = modelIdToViewIds.get(modelId);
+        if (CollectionUtils.isEmpty(viewIds)) {
+            return Lists.newArrayList();
+        }
+        return viewIds.stream().map(viewId -> String.valueOf(changeModel2View(nature, viewId)))
+                .collect(Collectors.toList());
+    }
+
     public static boolean isDimensionValueViewId(String nature) {
         if (StringUtils.isEmpty(nature)) {
             return false;

headless/server/src/main/java/com/tencent/supersonic/headless/server/aspect/MetricDrillDownChecker.java

@@ -11,11 +11,13 @@ import com.tencent.supersonic.headless.api.pojo.response.MetricResp;
 import com.tencent.supersonic.headless.api.pojo.response.MetricSchemaResp;
 import com.tencent.supersonic.headless.api.pojo.response.SemanticSchemaResp;
 import com.tencent.supersonic.headless.core.pojo.QueryStatement;
+import com.tencent.supersonic.headless.server.service.MetricService;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 import java.util.Collection;
@@ -28,6 +30,9 @@ import java.util.stream.Collectors;
 @Slf4j
 public class MetricDrillDownChecker {
 
+    @Autowired
+    private MetricService metricService;
+
     @Around("execution(* com.tencent.supersonic.headless.core.parser.QueryParser.parse(..))")
     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
         Object[] objects = joinPoint.getArgs();
@@ -52,7 +57,7 @@ public class MetricDrillDownChecker {
             List<DimensionResp> necessaryDimensions = getNecessaryDimensions(metric, semanticSchemaResp);
             List<DimensionResp> dimensionsMissing = getNecessaryDimensionMissing(necessaryDimensions, dimensionFields);
             if (!CollectionUtils.isEmpty(dimensionsMissing)) {
-                String errMsg = String.format("指标:%s 缺失必要维度:%s", metric.getName(),
+                String errMsg = String.format("指标:%s 缺失必要下钻维度:%s", metric.getName(),
                         dimensionsMissing.stream().map(DimensionResp::getName).collect(Collectors.toList()));
                 throw new InvalidArgumentException(errMsg);
             }
@@ -92,8 +97,9 @@ public class MetricDrillDownChecker {
             return true;
         }
         List<String> relateDimensions = metricResps.stream()
-                .filter(metric -> !CollectionUtils.isEmpty(metric.getDrillDownDimensions()))
-                .map(metric -> metric.getDrillDownDimensions().stream()
+                .map(this::getDrillDownDimensions)
+                .filter(drillDownDimensions -> !CollectionUtils.isEmpty(drillDownDimensions))
+                .map(drillDownDimensions -> drillDownDimensions.stream()
                         .map(DrillDownDimension::getDimensionId).collect(Collectors.toList()))
                 .flatMap(Collection::stream)
                 .map(id -> convertDimensionIdToBizName(id, semanticSchemaResp))
@@ -111,7 +117,7 @@ public class MetricDrillDownChecker {
         if (metric == null) {
             return Lists.newArrayList();
         }
-        List<DrillDownDimension> drillDownDimensions = metric.getDrillDownDimensions();
+        List<DrillDownDimension> drillDownDimensions = getDrillDownDimensions(metric);
         if (CollectionUtils.isEmpty(drillDownDimensions)) {
             return Lists.newArrayList();
         }
@@ -147,4 +153,8 @@ public class MetricDrillDownChecker {
         return dimension.getBizName();
     }
 
+    private List<DrillDownDimension> getDrillDownDimensions(MetricResp metricResp) {
+        return metricService.getDrillDownDimension(metricResp.getId());
+    }
+
 }

headless/server/src/main/java/com/tencent/supersonic/headless/server/manager/ModelYamlManager.java

@@ -30,7 +30,7 @@ import java.util.stream.Collectors;
 @Slf4j
 public class ModelYamlManager {
 
-    public static DataModelYamlTpl convert2YamlObj(ModelResp modelResp, DatabaseResp databaseResp) {
+    public static synchronized DataModelYamlTpl convert2YamlObj(ModelResp modelResp, DatabaseResp databaseResp) {
         ModelDetail modelDetail = modelResp.getModelDetail();
         DbAdaptor engineAdaptor = DbAdaptorFactory.getEngineAdaptor(databaseResp.getType());
         SysTimeDimensionBuilder.addSysTimeDimension(modelDetail.getDimensions(), engineAdaptor);

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/DownloadServiceImpl.java

@@ -109,8 +109,9 @@ public class DownloadServiceImpl implements DownloadService {
         metaFilter.setIds(metricIds);
         List<MetricResp> metricResps = metricService.getMetrics(metaFilter);
         Map<String, List<MetricResp>> metricMap = getMetricMap(metricResps);
-        List<Long> dimensionIds = metricResps.stream().map(MetricResp::getRelateDimension)
-                .map(RelateDimension::getDrillDownDimensions).flatMap(Collection::stream)
+        List<Long> dimensionIds = metricResps.stream()
+                .map(metricResp -> metricService.getDrillDownDimension(metricResp.getId()))
+                .flatMap(Collection::stream)
                 .map(DrillDownDimension::getDimensionId).collect(Collectors.toList());
         metaFilter.setIds(dimensionIds);
         Map<Long, DimensionResp> dimensionRespMap = dimensionService.getDimensions(metaFilter)

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/KnowledgeServiceImpl.java

@@ -8,13 +8,14 @@ import com.tencent.supersonic.headless.core.knowledge.SearchService;
 import com.tencent.supersonic.headless.core.knowledge.helper.HanlpHelper;
 import com.tencent.supersonic.headless.server.service.KnowledgeService;
 import com.tencent.supersonic.headless.server.service.ViewService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
 
 @Service
 @Slf4j
@@ -68,17 +69,19 @@ public class KnowledgeServiceImpl implements KnowledgeService {
 
     @Override
     public List<S2Term> getTerms(String text) {
-        return HanlpHelper.getTerms(text);
+        Map<Long, List<Long>> modelIdToViewIds = viewService.getModelIdToViewIds(new ArrayList<>());
+        return HanlpHelper.getTerms(text, modelIdToViewIds);
     }
 
     @Override
     public List<HanlpMapResult> prefixSearch(String key, int limit, Set<Long> viewIds) {
         Map<Long, List<Long>> modelIdToViewIds = viewService.getModelIdToViewIds(new ArrayList<>(viewIds));
-        return prefixSearchByModel(key, limit, modelIdToViewIds.keySet());
+        return prefixSearchByModel(key, limit, modelIdToViewIds);
     }
 
-    public List<HanlpMapResult> prefixSearchByModel(String key, int limit, Set<Long> models) {
-        return SearchService.prefixSearch(key, limit, models);
+    public List<HanlpMapResult> prefixSearchByModel(String key, int limit,
+                                                    Map<Long, List<Long>> modelIdToViewIds) {
+        return SearchService.prefixSearch(key, limit, modelIdToViewIds);
     }
 
     @Override

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/MetricServiceImpl.java

@@ -5,6 +5,7 @@ import com.alibaba.fastjson.TypeReference;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.common.pojo.Constants;
 import com.tencent.supersonic.common.pojo.DataEvent;
@@ -16,6 +17,7 @@ import com.tencent.supersonic.common.pojo.enums.TypeEnums;
 import com.tencent.supersonic.common.util.BeanMapper;
 import com.tencent.supersonic.common.util.ChatGptHelper;
 import com.tencent.supersonic.headless.api.pojo.DrillDownDimension;
+import com.tencent.supersonic.headless.api.pojo.MeasureParam;
 import com.tencent.supersonic.headless.api.pojo.MetricParam;
 import com.tencent.supersonic.headless.api.pojo.MetricQueryDefaultConfig;
 import com.tencent.supersonic.headless.api.pojo.enums.MetricDefineType;
@@ -40,6 +42,12 @@ import com.tencent.supersonic.headless.server.service.ModelService;
 import com.tencent.supersonic.headless.server.service.ViewService;
 import com.tencent.supersonic.headless.server.utils.MetricCheckUtils;
 import com.tencent.supersonic.headless.server.utils.MetricConverter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
@@ -48,11 +56,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
 
 @Service
 @Slf4j
@@ -228,28 +231,44 @@ public class MetricServiceImpl implements MetricService {
     }
 
     private List<MetricResp> filterByField(List<MetricResp> metricResps, List<String> fields) {
-        List<MetricResp> metricRespFiltered = Lists.newArrayList();
+        Set<MetricResp> metricRespFiltered = Sets.newHashSet();
         for (MetricResp metricResp : metricResps) {
-            for (String field : fields) {
-                if (MetricDefineType.METRIC.equals(metricResp.getMetricDefineType())) {
-                    List<Long> ids = metricResp.getMetricDefineByMetricParams().getMetrics()
-                            .stream().map(MetricParam::getId).collect(Collectors.toList());
-                    List<MetricResp> metricById = metricResps.stream()
-                            .filter(metric -> ids.contains(metric.getId()))
-                            .collect(Collectors.toList());
-                    for (MetricResp metric : metricById) {
-                        if (metric.getExpr().contains(field)) {
-                            metricRespFiltered.add(metricResp);
-                        }
-                    }
-                } else {
-                    if (metricResp.getExpr().contains(field)) {
-                        metricRespFiltered.add(metricResp);
-                    }
+            filterByField(metricResps, metricResp, fields, metricRespFiltered);
+        }
+        return new ArrayList<>(metricRespFiltered);
+    }
+
+    private boolean filterByField(List<MetricResp> metricResps, MetricResp metricResp,
+                                  List<String> fields, Set<MetricResp> metricRespFiltered) {
+        if (MetricDefineType.METRIC.equals(metricResp.getMetricDefineType())) {
+            List<Long> ids = metricResp.getMetricDefineByMetricParams().getMetrics()
+                    .stream().map(MetricParam::getId).collect(Collectors.toList());
+            List<MetricResp> metricById = metricResps.stream()
+                    .filter(metric -> ids.contains(metric.getId()))
+                    .collect(Collectors.toList());
+            for (MetricResp metric : metricById) {
+                if (filterByField(metricResps, metric, fields, metricRespFiltered)) {
+                    metricRespFiltered.add(metricResp);
+                    return true;
                 }
             }
+        } else if (MetricDefineType.FIELD.equals(metricResp.getMetricDefineType())) {
+            if (fields.stream().anyMatch(field -> metricResp.getExpr().contains(field))) {
+                metricRespFiltered.add(metricResp);
+                return true;
+            }
+        } else if (MetricDefineType.MEASURE.equals(metricResp.getMetricDefineType())) {
+            List<MeasureParam> measures = metricResp.getMetricDefineByMeasureParams().getMeasures();
+            List<String> fieldNameDepended = measures.stream().map(MeasureParam::getBizName)
+                    //measure bizName = model bizName_fieldName
+                    .map(name -> name.replaceFirst(metricResp.getModelBizName() + "_", ""))
+                    .collect(Collectors.toList());
+            if (fields.stream().anyMatch(fieldNameDepended::contains)) {
+                metricRespFiltered.add(metricResp);
+                return true;
+            }
         }
-        return metricRespFiltered;
+        return false;
     }
 
     @Override

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/SchemaServiceImpl.java

@@ -64,6 +64,13 @@ public class SchemaServiceImpl implements SchemaService {
 
     protected final Cache<String, List<ItemUseResp>> itemUseCache =
             CacheBuilder.newBuilder().expireAfterWrite(1, TimeUnit.DAYS).build();
+
+    protected final Cache<ViewFilterReq, List<ViewSchemaResp>> viewSchemaCache =
+            CacheBuilder.newBuilder().expireAfterWrite(30, TimeUnit.SECONDS).build();
+
+    protected final Cache<SchemaFilterReq, SemanticSchemaResp> semanticSchemaCache =
+            CacheBuilder.newBuilder().expireAfterWrite(30, TimeUnit.SECONDS).build();
+
     private final StatUtils statUtils;
     private final ModelService modelService;
     private final DimensionService dimensionService;
@@ -91,6 +98,22 @@ public class SchemaServiceImpl implements SchemaService {
     @SneakyThrows
     @Override
     public List<ViewSchemaResp> fetchViewSchema(ViewFilterReq filter) {
+        List<ViewSchemaResp> viewList = viewSchemaCache.getIfPresent(filter);
+        if (CollectionUtils.isEmpty(viewList)) {
+            viewList = buildViewSchema(filter);
+            viewSchemaCache.put(filter, viewList);
+        }
+        return viewList;
+    }
+
+    public ViewSchemaResp fetchViewSchema(Long viewId) {
+        if (viewId == null) {
+            return null;
+        }
+        return fetchViewSchema(new ViewFilterReq(viewId)).stream().findFirst().orElse(null);
+    }
+
+    public List<ViewSchemaResp> buildViewSchema(ViewFilterReq filter) {
         List<ViewSchemaResp> viewSchemaResps = new ArrayList<>();
         List<Long> viewIds = filter.getViewIds();
         MetaFilter metaFilter = new MetaFilter();
@@ -127,13 +150,6 @@ public class SchemaServiceImpl implements SchemaService {
         return viewSchemaResps;
     }
 
-    public ViewSchemaResp fetchViewSchema(Long viewId) {
-        if (viewId == null) {
-            return null;
-        }
-        return fetchViewSchema(new ViewFilterReq(viewId)).stream().findFirst().orElse(null);
-    }
-
     public List<ModelSchemaResp> fetchModelSchemaResps(List<Long> modelIds) {
         List<ModelSchemaResp> modelSchemaResps = Lists.newArrayList();
         if (CollectionUtils.isEmpty(modelIds)) {
@@ -258,8 +274,7 @@ public class SchemaServiceImpl implements SchemaService {
         return viewService.getViewList(metaFilter);
     }
 
-    @Override
-    public SemanticSchemaResp fetchSemanticSchema(SchemaFilterReq schemaFilterReq) {
+    public SemanticSchemaResp buildSemanticSchema(SchemaFilterReq schemaFilterReq) {
         SemanticSchemaResp semanticSchemaResp = new SemanticSchemaResp();
         semanticSchemaResp.setViewId(schemaFilterReq.getViewId());
         semanticSchemaResp.setModelIds(schemaFilterReq.getModelIds());
@@ -294,6 +309,16 @@ public class SchemaServiceImpl implements SchemaService {
         return semanticSchemaResp;
     }
 
+    @Override
+    public SemanticSchemaResp fetchSemanticSchema(SchemaFilterReq schemaFilterReq) {
+        SemanticSchemaResp semanticSchemaResp = semanticSchemaCache.getIfPresent(schemaFilterReq);
+        if (semanticSchemaResp == null) {
+            semanticSchemaResp = buildSemanticSchema(schemaFilterReq);
+            semanticSchemaCache.put(schemaFilterReq, semanticSchemaResp);
+        }
+        return semanticSchemaResp;
+    }
+
     @SneakyThrows
     @Override
     public List<ItemUseResp> getStatInfo(ItemUseReq itemUseReq) {

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/ViewServiceImpl.java

@@ -10,17 +10,29 @@ import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.common.pojo.enums.AuthType;
 import com.tencent.supersonic.common.pojo.enums.StatusEnum;
 import com.tencent.supersonic.common.pojo.enums.TypeEnums;
+import com.tencent.supersonic.common.pojo.exception.InvalidArgumentException;
 import com.tencent.supersonic.common.util.BeanMapper;
 import com.tencent.supersonic.headless.api.pojo.QueryConfig;
 import com.tencent.supersonic.headless.api.pojo.ViewDetail;
 import com.tencent.supersonic.headless.api.pojo.request.ViewReq;
+import com.tencent.supersonic.headless.api.pojo.response.DimensionResp;
 import com.tencent.supersonic.headless.api.pojo.response.DomainResp;
+import com.tencent.supersonic.headless.api.pojo.response.MetricResp;
 import com.tencent.supersonic.headless.api.pojo.response.ViewResp;
 import com.tencent.supersonic.headless.server.persistence.dataobject.ViewDO;
 import com.tencent.supersonic.headless.server.persistence.mapper.ViewDOMapper;
 import com.tencent.supersonic.headless.server.pojo.MetaFilter;
+import com.tencent.supersonic.headless.server.service.DimensionService;
 import com.tencent.supersonic.headless.server.service.DomainService;
+import com.tencent.supersonic.headless.server.service.MetricService;
 import com.tencent.supersonic.headless.server.service.ViewService;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Date;
@@ -29,12 +41,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.stream.Collectors;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
 
 @Service
 public class ViewServiceImpl
@@ -46,21 +54,33 @@ public class ViewServiceImpl
     @Autowired
     private DomainService domainService;
 
+    @Lazy
+    @Autowired
+    private DimensionService dimensionService;
+
+    @Lazy
+    @Autowired
+    private MetricService metricService;
+
     @Override
     public ViewResp save(ViewReq viewReq, User user) {
         viewReq.createdBy(user.getName());
         ViewDO viewDO = convert(viewReq);
         viewDO.setStatus(StatusEnum.ONLINE.getCode());
+        ViewResp viewResp = convert(viewDO);
+        conflictCheck(viewResp);
         save(viewDO);
-        return convert(viewDO);
+        return viewResp;
     }
 
     @Override
     public ViewResp update(ViewReq viewReq, User user) {
         viewReq.updatedBy(user.getName());
         ViewDO viewDO = convert(viewReq);
+        ViewResp viewResp = convert(viewDO);
+        conflictCheck(viewResp);
         updateById(viewDO);
-        return convert(viewDO);
+        return viewResp;
     }
 
     @Override
@@ -78,6 +98,9 @@ public class ViewServiceImpl
         if (!CollectionUtils.isEmpty(metaFilter.getIds())) {
             wrapper.lambda().in(ViewDO::getId, metaFilter.getIds());
         }
+        if (metaFilter.getStatus() != null) {
+            wrapper.lambda().eq(ViewDO::getStatus, metaFilter.getStatus());
+        }
         wrapper.lambda().ne(ViewDO::getStatus, StatusEnum.DELETED.getCode());
         return list(wrapper).stream().map(this::convert).collect(Collectors.toList());
     }
@@ -175,4 +198,43 @@ public class ViewServiceImpl
                         viewResp -> viewResp.getAllModels().stream().map(modelId -> Pair.of(modelId, viewResp.getId())))
                 .collect(Collectors.groupingBy(Pair::getLeft, Collectors.mapping(Pair::getRight, Collectors.toList())));
     }
+
+    private void conflictCheck(ViewResp viewResp) {
+        List<Long> allDimensionIds = viewResp.getAllDimensions();
+        List<Long> allMetricIds = viewResp.getAllMetrics();
+        MetaFilter metaFilter = new MetaFilter();
+        metaFilter.setIds(allDimensionIds);
+        List<DimensionResp> dimensionResps = dimensionService.getDimensions(metaFilter);
+        metaFilter.setIds(allMetricIds);
+        List<MetricResp> metricResps = metricService.getMetrics(metaFilter);
+
+        List<String> duplicateDimensionNames = findDuplicates(dimensionResps, DimensionResp::getName);
+        List<String> duplicateDimensionBizNames = findDuplicates(dimensionResps, DimensionResp::getBizName);
+
+        List<String> duplicateMetricNames = findDuplicates(metricResps, MetricResp::getName);
+        List<String> duplicateMetricBizNames = findDuplicates(metricResps, MetricResp::getBizName);
+        if (!duplicateDimensionNames.isEmpty()) {
+            throw new InvalidArgumentException("存在相同的维度名: " + duplicateDimensionNames);
+        }
+        if (!duplicateDimensionBizNames.isEmpty()) {
+            throw new InvalidArgumentException("存在相同的维度英文名: " + duplicateDimensionBizNames);
+        }
+        if (!duplicateMetricNames.isEmpty()) {
+            throw new InvalidArgumentException("存在相同的指标名: " + duplicateMetricNames);
+        }
+        if (!duplicateMetricBizNames.isEmpty()) {
+            throw new InvalidArgumentException("存在相同的指标英文名: " + duplicateMetricBizNames);
+        }
+    }
+
+    private <T, R> List<String> findDuplicates(List<T> list, Function<T, R> keyExtractor) {
+        return list.stream()
+                .collect(Collectors.groupingBy(keyExtractor, Collectors.counting()))
+                .entrySet().stream()
+                .filter(entry -> entry.getValue() > 1)
+                .map(Map.Entry::getKey)
+                .map(Object::toString)
+                .collect(Collectors.toList());
+    }
+
 }

headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/MetricConverter.java

@@ -72,6 +72,7 @@ public class MetricConverter {
         ModelResp modelResp = modelMap.get(metricDO.getModelId());
         if (modelResp != null) {
             metricResp.setModelName(modelResp.getName());
+            metricResp.setModelBizName(modelResp.getBizName());
             metricResp.setDomainId(modelResp.getDomainId());
         }
         metricResp.setIsCollect(collect != null && collect.contains(metricDO.getId()));