(improvement)(Headless) Put term into dict and let it can be mapped by mapper (#1002)

2025-12-14 22:25:19 +00:00 · 2024-05-16 10:15:04 +08:00
parent 21af74c674
commit 55c625a915
34 changed files with 292 additions and 137 deletions
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/dataobject/TermSetDO.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/dataobject/TermSetDO.java
@@ -4,18 +4,23 @@ import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
+
 import java.util.Date;

@Data
-@TableName("s2_term_set")
-public class TermSetDO {
+@TableName("s2_term")
+public class TermDO {

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    private Long domainId;

-    private String terms;
+    private String name;
+
+    private String description;
+
+    private String alias;

    private Date createdAt;

--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/mapper/TermSetMapper.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/mapper/TermSetMapper.java
@@ -1,11 +1,11 @@
 package com.tencent.supersonic.headless.server.persistence.mapper;

 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.tencent.supersonic.headless.server.persistence.dataobject.TermSetDO;
+import com.tencent.supersonic.headless.server.persistence.dataobject.TermDO;
 import org.apache.ibatis.annotations.Mapper;

@Mapper
-public interface TermSetMapper extends BaseMapper<TermSetDO> {
+public interface TermMapper extends BaseMapper<TermDO> {


 }
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/DomainController.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/DomainController.java
@@ -32,21 +32,19 @@ public class DomainController {
    }

    @PostMapping("/createDomain")
-    public Boolean createDomain(@RequestBody DomainReq domainReq,
+    public DomainResp createDomain(@RequestBody DomainReq domainReq,
                                HttpServletRequest request,
                                HttpServletResponse response) {
        User user = UserHolder.findUser(request, response);
-        domainService.createDomain(domainReq, user);
-        return true;
+        return domainService.createDomain(domainReq, user);
    }

    @PostMapping("/updateDomain")
-    public Boolean updateDomain(@RequestBody DomainUpdateReq domainUpdateReq,
+    public DomainResp updateDomain(@RequestBody DomainUpdateReq domainUpdateReq,
                                HttpServletRequest request,
                                HttpServletResponse response) {
        User user = UserHolder.findUser(request, response);
-        domainService.updateDomain(domainUpdateReq, user);
-        return true;
+        return domainService.updateDomain(domainUpdateReq, user);
    }

    @DeleteMapping("/deleteDomain/{domainId}")
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/TermController.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/TermController.java
@@ -2,11 +2,13 @@ package com.tencent.supersonic.headless.server.rest;

 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.utils.UserHolder;
-import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
-import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
+import com.tencent.supersonic.headless.api.pojo.request.TermReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermResp;
 import com.tencent.supersonic.headless.server.service.TermService;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -15,6 +17,7 @@ import org.springframework.web.bind.annotation.RestController;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.util.List;

@RestController
@RequestMapping("/api/semantic/term")
@@ -24,17 +27,23 @@ public class TermController {
    private TermService termService;

    @PostMapping("/saveOrUpdate")
-    public boolean saveOrUpdate(@RequestBody TermSetReq termSetReq,
+    public boolean saveOrUpdate(@RequestBody TermReq termReq,
                             HttpServletRequest request,
                             HttpServletResponse response) {
        User user = UserHolder.findUser(request, response);
-        termService.saveOrUpdate(termSetReq, user);
+        termService.saveOrUpdate(termReq, user);
        return true;
    }

    @GetMapping
-    public TermSetResp getTermSet(@RequestParam("domainId") Long domainId) {
-        return termService.getTermSet(domainId);
+    public List<TermResp> getTerms(@RequestParam("domainId") Long domainId) {
+        return termService.getTerms(domainId);
+    }
+
+    @DeleteMapping("/{id}")
+    public boolean delete(@PathVariable("id") Long id) {
+        termService.delete(id);
+        return true;
    }

 }
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/DomainService.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/DomainService.java
@@ -16,9 +16,9 @@ public interface DomainService {

    Map<Long, String> getDomainFullPath();

-    void createDomain(DomainReq domainReq, User user);
+    DomainResp createDomain(DomainReq domainReq, User user);

-    void updateDomain(DomainUpdateReq domainUpdateReq, User user);
+    DomainResp updateDomain(DomainUpdateReq domainUpdateReq, User user);

    void deleteDomain(Long id);

--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/TermService.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/TermService.java
@@ -2,9 +2,8 @@ package com.tencent.supersonic.headless.server.service;


 import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.headless.api.pojo.Term;
-import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
-import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
+import com.tencent.supersonic.headless.api.pojo.request.TermReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermResp;

 import java.util.List;
 import java.util.Map;
@@ -12,10 +11,12 @@ import java.util.Set;

 public interface TermService {

-    void saveOrUpdate(TermSetReq termSetReq, User user);
+    void saveOrUpdate(TermReq termSetReq, User user);

-    TermSetResp getTermSet(Long domainId);
+    void delete(Long id);

-    Map<Long, List<Term>> getTermSets(Set<Long> domainIds);
+    List<TermResp> getTerms(Long domainId);
+
+    Map<Long, List<TermResp>> getTermSets(Set<Long> domainIds);

 }
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/DomainServiceImpl.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/DomainServiceImpl.java
@@ -57,18 +57,20 @@ public class DomainServiceImpl implements DomainService {
    }

    @Override
-    public void createDomain(DomainReq domainReq, User user) {
+    public DomainResp createDomain(DomainReq domainReq, User user) {
        DomainDO domainDO = DomainConvert.convert(domainReq, user);
        domainDO.setStatus(StatusEnum.ONLINE.getCode());
        domainRepository.createDomain(domainDO);
+        return DomainConvert.convert(domainDO);
    }

    @Override
-    public void updateDomain(DomainUpdateReq domainUpdateReq, User user) {
+    public DomainResp updateDomain(DomainUpdateReq domainUpdateReq, User user) {
        domainUpdateReq.updatedBy(user.getName());
        DomainDO domainDO = getDomainDO(domainUpdateReq.getId());
        BeanMapper.mapper(domainUpdateReq, domainDO);
        domainRepository.updateDomain(domainDO);
+        return DomainConvert.convert(domainDO);
    }

    @Override
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/MetaDiscoveryServiceImpl.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/MetaDiscoveryServiceImpl.java
@@ -8,7 +8,6 @@ import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
 import com.tencent.supersonic.headless.api.pojo.SchemaItem;
 import com.tencent.supersonic.headless.api.pojo.SchemaMapInfo;
 import com.tencent.supersonic.headless.api.pojo.SemanticSchema;
-import com.tencent.supersonic.headless.api.pojo.Term;
 import com.tencent.supersonic.headless.api.pojo.request.QueryMapReq;
 import com.tencent.supersonic.headless.api.pojo.request.QueryReq;
 import com.tencent.supersonic.headless.api.pojo.response.DataSetMapInfo;
@@ -20,7 +19,6 @@ import com.tencent.supersonic.headless.server.pojo.MetaFilter;
 import com.tencent.supersonic.headless.server.service.ChatQueryService;
 import com.tencent.supersonic.headless.server.service.DataSetService;
 import com.tencent.supersonic.headless.server.service.MetaDiscoveryService;
-import com.tencent.supersonic.headless.server.service.TermService;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -48,9 +46,6 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
    @Autowired
    private SemanticService semanticService;

-    @Autowired
-    private TermService termService;
-
    @Override
    public MapInfoResp getMapMeta(QueryMapReq queryMapReq) {

@@ -77,7 +72,7 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
        Map<Long, DataSetResp> dataSetMap = dataSetList.stream()
                .collect(Collectors.toMap(DataSetResp::getId, d -> d));
        mapInfoResp.setDataSetMapInfo(getDataSetInfo(mapResp.getMapInfo(), dataSetMap, topN));
-        mapInfoResp.setTerms(getTerms(dataSetList, dataSetMap));
+        mapInfoResp.setTerms(getTerms(mapResp.getMapInfo(), dataSetMap));
        return mapInfoResp;
    }

@@ -109,7 +104,10 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
                                                               Map<Long, DataSetResp> dataSetMap) {
        Map<Long, List<SchemaElementMatch>> result = new HashMap<>();
        for (Map.Entry<Long, List<SchemaElementMatch>> entry : mapInfo.getDataSetElementMatches().entrySet()) {
-            List<SchemaElementMatch> values = entry.getValue();
+            List<SchemaElementMatch> values = entry.getValue().stream()
+                    .filter(schemaElementMatch ->
+                            !SchemaElementType.TERM.equals(schemaElementMatch.getElement().getType()))
+                    .collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(values) && dataSetMap.containsKey(entry.getKey())) {
                result.put(entry.getKey(), values);
            }
@@ -150,17 +148,21 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
        return result;
    }

-    private Map<String, List<Term>> getTerms(List<DataSetResp> dataSets, Map<Long, DataSetResp> dataSetNameMap) {
-        Set<Long> domainIds = dataSets.stream().map(DataSetResp::getDomainId).collect(Collectors.toSet());
-        Map<Long, Long> dataSetDomainIdMap = dataSets.stream()
-                .collect(Collectors.toMap(DataSetResp::getId, DataSetResp::getDomainId));
-        Map<Long, List<Term>> domainTermSetMap = termService.getTermSets(domainIds);
-        Map<String, List<Term>> dataSetTermSetMap = new HashMap<>();
-        for (DataSetResp dataSet : dataSets) {
-            dataSetTermSetMap.put(dataSetNameMap.get(dataSet.getId()).getName(),
-                    domainTermSetMap.get(dataSetDomainIdMap.get(dataSet.getId())));
+    private Map<String, List<SchemaElementMatch>> getTerms(SchemaMapInfo mapInfo,
+                                                           Map<Long, DataSetResp> dataSetNameMap) {
+        Map<String, List<SchemaElementMatch>> termMap = new HashMap<>();
+        Map<Long, List<SchemaElementMatch>> dataSetElementMatches = mapInfo.getDataSetElementMatches();
+        for (Map.Entry<Long, List<SchemaElementMatch>> entry : dataSetElementMatches.entrySet()) {
+            DataSetResp dataSetResp = dataSetNameMap.get(entry.getKey());
+            if (dataSetResp == null) {
+                continue;
+            }
+            List<SchemaElementMatch> terms = entry.getValue().stream().filter(schemaElementMatch
+                            -> SchemaElementType.TERM.equals(schemaElementMatch.getElement().getType()))
+                    .collect(Collectors.toList());
+            termMap.put(dataSetResp.getName(), terms);
        }
-        return dataSetTermSetMap;
+        return termMap;
    }

    /***
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/SchemaServiceImpl.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/SchemaServiceImpl.java
@@ -33,6 +33,7 @@ import com.tencent.supersonic.headless.api.pojo.response.ModelResp;
 import com.tencent.supersonic.headless.api.pojo.response.ModelSchemaResp;
 import com.tencent.supersonic.headless.api.pojo.response.SemanticSchemaResp;
 import com.tencent.supersonic.headless.api.pojo.response.TagResp;
+import com.tencent.supersonic.headless.api.pojo.response.TermResp;
 import com.tencent.supersonic.headless.server.pojo.MetaFilter;
 import com.tencent.supersonic.headless.server.pojo.ModelFilter;
 import com.tencent.supersonic.headless.server.pojo.TagFilter;
@@ -44,6 +45,7 @@ import com.tencent.supersonic.headless.server.service.ModelRelaService;
 import com.tencent.supersonic.headless.server.service.ModelService;
 import com.tencent.supersonic.headless.server.service.SchemaService;
 import com.tencent.supersonic.headless.server.service.TagMetaService;
+import com.tencent.supersonic.headless.server.service.TermService;
 import com.tencent.supersonic.headless.server.utils.DataSetSchemaBuilder;
 import com.tencent.supersonic.headless.server.utils.DimensionConverter;
 import com.tencent.supersonic.headless.server.utils.MetricConverter;
@@ -60,6 +62,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;

@@ -86,6 +89,7 @@ public class SchemaServiceImpl implements SchemaService {
    private final DataSetService dataSetService;
    private final ModelRelaService modelRelaService;
    private final TagMetaService tagService;
+    private final TermService termService;

    public SchemaServiceImpl(ModelService modelService,
            DimensionService dimensionService,
@@ -93,7 +97,7 @@ public class SchemaServiceImpl implements SchemaService {
            DomainService domainService,
            DataSetService dataSetService,
            ModelRelaService modelRelaService,
-            StatUtils statUtils, TagMetaService tagService) {
+            StatUtils statUtils, TagMetaService tagService, TermService termService) {
        this.modelService = modelService;
        this.dimensionService = dimensionService;
        this.metricService = metricService;
@@ -102,6 +106,7 @@ public class SchemaServiceImpl implements SchemaService {
        this.modelRelaService = modelRelaService;
        this.statUtils = statUtils;
        this.tagService = tagService;
+        this.termService = termService;
    }

    @SneakyThrows
@@ -165,9 +170,12 @@ public class SchemaServiceImpl implements SchemaService {
        metaFilter.setIds(filter.getDataSetIds());
        List<DataSetResp> dataSetResps = dataSetService.getDataSetList(metaFilter);
        Map<Long, DataSetResp> dataSetRespMap = getDataSetMap(dataSetResps);
-
+        Set<Long> domainIds = dataSetResps.stream().map(DataSetResp::getDomainId)
+                .collect(Collectors.toSet());
        List<Long> modelIds = dataSetRespMap.values().stream().map(DataSetResp::getAllModels)
                .flatMap(Collection::stream).collect(Collectors.toList());
+        Map<Long, List<TermResp>> termMaps = termService.getTermSets(domainIds);
+

        metaFilter.setModelIds(modelIds);
        metaFilter.setIds(Lists.newArrayList());
@@ -198,7 +206,7 @@ public class SchemaServiceImpl implements SchemaService {
            dataSetSchemaResp.setMetrics(metricSchemaResps);
            dataSetSchemaResp.setModelResps(modelResps.stream().filter(modelResp ->
                    dataSetResp.getAllModels().contains(modelResp.getId())).collect(Collectors.toList()));
-
+            dataSetSchemaResp.setTermResps(termMaps.getOrDefault(dataSetResp.getDomainId(), Lists.newArrayList()));
            dataSetSchemaResps.add(dataSetSchemaResp);
        }
        fillStaticInfo(dataSetSchemaResps);
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/TermServiceImpl.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/TermServiceImpl.java
@@ -5,11 +5,10 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.common.util.BeanMapper;
 import com.tencent.supersonic.common.util.JsonUtil;
-import com.tencent.supersonic.headless.api.pojo.Term;
-import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
-import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
-import com.tencent.supersonic.headless.server.persistence.dataobject.TermSetDO;
-import com.tencent.supersonic.headless.server.persistence.mapper.TermSetMapper;
+import com.tencent.supersonic.headless.api.pojo.request.TermReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermResp;
+import com.tencent.supersonic.headless.server.persistence.dataobject.TermDO;
+import com.tencent.supersonic.headless.server.persistence.mapper.TermMapper;
 import com.tencent.supersonic.headless.server.service.TermService;
 import org.springframework.stereotype.Service;
 import java.util.List;
@@ -19,48 +18,49 @@ import java.util.stream.Collectors;


@Service
-public class TermServiceImpl extends ServiceImpl<TermSetMapper, TermSetDO> implements TermService {
+public class TermServiceImpl extends ServiceImpl<TermMapper, TermDO> implements TermService {

    @Override
-    public void saveOrUpdate(TermSetReq termSetReq, User user) {
-        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
-        queryWrapper.lambda().eq(TermSetDO::getDomainId, termSetReq.getDomainId());
-        TermSetDO termSetDO = getOne(queryWrapper);
+    public void saveOrUpdate(TermReq termSetReq, User user) {
+        QueryWrapper<TermDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().eq(TermDO::getId, termSetReq.getId());
+        TermDO termSetDO = getOne(queryWrapper);
        if (termSetDO == null) {
            termSetReq.createdBy(user.getName());
-            termSetDO = new TermSetDO();
+            termSetDO = new TermDO();
        }
        termSetReq.updatedBy(user.getName());
        BeanMapper.mapper(termSetReq, termSetDO);
-        termSetDO.setTerms(JsonUtil.toString(termSetReq.getTerms()));
+        termSetDO.setAlias(JsonUtil.toString(termSetReq.getAlias()));
        saveOrUpdate(termSetDO);
    }

    @Override
-    public TermSetResp getTermSet(Long domainId) {
-        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
-        queryWrapper.lambda().eq(TermSetDO::getDomainId, domainId);
-        TermSetDO termSetDO = getOne(queryWrapper);
-        TermSetResp termSetResp = new TermSetResp(domainId);
-        if (termSetDO == null) {
-            return termSetResp;
-        }
-        return convert(termSetDO);
+    public void delete(Long id) {
+        removeById(id);
    }

    @Override
-    public Map<Long, List<Term>> getTermSets(Set<Long> domainIds) {
-        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
-        queryWrapper.lambda().in(TermSetDO::getDomainId, domainIds);
-        List<TermSetDO> list = list(queryWrapper);
-        return list.stream().map(this::convert).collect(
-                Collectors.toMap(TermSetResp::getDomainId, TermSetResp::getTerms, (k1, k2) -> k1));
+    public List<TermResp> getTerms(Long domainId) {
+        QueryWrapper<TermDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().eq(TermDO::getDomainId, domainId);
+        List<TermDO> termDOS = list(queryWrapper);
+        return termDOS.stream().map(this::convert).collect(Collectors.toList());
    }

-    private TermSetResp convert(TermSetDO termSetDO) {
-        TermSetResp termSetResp = new TermSetResp();
+    @Override
+    public Map<Long, List<TermResp>> getTermSets(Set<Long> domainIds) {
+        QueryWrapper<TermDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().in(TermDO::getDomainId, domainIds);
+        List<TermDO> list = list(queryWrapper);
+        return list.stream().map(this::convert).collect(
+                Collectors.groupingBy(TermResp::getDomainId));
+    }
+
+    private TermResp convert(TermDO termSetDO) {
+        TermResp termSetResp = new TermResp();
        BeanMapper.mapper(termSetDO, termSetResp);
-        termSetResp.setTerms(JsonUtil.toList(termSetDO.getTerms(), Term.class));
+        termSetResp.setAlias(JsonUtil.toList(termSetDO.getAlias(), String.class));
        return termSetResp;
    }

--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/WordService.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/WordService.java
@@ -2,6 +2,7 @@ package com.tencent.supersonic.headless.server.service.impl;

 import com.tencent.supersonic.common.pojo.enums.DictWordType;
 import com.tencent.supersonic.headless.api.pojo.SchemaElement;
+import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
 import com.tencent.supersonic.headless.api.pojo.SemanticSchema;
 import com.tencent.supersonic.headless.core.chat.knowledge.DictWord;
 import com.tencent.supersonic.headless.core.chat.knowledge.builder.WordBuilderFactory;
@@ -9,6 +10,7 @@ import com.tencent.supersonic.headless.server.service.SchemaService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;

 import java.util.ArrayList;
 import java.util.List;
@@ -34,7 +36,7 @@ public class WordService {
        addWordsByType(DictWordType.METRIC, semanticSchema.getMetrics(), words);
        addWordsByType(DictWordType.ENTITY, semanticSchema.getEntities(), words);
        addWordsByType(DictWordType.VALUE, semanticSchema.getDimensionValues(), words);
-
+        addWordsByType(DictWordType.TERM, semanticSchema.getTerms(), words);
        return words;
    }

@@ -54,6 +56,12 @@ public class WordService {
    }

    private List<SchemaElement> distinct(List<SchemaElement> metas) {
+        if (CollectionUtils.isEmpty(metas)) {
+            return metas;
+        }
+        if (SchemaElementType.TERM.equals(metas.get(0).getType())) {
+            return metas;
+        }
        return metas.stream()
                .collect(Collectors.toMap(SchemaElement::getId, Function.identity(), (e1, e2) -> e1))
                .values()
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/DataSetSchemaBuilder.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/DataSetSchemaBuilder.java
@@ -12,6 +12,7 @@ import com.tencent.supersonic.headless.api.pojo.SchemaValueMap;
 import com.tencent.supersonic.headless.api.pojo.response.DataSetSchemaResp;
 import com.tencent.supersonic.headless.api.pojo.response.DimSchemaResp;
 import com.tencent.supersonic.headless.api.pojo.response.MetricSchemaResp;
+import com.tencent.supersonic.headless.api.pojo.response.TermResp;
 import org.apache.logging.log4j.util.Strings;
 import org.springframework.beans.BeanUtils;
 import org.springframework.util.CollectionUtils;
@@ -54,6 +55,9 @@ public class DataSetSchemaBuilder {
        Set<SchemaElement> dimensionValues = getDimensionValues(resp);
        dataSetSchema.getDimensionValues().addAll(dimensionValues);

+        Set<SchemaElement> terms = getTerms(resp);
+        dataSetSchema.getTerms().addAll(terms);
+
        SchemaElement entity = getEntity(resp);
        if (Objects.nonNull(entity)) {
            dataSetSchema.setEntity(entity);
@@ -230,6 +234,28 @@ public class DataSetSchemaBuilder {
        return metrics;
    }

+    private static Set<SchemaElement> getTerms(DataSetSchemaResp resp) {
+        Set<SchemaElement> terms = new HashSet<>();
+        for (TermResp termResp : resp.getTermResps()) {
+            List<String> alias = termResp.getAlias();
+            SchemaElement metricToAdd = SchemaElement.builder()
+                    .dataSet(resp.getId())
+                    .dataSetName(resp.getName())
+                    .model(-1L)
+                    .id(termResp.getId())
+                    .name(termResp.getName())
+                    .bizName(termResp.getName())
+                    .type(SchemaElementType.TERM)
+                    .useCnt(0L)
+                    .alias(alias)
+                    .description(termResp.getDescription())
+                    .build();
+            terms.add(metricToAdd);
+
+        }
+        return terms;
+    }
+
    private static List<RelatedSchemaElement> getRelateSchemaElement(MetricSchemaResp metricSchemaResp) {
        RelateDimension relateDimension = metricSchemaResp.getRelateDimension();
        if (relateDimension == null || CollectionUtils.isEmpty(relateDimension.getDrillDownDimensions())) {
--- a/headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/DomainConvert.java
+++ b/headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/DomainConvert.java
@@ -10,6 +10,7 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;

 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Map;

 public class DomainConvert {
@@ -40,4 +41,8 @@ public class DomainConvert {
        return domainResp;
    }

+    public static DomainResp convert(DomainDO domainDO) {
+        return convert(domainDO, new HashMap<>());
+    }
+
 }