(fix)(chat) 修复插件功能，无法调用/插件结果被NL2SQL结果覆盖的问题 (#2277)

chat/server/src/main/java/com/tencent/supersonic/chat/server/plugin/build/webservice/WebServiceQuery.java

@@ -88,10 +88,10 @@ public class WebServiceQuery extends PluginSemanticQuery {
         restTemplate = ContextUtils.getBean(RestTemplate.class);
         try {
             responseEntity =
-                    restTemplate.exchange(requestUrl, HttpMethod.POST, entity, Object.class);
+                    restTemplate.exchange(requestUrl, HttpMethod.POST, entity, String.class);
             objectResponse = responseEntity.getBody();
             log.info("objectResponse:{}", objectResponse);
-            Map<String, Object> response = JsonUtil.objectToMap(objectResponse);
+            Map<String, Object> response = JSON.parseObject(objectResponse.toString());
             webServiceResponse.setResult(response);
         } catch (Exception e) {
             log.info("Exception:{}", e.getMessage());

chat/server/src/main/java/com/tencent/supersonic/chat/server/pojo/ParseContext.java

@@ -19,7 +19,7 @@ public class ParseContext {
     }
 
     public boolean enableNL2SQL() {
-        return Objects.nonNull(agent) && agent.containsDatasetTool();
+        return Objects.nonNull(agent) && agent.containsDatasetTool()&&response.getSelectedParses().size() == 0;
     }
 
     public boolean enableLLM() {

headless/chat/src/main/java/com/tencent/supersonic/headless/chat/knowledge/file/FileHandlerImpl.java

@@ -86,7 +86,7 @@ public class FileHandlerImpl implements FileHandler {
     }
 
     private PageInfo<DictValueResp> getDictValueRespPagWithKey(String fileName,
-            DictValueReq dictValueReq) {
+                                                               DictValueReq dictValueReq) {
         PageInfo<DictValueResp> dictValueRespPageInfo = new PageInfo<>();
         dictValueRespPageInfo.setPageSize(dictValueReq.getPageSize());
         dictValueRespPageInfo.setPageNum(dictValueReq.getCurrent());
@@ -95,7 +95,7 @@ public class FileHandlerImpl implements FileHandler {
         Integer startLine = 1;
         List<DictValueResp> dictValueRespList =
                 getFileData(filePath, startLine, fileLineNum.intValue()).stream().filter(
-                        dictValue -> dictValue.getValue().contains(dictValueReq.getKeyValue()))
+                                dictValue -> dictValue.getValue().contains(dictValueReq.getKeyValue()))
                         .collect(Collectors.toList());
         if (CollectionUtils.isEmpty(dictValueRespList)) {
             dictValueRespPageInfo.setList(new ArrayList<>());
@@ -118,7 +118,7 @@ public class FileHandlerImpl implements FileHandler {
     }
 
     private PageInfo<DictValueResp> getDictValueRespPagWithoutKey(String fileName,
-            DictValueReq dictValueReq) {
+                                                                  DictValueReq dictValueReq) {
         PageInfo<DictValueResp> dictValueRespPageInfo = new PageInfo<>();
         String filePath = localFileConfig.getDictDirectoryLatest() + FILE_SPILT + fileName;
         Long fileLineNum = getFileLineNum(filePath);

headless/chat/src/main/java/com/tencent/supersonic/headless/chat/mapper/EmbeddingMatchStrategy.java

@@ -63,7 +63,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
 
     @Override
     public List<EmbeddingResult> detect(ChatQueryContext chatQueryContext, List<S2Term> terms,
-            Set<Long> detectDataSetIds) {
+                                        Set<Long> detectDataSetIds) {
         if (chatQueryContext == null || CollectionUtils.isEmpty(detectDataSetIds)) {
             log.warn("Invalid input parameters: context={}, dataSetIds={}", chatQueryContext,
                     detectDataSetIds);
@@ -92,7 +92,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
      * Perform enhanced detection using LLM
      */
     private List<EmbeddingResult> detectWithLLM(ChatQueryContext chatQueryContext,
-            Set<Long> detectDataSetIds) {
+                                                Set<Long> detectDataSetIds) {
         try {
             String queryText = chatQueryContext.getRequest().getQueryText();
             if (StringUtils.isBlank(queryText)) {
@@ -126,7 +126,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
 
     @Override
     public List<EmbeddingResult> detectByBatch(ChatQueryContext chatQueryContext,
-            Set<Long> detectDataSetIds, Set<String> detectSegments) {
+                                               Set<Long> detectDataSetIds, Set<String> detectSegments) {
         return detectByBatch(chatQueryContext, detectDataSetIds, detectSegments, false);
     }
 
@@ -140,7 +140,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
      * @return List of embedding results
      */
     public List<EmbeddingResult> detectByBatch(ChatQueryContext chatQueryContext,
-            Set<Long> detectDataSetIds, Set<String> detectSegments, boolean useLlm) {
+                                               Set<Long> detectDataSetIds, Set<String> detectSegments, boolean useLlm) {
         Set<EmbeddingResult> results = ConcurrentHashMap.newKeySet();
         int embeddingMapperBatch = Integer
                 .valueOf(mapperConfig.getParameterValue(MapperConfig.EMBEDDING_MAPPER_BATCH));
@@ -168,7 +168,6 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
             variable.put("retrievedInfo", JSONObject.toJSONString(results));
 
             Prompt prompt = PromptTemplate.from(LLM_FILTER_PROMPT).apply(variable);
-
             ChatModelConfig chatModelConfig=null;
             if(chatQueryContext.getRequest().getChatAppConfig()!=null
                     && chatQueryContext.getRequest().getChatAppConfig().containsKey("REWRITE_MULTI_TURN")){
@@ -201,7 +200,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
      * @return Callable task
      */
     private Callable<Void> createTask(ChatQueryContext chatQueryContext, Set<Long> detectDataSetIds,
-            List<String> queryTextsSub, Set<EmbeddingResult> results, boolean useLlm) {
+                                      List<String> queryTextsSub, Set<EmbeddingResult> results, boolean useLlm) {
         return () -> {
             List<EmbeddingResult> oneRoundResults = detectByQueryTextsSub(detectDataSetIds,
                     queryTextsSub, chatQueryContext, useLlm);
@@ -222,7 +221,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
      * @return List of embedding results for this batch
      */
     private List<EmbeddingResult> detectByQueryTextsSub(Set<Long> detectDataSetIds,
-            List<String> queryTextsSub, ChatQueryContext chatQueryContext, boolean useLlm) {
+                                                        List<String> queryTextsSub, ChatQueryContext chatQueryContext, boolean useLlm) {
         Map<Long, List<Long>> modelIdToDataSetIds = chatQueryContext.getModelIdToDataSetIds();
 
         // Get configuration parameters
@@ -244,12 +243,12 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
 
         // Process results
         List<EmbeddingResult> collect = retrieveQueryResults.stream().peek(result -> {
-            if (!useLlm && CollectionUtils.isNotEmpty(result.getRetrieval())) {
+                    if (!useLlm && CollectionUtils.isNotEmpty(result.getRetrieval())) {
-                result.getRetrieval()
+                        result.getRetrieval()
-                        .removeIf(retrieval -> !result.getQuery().contains(retrieval.getQuery())
+                                .removeIf(retrieval -> !result.getQuery().contains(retrieval.getQuery())
-                                && retrieval.getSimilarity() < threshold);
+                                        && retrieval.getSimilarity() < threshold);
-            }
+                    }
-        }).filter(result -> CollectionUtils.isNotEmpty(result.getRetrieval()))
+                }).filter(result -> CollectionUtils.isNotEmpty(result.getRetrieval()))
                 .flatMap(result -> result.getRetrieval().stream()
                         .map(retrieval -> convertToEmbeddingResult(result, retrieval)))
                 .collect(Collectors.toList());
@@ -268,7 +267,7 @@ public class EmbeddingMatchStrategy extends BatchMatchStrategy<EmbeddingResult>
      * @return Converted EmbeddingResult
      */
     private EmbeddingResult convertToEmbeddingResult(RetrieveQueryResult queryResult,
-            Retrieval retrieval) {
+                                                     Retrieval retrieval) {
         EmbeddingResult embeddingResult = new EmbeddingResult();
         BeanUtils.copyProperties(retrieval, embeddingResult);
         embeddingResult.setDetectWord(queryResult.getQuery());

headless/chat/src/main/java/com/tencent/supersonic/headless/chat/mapper/KeywordMapper.java

@@ -1,10 +1,7 @@
 package com.tencent.supersonic.headless.chat.mapper;
 
 import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.*;
-import com.tencent.supersonic.headless.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
-import com.tencent.supersonic.headless.api.pojo.SchemaMapInfo;
 import com.tencent.supersonic.headless.api.pojo.response.S2Term;
 import com.tencent.supersonic.headless.chat.ChatQueryContext;
 import com.tencent.supersonic.headless.chat.knowledge.DatabaseMapResult;
@@ -54,7 +51,7 @@ public class KeywordMapper extends BaseMapper {
     }
 
     private void convertMapResultToMapInfo(List<HanlpMapResult> mapResults,
-            ChatQueryContext chatQueryContext, List<S2Term> terms) {
+                                           ChatQueryContext chatQueryContext, List<S2Term> terms) {
         if (CollectionUtils.isEmpty(mapResults)) {
             return;
         }
@@ -90,13 +87,14 @@ public class KeywordMapper extends BaseMapper {
                         .similarity(hanlpMapResult.getSimilarity())
                         .detectWord(hanlpMapResult.getDetectWord()).build();
                 // doDimValueAliasLogic 将维度值别名进行替换成真实维度值
-                doDimValueAliasLogic(schemaElementMatch);
+                doDimValueAliasLogic(schemaElementMatch,chatQueryContext.getSemanticSchema().getDimensionValues());
                 addToSchemaMap(chatQueryContext.getMapInfo(), dataSetId, schemaElementMatch);
             }
         }
     }
 
-    private void doDimValueAliasLogic(SchemaElementMatch schemaElementMatch) {
+    private void doDimValueAliasLogic(SchemaElementMatch schemaElementMatch,
+                                      List<SchemaElement> dimensionValues) {
         SchemaElement element = schemaElementMatch.getElement();
         if (SchemaElementType.VALUE.equals(element.getType())) {
             Long dimId = element.getId();
@@ -112,11 +110,23 @@ public class KeywordMapper extends BaseMapper {
                     schemaElementMatch.setWord(wordTech);
                 }
             }
+            SchemaElement dimensionValue = dimensionValues.stream()
+                    .filter(dimValue -> dimId.equals(dimValue.getId())).findFirst().orElse(null);
+            if (dimensionValue != null) {
+                SchemaValueMap dimValue =
+                        dimensionValue.getSchemaValueMaps().stream().filter(schemaValueMap -> {
+                            return StringUtils.equals(schemaValueMap.getBizName(), word)
+                                    || schemaValueMap.getAlias().contains(word);
+                        }).findFirst().orElse(null);
+                if (dimValue != null) {
+                    schemaElementMatch.setWord(dimValue.getTechName());
+                }
+            }
         }
     }
 
     private void convertMapResultToMapInfo(ChatQueryContext chatQueryContext,
-            List<DatabaseMapResult> mapResults) {
+                                           List<DatabaseMapResult> mapResults) {
         for (DatabaseMapResult match : mapResults) {
             SchemaElement schemaElement = match.getSchemaElement();
             Set<Long> regElementSet =
@@ -143,8 +153,8 @@ public class KeywordMapper extends BaseMapper {
             return new HashSet<>();
         }
         return elements.stream().filter(
-                elementMatch -> SchemaElementType.METRIC.equals(elementMatch.getElement().getType())
+                        elementMatch -> SchemaElementType.METRIC.equals(elementMatch.getElement().getType())
-                        || SchemaElementType.DIMENSION.equals(elementMatch.getElement().getType()))
+                                || SchemaElementType.DIMENSION.equals(elementMatch.getElement().getType()))
                 .map(elementMatch -> elementMatch.getElement().getId()).collect(Collectors.toSet());
     }
 }

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/mapper/DimensionDOCustomMapper.java

@@ -13,5 +13,7 @@ public interface DimensionDOCustomMapper {
 
     void batchUpdateStatus(List<DimensionDO> dimensionDOS);
 
+    void batchUpdate(List<DimensionDO> dimensionDOS);
+
     List<DimensionDO> queryDimensions(DimensionsFilter dimensionsFilter);
 }

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/mapper/MetricDOCustomMapper.java

@@ -13,6 +13,8 @@ public interface MetricDOCustomMapper {
 
     void batchUpdateStatus(List<MetricDO> metricDOS);
 
+    void batchUpdate(List<MetricDO> metricDOS);
+
     void batchPublish(List<MetricDO> metricDOS);
 
     void batchUnPublish(List<MetricDO> metricDOS);

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/repository/DimensionRepository.java

@@ -16,6 +16,8 @@ public interface DimensionRepository {
 
     void batchUpdateStatus(List<DimensionDO> dimensionDOS);
 
+    void batchUpdate(List<DimensionDO> dimensionDOS);
+
     DimensionDO getDimensionById(Long id);
 
     List<DimensionDO> getDimension(DimensionFilter dimensionFilter);

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/repository/MetricRepository.java

@@ -17,6 +17,8 @@ public interface MetricRepository {
 
     void batchUpdateStatus(List<MetricDO> metricDOS);
 
+    void batchUpdateMetric(List<MetricDO> metricDOS);
+
     void batchPublish(List<MetricDO> metricDOS);
 
     void batchUnPublish(List<MetricDO> metricDOS);

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/repository/impl/DimensionRepositoryImpl.java

@@ -46,6 +46,11 @@ public class DimensionRepositoryImpl implements DimensionRepository {
         dimensionDOCustomMapper.batchUpdateStatus(dimensionDOS);
     }
 
+    @Override
+    public void batchUpdate(List<DimensionDO> dimensionDOS) {
+        dimensionDOCustomMapper.batchUpdate(dimensionDOS);
+    }
+
     @Override
     public DimensionDO getDimensionById(Long id) {
         return dimensionDOMapper.selectById(id);

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/repository/impl/MetricRepositoryImpl.java

@@ -53,6 +53,11 @@ public class MetricRepositoryImpl implements MetricRepository {
         metricDOCustomMapper.batchUpdateStatus(metricDOS);
     }
 
+    @Override
+    public void batchUpdateMetric(List<MetricDO> metricDOS) {
+        metricDOCustomMapper.batchUpdate(metricDOS);
+    }
+
     @Override
     public void batchPublish(List<MetricDO> metricDOS) {
         metricDOCustomMapper.batchPublish(metricDOS);

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/DimensionService.java

@@ -27,10 +27,14 @@ public interface DimensionService {
 
     DimensionResp createDimension(DimensionReq dimensionReq, User user) throws Exception;
 
+    void alterDimensionBatch(List<DimensionReq> dimensionReqs, Long modelId, User user) throws Exception;
+
     void createDimensionBatch(List<DimensionReq> dimensionReqs, User user) throws Exception;
 
     void updateDimension(DimensionReq dimensionReq, User user) throws Exception;
 
+    void updateDimensionBatch(List<DimensionReq> dimensionReqs, User user) throws Exception;
+
     PageInfo<DimensionResp> queryDimension(PageDimensionReq pageDimensionReq);
 
     List<DimensionResp> queryDimensions(DimensionsFilter dimensionsFilter);
@@ -39,6 +43,8 @@ public interface DimensionService {
 
     void deleteDimension(Long id, User user);
 
+    void deleteDimensionBatch(List<Long> idList, User user);
+
     List<DimensionResp> getDimensionInModelCluster(Long modelId);
 
     List<String> mockAlias(DimensionReq dimensionReq, String mockType, User user);

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/MetricService.java

@@ -26,8 +26,12 @@ public interface MetricService {
 
     void createMetricBatch(List<MetricReq> metricReqs, User user) throws Exception;
 
+    void alterMetricBatch(List<MetricReq> metricReqs, Long modelId, User user) throws Exception;
+
     MetricResp updateMetric(MetricReq metricReq, User user) throws Exception;
 
+    void updateMetricBatch(List<MetricReq> metricReqs, User user) throws Exception;
+
     void batchUpdateStatus(MetaBatchReq metaBatchReq, User user);
 
     void batchPublish(List<Long> metricIds, User user);
@@ -40,6 +44,8 @@ public interface MetricService {
 
     void deleteMetric(Long id, User user) throws Exception;
 
+    void deleteMetricBatch(List<Long> idList, User user);
+
     PageInfo<MetricResp> queryMetricMarket(PageMetricReq pageMetricReq, User user);
 
     PageInfo<MetricResp> queryMetric(PageMetricReq pageMetricReq, User user);

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/ModelService.java

@@ -11,6 +11,8 @@ import com.tencent.supersonic.headless.api.pojo.request.*;
 import com.tencent.supersonic.headless.api.pojo.response.DatabaseResp;
 import com.tencent.supersonic.headless.api.pojo.response.ModelResp;
 import com.tencent.supersonic.headless.api.pojo.response.UnAvailableItemResp;
+import com.tencent.supersonic.headless.server.persistence.dataobject.DimensionDO;
+import com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO;
 import com.tencent.supersonic.headless.server.pojo.ModelFilter;
 
 import java.sql.SQLException;
@@ -53,5 +55,7 @@ public interface ModelService {
 
     void batchUpdateStatus(MetaBatchReq metaBatchReq, User user);
 
-    Dimension updateDimension(DimensionReq dimensionReq, User user);
+    void updateModelByDimAndMetric(Long modelId, List<DimensionReq> dimensionReqList, List<MetricReq> metricReqList, User user);
+
+    void deleteModelDetailByDimAndMetric(Long modelId, List<DimensionDO> dimensionReqList, List<MetricDO> metricReqList);
 }

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

@@ -67,8 +67,8 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
     private ApplicationEventPublisher eventPublisher;
 
     public DimensionServiceImpl(DimensionRepository dimensionRepository, ModelService modelService,
-            AliasGenerateHelper aliasGenerateHelper, DatabaseService databaseService,
+                                AliasGenerateHelper aliasGenerateHelper, DatabaseService databaseService,
-            ModelRelaService modelRelaService, DataSetService dataSetService) {
+                                ModelRelaService modelRelaService, DataSetService dataSetService) {
         this.modelService = modelService;
         this.dimensionRepository = dimensionRepository;
         this.aliasGenerateHelper = aliasGenerateHelper;
@@ -86,49 +86,70 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
         sendEventBatch(Lists.newArrayList(dimensionDO), EventType.ADD);
 
         // should update modelDetail
-        modelService.updateDimension(dimensionReq, user);
+        modelService.updateModelByDimAndMetric(dimensionReq.getModelId(), Lists.newArrayList(dimensionReq), null, user);
 
         return DimensionConverter.convert2DimensionResp(dimensionDO);
     }
 
     @Override
-    public void createDimensionBatch(List<DimensionReq> dimensionReqs, User user) {
+    public void alterDimensionBatch(List<DimensionReq> dimensionReqs, Long modelId, User user) throws Exception {
-        if (CollectionUtils.isEmpty(dimensionReqs)) {
-            return;
-        }
-        Long modelId = dimensionReqs.get(0).getModelId();
         List<DimensionResp> dimensionResps = getDimensions(modelId);
+        // get all dimension in model, only use bizname, because name can be changed to everything
         Map<String, DimensionResp> bizNameMap = dimensionResps.stream()
                 .collect(Collectors.toMap(DimensionResp::getBizName, a -> a, (k1, k2) -> k1));
-        Map<String, DimensionResp> nameMap = dimensionResps.stream()
-                .collect(Collectors.toMap(DimensionResp::getName, a -> a, (k1, k2) -> k1));
 
         List<DimensionReq> dimensionToInsert = Lists.newArrayList();
+        List<DimensionReq> dimensionToUpdate = Lists.newArrayList();
+        List<Long> dimensionToDelete = Lists.newArrayList();
+
+        // look for which dimension need to insert, update, delete
         dimensionReqs.stream().forEach(dimension -> {
-            if (!bizNameMap.containsKey(dimension.getBizName())
+            if (!bizNameMap.containsKey(dimension.getBizName())) {
-                    && !nameMap.containsKey(dimension.getName())) {
                 dimensionToInsert.add(dimension);
             } else {
                 DimensionResp dimensionRespByBizName = bizNameMap.get(dimension.getBizName());
-                DimensionResp dimensionRespByName = nameMap.get(dimension.getName());
                 if (null != dimensionRespByBizName && isChange(dimension, dimensionRespByBizName)) {
                     dimension.setId(dimensionRespByBizName.getId());
-                    this.updateDimension(dimension, user);
+                    dimension.updatedBy(user.getName());
-                } else {
+                    dimensionToUpdate.add(dimension);
-                    if (null != dimensionRespByName && isChange(dimension, dimensionRespByName)) {
-                        dimension.setId(dimensionRespByName.getId());
-                        this.updateDimension(dimension, user);
-                    }
                 }
             }
         });
-        if (CollectionUtils.isEmpty(dimensionToInsert)) {
+
-            return;
+        // the bizNames from alter dimensions
+        List<String> bizNames = dimensionReqs.stream().map(DimensionReq::getBizName).collect(Collectors.toList());
+        bizNameMap.keySet().forEach(bizNameInDb -> {
+            if (!bizNames.contains(bizNameInDb)) {
+                dimensionToDelete.add(bizNameMap.get(bizNameInDb).getId());
+            }
+        });
+
+        // insert
+        if (!CollectionUtils.isEmpty(dimensionToInsert)) {
+            createDimensionBatch(dimensionToInsert, user);
         }
+
+        // update
+        if (!CollectionUtils.isEmpty(dimensionToUpdate)) {
+            updateDimensionBatch(dimensionToUpdate, user);
+        }
+
+        // delete
+        if (!CollectionUtils.isEmpty(dimensionToDelete)) {
+            deleteDimensionBatch(dimensionToDelete, user);
+        }
+
+    }
+
+    @Override
+    public void createDimensionBatch(List<DimensionReq> dimensionReqs, User user) {
         List<DimensionDO> dimensionDOS =
-                dimensionToInsert.stream().peek(dimension -> dimension.createdBy(user.getName()))
+                dimensionReqs.stream().peek(dimension -> dimension.createdBy(user.getName()))
                         .map(DimensionConverter::convert2DimensionDO).collect(Collectors.toList());
         dimensionRepository.createDimensionBatch(dimensionDOS);
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(dimensionReqs.get(0).getModelId(), dimensionReqs, null,  user);
+
         sendEventBatch(dimensionDOS, EventType.ADD);
     }
 
@@ -141,13 +162,23 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
         DimensionConverter.convert(dimensionDO, dimensionReq);
         dimensionRepository.updateDimension(dimensionDO);
         // should update modelDetail as well
-        modelService.updateDimension(dimensionReq, user);
+        modelService.updateModelByDimAndMetric(dimensionReq.getModelId(), Lists.newArrayList(dimensionReq), null,  user);
 
         if (!oldName.equals(dimensionDO.getName())) {
             sendEvent(getDataItem(dimensionDO), EventType.UPDATE);
         }
     }
 
+    @Override
+    public void updateDimensionBatch(List<DimensionReq> dimensionReqList, User user) {
+        checkExist(dimensionReqList);
+        List<DimensionDO> dimensionDOS = dimensionReqList.stream().map(DimensionConverter::convert2DimensionDO).collect(Collectors.toList());
+        dimensionRepository.batchUpdate(dimensionDOS);
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(dimensionReqList.get(0).getModelId(),dimensionReqList, null, user);
+        sendEventBatch(dimensionDOS, EventType.UPDATE);
+    }
+
     @Override
     public void batchUpdateStatus(MetaBatchReq metaBatchReq, User user) {
         if (CollectionUtils.isEmpty(metaBatchReq.getIds())) {
@@ -199,9 +230,30 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
         dimensionDO.setUpdatedAt(new Date());
         dimensionDO.setUpdatedBy(user.getName());
         dimensionRepository.updateDimension(dimensionDO);
+        // should update modelDetail
+        modelService.deleteModelDetailByDimAndMetric(dimensionDO.getModelId(), Lists.newArrayList(dimensionDO), null);
         sendEventBatch(Lists.newArrayList(dimensionDO), EventType.DELETE);
     }
 
+    @Override
+    public void deleteDimensionBatch(List<Long> idList, User user) {
+        DimensionsFilter dimensionFilter = new DimensionsFilter();
+        dimensionFilter.setDimensionIds(idList);
+        List<DimensionDO> dimensionDOList = dimensionRepository.getDimensions(dimensionFilter);
+        if (CollectionUtils.isEmpty(dimensionDOList)) {
+            throw new RuntimeException(String.format("the dimension %s not exist", StringUtils.join(",",idList)));
+        }
+        dimensionDOList.forEach(dimensionDO -> {
+            dimensionDO.setStatus(StatusEnum.DELETED.getCode());
+            dimensionDO.setUpdatedAt(new Date());
+            dimensionDO.setUpdatedBy(user.getName());
+        });
+        dimensionRepository.batchUpdateStatus(dimensionDOList);
+        // should update modelDetail
+        modelService.deleteModelDetailByDimAndMetric(dimensionDOList.get(0).getModelId(), dimensionDOList, null);
+        sendEventBatch(dimensionDOList, EventType.DELETE);
+    }
+
     @Override
     public DimensionResp getDimension(String bizName, Long modelId) {
         List<DimensionResp> dimensionResps = getDimensions(modelId);
@@ -271,7 +323,7 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
     }
 
     private List<DimensionResp> filterByField(List<DimensionResp> dimensionResps,
-            List<String> fields) {
+                                              List<String> fields) {
         List<DimensionResp> dimensionFiltered = Lists.newArrayList();
         for (DimensionResp dimensionResp : dimensionResps) {
             for (String field : fields) {
@@ -306,7 +358,7 @@ public class DimensionServiceImpl extends ServiceImpl<DimensionDOMapper, Dimensi
         List<DimensionResp> dimensionResps = Lists.newArrayList();
         if (!CollectionUtils.isEmpty(dimensionDOS)) {
             dimensionResps = dimensionDOS.stream().map(
-                    dimensionDO -> DimensionConverter.convert2DimensionResp(dimensionDO, modelMap))
+                            dimensionDO -> DimensionConverter.convert2DimensionResp(dimensionDO, modelMap))
                     .collect(Collectors.toList());
         }
         return dimensionResps;

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

@@ -11,23 +11,20 @@ import com.google.common.collect.Sets;
 import com.tencent.supersonic.common.pojo.*;
 import com.tencent.supersonic.common.pojo.enums.*;
 import com.tencent.supersonic.common.util.BeanMapper;
+import com.tencent.supersonic.common.util.JsonUtil;
 import com.tencent.supersonic.headless.api.pojo.*;
+import com.tencent.supersonic.headless.api.pojo.enums.DimensionType;
 import com.tencent.supersonic.headless.api.pojo.enums.MapModeEnum;
 import com.tencent.supersonic.headless.api.pojo.enums.MetricDefineType;
 import com.tencent.supersonic.headless.api.pojo.request.*;
 import com.tencent.supersonic.headless.api.pojo.response.*;
 import com.tencent.supersonic.headless.server.facade.service.ChatLayerService;
-import com.tencent.supersonic.headless.server.persistence.dataobject.CollectDO;
+import com.tencent.supersonic.headless.server.persistence.dataobject.*;
-import com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO;
-import com.tencent.supersonic.headless.server.persistence.dataobject.MetricQueryDefaultConfigDO;
 import com.tencent.supersonic.headless.server.persistence.mapper.MetricDOMapper;
 import com.tencent.supersonic.headless.server.persistence.repository.MetricRepository;
 import com.tencent.supersonic.headless.server.pojo.*;
 import com.tencent.supersonic.headless.server.service.*;
-import com.tencent.supersonic.headless.server.utils.AliasGenerateHelper;
+import com.tencent.supersonic.headless.server.utils.*;
-import com.tencent.supersonic.headless.server.utils.MetricCheckUtils;
-import com.tencent.supersonic.headless.server.utils.MetricConverter;
-import com.tencent.supersonic.headless.server.utils.ModelClusterBuilder;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
@@ -61,9 +58,9 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
     private ChatLayerService chatLayerService;
 
     public MetricServiceImpl(MetricRepository metricRepository, ModelService modelService,
-            AliasGenerateHelper aliasGenerateHelper, CollectService collectService,
+                             AliasGenerateHelper aliasGenerateHelper, CollectService collectService,
-            DataSetService dataSetService, ApplicationEventPublisher eventPublisher,
+                             DataSetService dataSetService, ApplicationEventPublisher eventPublisher,
-            DimensionService dimensionService, @Lazy ChatLayerService chatLayerService) {
+                             DimensionService dimensionService, @Lazy ChatLayerService chatLayerService) {
         this.metricRepository = metricRepository;
         this.modelService = modelService;
         this.aliasGenerateHelper = aliasGenerateHelper;
@@ -77,57 +74,82 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
     @Override
     public MetricResp createMetric(MetricReq metricReq, User user) {
         checkExist(Lists.newArrayList(metricReq));
-        MetricCheckUtils.checkParam(metricReq);
+        MetricCheckUtils.checkParam(Lists.newArrayList(metricReq));
         metricReq.createdBy(user.getName());
         MetricDO metricDO = MetricConverter.convert2MetricDO(metricReq);
         metricRepository.createMetric(metricDO);
         sendEventBatch(Lists.newArrayList(metricDO), EventType.ADD);
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(metricReq.getModelId(),null, Lists.newArrayList(metricReq), user);
+
+
         return MetricConverter.convert2MetricResp(metricDO);
     }
 
     @Override
     public void createMetricBatch(List<MetricReq> metricReqs, User user) {
-        if (CollectionUtils.isEmpty(metricReqs)) {
-            return;
-        }
-        Long modelId = metricReqs.get(0).getModelId();
-        List<MetricResp> metricResps = getMetrics(new MetaFilter(Lists.newArrayList(modelId)));
-        Map<String, MetricResp> bizNameMap = metricResps.stream()
-                .collect(Collectors.toMap(MetricResp::getBizName, a -> a, (k1, k2) -> k1));
-        Map<String, MetricResp> nameMap = metricResps.stream()
-                .collect(Collectors.toMap(MetricResp::getName, a -> a, (k1, k2) -> k1));
-        List<MetricReq> metricToInsert = Lists.newArrayList();
-        metricReqs.stream().forEach(metric -> {
-            if (!bizNameMap.containsKey(metric.getBizName())
-                    && !nameMap.containsKey(metric.getName())) {
-                metricToInsert.add(metric);
-            } else {
-                MetricResp metricRespByBizName = bizNameMap.get(metric.getBizName());
-                MetricResp metricRespByName = nameMap.get(metric.getName());
-                if (null != metricRespByBizName) {
-                    metric.setId(metricRespByBizName.getId());
-                    this.updateMetric(metric, user);
-                } else {
-                    if (null != metricRespByName) {
-                        metric.setId(metricRespByName.getId());
-                        this.updateMetric(metric, user);
-                    }
-                }
-            }
-        });
-        if (CollectionUtils.isEmpty(metricToInsert)) {
-            return;
-        }
         List<MetricDO> metricDOS =
-                metricToInsert.stream().peek(metric -> metric.createdBy(user.getName()))
+                metricReqs.stream().peek(metric -> metric.createdBy(user.getName()))
                         .map(MetricConverter::convert2MetricDO).collect(Collectors.toList());
         metricRepository.createMetricBatch(metricDOS);
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(metricReqs.get(0).getModelId(), null, metricReqs, user);
+
         sendEventBatch(metricDOS, EventType.ADD);
     }
 
+    @Override
+    public void alterMetricBatch(List<MetricReq> metricReqs, Long modelId, User user) {
+        List<MetricResp> metricResps = getMetrics(new MetaFilter(Lists.newArrayList(modelId)));
+        // get all metric in model, only use bizname, because name can be changed to everything
+        Map<String, MetricResp> bizNameMap = metricResps.stream()
+                .collect(Collectors.toMap(MetricResp::getBizName, a -> a, (k1, k2) -> k1));
+
+        List<MetricReq> metricToInsert = Lists.newArrayList();
+        List<MetricReq> metricToUpdate = Lists.newArrayList();
+        List<Long> metricToDelete = Lists.newArrayList();
+
+        metricReqs.stream().forEach(metric -> {
+            if (!bizNameMap.containsKey(metric.getBizName())) {
+                metricToInsert.add(metric);
+            } else {
+                MetricResp metricRespByBizName = bizNameMap.get(metric.getBizName());
+                if (null != metricRespByBizName && isChange(metric, metricRespByBizName)) {
+                    metric.setId(metricRespByBizName.getId());
+                    metric.updatedBy(user.getName());
+                    metricToUpdate.add(metric);
+                }
+            }
+        });
+
+        // the bizNames from alter dimensions
+        List<String> bizNames = metricReqs.stream().map(MetricReq::getBizName).collect(Collectors.toList());
+        bizNameMap.keySet().forEach(bizNameInDb -> {
+            if (!bizNames.contains(bizNameInDb)) {
+                metricToDelete.add(bizNameMap.get(bizNameInDb).getId());
+            }
+        });
+
+        // insert
+        if (!CollectionUtils.isEmpty(metricToInsert)) {
+            createMetricBatch(metricToInsert, user);
+        }
+
+        // update
+        if (!CollectionUtils.isEmpty(metricToUpdate)) {
+            updateMetricBatch(metricToUpdate, user);
+        }
+
+        // delete
+        if (!CollectionUtils.isEmpty(metricToDelete)) {
+            deleteMetricBatch(metricToDelete, user);
+        }
+
+    }
+
     @Override
     public MetricResp updateMetric(MetricReq metricReq, User user) {
-        MetricCheckUtils.checkParam(metricReq);
+        MetricCheckUtils.checkParam(Lists.newArrayList(metricReq));
         checkExist(Lists.newArrayList(metricReq));
         metricReq.updatedBy(user.getName());
         MetricDO metricDO = metricRepository.getMetricById(metricReq.getId());
@@ -140,9 +162,23 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
             dataItem.setNewName(metricDO.getName());
             sendEvent(dataItem, EventType.UPDATE);
         }
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(metricReq.getModelId(), null, Lists.newArrayList(metricReq), user);
         return MetricConverter.convert2MetricResp(metricDO);
     }
 
+    @Override
+    public void updateMetricBatch(List<MetricReq> metricReqs, User user) {
+        MetricCheckUtils.checkParam(metricReqs);
+        checkExist(metricReqs);
+        List<MetricDO> metricDOS = metricReqs.stream().map(MetricConverter::convert2MetricDO).collect(Collectors.toList());
+        metricRepository.batchUpdateMetric(metricDOS);
+        // should update modelDetail as well
+        modelService.updateModelByDimAndMetric(metricReqs.get(0).getModelId(), null, metricReqs, user);
+        sendEventBatch(metricDOS, EventType.UPDATE);
+    }
+
+
     @Override
     public void batchUpdateStatus(MetaBatchReq metaBatchReq, User user) {
         if (CollectionUtils.isEmpty(metaBatchReq.getIds())) {
@@ -240,9 +276,30 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
         metricDO.setUpdatedAt(new Date());
         metricDO.setUpdatedBy(user.getName());
         metricRepository.updateMetric(metricDO);
+        // should update modelDetail
+        modelService.deleteModelDetailByDimAndMetric(metricDO.getModelId(), null, Lists.newArrayList(metricDO));
         sendEventBatch(Lists.newArrayList(metricDO), EventType.DELETE);
     }
 
+    @Override
+    public void deleteMetricBatch(List<Long> idList, User user) {
+        MetricsFilter metricsFilter = new MetricsFilter();
+        metricsFilter.setMetricIds(idList);
+        List<MetricDO> metricDOList = metricRepository.getMetrics(metricsFilter);
+        if (CollectionUtils.isEmpty(metricDOList)) {
+            throw new RuntimeException(String.format("the metrics %s not exist", StringUtils.join(",",idList)));
+        }
+        metricDOList.forEach(metricDO -> {
+            metricDO.setStatus(StatusEnum.DELETED.getCode());
+            metricDO.setUpdatedAt(new Date());
+            metricDO.setUpdatedBy(user.getName());
+        });
+        metricRepository.batchUpdateStatus(metricDOList);
+        // should update modelDetail
+        modelService.deleteModelDetailByDimAndMetric(metricDOList.get(0).getModelId(), null, metricDOList);
+        sendEventBatch(metricDOList, EventType.DELETE);
+    }
+
     @Override
     public PageInfo<MetricResp> queryMetricMarket(PageMetricReq pageMetricReq, User user) {
         // search by whole text
@@ -376,7 +433,7 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
     }
 
     private boolean filterByField(List<MetricResp> metricResps, MetricResp metricResp,
-            List<String> fields, Set<MetricResp> metricRespFiltered) {
+                                  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());
@@ -413,8 +470,8 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
         metricFilter.setModelIds(Lists.newArrayList(modelId));
         List<MetricResp> metricResps = getMetrics(metricFilter);
         return metricResps.stream().filter(
-                metricResp -> MetricDefineType.FIELD.equals(metricResp.getMetricDefineType())
+                        metricResp -> MetricDefineType.FIELD.equals(metricResp.getMetricDefineType())
-                        || MetricDefineType.MEASURE.equals(metricResp.getMetricDefineType()))
+                                || MetricDefineType.MEASURE.equals(metricResp.getMetricDefineType()))
                 .collect(Collectors.toList());
     }
 
@@ -549,7 +606,7 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
         return metricQueryDefaultConfig;
     }
 
-    private void checkExist(List<MetricBaseReq> metricReqs) {
+    private void checkExist(List<MetricReq> metricReqs) {
         Long modelId = metricReqs.get(0).getModelId();
         MetaFilter metaFilter = new MetaFilter();
         metaFilter.setModelIds(Lists.newArrayList(modelId));
@@ -588,7 +645,7 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
         Map<Long, ModelResp> modelMap = modelService.getModelMap(modelFilter);
         if (!CollectionUtils.isEmpty(metricDOS)) {
             metricResps = metricDOS.stream().map(
-                    metricDO -> MetricConverter.convert2MetricResp(metricDO, modelMap, collect))
+                            metricDO -> MetricConverter.convert2MetricResp(metricDO, modelMap, collect))
                     .collect(Collectors.toList());
         }
         return metricResps;
@@ -646,7 +703,7 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
 
     @Override
     public void batchFillMetricDefaultAgg(List<MetricResp> metricResps,
-            List<ModelResp> modelResps) {
+                                          List<ModelResp> modelResps) {
         Map<Long, ModelResp> modelRespMap =
                 modelResps.stream().collect(Collectors.toMap(ModelResp::getId, m -> m));
         for (MetricResp metricResp : metricResps) {
@@ -795,7 +852,7 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
     }
 
     private Set<Long> getModelIds(Set<Long> modelIdsByDomainId, List<MetricResp> metricResps,
-            List<DimensionResp> dimensionResps) {
+                                  List<DimensionResp> dimensionResps) {
         Set<Long> result = new HashSet<>();
         if (org.apache.commons.collections.CollectionUtils.isNotEmpty(modelIdsByDomainId)) {
             result.addAll(modelIdsByDomainId);
@@ -830,8 +887,9 @@ public class MetricServiceImpl extends ServiceImpl<MetricDOMapper, MetricDO>
         return modelResps.stream().map(ModelResp::getId).collect(Collectors.toSet());
     }
 
-    private boolean isNameChange(MetricReq metricReq, MetricResp metricResp) {
+    private boolean isChange(MetricReq metricReq, MetricResp metricResp) {
         boolean isNameChange = !metricReq.getName().equals(metricResp.getName());
-        return isNameChange;
+        boolean isBizNameChange = !Objects.equals(metricReq.getMetricDefineByMeasureParams(),metricResp.getMetricDefineByMeasureParams());
+        return isNameChange || isBizNameChange;
     }
 }

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

@@ -15,6 +15,8 @@ import com.tencent.supersonic.headless.api.pojo.request.*;
 import com.tencent.supersonic.headless.api.pojo.response.*;
 import com.tencent.supersonic.headless.server.modeller.SemanticModeller;
 import com.tencent.supersonic.headless.server.persistence.dataobject.DateInfoDO;
+import com.tencent.supersonic.headless.server.persistence.dataobject.DimensionDO;
+import com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO;
 import com.tencent.supersonic.headless.server.persistence.dataobject.ModelDO;
 import com.tencent.supersonic.headless.server.persistence.repository.DateInfoRepository;
 import com.tencent.supersonic.headless.server.persistence.repository.ModelRepository;
@@ -65,10 +67,10 @@ public class ModelServiceImpl implements ModelService {
             new ThreadPoolExecutor(0, 5, 5L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
 
     public ModelServiceImpl(ModelRepository modelRepository, DatabaseService databaseService,
-            @Lazy DimensionService dimensionService, @Lazy MetricService metricService,
+                            @Lazy DimensionService dimensionService, @Lazy MetricService metricService,
-            DomainService domainService, UserService userService, DataSetService dataSetService,
+                            DomainService domainService, UserService userService, DataSetService dataSetService,
-            DateInfoRepository dateInfoRepository, ModelRelaService modelRelaService,
+                            DateInfoRepository dateInfoRepository, ModelRelaService modelRelaService,
-            ApplicationEventPublisher eventPublisher) {
+                            ApplicationEventPublisher eventPublisher) {
         this.modelRepository = modelRepository;
         this.databaseService = databaseService;
         this.dimensionService = dimensionService;
@@ -87,8 +89,12 @@ public class ModelServiceImpl implements ModelService {
         // checkParams(modelReq);
         ModelDO modelDO = ModelConverter.convert(modelReq, user);
         modelRepository.createModel(modelDO);
-        batchCreateDimension(modelDO, user);
+        // create or update dimension
-        batchCreateMetric(modelDO, user);
+        List<DimensionReq> dimensionReqs = ModelConverter.convertDimensionList(modelDO);
+        dimensionService.alterDimensionBatch(dimensionReqs, modelDO.getId(), user);
+        // create or update metric
+        List<MetricReq> metricReqs = ModelConverter.convertMetricList(modelDO);
+        metricService.alterMetricBatch(metricReqs, modelDO.getId(), user);
         sendEvent(modelDO, EventType.ADD);
         return ModelConverter.convert(modelDO);
     }
@@ -117,8 +123,12 @@ public class ModelServiceImpl implements ModelService {
         ModelDO modelDO = modelRepository.getModelById(modelReq.getId());
         ModelConverter.convert(modelDO, modelReq, user);
         modelRepository.updateModel(modelDO);
-        batchCreateDimension(modelDO, user);
+        // create or update dimension
-        batchCreateMetric(modelDO, user);
+        List<DimensionReq> dimensionReqs = ModelConverter.convertDimensionList(modelDO);
+        dimensionService.alterDimensionBatch(dimensionReqs, modelDO.getId(), user);
+        // create or update metric
+        List<MetricReq> metricReqs = ModelConverter.convertMetricList(modelDO);
+        metricService.alterMetricBatch(metricReqs, modelDO.getId(), user);
         sendEvent(modelDO, EventType.UPDATE);
         return ModelConverter.convert(modelDO);
     }
@@ -206,7 +216,7 @@ public class ModelServiceImpl implements ModelService {
     }
 
     private void doBuild(ModelBuildReq modelBuildReq, DbSchema curSchema, List<DbSchema> dbSchemas,
-            Map<String, ModelSchema> modelSchemaMap) {
+                         Map<String, ModelSchema> modelSchemaMap) {
         ModelSchema modelSchema = new ModelSchema();
         List<SemanticModeller> semanticModellers = CoreComponentFactory.getSemanticModellers();
         for (SemanticModeller semanticModeller : semanticModellers) {
@@ -224,7 +234,7 @@ public class ModelServiceImpl implements ModelService {
     }
 
     private List<DbSchema> convert(Map<String, List<DBColumn>> dbColumnMap,
-            ModelBuildReq modelBuildReq) {
+                                   ModelBuildReq modelBuildReq) {
         return dbColumnMap.keySet().stream()
                 .map(key -> convert(modelBuildReq, key, dbColumnMap.get(key)))
                 .collect(Collectors.toList());
@@ -239,32 +249,6 @@ public class ModelServiceImpl implements ModelService {
         return dbSchema;
     }
 
-    private void batchCreateDimension(ModelDO modelDO, User user) throws Exception {
-        List<DimensionReq> dimensionReqs = ModelConverter.convertDimensionList(modelDO);
-        List<DimensionReq> dimensionToCreate = new ArrayList<>();
-        for (DimensionReq dimensionReq : dimensionReqs) {
-            DimensionResp dimensionResp =
-                    dimensionService.getDimension(dimensionReq.getBizName(), modelDO.getId());
-            if (dimensionResp == null) {
-                dimensionToCreate.add(dimensionReq);
-            }
-        }
-        dimensionService.createDimensionBatch(dimensionToCreate, user);
-    }
-
-    private void batchCreateMetric(ModelDO modelDO, User user) throws Exception {
-        List<MetricReq> metricReqs = ModelConverter.convertMetricList(modelDO);
-        List<MetricReq> metricToCreate = new ArrayList<>();
-        for (MetricReq metricReq : metricReqs) {
-            MetricResp metricResp =
-                    metricService.getMetric(modelDO.getId(), metricReq.getBizName());
-            if (metricResp == null) {
-                metricToCreate.add(metricReq);
-            }
-        }
-        metricService.createMetricBatch(metricToCreate, user);
-    }
-
     private void checkParams(ModelReq modelReq) {
         String forbiddenCharacters = NameCheckUtils.findForbiddenCharacters(modelReq.getName());
         if (StringUtils.isNotBlank(forbiddenCharacters)) {
@@ -399,7 +383,7 @@ public class ModelServiceImpl implements ModelService {
     }
 
     public List<ModelResp> getModelRespAuthInheritDomain(User user, Long domainId,
-            AuthType authType) {
+                                                         AuthType authType) {
         List<Long> domainIds =
                 domainService.getDomainAuthSet(user, authType).stream().filter(domainResp -> {
                     if (domainId == null) {
@@ -537,32 +521,83 @@ public class ModelServiceImpl implements ModelService {
     }
 
     @Override
-    public Dimension updateDimension(DimensionReq dimensionReq, User user) {
+    public void updateModelByDimAndMetric(Long modelId, List<DimensionReq> dimensionReqList, List<MetricReq> metricReqList, User user) {
-        ModelDO modelDO = getModelDO(dimensionReq.getModelId());
+        ModelDO modelDO = getModelDO(modelId);
         ModelDetail modelDetail = JsonUtil.toObject(modelDO.getModelDetail(), ModelDetail.class);
-        Optional<Dimension> dimOptional = modelDetail.getDimensions().stream()
+        if (!CollectionUtils.isEmpty(dimensionReqList)) {
-                .filter(dimension -> dimension.getBizName().equals(dimensionReq.getBizName()))
+            dimensionReqList.forEach(dimensionReq -> {
-                .findFirst();
+                Optional<Dimension> dimOptional = modelDetail.getDimensions().stream()
-        Dimension result;
+                        .filter(dimension -> dimension.getBizName().equals(dimensionReq.getBizName()))
-        if (dimOptional.isPresent()) {
+                        .findFirst();
-            Dimension dimension = dimOptional.get();
+                if (dimOptional.isPresent()) {
-            dimension.setExpr(dimensionReq.getExpr());
+                    Dimension dimension = dimOptional.get();
-            dimension.setName(dimensionReq.getName());
+                    dimension.setExpr(dimensionReq.getExpr());
-            dimension.setType(DimensionType.valueOf(dimensionReq.getType()));
+                    dimension.setName(dimensionReq.getName());
-            dimension.setDescription(dimensionReq.getDescription());
+                    dimension.setType(DimensionType.valueOf(dimensionReq.getType()));
-            result = dimension;
+                    dimension.setDescription(dimensionReq.getDescription());
-        } else {
+                } else {
-            Dimension dimension = Dimension.builder().name(dimensionReq.getName())
+                    Dimension dimension = Dimension.builder().name(dimensionReq.getName())
-                    .bizName(dimensionReq.getBizName()).expr(dimensionReq.getExpr())
+                            .bizName(dimensionReq.getBizName()).expr(dimensionReq.getExpr())
-                    .type(DimensionType.valueOf(dimensionReq.getType()))
+                            .type(DimensionType.valueOf(dimensionReq.getType()))
-                    .description(dimensionReq.getDescription()).build();
+                            .description(dimensionReq.getDescription()).build();
-            modelDetail.getDimensions().add(dimension);
+                    modelDetail.getDimensions().add(dimension);
-            result = dimension;
+                }
+            });
+        }
+
+        if (!CollectionUtils.isEmpty(metricReqList)) {
+            // 目前modeltail中的measure
+            Map<String, Measure> mesureMap = modelDetail.getMeasures().stream().collect(Collectors.toMap(Measure::getBizName, a -> a, (k1, k2) -> k1));
+            metricReqList.forEach(metricReq -> {
+                if (null != metricReq.getMetricDefineByMeasureParams() && !CollectionUtils.isEmpty(metricReq.getMetricDefineByMeasureParams().getMeasures())) {
+                    for(Measure alterMeasure : metricReq.getMetricDefineByMeasureParams().getMeasures()) {
+                        if (mesureMap.containsKey(alterMeasure.getBizName())) {
+                            Measure measure = mesureMap.get(alterMeasure.getBizName());
+                            BeanUtils.copyProperties(alterMeasure, measure);
+                        } else {
+                            modelDetail.getMeasures().add(alterMeasure);
+                        }
+                    }
+                } else {
+                    modelDetail.getMeasures().clear();
+                }
+            });
+        }
+
+        modelDO.setModelDetail(JsonUtil.toString(modelDetail));
+        modelRepository.updateModel(modelDO);
+    }
+
+    @Override
+    public void deleteModelDetailByDimAndMetric(Long modelId, List<DimensionDO> dimensionList, List<MetricDO> metricReqList) {
+        ModelDO modelDO = getModelDO(modelId);
+        ModelDetail modelDetail = JsonUtil.toObject(modelDO.getModelDetail(), ModelDetail.class);
+        if (!CollectionUtils.isEmpty(dimensionList)) {
+            dimensionList.forEach(dimensionReq -> {
+                Optional<Dimension> dimOptional = modelDetail.getDimensions().stream()
+                        .filter(dimension -> dimension.getBizName().equals(dimensionReq.getBizName()))
+                        .findFirst();
+                if (dimOptional.isPresent()) {
+                    Dimension dimension = dimOptional.get();
+                    modelDetail.getDimensions().remove(dimension);
+                }
+            });
+        }
+
+        if (!CollectionUtils.isEmpty(metricReqList)) {
+            metricReqList.forEach(metricReq -> {
+                Optional<Measure> metricOptional = modelDetail.getMeasures().stream()
+                        .filter(measure -> measure.getBizName().equals(metricReq.getBizName()))
+                        .findFirst();
+                if (metricOptional.isPresent()) {
+                    Measure measure = metricOptional.get();
+                    modelDetail.getMeasures().remove(measure);
+                }
+            });
         }
 
         modelDO.setModelDetail(JsonUtil.toString(modelDetail));
         modelRepository.updateModel(modelDO);
-        return result;
     }
 
     protected ModelDO getModelDO(Long id) {
@@ -603,7 +638,7 @@ public class ModelServiceImpl implements ModelService {
     }
 
     public static boolean checkDataSetPermission(Set<String> orgIds, User user,
-            ModelResp modelResp) {
+                                                 ModelResp modelResp) {
         if (checkAdminPermission(orgIds, user, modelResp)) {
             return true;
         }

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

@@ -113,7 +113,7 @@ public class DataSetSchemaBuilder {
             if (dim.isTimeDimension()) {
                 String timeFormat =
                         String.valueOf(dim.getExt().get(DimensionConstants.DIMENSION_TIME_FORMAT));
-                setDefaultTimeFormat(dimToAdd, dim.getTypeParams(), timeFormat);
+                setDefaultTimeFormat(dimToAdd, timeFormat);
             }
             dimensions.add(dimToAdd);
         }
@@ -125,7 +125,13 @@ public class DataSetSchemaBuilder {
         for (DimSchemaResp dim : resp.getDimensions()) {
             Set<String> dimValueAlias = new HashSet<>();
             List<DimValueMap> dimValueMaps = dim.getDimValueMaps();
+            List<SchemaValueMap> schemaValueMaps = new ArrayList<>();
             if (!CollectionUtils.isEmpty(dimValueMaps)) {
+                for (DimValueMap dimValueMap : dimValueMaps) {
+                    SchemaValueMap schemaValueMap = new SchemaValueMap();
+                    BeanUtils.copyProperties(dimValueMap, schemaValueMap);
+                    schemaValueMaps.add(schemaValueMap);
+                }
                 for (DimValueMap dimValueMap : dimValueMaps) {
                     if (StringUtils.isNotEmpty(dimValueMap.getBizName())) {
                         dimValueAlias.add(dimValueMap.getBizName());
@@ -138,7 +144,7 @@ public class DataSetSchemaBuilder {
             SchemaElement dimValueToAdd = SchemaElement.builder().dataSetId(resp.getId())
                     .dataSetName(resp.getName()).model(dim.getModelId()).id(dim.getId())
                     .name(dim.getName()).bizName(dim.getBizName()).type(SchemaElementType.VALUE)
-                    .useCnt(dim.getUseCnt())
+                    .schemaValueMaps(schemaValueMaps).useCnt(dim.getUseCnt())
                     .alias(new ArrayList<>(Arrays.asList(dimValueAlias.toArray(new String[0]))))
                     .isTag(dim.getIsTag()).description(dim.getDescription()).build();
             dimensionValues.add(dimValueToAdd);
@@ -193,7 +199,7 @@ public class DataSetSchemaBuilder {
     }
 
     private static void setDefaultTimeFormat(SchemaElement dimToAdd,
-            DimensionTimeTypeParams dimensionTimeTypeParams, String timeFormat) {
+                                             String timeFormat) {
         dimToAdd.getExtInfo().put(DimensionConstants.DIMENSION_TIME_FORMAT, timeFormat);
     }
 }

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

@@ -70,6 +70,9 @@ public class DimensionConverter {
         if (dimensionReq.getExt() != null) {
             dimensionDO.setExt(JSONObject.toJSONString(dimensionReq.getExt()));
         }
+        if (dimensionReq.getTypeParams() != null) {
+            dimensionDO.setTypeParams(JSONObject.toJSONString(dimensionReq.getTypeParams()));
+        }
         dimensionDO.setStatus(StatusEnum.ONLINE.getCode());
         return dimensionDO;
     }

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

@@ -10,54 +10,58 @@ import com.tencent.supersonic.headless.api.pojo.request.MetricReq;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.util.CollectionUtils;
 
+import java.util.List;
+
 public class MetricCheckUtils {
 
-    public static void checkParam(MetricReq metricReq) {
+    public static void checkParam(List<MetricReq> metricReqList) {
-        String expr = "";
+        metricReqList.forEach(metricReq -> {
-        if (MetricDefineType.METRIC.equals(metricReq.getMetricDefineType())) {
+            String expr = "";
-            MetricDefineByMetricParams typeParams = metricReq.getMetricDefineByMetricParams();
+            if (MetricDefineType.METRIC.equals(metricReq.getMetricDefineType())) {
-            if (typeParams == null) {
+                MetricDefineByMetricParams typeParams = metricReq.getMetricDefineByMetricParams();
-                throw new InvalidArgumentException("指标定义参数不可为空");
+                if (typeParams == null) {
+                    throw new InvalidArgumentException("指标定义参数不可为空");
+                }
+                expr = typeParams.getExpr();
+                if (CollectionUtils.isEmpty(typeParams.getMetrics())) {
+                    throw new InvalidArgumentException("定义指标的指标列表参数不可为空");
+                }
+                if (hasAggregateFunction(expr)) {
+                    throw new InvalidArgumentException("基于指标来创建指标,表达式中不可再包含聚合函数");
+                }
             }
-            expr = typeParams.getExpr();
+            if (MetricDefineType.MEASURE.equals(metricReq.getMetricDefineType())) {
-            if (CollectionUtils.isEmpty(typeParams.getMetrics())) {
+                MetricDefineByMeasureParams typeParams = metricReq.getMetricDefineByMeasureParams();
-                throw new InvalidArgumentException("定义指标的指标列表参数不可为空");
+                if (typeParams == null) {
+                    throw new InvalidArgumentException("指标定义参数不可为空");
+                }
+                expr = typeParams.getExpr();
+                if (hasAggregateFunction(expr)) {
+                    throw new InvalidArgumentException("基于度量来创建指标,表达式中不可再包含聚合函数");
+                }
             }
-            if (hasAggregateFunction(expr)) {
+            if (MetricDefineType.FIELD.equals(metricReq.getMetricDefineType())) {
-                throw new InvalidArgumentException("基于指标来创建指标,表达式中不可再包含聚合函数");
+                MetricDefineByFieldParams typeParams = metricReq.getMetricDefineByFieldParams();
+                if (typeParams == null) {
+                    throw new InvalidArgumentException("指标定义参数不可为空");
+                }
+                expr = typeParams.getExpr();
+                // if (CollectionUtils.isEmpty(typeParams.getFields())) {
+                // throw new InvalidArgumentException("定义指标的字段列表参数不可为空");
+                // }
+                if (!hasAggregateFunction(expr)) {
+                    throw new InvalidArgumentException("基于字段来创建指标,表达式中必须包含聚合函数");
+                }
             }
-        }
+            if (StringUtils.isBlank(expr)) {
-        if (MetricDefineType.MEASURE.equals(metricReq.getMetricDefineType())) {
+                throw new InvalidArgumentException("表达式不可为空");
-            MetricDefineByMeasureParams typeParams = metricReq.getMetricDefineByMeasureParams();
-            if (typeParams == null) {
-                throw new InvalidArgumentException("指标定义参数不可为空");
             }
-            expr = typeParams.getExpr();
+            String forbiddenCharacters = NameCheckUtils.findForbiddenCharacters(metricReq.getName());
-            if (hasAggregateFunction(expr)) {
+            if (StringUtils.isNotBlank(forbiddenCharacters)) {
-                throw new InvalidArgumentException("基于度量来创建指标,表达式中不可再包含聚合函数");
+                throw new InvalidArgumentException(
+                        String.format("名称包含特殊字符%s, 请修改", forbiddenCharacters));
             }
-        }
+        });
-        if (MetricDefineType.FIELD.equals(metricReq.getMetricDefineType())) {
-            MetricDefineByFieldParams typeParams = metricReq.getMetricDefineByFieldParams();
-            if (typeParams == null) {
-                throw new InvalidArgumentException("指标定义参数不可为空");
-            }
-            expr = typeParams.getExpr();
-            // if (CollectionUtils.isEmpty(typeParams.getFields())) {
-            // throw new InvalidArgumentException("定义指标的字段列表参数不可为空");
-            // }
-            if (!hasAggregateFunction(expr)) {
-                throw new InvalidArgumentException("基于字段来创建指标,表达式中必须包含聚合函数");
-            }
-        }
-        if (StringUtils.isBlank(expr)) {
-            throw new InvalidArgumentException("表达式不可为空");
-        }
-        String forbiddenCharacters = NameCheckUtils.findForbiddenCharacters(metricReq.getName());
-        if (StringUtils.isNotBlank(forbiddenCharacters)) {
-            throw new InvalidArgumentException(
-                    String.format("名称包含特殊字符%s, 请修改", forbiddenCharacters));
-        }
     }
 
     private static boolean hasAggregateFunction(String expr) {

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

@@ -28,7 +28,7 @@ public class ModelConverter {
 
     public static ModelDO convert(ModelReq modelReq, User user) {
         ModelDO modelDO = new ModelDO();
-        ModelDetail modelDetail = createModelDetail(modelReq);
+        ModelDetail modelDetail = convert(modelReq);
         modelReq.createdBy(user.getName());
         BeanMapper.mapper(modelReq, modelDO);
         modelDO.setStatus(StatusEnum.ONLINE.getCode());
@@ -68,7 +68,7 @@ public class ModelConverter {
     }
 
     public static ModelDO convert(ModelDO modelDO, ModelReq modelReq, User user) {
-        ModelDetail modelDetail = updateModelDetail(modelReq);
+        ModelDetail modelDetail = convert(modelReq);
         BeanMapper.mapper(modelReq, modelDO);
         if (modelReq.getDrillDownDimensions() != null) {
             modelDO.setDrillDownDimensions(
@@ -143,7 +143,7 @@ public class ModelConverter {
     }
 
     public static ModelReq convert(ModelSchema modelSchema, ModelBuildReq modelBuildReq,
-            String tableName) {
+                                   String tableName) {
         ModelReq modelReq = new ModelReq();
         modelReq.setName(modelBuildReq.getName() != null ? modelBuildReq.getName() : tableName);
         modelReq.setBizName(
@@ -169,7 +169,7 @@ public class ModelConverter {
 
             if (getIdentifyType(fieldType) != null) {
                 Optional<Identify> optional = modelDetail.getIdentifiers().stream().filter(
-                        identify -> identify.getBizName().equals(semanticColumn.getColumnName()))
+                                identify -> identify.getBizName().equals(semanticColumn.getColumnName()))
                         .findAny();
                 if (optional.isEmpty()) {
                     Identify identify = new Identify(semanticColumn.getName(),
@@ -178,7 +178,7 @@ public class ModelConverter {
                 }
             } else if (FieldType.measure.equals(fieldType)) {
                 Optional<Measure> optional = modelDetail.getMeasures().stream().filter(
-                        measure -> measure.getBizName().equals(semanticColumn.getColumnName()))
+                                measure -> measure.getBizName().equals(semanticColumn.getColumnName()))
                         .findAny();
                 if (optional.isEmpty()) {
                     Measure measure = new Measure(semanticColumn.getName(),
@@ -188,7 +188,7 @@ public class ModelConverter {
                 }
             } else {
                 Optional<Dimension> optional = modelDetail.getDimensions().stream().filter(
-                        dimension -> dimension.getBizName().equals(semanticColumn.getColumnName()))
+                                dimension -> dimension.getBizName().equals(semanticColumn.getColumnName()))
                         .findAny();
                 if (optional.isEmpty()) {
                     Dimension dim = new Dimension(semanticColumn.getName(),
@@ -288,18 +288,21 @@ public class ModelConverter {
                 .collect(Collectors.toList());
     }
 
-    private static ModelDetail createModelDetail(ModelReq modelReq) {
+    private static ModelDetail convert(ModelReq modelReq) {
         ModelDetail modelDetail = new ModelDetail();
         List<Measure> measures = modelReq.getModelDetail().getMeasures();
         List<Dimension> dimensions = modelReq.getModelDetail().getDimensions();
         List<Identify> identifiers = modelReq.getModelDetail().getIdentifiers();
         List<Field> fields = modelReq.getModelDetail().getFields();
+        List<String> fieldNames = fields.stream().map(Field::getFieldName).collect(Collectors.toList());
 
         if (measures != null) {
             for (Measure measure : measures) {
                 if (StringUtils.isNotBlank(measure.getBizName())
                         && StringUtils.isBlank(measure.getExpr())) {
                     measure.setExpr(measure.getBizName());
+                }
+                if (StringUtils.isNotBlank(measure.getBizName()) && !fieldNames.contains(measure.getBizName())) {
                     fields.add(new Field(measure.getBizName(), ""));
                 }
             }
@@ -309,53 +312,24 @@ public class ModelConverter {
                 if (StringUtils.isNotBlank(dimension.getBizName())
                         && StringUtils.isBlank(dimension.getExpr())) {
                     dimension.setExpr(dimension.getBizName());
+                }
+                if (StringUtils.isNotBlank(dimension.getBizName()) && !fieldNames.contains(dimension.getBizName())) {
                     fields.add(new Field(dimension.getBizName(), ""));
                 }
             }
         }
         if (identifiers != null) {
             for (Identify identify : identifiers) {
-                if (StringUtils.isNotBlank(identify.getBizName())
+                if (StringUtils.isNotBlank(identify.getBizName()) && StringUtils.isBlank(identify.getName())) {
-                        && StringUtils.isBlank(identify.getName())) {
                     identify.setName(identify.getBizName());
                 }
                 identify.setIsCreateDimension(1);
-                fields.add(new Field(identify.getBizName(), ""));
+                if (StringUtils.isNotBlank(identify.getBizName()) && !fieldNames.contains(identify.getBizName())) {
-            }
+                    fields.add(new Field(identify.getBizName(), ""));
-        }
-
-        BeanMapper.mapper(modelReq.getModelDetail(), modelDetail);
-        return modelDetail;
-    }
-
-    private static ModelDetail updateModelDetail(ModelReq modelReq) {
-        ModelDetail modelDetail = new ModelDetail();
-        List<Measure> measures = modelReq.getModelDetail().getMeasures();
-        List<Dimension> dimensions = modelReq.getModelDetail().getDimensions();
-        if (!CollectionUtils.isEmpty(dimensions)) {
-            for (Dimension dimension : dimensions) {
-                if (StringUtils.isNotBlank(dimension.getBizName())
-                        && StringUtils.isBlank(dimension.getExpr())) {
-                    dimension.setExpr(dimension.getBizName());
                 }
             }
         }
-        if (measures == null) {
-            measures = Lists.newArrayList();
-        }
-        for (Measure measure : measures) {
-            if (StringUtils.isBlank(measure.getBizName())) {
-                continue;
-            }
-            // Compatible with front-end tmp
 
-            String oriFieldName =
-                    measure.getBizName().replaceFirst(modelReq.getBizName() + "_", "");
-            measure.setExpr(oriFieldName);
-            if (!measure.getBizName().startsWith(modelReq.getBizName())) {
-                measure.setBizName(String.format("%s_%s", modelReq.getBizName(), oriFieldName));
-            }
-        }
         BeanMapper.mapper(modelReq.getModelDetail(), modelDetail);
         return modelDetail;
     }

headless/server/src/main/resources/mapper/custom/DimensionDOCustomMapper.xml

@@ -3,26 +3,27 @@
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.tencent.supersonic.headless.server.persistence.mapper.DimensionDOCustomMapper">
     <resultMap id="BaseResultMap" type="com.tencent.supersonic.headless.server.persistence.dataobject.DimensionDO">
-        <id column="id" jdbcType="BIGINT" property="id" />
+        <id column="id" jdbcType="BIGINT" property="id"/>
-        <result column="model_id" jdbcType="BIGINT" property="modelId" />
+        <result column="model_id" jdbcType="BIGINT" property="modelId"/>
-        <result column="name" jdbcType="VARCHAR" property="name" />
+        <result column="name" jdbcType="VARCHAR" property="name"/>
-        <result column="biz_name" jdbcType="VARCHAR" property="bizName" />
+        <result column="biz_name" jdbcType="VARCHAR" property="bizName"/>
-        <result column="description" jdbcType="VARCHAR" property="description" />
+        <result column="description" jdbcType="VARCHAR" property="description"/>
-        <result column="status" jdbcType="INTEGER" property="status" />
+        <result column="status" jdbcType="INTEGER" property="status"/>
-        <result column="sensitive_level" jdbcType="INTEGER" property="sensitiveLevel" />
+        <result column="sensitive_level" jdbcType="INTEGER" property="sensitiveLevel"/>
-        <result column="type" jdbcType="VARCHAR" property="type" />
+        <result column="type" jdbcType="VARCHAR" property="type"/>
-        <result column="created_at" jdbcType="TIMESTAMP" property="createdAt" />
+        <result column="created_at" jdbcType="TIMESTAMP" property="createdAt"/>
-        <result column="created_by" jdbcType="VARCHAR" property="createdBy" />
+        <result column="created_by" jdbcType="VARCHAR" property="createdBy"/>
-        <result column="updated_at" jdbcType="TIMESTAMP" property="updatedAt" />
+        <result column="updated_at" jdbcType="TIMESTAMP" property="updatedAt"/>
-        <result column="updated_by" jdbcType="VARCHAR" property="updatedBy" />
+        <result column="updated_by" jdbcType="VARCHAR" property="updatedBy"/>
-        <result column="semantic_type" jdbcType="VARCHAR" property="semanticType" />
+        <result column="semantic_type" jdbcType="VARCHAR" property="semanticType"/>
-        <result column="alias" jdbcType="VARCHAR" property="alias" />
+        <result column="alias" jdbcType="VARCHAR" property="alias"/>
-        <result column="default_values" jdbcType="VARCHAR" property="defaultValues" />
+        <result column="default_values" jdbcType="VARCHAR" property="defaultValues"/>
-        <result column="dim_value_maps" jdbcType="VARCHAR" property="dimValueMaps" />
+        <result column="dim_value_maps" jdbcType="VARCHAR" property="dimValueMaps"/>
     </resultMap>
-    <resultMap extends="BaseResultMap" id="ResultMapWithBLOBs" type="com.tencent.supersonic.headless.server.persistence.dataobject.DimensionDO">
+    <resultMap extends="BaseResultMap" id="ResultMapWithBLOBs"
-        <result column="type_params" jdbcType="LONGVARCHAR" property="typeParams" />
+               type="com.tencent.supersonic.headless.server.persistence.dataobject.DimensionDO">
-        <result column="expr" jdbcType="LONGVARCHAR" property="expr" />
+        <result column="type_params" jdbcType="LONGVARCHAR" property="typeParams"/>
+        <result column="expr" jdbcType="LONGVARCHAR" property="expr"/>
     </resultMap>
 
 
@@ -46,7 +47,7 @@
                                 <when test="criterion.listValue">
                                     and ${criterion.condition}
                                     <foreach close=")" collection="criterion.value" item="listItem"
-                                            open="(" separator=",">
+                                             open="(" separator=",">
                                         #{listItem}
                                     </foreach>
                                 </when>
@@ -59,7 +60,7 @@
     </sql>
     <sql id="Base_Column_List">
         id
-        , name, biz_name, description, status, model_id, type, type_params, expr, datasource_id,
+        , name, biz_name, description, status, model_id, type, type_params, expr,
     created_at, created_by, updated_by, updated_at, semantic_type
     </sql>
 
@@ -86,21 +87,36 @@
     <update id="batchUpdate" parameterType="java.util.List">
         <foreach collection="list" item="dimension" separator=";">
             update s2_dimension
-            set name = #{dimension.name,jdbcType=VARCHAR},
+            set
-            biz_name = #{dimension.bizName,jdbcType=VARCHAR},
+            <if test="dimension.name != null and dimension.name !=''">name = #{dimension.name,jdbcType=VARCHAR},</if>
-            description = #{dimension.description,jdbcType=VARCHAR},
+            <if test="dimension.bizName != null and dimension.bizName !=''">biz_name =
-            status = #{dimension.status,jdbcType=INTEGER},
+                #{dimension.bizName,jdbcType=VARCHAR},
-            model_id = #{dimension.modelId,jdbcType=BIGINT},
+            </if>
-            type = #{dimension.type,jdbcType=VARCHAR},
+            <if test="dimension.description != null and dimension.description !=''">description =
-            type_params = #{dimension.typeParams,jdbcType=VARCHAR},
+                #{dimension.description,jdbcType=VARCHAR},
-            datasource_id = #{dimension.datasourceId,jdbcType=BIGINT},
+            </if>
-            created_at = #{dimension.createdAt,jdbcType=TIMESTAMP},
+            <if test="dimension.status != null">status = #{dimension.status,jdbcType=INTEGER},</if>
-            created_by = #{dimension.createdBy,jdbcType=VARCHAR},
+            <if test="dimension.modelId != null">model_id = #{dimension.modelId,jdbcType=BIGINT},</if>
-            updated_by = #{dimension.updatedBy,jdbcType=VARCHAR},
+            <if test="dimension.type != null and dimension.type !=''">type = #{dimension.type,jdbcType=VARCHAR},</if>
-            updated_at = #{dimension.updatedAt,jdbcType=TIMESTAMP},
+            <if test="dimension.typeParams != null and dimension.typeParams !=''">type_params =
-            semantic_type = #{dimension.semanticType,jdbcType=VARCHAR},
+                #{dimension.typeParams,jdbcType=VARCHAR},
-            sensitive_level = #{dimension.sensitiveLevel,jdbcType=INTEGER},
+            </if>
-            expr = #{dimension.expr,jdbcType=LONGVARCHAR}
+            <if test="dimension.createdAt != null">created_at = #{dimension.createdAt,jdbcType=TIMESTAMP},</if>
+            <if test="dimension.createdBy != null and dimension.createdBy !=''">created_by =
+                #{dimension.createdBy,jdbcType=VARCHAR},
+            </if>
+            <if test="dimension.semanticType != null and dimension.semanticType !=''">semantic_type =
+                #{dimension.semanticType,jdbcType=VARCHAR},
+            </if>
+            <if test="dimension.sensitiveLevel != null and dimension.sensitiveLevel !=''">sensitive_level =
+                #{dimension.sensitiveLevel,jdbcType=INTEGER},
+            </if>
+            <if test="dimension.expr != null and dimension.expr !=''">expr = #{dimension.expr,jdbcType=LONGVARCHAR},
+            </if>
+            <if test="dimension.updatedBy != null and dimension.updatedBy !=''">updated_by =
+                #{dimension.updatedBy,jdbcType=VARCHAR},
+            </if>
+            <if test="dimension.updatedAt != null">updated_at = #{dimension.updatedAt,jdbcType=TIMESTAMP}</if>
             where id = #{dimension.id,jdbcType=BIGINT}
         </foreach>
     </update>
@@ -123,14 +139,14 @@
         <if test="modelIds != null and modelIds.size >0">
             and model_id in
             <foreach collection="modelIds" index="index" item="model" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{model}
             </foreach>
         </if>
         <if test="dimensionIds != null and dimensionIds.size >0">
             and id in
             <foreach collection="dimensionIds" index="index" item="dimensionId" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{dimensionId}
             </foreach>
         </if>
@@ -138,13 +154,13 @@
             AND (
             (name IN
             <foreach collection="dimensionNames" index="index" item="dimensionName" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{dimensionName}
             </foreach>)
             OR
             (biz_name IN
             <foreach collection="dimensionNames" index="index" item="dimensionName" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{dimensionName}
             </foreach>)
             )

headless/server/src/main/resources/mapper/custom/MetricDOCustomMapper.xml

@@ -3,7 +3,7 @@
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.tencent.supersonic.headless.server.persistence.mapper.MetricDOCustomMapper">
     <resultMap id="BaseResultMap"
-            type="com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO">
+               type="com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO">
         <id column="id" jdbcType="BIGINT" property="id"/>
         <result column="model_id" jdbcType="BIGINT" property="modelId"/>
         <result column="name" jdbcType="VARCHAR" property="name"/>
@@ -23,7 +23,7 @@
         <result column="define_type" jdbcType="VARCHAR" property="defineType"/>
     </resultMap>
     <resultMap extends="BaseResultMap" id="ResultMapWithBLOBs"
-            type="com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO">
+               type="com.tencent.supersonic.headless.server.persistence.dataobject.MetricDO">
         <result column="type_params" jdbcType="LONGVARCHAR" property="typeParams"/>
     </resultMap>
     <sql id="Example_Where_Clause">
@@ -46,7 +46,7 @@
                                 <when test="criterion.listValue">
                                     and ${criterion.condition}
                                     <foreach close=")" collection="criterion.value" item="listItem"
-                                            open="(" separator=",">
+                                             open="(" separator=",">
                                         #{listItem}
                                     </foreach>
                                 </when>
@@ -97,6 +97,35 @@
         </foreach>
     </update>
 
+    <update id="batchUpdate" parameterType="java.util.List">
+        <foreach collection="list" item="metric" separator=";">
+            update s2_metric
+            set
+            <if test="metric.name != null and metric.name !=''">name = #{metric.name,jdbcType=VARCHAR},</if>
+            <if test="metric.bizName != null and metric.bizName !=''">biz_name = #{metric.bizName,jdbcType=VARCHAR},
+            </if>
+            <if test="metric.description != null and metric.description !=''">description =
+                #{metric.description,jdbcType=VARCHAR},
+            </if>
+            <if test="metric.status != null">status = #{metric.status,jdbcType=INTEGER},</if>
+            <if test="metric.modelId != null">model_id = #{metric.modelId,jdbcType=BIGINT},</if>
+            <if test="metric.type != null and metric.type !=''">type = #{metric.type,jdbcType=VARCHAR},</if>
+            <if test="metric.typeParams != null and metric.typeParams !=''">type_params =
+                #{metric.typeParams,jdbcType=VARCHAR},
+            </if>
+            <if test="metric.createdAt != null">created_at = #{metric.createdAt,jdbcType=TIMESTAMP},</if>
+            <if test="metric.createdBy != null and dimension.createdBy !=''">created_by =
+                #{metric.createdBy,jdbcType=VARCHAR},
+            </if>
+            <if test="metric.sensitiveLevel != null">sensitive_level = #{metric.sensitiveLevel,jdbcType=INTEGER},</if>
+            <if test="metric.updatedBy != null and metric.updatedBy !=''">updated_by =
+                #{metric.updatedBy,jdbcType=VARCHAR},
+            </if>
+            <if test="metric.updatedAt != null">updated_at = #{metric.updatedAt,jdbcType=TIMESTAMP}</if>
+            where id = #{metric.id,jdbcType=BIGINT}
+        </foreach>
+    </update>
+
     <update id="batchPublish" parameterType="java.util.List">
         <foreach collection="list" item="metric" separator=";">
             update s2_metric
@@ -134,14 +163,14 @@
         <if test="modelIds != null and modelIds.size >0">
             and model_id in
             <foreach collection="modelIds" index="index" item="model" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{model}
             </foreach>
         </if>
         <if test="metricIds != null  and metricIds.size >0">
             and id in
             <foreach collection="metricIds" index="index" item="metricId" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{metricId}
             </foreach>
         </if>
@@ -149,13 +178,13 @@
             AND (
             (name IN
             <foreach collection="metricNames" index="index" item="metricName" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{metricName}
             </foreach>)
             OR
             (biz_name IN
             <foreach collection="metricNames" index="index" item="metricName" open="(" close=")"
-                    separator=",">
+                     separator=",">
                 #{metricName}
             </foreach>)
             )

webapp/packages/chat-sdk/src/Chat/Conversation/style.module.less

@@ -1,8 +1,11 @@
 .conversation {
   position: relative;
-  width: 0;
+  width: 248px;
   height: 100%;
-  background: #fff;
+  background: #f9f9f9;
+  padding: 10px 10px;
+  border-right: 1px solid #f1f1f1;
+
 
   .rightSection {
     width: 100%;

webapp/packages/supersonic-fe/src/pages/SemanticModel/components/ClassDimensionTable.tsx

@@ -435,17 +435,17 @@ const ClassDimensionTable: React.FC<Props> = ({}) => {
           queryDimensionList({ ...filterParams, ...currentPagin });
         }}
         toolBarRender={() => [
-          <Button
+          // <Button
-            key="create"
+          //   key="create"
-            type="primary"
+          //   type="primary"
-            onClick={() => {
+          //   onClick={() => {
-              toDimensionEditPage(domainId, modelId!, 0);
+          //     toDimensionEditPage(domainId, modelId!, 0);
-              // setDimensionItem(undefined);
+          //     // setDimensionItem(undefined);
-              // setCreateModalVisible(true);
+          //     // setCreateModalVisible(true);
-            }}
+          //   }}
-          >
+          // >
-            创建维度
+          //   创建维度
-          </Button>,
+          // </Button>,
           <BatchCtrlDropDownButton
             key="ctrlBtnList"
             extenderList={['batchSensitiveLevel', 'exportTagButton']}

webapp/packages/supersonic-fe/src/pages/SemanticModel/components/MetricInfoCreateForm.tsx

@@ -367,6 +367,15 @@ const MetricInfoCreateForm: React.FC<CreateFormProps> = ({
       message.error('请输入度量表达式');
       return;
     }
+
+    if (defineType === METRIC_DEFINE_TYPE.MEASURE) {
+      const { bizName, name, metricDefineByMeasureParams } = queryParams;
+      queryParams[queryParamsTypeParamsKey[METRIC_DEFINE_TYPE.MEASURE]].measures =
+        metricDefineByMeasureParams.measures.map((item: ISemantic.IMeasure) => {
+          return item.bizName === bizName && name ? { ...item, name } : item;
+        });
+    }
+
     if (!dataFormatType) {
       delete queryParams.dataFormat;
     }

webapp/packages/supersonic-fe/src/pages/SemanticModel/components/MetricMeasuresFormTable.tsx

@@ -75,6 +75,14 @@ const MetricMeasuresFormTable: React.FC<Props> = ({
     return tableData;
   };
 
+  useEffect(() => {
+    if (measuresParams?.measures) {
+      setSelectedKeys(measuresParams.measures.map((item: ISemantic.IMeasure) => item.bizName));
+    }
+    typeParams?.expr && setExprString(typeParams.expr);
+  }, [measuresParams, typeParams?.expr]);
+
+
   useEffect(() => {
     setTableData(getTableData());
   }, [measuresList, measuresParams]);
@@ -211,8 +219,8 @@ const MetricMeasuresFormTable: React.FC<Props> = ({
         <Divider style={{ marginBottom: 0 }} />
         <ProCard
           title={<FormLabelRequire title="表达式" />}
-          // tooltip="由于度量已自带聚合函数，因此通过度量创建指标时，表达式中无需再写聚合函数，如
+        // tooltip="由于度量已自带聚合函数，因此通过度量创建指标时，表达式中无需再写聚合函数，如
-          // 通过度量a和度量b来创建指标，由于建模的时候度量a和度量b被指定了聚合函数SUM，因此创建指标时表达式只需要写成 a+b, 而不需要带聚合函数"
+        // 通过度量a和度量b来创建指标，由于建模的时候度量a和度量b被指定了聚合函数SUM，因此创建指标时表达式只需要写成 a+b, 而不需要带聚合函数"
         >
           <p
             className={styles.desc}