topdog/supersonic
1
0
Fork 0
mirror of https://github.com/tencentmusic/supersonic.git synced 2025-12-10 11:07:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[improvement][project] global refactor , code format , support llm , support fuzzy detect ,support query filter and so on.

Browse Source
This commit is contained in:
lexluo
2023-07-08 15:00:03 +08:00
parent 5ffd617431
commit 404163f391
329 changed files with 21050 additions and 5036 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
assembly/bin/build-standalone.sh Executable file
View File

@@ -0,0 +1,23 @@
#!/usr/bin/env bash
sbinDir=$(cd "$(dirname "$0")"; pwd)
baseDir=$(readlink -f $sbinDir/../)
runtimeDir=$baseDir/runtime
buildDir=$baseDir/build
cd $baseDir
#1. build semantic chat service
rm -fr ${buildDir}/*.tar.gz
rm -fr dist
mvn -f $baseDir/../ clean package -DskipTests
#2. move package to build
cp $baseDir/../launchers/standalone/target/*.tar.gz ${buildDir}/supersonic.tar.gz
#3. build webapp
chmod +x $baseDir/../webapp/start-fe-prod.sh
cd ../webapp
sh ./start-fe-prod.sh
cp -fr ./supersonic-webapp.tar.gz ${buildDir}/

2
assembly/bin/start-all.sh
View File

@@ -2,7 +2,7 @@
sbinDir=$(cd "$(dirname "$0")"; pwd)
baseDir=$(readlink -f $sbinDir/../)
runtimeDir=$baseDir/runtime
runtimeDir=$baseDir/../runtime
buildDir=$baseDir/build
cd $baseDir

30
assembly/bin/start-standalone.sh Executable file
View File

@@ -0,0 +1,30 @@
#!/usr/bin/env bash
sbinDir=$(cd "$(dirname "$0")"; pwd)
baseDir=$(readlink -f $sbinDir/../)
runtimeDir=$baseDir/../runtime
buildDir=$baseDir/build
cd $baseDir
#1. clear file
mkdir -p ${runtimeDir}
rm -fr ${runtimeDir}/*
#2. package lib
tar -zxvf ${buildDir}/supersonic.tar.gz -C ${runtimeDir}
mv ${runtimeDir}/launchers-standalone-* ${runtimeDir}/supersonic-standalone
tar -zxvf ${buildDir}/supersonic-webapp.tar.gz -C ${buildDir}
mkdir -p ${runtimeDir}/supersonic-standalone/webapp
cp -fr ${buildDir}/supersonic-webapp/* ${runtimeDir}/supersonic-standalone/webapp
rm -fr ${buildDir}/supersonic-webapp
#3. start service
sh ${runtimeDir}/supersonic-standalone/bin/service.sh restart

4
auth/api/pom.xml
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.tencent.supersonic</groupId>

2
auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/domain/pojo/AuthGroup.java → auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthGroup.java
View File

@@ -1,4 +1,4 @@
package com.tencent.supersonic.auth.authorization.domain.pojo;
package com.tencent.supersonic.auth.api.authorization.pojo;
import java.util.List;
import lombok.Data;

2
auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/domain/pojo/AuthRule.java → auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthRule.java
View File

@@ -1,4 +1,4 @@
package com.tencent.supersonic.auth.authorization.domain.pojo;
package com.tencent.supersonic.auth.api.authorization.pojo;
import java.beans.Transient;
import java.util.ArrayList;

5
auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/request/QueryAuthResReq.java
View File

@@ -1,6 +1,7 @@
package com.tencent.supersonic.auth.api.authorization.request;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
@@ -11,6 +12,10 @@ import lombok.ToString;
public class QueryAuthResReq {
private String user;
private List<String> departmentIds = new ArrayList<>();
private List<AuthRes> resources;
private String domainId;
}

10
auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/service/AuthService.java
View File

@@ -1,10 +1,18 @@
package com.tencent.supersonic.auth.api.authorization.service;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
public interface AuthService {
AuthorizedResourceResp queryAuthorizedResources(HttpServletRequest request, QueryAuthResReq req);
List<AuthGroup> queryAuthGroups(String domainId, Integer groupId);
void updateAuthGroup(AuthGroup group);
void removeAuthGroup(AuthGroup group);
AuthorizedResourceResp queryAuthorizedResources(QueryAuthResReq req, HttpServletRequest request);
}

4
auth/authentication/pom.xml
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>auth</artifactId>

100
auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/domain/dataobject/UserDOExample.java
View File

@@ -37,13 +37,6 @@ public class UserDOExample {
oredCriteria = new ArrayList<Criteria>();
}
/**
* @mbg.generated
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
* @mbg.generated
*/
@@ -54,8 +47,8 @@ public class UserDOExample {
/**
* @mbg.generated
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
@@ -65,6 +58,13 @@ public class UserDOExample {
return distinct;
}
/**
* @mbg.generated
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* @mbg.generated
*/
@@ -116,13 +116,6 @@ public class UserDOExample {
distinct = false;
}
/**
* @mbg.generated
*/
public void setLimitStart(Integer limitStart) {
this.limitStart = limitStart;
}
/**
* @mbg.generated
*/
@@ -133,8 +126,8 @@ public class UserDOExample {
/**
* @mbg.generated
*/
public void setLimitEnd(Integer limitEnd) {
this.limitEnd = limitEnd;
public void setLimitStart(Integer limitStart) {
this.limitStart = limitStart;
}
/**
@@ -144,6 +137,13 @@ public class UserDOExample {
return limitEnd;
}
/**
* @mbg.generated
*/
public void setLimitEnd(Integer limitEnd) {
this.limitEnd = limitEnd;
}
/**
* s2_user null
*/
@@ -561,38 +561,6 @@ public class UserDOExample {
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
@@ -628,5 +596,37 @@ public class UserDOExample {
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
}
}

3
auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/domain/interceptor/DefaultAuthenticationInterceptor.java
View File

@@ -14,14 +14,11 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
@Component
@Slf4j
public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws AccessException {

4
auth/authorization/pom.xml
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>auth</artifactId>

118
auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/application/AuthApplicationService.java
View File

@@ -1,118 +0,0 @@
package com.tencent.supersonic.auth.authorization.application;
import com.google.common.base.Strings;
import com.google.gson.Gson;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthResGrp;
import com.tencent.supersonic.auth.api.authorization.pojo.DimensionFilter;
import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
import com.tencent.supersonic.auth.authorization.domain.pojo.AuthGroup;
import com.tencent.supersonic.auth.authorization.domain.pojo.AuthRule;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Component
@Slf4j
public class AuthApplicationService {
@Autowired
private JdbcTemplate jdbcTemplate;
private List<AuthGroup> load() {
List<String> rows = jdbcTemplate.queryForList("select config from s2_auth_groups", String.class);
Gson g = new Gson();
return rows.stream().map(row -> g.fromJson(row, AuthGroup.class)).collect(Collectors.toList());
}
public List<AuthGroup> queryAuthGroups(String domainId, Integer groupId) {
return load().stream()
.filter(group -> (Objects.isNull(groupId) || groupId.equals(group.getGroupId()))
&& domainId.equals(group.getDomainId()))
.collect(Collectors.toList());
}
public void updateAuthGroup(AuthGroup group) {
Gson g = new Gson();
if (group.getGroupId() == null) {
int nextGroupId = 1;
String sql = "select max(group_id) as group_id from s2_auth_groups";
Integer obj = jdbcTemplate.queryForObject(sql, Integer.class);
if (obj != null) {
nextGroupId = obj + 1;
}
group.setGroupId(nextGroupId);
jdbcTemplate.update("insert into s2_auth_groups (group_id, config) values (?, ?);", nextGroupId,
g.toJson(group));
} else {
jdbcTemplate.update("update s2_auth_groups set config = ? where group_id = ?;", g.toJson(group),
group.getGroupId());
}
}
public AuthorizedResourceResp queryAuthorizedResources(QueryAuthResReq req, HttpServletRequest request) {
List<AuthGroup> groups = load().stream().
filter(group -> group.getAuthorizedUsers().contains(req.getUser()) && req.getDomainId()
.equals(group.getDomainId())).
collect(Collectors.toList());
AuthorizedResourceResp resource = new AuthorizedResourceResp();
Map<String, List<AuthGroup>> authGroupsByDomainId = groups.stream()
.collect(Collectors.groupingBy(AuthGroup::getDomainId));
Map<String, List<AuthRes>> reqAuthRes = req.getResources().stream()
.collect(Collectors.groupingBy(AuthRes::getDomainId));
for (String domainId : reqAuthRes.keySet()) {
List<AuthRes> reqResourcesList = reqAuthRes.get(domainId);
AuthResGrp rg = new AuthResGrp();
if (authGroupsByDomainId.containsKey(domainId)) {
List<AuthGroup> authGroups = authGroupsByDomainId.get(domainId);
for (AuthRes reqRes : reqResourcesList) {
for (AuthGroup authRuleGroup : authGroups) {
List<AuthRule> authRules = authRuleGroup.getAuthRules();
List<String> allAuthItems = new ArrayList<>();
authRules.stream().forEach(authRule -> allAuthItems.addAll(authRule.resourceNames()));
if (allAuthItems.contains(reqRes.getName())) {
rg.getGroup().add(reqRes);
}
}
}
}
if (Objects.nonNull(rg) && !CollectionUtils.isEmpty(rg.getGroup())) {
resource.getResources().add(rg);
}
}
if (StringUtils.isNotEmpty(req.getDomainId())) {
List<AuthGroup> authGroups = authGroupsByDomainId.get(req.getDomainId());
if (!CollectionUtils.isEmpty(authGroups)) {
for (AuthGroup group : authGroups) {
if (group.getDimensionFilters() != null
&& group.getDimensionFilters().stream().anyMatch(expr -> !Strings.isNullOrEmpty(expr))) {
DimensionFilter df = new DimensionFilter();
df.setDescription(group.getDimensionFilterDescription());
df.setExpressions(group.getDimensionFilters());
resource.getFilters().add(df);
}
}
}
}
return resource;
}
public void removeAuthGroup(AuthGroup group) {
jdbcTemplate.update("delete from s2_auth_groups where group_id = ?", group.getGroupId());
}
}

134
auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/application/AuthServiceImpl.java
View File

@@ -1,24 +1,148 @@
package com.tencent.supersonic.auth.authorization.application;
import com.google.common.base.Strings;
import com.google.gson.Gson;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthResGrp;
import com.tencent.supersonic.auth.api.authorization.pojo.DimensionFilter;
import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
import com.tencent.supersonic.auth.api.authorization.service.AuthService;
import javax.servlet.http.HttpServletRequest;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
@Service
@Slf4j
public class AuthServiceImpl implements AuthService {
private final AuthApplicationService authApplicationService;
private JdbcTemplate jdbcTemplate;
public AuthServiceImpl(AuthApplicationService authApplicationService) {
this.authApplicationService = authApplicationService;
public AuthServiceImpl(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
private List<AuthGroup> load() {
List<String> rows = jdbcTemplate.queryForList("select config from s2_auth_groups", String.class);
Gson g = new Gson();
return rows.stream().map(row -> g.fromJson(row, AuthGroup.class)).collect(Collectors.toList());
}
@Override
public AuthorizedResourceResp queryAuthorizedResources(HttpServletRequest request, QueryAuthResReq req) {
return authApplicationService.queryAuthorizedResources(req, request);
public List<AuthGroup> queryAuthGroups(String domainId, Integer groupId) {
return load().stream()
.filter(group -> (Objects.isNull(groupId) || groupId.equals(group.getGroupId()))
&& domainId.equals(group.getDomainId()))
.collect(Collectors.toList());
}
@Override
public void updateAuthGroup(AuthGroup group) {
Gson g = new Gson();
if (group.getGroupId() == null) {
int nextGroupId = 1;
String sql = "select max(group_id) as group_id from s2_auth_groups";
Integer obj = jdbcTemplate.queryForObject(sql, Integer.class);
if (obj != null) {
nextGroupId = obj + 1;
}
group.setGroupId(nextGroupId);
jdbcTemplate.update("insert into s2_auth_groups (group_id, config) values (?, ?);", nextGroupId,
g.toJson(group));
} else {
jdbcTemplate.update("update s2_auth_groups set config = ? where group_id = ?;", g.toJson(group),
group.getGroupId());
}
}
@Override
public void removeAuthGroup(AuthGroup group) {
jdbcTemplate.update("delete from s2_auth_groups where group_id = ?", group.getGroupId());
}
@Override
public AuthorizedResourceResp queryAuthorizedResources(QueryAuthResReq req, HttpServletRequest request) {
List<AuthGroup> groups = getAuthGroups(req);
AuthorizedResourceResp resource = new AuthorizedResourceResp();
Map<String, List<AuthGroup>> authGroupsByDomainId = groups.stream()
.collect(Collectors.groupingBy(AuthGroup::getDomainId));
Map<String, List<AuthRes>> reqAuthRes = req.getResources().stream()
.collect(Collectors.groupingBy(AuthRes::getDomainId));
for (String domainId : reqAuthRes.keySet()) {
List<AuthRes> reqResourcesList = reqAuthRes.get(domainId);
AuthResGrp rg = new AuthResGrp();
if (authGroupsByDomainId.containsKey(domainId)) {
List<AuthGroup> authGroups = authGroupsByDomainId.get(domainId);
for (AuthRes reqRes : reqResourcesList) {
for (AuthGroup authRuleGroup : authGroups) {
List<AuthRule> authRules = authRuleGroup.getAuthRules();
List<String> allAuthItems = new ArrayList<>();
authRules.forEach(authRule -> allAuthItems.addAll(authRule.resourceNames()));
if (allAuthItems.contains(reqRes.getName())) {
rg.getGroup().add(reqRes);
}
}
}
}
if (!CollectionUtils.isEmpty(rg.getGroup())) {
resource.getResources().add(rg);
}
}
if (StringUtils.isNotEmpty(req.getDomainId())) {
List<AuthGroup> authGroups = authGroupsByDomainId.get(req.getDomainId());
if (!CollectionUtils.isEmpty(authGroups)) {
for (AuthGroup group : authGroups) {
if (group.getDimensionFilters() != null
&& group.getDimensionFilters().stream().anyMatch(expr -> !Strings.isNullOrEmpty(expr))) {
DimensionFilter df = new DimensionFilter();
df.setDescription(group.getDimensionFilterDescription());
df.setExpressions(group.getDimensionFilters());
resource.getFilters().add(df);
}
}
}
}
return resource;
}
private List<AuthGroup> getAuthGroups(QueryAuthResReq req) {
List<AuthGroup> groups = load().stream().
filter(group -> {
if (!Objects.equals(group.getDomainId(), req.getDomainId())) {
return false;
}
if (!CollectionUtils.isEmpty(group.getAuthorizedUsers()) && group.getAuthorizedUsers()
.contains(req.getUser())) {
return true;
}
for (String deparmentId : req.getDepartmentIds()) {
if (!CollectionUtils.isEmpty(group.getAuthorizedDepartmentIds())
&& group.getAuthorizedDepartmentIds().contains(deparmentId)) {
return true;
}
}
return false;
}).collect(Collectors.toList());
log.info("user:{} department:{} authGroups:{}", req.getUser(), req.getDepartmentIds(), groups);
return groups;
}
}

20
auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/rest/AuthController.java
View File

@@ -2,8 +2,8 @@ package com.tencent.supersonic.auth.authorization.rest;
import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
import com.tencent.supersonic.auth.authorization.application.AuthApplicationService;
import com.tencent.supersonic.auth.authorization.domain.pojo.AuthGroup;
import com.tencent.supersonic.auth.api.authorization.service.AuthService;
import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
@@ -19,16 +19,16 @@ import org.springframework.web.bind.annotation.RestController;
@Slf4j
public class AuthController {
private final AuthApplicationService service;
private final AuthService authService;
public AuthController(AuthApplicationService service) {
this.service = service;
public AuthController(AuthService authService) {
this.authService = authService;
}
@GetMapping("/queryGroup")
public List<AuthGroup> queryAuthGroup(@RequestParam("domainId") String domainId,
@RequestParam(value = "groupId", required = false) Integer groupId) {
return service.queryAuthGroups(domainId, groupId);
return authService.queryAuthGroups(domainId, groupId);
}
/**
@@ -37,12 +37,12 @@ public class AuthController {
@PostMapping("/createGroup")
public void newAuthGroup(@RequestBody AuthGroup group) {
group.setGroupId(null);
service.updateAuthGroup(group);
authService.updateAuthGroup(group);
}
@PostMapping("/removeGroup")
public void removeAuthGroup(@RequestBody AuthGroup group) {
service.removeAuthGroup(group);
authService.removeAuthGroup(group);
}
/**
@@ -55,7 +55,7 @@ public class AuthController {
if (group.getGroupId() == null || group.getGroupId() == 0) {
throw new RuntimeException("groupId is empty");
}
service.updateAuthGroup(group);
authService.updateAuthGroup(group);
}
/**
@@ -68,6 +68,6 @@ public class AuthController {
@PostMapping("/queryAuthorizedRes")
public AuthorizedResourceResp queryAuthorizedResources(@RequestBody QueryAuthResReq req,
HttpServletRequest request) {
return service.queryAuthorizedResources(req, request);
return authService.queryAuthorizedResources(req, request);
}
}

4
auth/pom.xml
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>supersonic</artifactId>

2
chat/api/src/main/java/com/tencent/supersonic/chat/api/service/SchemaMapper.java → chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SchemaMapper.java
View File

@@ -1,4 +1,4 @@
package com.tencent.supersonic.chat.api.service;
package com.tencent.supersonic.chat.api.component;
import com.tencent.supersonic.chat.api.request.QueryContextReq;

5
chat/api/src/main/java/com/tencent/supersonic/chat/api/service/SemanticLayer.java → chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticLayer.java
View File

@@ -1,8 +1,9 @@
package com.tencent.supersonic.chat.api.service;
package com.tencent.supersonic.chat.api.component;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.semantic.api.query.request.QuerySqlReq;
import com.tencent.supersonic.semantic.api.query.request.QueryStructReq;
import java.util.List;
@@ -23,6 +24,8 @@ public interface SemanticLayer {
QueryResultWithSchemaResp queryByStruct(QueryStructReq queryStructReq, User user);
QueryResultWithSchemaResp queryBySql(QuerySqlReq querySqlReq, User user);
DomainSchemaResp getDomainSchemaInfo(Long domain);
List<DomainSchemaResp> getDomainSchemaInfo(List<Long> ids);

4
chat/api/src/main/java/com/tencent/supersonic/chat/api/service/SemanticParser.java → chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticParser.java
View File

@@ -1,4 +1,4 @@
package com.tencent.supersonic.chat.api.service;
package com.tencent.supersonic.chat.api.component;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
@@ -13,5 +13,5 @@ import com.tencent.supersonic.chat.api.request.QueryContextReq;
*/
public interface SemanticParser {
boolean parse(QueryContextReq queryContext, ChatContext chatCtx);
void parse(QueryContextReq queryContext, ChatContext chatContext);
}

18
chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticQuery.java Normal file
View File

@@ -0,0 +1,18 @@
package com.tencent.supersonic.chat.api.component;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
/**
* This class defines the contract for a semantic query that executes specific type of
* query based on the results of semantic parsing.
*/
public interface SemanticQuery {
String getQueryMode();
QueryResultResp execute(User user);
SemanticParseInfo getParseInfo();
}

16
chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/QueryFilter.java Normal file
View File

@@ -0,0 +1,16 @@
package com.tencent.supersonic.chat.api.pojo;
import lombok.Data;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Data
public class QueryFilter {
private List<Filter> filters = new ArrayList<>();
private Map<String, Object> params = new HashMap<>();
}

4
chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaElementCount.java → chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/QueryMatchInfo.java
View File

@@ -3,8 +3,10 @@ package com.tencent.supersonic.chat.api.pojo;
import lombok.Data;
@Data
public class SchemaElementCount {
public class QueryMatchInfo {
SchemaElementType elementType;
String detectWord;
private Integer count = 0;
private double maxSimilarity;
}

9
chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaElementMatch.java
View File

@@ -1,10 +1,16 @@
package com.tencent.supersonic.chat.api.pojo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@Data
@ToString
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class SchemaElementMatch {
SchemaElementType elementType;
@@ -18,7 +24,4 @@ public class SchemaElementMatch {
String word;
Long frequency;
public SchemaElementMatch() {
}
}

8
chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaMapInfo.java
View File

@@ -21,12 +21,12 @@ public class SchemaMapInfo {
return domainElementMatches;
}
public void setMatchedElements(Integer domain, List<SchemaElementMatch> elementMatches) {
domainElementMatches.put(domain, elementMatches);
}
public void setDomainElementMatches(
Map<Integer, List<SchemaElementMatch>> domainElementMatches) {
this.domainElementMatches = domainElementMatches;
}
public void setMatchedElements(Integer domain, List<SchemaElementMatch> elementMatches) {
domainElementMatches.put(domain, elementMatches);
}
}

4
chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SemanticParseInfo.java
View File

@@ -5,6 +5,7 @@ import com.tencent.supersonic.common.enums.AggregateTypeEnum;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.Order;
import com.tencent.supersonic.common.pojo.SchemaItem;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
@@ -27,4 +28,7 @@ public class SemanticParseInfo {
private DateConf dateInfo;
private Long limit;
private Boolean nativeQuery = false;
private Double bonus = 0d;
private List<SchemaElementMatch> elementMatches = new ArrayList<>();
private Object info;
}

10
chat/api/src/main/java/com/tencent/supersonic/chat/api/request/QueryContextReq.java
View File

@@ -1,11 +1,14 @@
package com.tencent.supersonic.chat.api.request;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.QueryFilter;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
@Data
public class QueryContextReq {
@@ -13,7 +16,8 @@ public class QueryContextReq {
private Integer chatId;
private Integer domainId = 0;
private User user;
private SemanticParseInfo parseInfo = new SemanticParseInfo();
private QueryFilter queryFilter;
private List<SemanticQuery> candidateQueries = new ArrayList<>();
private SchemaMapInfo mapInfo = new SchemaMapInfo();
private boolean saveAnswer = true;
}

2
chat/api/src/main/java/com/tencent/supersonic/chat/api/response/QueryResultResp.java
View File

@@ -11,13 +11,13 @@ import lombok.Data;
@Data
public class QueryResultResp {
public EntityInfo entityInfo;
private Long queryId;
private String queryMode;
private String querySql;
private int queryState;
private List<QueryColumn> queryColumns;
private QueryAuthorization queryAuthorization;
public EntityInfo entityInfo;
private SemanticParseInfo chatContext;
private Object response;
private List<Map<String, Object>> queryResults;

29
chat/api/src/main/java/com/tencent/supersonic/chat/api/service/SemanticQuery.java
View File

@@ -1,29 +0,0 @@
package com.tencent.supersonic.chat.api.service;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import java.io.Serializable;
import java.util.List;
/**
* This interface defines the contract for a semantic query that executes specific type of
* query based on the results of semantic parsing.
*/
public interface SemanticQuery extends Serializable {
String getQueryMode();
QueryResultResp execute(QueryContextReq queryCtx, ChatContext chatCtx) throws Exception;
SchemaElementCount match(List<SchemaElementMatch> elementMatches, QueryContextReq queryCtx);
void updateContext(QueryResultResp queryResponse, ChatContext chatCtx, QueryContextReq queryCtx);
SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx);
}

12
chat/core/pom.xml
View File

@@ -113,6 +113,12 @@
<artifactId>semantic-api</artifactId>
<version>${project.version}</version>
</dependency>
<!-- <dependency>-->
<!-- <groupId>com.tencent.supersonic</groupId>-->
<!-- <artifactId>semantic-query</artifactId>-->
<!-- <version>${project.version}</version>-->
<!-- <scope>compile</scope>-->
<!-- </dependency>-->
<dependency>
<groupId>com.tencent.supersonic</groupId>
<artifactId>semantic-query</artifactId>
@@ -125,6 +131,12 @@
<version>${project.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.tencent.supersonic</groupId>
<artifactId>semantic-query</artifactId>
<version>${project.version}</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>

35
chat/core/src/main/java/com/tencent/supersonic/chat/application/ChatServiceImpl.java
View File

@@ -18,20 +18,19 @@ import com.tencent.supersonic.chat.domain.service.ChatService;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Objects;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
@Service("ChatService")
@Primary
@Slf4j
public class ChatServiceImpl implements ChatService {
private ChatContextRepository chatContextRepository;
private ChatRepository chatRepository;
private ChatQueryRepository chatQueryRepository;
private final Logger logger = LoggerFactory.getLogger(ChatService.class);
public ChatServiceImpl(ChatContextRepository chatContextRepository, ChatRepository chatRepository,
ChatQueryRepository chatQueryRepository) {
@@ -64,27 +63,32 @@ public class ChatServiceImpl implements ChatService {
@Override
public void updateContext(ChatContext chatCtx) {
logger.debug("save ChatContext {}", chatCtx);
log.debug("save ChatContext {}", chatCtx);
chatContextRepository.updateContext(chatCtx);
}
@Override
public void updateContext(ChatContext chatCtx, QueryContextReq queryCtx, SemanticParseInfo semanticParseInfo) {
chatCtx.setParseInfo(semanticParseInfo);
chatCtx.setQueryText(queryCtx.getQueryText());
updateContext(chatCtx);
}
@Override
public void switchContext(ChatContext chatCtx) {
logger.debug("switchContext ChatContext {}", chatCtx);
log.debug("switchContext ChatContext {}", chatCtx);
chatCtx.setParseInfo(new SemanticParseInfo());
}
@Override
public Boolean addChat(User user, String chatName) {
SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String datetime = tempDate.format(new java.util.Date());
ChatDO intelligentConversionDO = new ChatDO();
intelligentConversionDO.setChatName(chatName);
intelligentConversionDO.setCreator(user.getName());
intelligentConversionDO.setCreateTime(datetime);
intelligentConversionDO.setCreateTime(getCurrentTime());
intelligentConversionDO.setIsDelete(0);
intelligentConversionDO.setLastTime(datetime);
intelligentConversionDO.setLastTime(getCurrentTime());
intelligentConversionDO.setLastQuestion("Hello, welcome to using supersonic");
intelligentConversionDO.setIsTop(0);
return chatRepository.createChat(intelligentConversionDO);
@@ -97,9 +101,7 @@ public class ChatServiceImpl implements ChatService {
@Override
public boolean updateChatName(Long chatId, String chatName, String userName) {
SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String lastTime = tempDate.format(new java.util.Date());
return chatRepository.updateChatName(chatId, chatName, lastTime, userName);
return chatRepository.updateChatName(chatId, chatName, getCurrentTime(), userName);
}
@Override
@@ -129,6 +131,8 @@ public class ChatServiceImpl implements ChatService {
@Override
public void addQuery(QueryResultResp queryResponse, QueryContextReq queryContext, ChatContext chatCtx) {
chatQueryRepository.createChatQuery(queryResponse, queryContext, chatCtx);
chatRepository.updateLastQuestion(chatCtx.getChatId().longValue(), queryContext.getQueryText(),
getCurrentTime());
}
@Override
@@ -141,4 +145,9 @@ public class ChatServiceImpl implements ChatService {
return chatQueryRepository.updateChatQuery(chatQueryDO);
}
private String getCurrentTime() {
SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return tempDate.format(new java.util.Date());
}
}

104
chat/core/src/main/java/com/tencent/supersonic/chat/application/ConfigServiceImpl.java
View File

@@ -2,9 +2,7 @@ package com.tencent.supersonic.chat.application;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfig;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigBase;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigEditReq;
@@ -14,14 +12,22 @@ import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.DefaultMetric;
import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.ItemVisibilityInfo;
import com.tencent.supersonic.chat.domain.pojo.config.KnowledgeInfo;
import com.tencent.supersonic.chat.domain.repository.ChatConfigRepository;
import com.tencent.supersonic.chat.domain.service.ConfigService;
import com.tencent.supersonic.chat.domain.utils.ChatConfigUtils;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.common.util.json.JsonUtil;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.DomainResp;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
@@ -35,15 +41,16 @@ import org.springframework.util.CollectionUtils;
public class ConfigServiceImpl implements ConfigService {
private final ChatConfigRepository chaConfigRepository;
private final SemanticLayer semanticLayer;
private final ChatConfigUtils chatConfigUtils;
private final DefaultSemanticInternalUtils defaultSemanticUtils;
public ConfigServiceImpl(ChatConfigRepository chaConfigRepository,
@Lazy SemanticLayer semanticLayer,
ChatConfigUtils chatConfigUtils) {
ChatConfigUtils chatConfigUtils,
@Lazy DefaultSemanticInternalUtils defaultSemanticUtils) {
this.chaConfigRepository = chaConfigRepository;
this.semanticLayer = semanticLayer;
this.chatConfigUtils = chatConfigUtils;
this.defaultSemanticUtils = defaultSemanticUtils;
}
@Override
@@ -101,19 +108,19 @@ public class ConfigServiceImpl implements ConfigService {
}
public EntityRichInfo fetchEntityDescByDomainId(Long domainId) {
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
ChatConfigInfo chaConfigDesc = chaConfigRepository.getConfigByDomainId(domainId);
return fetchEntityDescByConfig(chaConfigDesc);
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domainId);
return fetchEntityDescByConfig(chaConfigDesc, domainSchemaDesc);
}
public EntityRichInfo fetchEntityDescByConfig(ChatConfigInfo chatConfigDesc) {
public EntityRichInfo fetchEntityDescByConfig(ChatConfigInfo chatConfigDesc, DomainSchemaResp domain) {
Long domainId = chatConfigDesc.getDomainId();
EntityRichInfo entityDesc = new EntityRichInfo();
if (Objects.isNull(chatConfigDesc) || Objects.isNull(chatConfigDesc.getEntity())) {
log.info("domainId:{}, entityDesc info is null", domainId);
return entityDesc;
}
DomainSchemaResp domain = semanticLayer.getDomainSchemaInfo(domainId);
entityDesc.setDomainId(domain.getId());
entityDesc.setDomainBizName(domain.getBizName());
@@ -128,13 +135,14 @@ public class ConfigServiceImpl implements ConfigService {
public List<DefaultMetric> fetchDefaultMetricDescByDomainId(Long domainId) {
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
ChatConfigInfo chatConfigDesc = chaConfigRepository.getConfigByDomainId(domainId);
return fetchDefaultMetricDescByConfig(chatConfigDesc);
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domainId);
return fetchDefaultMetricDescByConfig(chatConfigDesc, domainSchemaDesc);
}
public List<DefaultMetric> fetchDefaultMetricDescByConfig(ChatConfigInfo chatConfigDesc) {
public List<DefaultMetric> fetchDefaultMetricDescByConfig(ChatConfigInfo chatConfigDesc, DomainSchemaResp domain) {
Long domainId = chatConfigDesc.getDomainId();
DomainSchemaResp domain = semanticLayer.getDomainSchemaInfo(domainId);
List<DefaultMetric> defaultMetricDescList = new ArrayList<>();
if (Objects.isNull(chatConfigDesc) || CollectionUtils.isEmpty(chatConfigDesc.getDefaultMetrics())) {
log.info("domainId:{}, defaultMetricDescList info is null", domainId);
@@ -158,14 +166,17 @@ public class ConfigServiceImpl implements ConfigService {
}
public ItemVisibilityInfo fetchVisibilityDescByDomainId(Long domainId) {
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
ChatConfigInfo chatConfigDesc = chaConfigRepository.getConfigByDomainId(domainId);
return fetchVisibilityDescByConfig(chatConfigDesc);
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domainId);
return fetchVisibilityDescByConfig(chatConfigDesc, domainSchemaDesc);
}
private ItemVisibilityInfo fetchVisibilityDescByConfig(ChatConfigInfo chatConfigDesc) {
private ItemVisibilityInfo fetchVisibilityDescByConfig(ChatConfigInfo chatConfigDesc,
DomainSchemaResp domainSchemaDesc) {
ItemVisibilityInfo itemVisibilityDesc = new ItemVisibilityInfo();
Long domainId = chatConfigDesc.getDomainId();
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domainId);
List<Long> dimIdAllList = chatConfigUtils.generateAllDimIdList(domainSchemaDesc);
List<Long> metricIdAllList = chatConfigUtils.generateAllMetricIdList(domainSchemaDesc);
@@ -194,18 +205,65 @@ public class ConfigServiceImpl implements ConfigService {
@Override
public ChatConfigRichInfo getConfigRichInfo(Long domainId) {
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
ChatConfigRichInfo chaConfigRichDesc = new ChatConfigRichInfo();
ChatConfigInfo chatConfigDesc = chaConfigRepository.getConfigByDomainId(domainId);
if (Objects.isNull(chatConfigDesc)) {
log.info("there is no chatConfigDesc for domainId:{}", domainId);
return chaConfigRichDesc;
}
BeanUtils.copyProperties(chatConfigDesc, chaConfigRichDesc);
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domainId);
chaConfigRichDesc.setBizName(domainSchemaDesc.getBizName());
chaConfigRichDesc.setName(domainSchemaDesc.getName());
DomainSchemaResp domainSchemaInfo = semanticLayer.getDomainSchemaInfo(domainId);
chaConfigRichDesc.setBizName(domainSchemaInfo.getBizName());
chaConfigRichDesc.setName(domainSchemaInfo.getName());
chaConfigRichDesc.setDefaultMetrics(fetchDefaultMetricDescByConfig(chatConfigDesc));
chaConfigRichDesc.setVisibility(fetchVisibilityDescByConfig(chatConfigDesc));
chaConfigRichDesc.setEntity(fetchEntityDescByConfig(chatConfigDesc));
chaConfigRichDesc.setKnowledgeInfos(
fillKnowledgeBizName(chaConfigRichDesc.getKnowledgeInfos(), domainSchemaInfo));
chaConfigRichDesc.setDefaultMetrics(fetchDefaultMetricDescByConfig(chatConfigDesc, domainSchemaInfo));
chaConfigRichDesc.setVisibility(fetchVisibilityDescByConfig(chatConfigDesc, domainSchemaInfo));
chaConfigRichDesc.setEntity(fetchEntityDescByConfig(chatConfigDesc, domainSchemaInfo));
return chaConfigRichDesc;
}
private List<KnowledgeInfo> fillKnowledgeBizName(List<KnowledgeInfo> knowledgeInfos,
DomainSchemaResp domainSchemaInfo) {
if (CollectionUtils.isEmpty(knowledgeInfos)) {
return new ArrayList<>();
}
Map<Long, DimSchemaResp> dimIdAndRespPair = domainSchemaInfo.getDimensions().stream()
.collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
knowledgeInfos.stream().forEach(knowledgeInfo -> {
if (Objects.nonNull(knowledgeInfo)) {
DimSchemaResp dimSchemaResp = dimIdAndRespPair.get(knowledgeInfo.getItemId());
if (Objects.nonNull(dimSchemaResp)) {
knowledgeInfo.setBizName(dimSchemaResp.getBizName());
}
if (CollectionUtils.isEmpty(knowledgeInfo.getBlackList())) {
knowledgeInfo.setBlackList(new ArrayList<>());
}
if (CollectionUtils.isEmpty(knowledgeInfo.getRuleList())) {
knowledgeInfo.setRuleList(new ArrayList<>());
}
if (CollectionUtils.isEmpty(knowledgeInfo.getWhiteList())) {
knowledgeInfo.setWhiteList(new ArrayList<>());
}
}
});
return knowledgeInfos;
}
@Override
public List<ChatConfigRichInfo> getAllChatRichConfig() {
List<ChatConfigRichInfo> chatConfigRichInfoList = new ArrayList<>();
List<DomainResp> domainRespList = defaultSemanticUtils.getDomainListForAdmin();
domainRespList.stream().forEach(domainResp -> {
ChatConfigRichInfo chatConfigRichInfo = getConfigRichInfo(domainResp.getId());
if (Objects.nonNull(chatConfigRichInfo)) {
chatConfigRichInfoList.add(chatConfigRichInfo);
}
});
return chatConfigRichInfoList;
}
}

42
chat/core/src/main/java/com/tencent/supersonic/chat/application/DomainEntityService.java
View File

@@ -2,49 +2,44 @@ package com.tencent.supersonic.chat.application;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.api.pojo.DataInfo;
import com.tencent.supersonic.chat.api.pojo.DomainInfo;
import com.tencent.supersonic.chat.api.pojo.EntityInfo;
import com.tencent.supersonic.chat.api.pojo.Filter;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
import java.util.Map;
@Service
@Slf4j
public class DomainEntityService {
private final Logger logger = LoggerFactory.getLogger(DomainEntityService.class);
@Autowired
private SemanticLayer semanticLayer;
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
@Autowired
private DefaultSemanticInternalUtils defaultSemanticUtils;
public EntityInfo getEntityInfo(QueryContextReq queryCtx, ChatContext chatCtx, User user) {
SemanticParseInfo parseInfo = queryCtx.getParseInfo();
public EntityInfo getEntityInfo(SemanticParseInfo parseInfo, User user) {
if (parseInfo != null && parseInfo.getDomainId() > 0) {
EntityInfo entityInfo = getEntityInfo(parseInfo.getDomainId());
if (parseInfo.getDimensionFilters().size() <= 0) {
@@ -56,7 +51,8 @@ public class DomainEntityService {
String domainInfoPrimaryName = entityInfo.getDomainInfo().getPrimaryEntityBizName();
String domainInfoId = "";
for (Filter chatFilter : parseInfo.getDimensionFilters()) {
if (chatFilter.getBizName().equals(domainInfoPrimaryName)) {
if (chatFilter != null && chatFilter.getBizName() != null && chatFilter.getBizName()
.equals(domainInfoPrimaryName)) {
if (chatFilter.getOperator().equals(FilterOperatorEnum.EQUALS)) {
domainInfoId = chatFilter.getValue().toString();
}
@@ -72,7 +68,7 @@ public class DomainEntityService {
return entityInfo;
} catch (Exception e) {
logger.error("setMaintDomain error {}", e);
log.error("setMaintDomain error {}", e);
}
}
}
@@ -88,7 +84,7 @@ public class DomainEntityService {
private EntityInfo getEntityInfo(EntityRichInfo entityDesc) {
EntityInfo entityInfo = new EntityInfo();
if (entityDesc != null) {
if (entityDesc != null && Objects.nonNull(entityDesc.getDomainId())) {
DomainInfo domainInfo = new DomainInfo();
domainInfo.setItemId(Integer.valueOf(entityDesc.getDomainId().intValue()));
domainInfo.setName(entityDesc.getDomainName());
@@ -148,7 +144,7 @@ public class DomainEntityService {
queryResultWithColumns = semanticLayer.queryByStruct(SchemaInfoConverter.convertTo(semanticParseInfo),
user);
} catch (Exception e) {
logger.warn("setMainDomain queryByStruct error, e:", e);
log.warn("setMainDomain queryByStruct error, e:", e);
}
if (queryResultWithColumns != null) {

75
chat/core/src/main/java/com/tencent/supersonic/chat/application/QueryServiceImpl.java
View File

@@ -2,52 +2,44 @@ package com.tencent.supersonic.chat.application;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.component.*;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import com.tencent.supersonic.chat.api.service.SchemaMapper;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.chat.application.query.SemanticQueryFactory;
import com.tencent.supersonic.chat.application.query.QuerySelector;
import com.tencent.supersonic.chat.domain.pojo.chat.QueryData;
import com.tencent.supersonic.chat.domain.service.ChatService;
import com.tencent.supersonic.chat.domain.pojo.search.QueryState;
import com.tencent.supersonic.chat.domain.service.QueryService;
import com.tencent.supersonic.chat.domain.service.ChatService;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.util.json.JsonUtil;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
@Service
@Component("chatQueryService")
@Primary
@Slf4j
public class QueryServiceImpl implements QueryService {
private final Logger logger = LoggerFactory.getLogger(QueryServiceImpl.class);
private List<SchemaMapper> schemaMappers;
private List<SemanticParser> semanticParsers;
@Autowired
private ChatService chatService;
@Autowired
private SemanticLayer semanticLayer;
public QueryServiceImpl() {
schemaMappers = SpringFactoriesLoader.loadFactories(SchemaMapper.class,
Thread.currentThread().getContextClassLoader());
semanticParsers = SpringFactoriesLoader.loadFactories(SemanticParser.class,
Thread.currentThread().getContextClassLoader());
}
private List<SchemaMapper> schemaMappers = ComponentFactory.getSchemaMappers();
private List<SemanticParser> semanticParsers = ComponentFactory.getSemanticParsers();
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
private QuerySelector querySelector = ComponentFactory.getQuerySelector();
@Override
public QueryResultResp executeQuery(QueryContextReq queryCtx) throws Exception {
schemaMappers.stream().forEach(s -> s.map(queryCtx));
@@ -55,25 +47,30 @@ public class QueryServiceImpl implements QueryService {
ChatContext chatCtx = chatService.getOrCreateContext(queryCtx.getChatId());
for (SemanticParser semanticParser : semanticParsers) {
logger.info("semanticParser processing:{}", JsonUtil.prettyToString(semanticParser));
boolean isFinish = semanticParser.parse(queryCtx, chatCtx);
if (isFinish) {
logger.info("semanticParser is finish ,semanticParser:{}", semanticParser.getClass().getName());
break;
log.info("semanticParser processing:[{}]", semanticParser.getClass().getName());
semanticParser.parse(queryCtx, chatCtx);
}
}
// submit semantic query based on the result of semantic parsing
SemanticQuery query = SemanticQueryFactory.get(queryCtx.getParseInfo().getQueryMode());
QueryResultResp queryResponse = query.execute(queryCtx, chatCtx);
if (queryCtx.getCandidateQueries().size() > 0) {
log.info("pick before [{}]", queryCtx.getCandidateQueries().stream().collect(
Collectors.toList()));
SemanticQuery semanticQuery = querySelector.select(queryCtx.getCandidateQueries());
log.info("pick after [{}]", semanticQuery);
QueryResultResp queryResponse = semanticQuery.execute(queryCtx.getUser());
if (queryResponse != null) {
// update chat context after a successful semantic query
query.updateContext(queryResponse, chatCtx, queryCtx);
if (queryCtx.isSaveAnswer() && queryResponse.getQueryState() == QueryState.NORMAL.getState()) {
chatService.updateContext(chatCtx, queryCtx, semanticQuery.getParseInfo());
}
queryResponse.setChatContext(chatCtx.getParseInfo());
chatService.addQuery(queryResponse, queryCtx, chatCtx);
return queryResponse;
}
}
return null;
}
@Override
public SemanticParseInfo queryContext(QueryContextReq queryCtx) {
@@ -82,7 +79,7 @@ public class QueryServiceImpl implements QueryService {
}
@Override
public QueryResultResp queryData(QueryData queryData, User user) throws Exception {
public QueryResultResp executeDirectQuery(QueryData queryData, User user) throws Exception {
SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
QueryResultResp queryResponse = new QueryResultResp();
BeanUtils.copyProperties(queryData, semanticParseInfo);

8
chat/core/src/main/java/com/tencent/supersonic/chat/application/RecommendServiceImpl.java
View File

@@ -2,14 +2,15 @@ package com.tencent.supersonic.chat.application;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.chat.domain.pojo.chat.RecommendResponse;
import com.tencent.supersonic.chat.domain.service.RecommendService;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/***
@@ -18,8 +19,7 @@ import org.springframework.stereotype.Service;
@Service
public class RecommendServiceImpl implements RecommendService {
@Autowired
private SemanticLayer semanticLayer;
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
@Override
public RecommendResponse recommend(QueryContextReq queryCtx) {

25
chat/core/src/main/java/com/tencent/supersonic/chat/application/SearchServiceImpl.java
View File

@@ -32,9 +32,9 @@ import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -43,9 +43,11 @@ import org.springframework.stereotype.Service;
* search service impl
*/
@Service
@Slf4j
public class SearchServiceImpl implements SearchService {
private static final Logger LOGGER = LoggerFactory.getLogger(SearchServiceImpl.class);
private static final int RESULT_SIZE = 10;
@Autowired
private WordNatureService wordNatureService;
@Autowired
@@ -53,9 +55,6 @@ public class SearchServiceImpl implements SearchService {
@Autowired
private SearchMatchStrategy searchMatchStrategy;
private static final int RESULT_SIZE = 10;
@Override
public List<SearchResult> search(QueryContextReq queryCtx) {
String queryText = queryCtx.getQueryText();
@@ -67,7 +66,7 @@ public class SearchServiceImpl implements SearchService {
// 2.detect by segment
List<Term> originals = HanlpHelper.getSegment().seg(queryText.toLowerCase()).stream()
.collect(Collectors.toList());
Map<MatchText, List<MapResult>> regTextMap = searchMatchStrategy.matchWithMatchText(queryText, originals,
Map<MatchText, List<MapResult>> regTextMap = searchMatchStrategy.match(queryText, originals,
queryCtx.getDomainId());
regTextMap.entrySet().stream().forEach(m -> HanlpHelper.transLetterOriginal(m.getValue()));
// 3.get the most matching data
@@ -77,14 +76,14 @@ public class SearchServiceImpl implements SearchService {
.reduce((entry1, entry2) ->
entry1.getKey().getDetectSegment().length() >= entry2.getKey().getDetectSegment().length()
? entry1 : entry2);
LOGGER.debug("mostSimilarSearchResult:{}", mostSimilarSearchResult);
log.debug("mostSimilarSearchResult:{}", mostSimilarSearchResult);
// 4.optimize the results after the query
if (!mostSimilarSearchResult.isPresent()) {
LOGGER.info("unable to find any information through search , queryCtx:{}", queryCtx);
log.info("unable to find any information through search , queryCtx:{}", queryCtx);
return Lists.newArrayList();
}
Map.Entry<MatchText, List<MapResult>> searchTextEntry = mostSimilarSearchResult.get();
LOGGER.info("searchTextEntry:{},queryCtx:{}", searchTextEntry, queryCtx);
log.info("searchTextEntry:{},queryCtx:{}", searchTextEntry, queryCtx);
Set<SearchResult> searchResults = new LinkedHashSet();
DomainInfoStat domainStat = NatureHelper.getDomainStat(originals);
@@ -98,7 +97,7 @@ public class SearchServiceImpl implements SearchService {
// 4.2 process based on dimension values
MatchText matchText = searchTextEntry.getKey();
Map<String, String> natureToNameMap = getNatureToNameMap(searchTextEntry, new HashSet<>(possibleDomains));
LOGGER.debug("possibleDomains:{},natureToNameMap:{}", possibleDomains, natureToNameMap);
log.debug("possibleDomains:{},natureToNameMap:{}", possibleDomains, natureToNameMap);
for (Map.Entry<String, String> natureToNameEntry : natureToNameMap.entrySet()) {
searchDimensionValue(metricsDb, domainToName, domainStat.getMetricDomainCount(), searchResults,
@@ -120,7 +119,7 @@ public class SearchServiceImpl implements SearchService {
Long contextDomain = chatService.getContextDomain(queryCtx.getChatId());
LOGGER.debug("possibleDomains:{},domainStat:{},contextDomain:{}", possibleDomains, domainStat, contextDomain);
log.debug("possibleDomains:{},domainStat:{},contextDomain:{}", possibleDomains, domainStat, contextDomain);
// If nothing is recognized or only metric are present, then add the contextDomain.
if (nothingOrOnlyMetric(domainStat) && effectiveDomain(contextDomain)) {
@@ -249,7 +248,7 @@ public class SearchServiceImpl implements SearchService {
domainToName.get(domain), domain, semanticType));
}
}
LOGGER.info("parseResult:{},dimensionMetricClassIds:{},possibleDomains:{}", mapResult,
log.info("parseResult:{},dimensionMetricClassIds:{},possibleDomains:{}", mapResult,
dimensionMetricClassIds, possibleDomains);
}
return existMetric;

5
chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/ApplicationStartedInit.java
View File

@@ -45,7 +45,7 @@ public class ApplicationStartedInit implements ApplicationListener<ApplicationSt
*/
@Scheduled(cron = "${reload.knowledge.corn:0 0/1 * * * ?}")
public void reloadKnowledge() {
log.debug("reloadKnowledge start");
log.info("reloadKnowledge start");
try {
List<WordNature> wordNatures = wordNatureService.getAllWordNature();
@@ -55,6 +55,7 @@ public class ApplicationStartedInit implements ApplicationListener<ApplicationSt
log.debug("wordNatures is not change, reloadKnowledge end");
return;
}
log.info("wordNatures is change");
wordNatureService.setPreWordNatures(wordNatures);
onlineKnowledgeService.updateOnlineKnowledge(wordNatureService.getAllWordNature());
wordNatureService.getCache().refresh("");
@@ -63,6 +64,6 @@ public class ApplicationStartedInit implements ApplicationListener<ApplicationSt
log.error("reloadKnowledge error", e);
}
log.debug("reloadKnowledge end");
log.info("reloadKnowledge end");
}
}

15
chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/DictApplicationService.java
View File

@@ -29,19 +29,16 @@ import org.springframework.util.CollectionUtils;
@Service
public class DictApplicationService {
@Value("${dict.flush.enable:true}")
private Boolean dictFlushEnable;
@Value("${dict.file.type:txt}")
private String dictFileType;
private String dimValue = "DimValue_%d_%d";
private String dateTimeFormatter = "yyyyMMddHHmmss";
private final DictMetaUtils metaUtils;
private final DictQueryUtils dictQueryUtils;
private final FileHandler fileHandler;
private final DictRepository dictRepository;
@Value("${dict.flush.enable:true}")
private Boolean dictFlushEnable;
@Value("${dict.file.type:txt}")
private String dictFileType;
private String dimValue = "DimValue_%d_%d";
private String dateTimeFormatter = "yyyyMMddHHmmss";
public DictApplicationService(DictMetaUtils metaUtils,
DictQueryUtils dictQueryUtils,

7
chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/NatureHelper.java
View File

@@ -13,6 +13,8 @@ import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -20,10 +22,9 @@ import org.slf4j.LoggerFactory;
/**
* nature parse helper
*/
@Slf4j
public class NatureHelper {
private static final Logger LOGGER = LoggerFactory.getLogger(NatureHelper.class);
private static boolean isDomainOrEntity(Term term, Integer domain) {
return (NatureType.NATURE_SPILT + domain).equals(term.nature.toString()) || term.nature.toString()
.endsWith(NatureType.ENTITY.getType());
@@ -47,7 +48,7 @@ public class NatureHelper {
}
return Integer.valueOf(split[1]);
} catch (NumberFormatException e) {
LOGGER.error("", e);
log.error("", e);
}
return null;
}

19
chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/WordNatureService.java
View File

@@ -3,8 +3,9 @@ package com.tencent.supersonic.chat.application.knowledge;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.nlp.ItemDO;
import com.tencent.supersonic.common.nlp.NatureType;
@@ -13,9 +14,10 @@ import com.tencent.supersonic.knowledge.application.online.WordNatureStrategyFac
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -23,14 +25,11 @@ import org.springframework.stereotype.Service;
* word nature service
**/
@Service
@Slf4j
public class WordNatureService {
private static final Logger LOGGER = LoggerFactory.getLogger(WordNatureService.class);
@Autowired
private SemanticLayer semanticLayer;
private static final Integer META_CACHE_TIME = 5;
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
private List<WordNature> preWordNatures = new ArrayList<>();
private LoadingCache<String, DomainInfos> cache = CacheBuilder.newBuilder()
@@ -39,14 +38,14 @@ public class WordNatureService {
new CacheLoader<String, DomainInfos>() {
@Override
public DomainInfos load(String key) {
LOGGER.info("load getDomainSchemaInfo cache [{}]", key);
log.info("load getDomainSchemaInfo cache [{}]", key);
return SchemaInfoConverter.convert(semanticLayer.getDomainSchemaInfo(new ArrayList<>()));
}
}
);
public List<WordNature> getAllWordNature() {
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
DomainInfos domainInfos = SchemaInfoConverter.convert(semanticLayer.getDomainSchemaInfo(new ArrayList<>()));
List<WordNature> natures = new ArrayList<>();
@@ -64,7 +63,7 @@ public class WordNatureService {
private void addNatureToResult(NatureType value, List<ItemDO> metas, List<WordNature> natures) {
List<WordNature> natureList = WordNatureStrategyFactory.get(value).getWordNatureList(metas);
LOGGER.debug("nature type:{} , nature size:{}", value.name(), natureList.size());
log.debug("nature type:{} , nature size:{}", value.name(), natureList.size());
natures.addAll(natureList);
}

144
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/DatabaseSchemaMapper.java Normal file
View File

@@ -0,0 +1,144 @@
package com.tencent.supersonic.chat.application.mapper;
import com.hankcs.hanlp.seg.common.Term;
import com.tencent.supersonic.chat.api.component.SchemaMapper;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.application.knowledge.WordNatureService;
import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
import com.tencent.supersonic.common.nlp.ItemDO;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.knowledge.infrastructure.nlp.HanlpHelper;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
@Slf4j
public class DatabaseSchemaMapper implements SchemaMapper {
@Override
public void map(QueryContextReq queryContext) {
log.debug("before db mapper,mapInfo:{}", queryContext.getMapInfo());
List<Term> terms = HanlpHelper.getSegment().seg(queryContext.getQueryText().toLowerCase()).stream()
.collect(Collectors.toList());
WordNatureService wordNatureService = ContextUtils.getBean(WordNatureService.class);
DomainInfos domainInfos = wordNatureService.getCache().getUnchecked("");
detectAndAddToSchema(queryContext, terms, domainInfos.getDimensions(),
SchemaElementType.DIMENSION);
detectAndAddToSchema(queryContext, terms, domainInfos.getMetrics(), SchemaElementType.METRIC);
log.debug("after db mapper,mapInfo:{}", queryContext.getMapInfo());
}
private void detectAndAddToSchema(QueryContextReq queryContext, List<Term> terms, List<ItemDO> domains,
SchemaElementType schemaElementType) {
try {
String queryText = queryContext.getQueryText();
Map<String, Set<ItemDO>> domainResultSet = getResultSet(queryText, terms, domains);
addToSchemaMapInfo(domainResultSet, queryContext.getMapInfo(), schemaElementType);
} catch (Exception e) {
log.error("detectAndAddToSchema error", e);
}
}
private Map<String, Set<ItemDO>> getResultSet(String queryText, List<Term> terms, List<ItemDO> domains) {
MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
Map<String, Set<ItemDO>> nameToItems = getNameToItems(domains);
Map<Integer, Integer> regOffsetToLength = terms.stream().sorted(Comparator.comparing(Term::length))
.collect(Collectors.toMap(Term::getOffset, term -> term.word.length(), (value1, value2) -> value2));
Map<String, Set<ItemDO>> domainResultSet = new HashMap<>();
for (Integer index = 0; index <= queryText.length() - 1; ) {
for (Integer i = index; i <= queryText.length(); ) {
i = mapperHelper.getStepIndex(regOffsetToLength, i);
if (i <= queryText.length()) {
String detectSegment = queryText.substring(index, i);
nameToItems.forEach(
(name, newItemDOs) -> {
if (name.contains(detectSegment)
&& mapperHelper.getSimilarity(detectSegment, name)
>= mapperHelper.getMetricDimensionThresholdConfig()) {
Set<ItemDO> preItemDOS = domainResultSet.putIfAbsent(detectSegment, newItemDOs);
if (Objects.nonNull(preItemDOS)) {
preItemDOS.addAll(newItemDOs);
}
}
}
);
}
}
index = mapperHelper.getStepIndex(regOffsetToLength, index);
}
return domainResultSet;
}
private Map<String, Set<ItemDO>> getNameToItems(List<ItemDO> domains) {
return domains.stream()
.collect(Collectors.toMap(ItemDO::getName, a -> {
Set<ItemDO> result = new HashSet<>();
result.add(a);
return result;
}, (k1, k2) -> {
k1.addAll(k2);
return k1;
}));
}
private void addToSchemaMapInfo(Map<String, Set<ItemDO>> mapResultRowSet, SchemaMapInfo schemaMap,
SchemaElementType schemaElementType) {
if (Objects.isNull(mapResultRowSet) || mapResultRowSet.size() <= 0) {
return;
}
MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
for (Map.Entry<String, Set<ItemDO>> entry : mapResultRowSet.entrySet()) {
String detectWord = entry.getKey();
Set<ItemDO> itemDOS = entry.getValue();
for (ItemDO itemDO : itemDOS) {
List<SchemaElementMatch> elements = schemaMap.getMatchedElements(itemDO.getDomain());
if (CollectionUtils.isEmpty(elements)) {
elements = new ArrayList<>();
schemaMap.setMatchedElements(itemDO.getDomain(), elements);
}
Set<Integer> regElementSet = elements.stream()
.filter(elementMatch -> schemaElementType.equals(elementMatch.getElementType()))
.map(elementMatch -> elementMatch.getElementID())
.collect(Collectors.toSet());
if (regElementSet.contains(itemDO.getItemId())) {
continue;
}
SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
.elementID(itemDO.getItemId()).word(itemDO.getName()).frequency(10000L)
.elementType(schemaElementType).detectWord(detectWord)
.similarity(mapperHelper.getSimilarity(detectWord, itemDO.getName()))
.build();
log.info("schemaElementType:{},add to schema, elementMatch {}", schemaElementType, schemaElementMatch);
elements.add(schemaElementMatch);
}
}
}
}

53
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/HanlpSchemaMapper.java
View File

@@ -1,17 +1,17 @@
package com.tencent.supersonic.chat.application.mapper;
import com.hankcs.hanlp.seg.common.Term;
import com.tencent.supersonic.chat.api.component.SchemaMapper;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SchemaMapper;
import com.tencent.supersonic.chat.application.knowledge.NatureHelper;
import com.tencent.supersonic.chat.domain.pojo.search.MatchText;
import com.tencent.supersonic.chat.domain.utils.NatureConverter;
import com.tencent.supersonic.common.nlp.MapResult;
import com.tencent.supersonic.common.nlp.NatureType;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.common.util.json.JsonUtil;
import com.tencent.supersonic.knowledge.application.online.BaseWordNature;
import com.tencent.supersonic.knowledge.application.online.WordNatureStrategyFactory;
import com.tencent.supersonic.knowledge.infrastructure.nlp.HanlpHelper;
@@ -19,15 +19,14 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Slf4j
public class HanlpSchemaMapper implements SchemaMapper {
private static final Logger LOGGER = LoggerFactory.getLogger(HanlpSchemaMapper.class);
@Override
public void map(QueryContextReq queryContext) {
@@ -35,22 +34,37 @@ public class HanlpSchemaMapper implements SchemaMapper {
.collect(Collectors.toList());
terms.forEach(
item -> LOGGER.info("word:{},nature:{},frequency:{}", item.word, item.nature.toString(),
item -> log.info("word:{},nature:{},frequency:{}", item.word, item.nature.toString(),
item.getFrequency())
);
QueryMatchStrategy matchStrategy = ContextUtils.getBean(QueryMatchStrategy.class);
List<MapResult> matches = matchStrategy.match(queryContext.getQueryText(), terms, queryContext.getDomainId());
Map<MatchText, List<MapResult>> matchResult = matchStrategy.match(queryContext.getQueryText(), terms,
queryContext.getDomainId());
List<MapResult> matches = new ArrayList<>();
if (Objects.nonNull(matchResult)) {
Optional<List<MapResult>> first = matchResult.entrySet().stream()
.filter(entry -> CollectionUtils.isNotEmpty(entry.getValue()))
.map(entry -> entry.getValue()).findFirst();
if (first.isPresent()) {
matches = first.get();
}
}
HanlpHelper.transLetterOriginal(matches);
LOGGER.info("queryContext:{},matches:{}", queryContext, matches);
log.info("queryContext:{},matches:{}", queryContext, matches);
convertTermsToSchemaMapInfo(matches, queryContext.getMapInfo());
convertTermsToSchemaMapInfo(matches, queryContext.getMapInfo(), terms);
}
private void convertTermsToSchemaMapInfo(List<MapResult> mapResults, SchemaMapInfo schemaMap) {
private void convertTermsToSchemaMapInfo(List<MapResult> mapResults, SchemaMapInfo schemaMap, List<Term> terms) {
if (CollectionUtils.isEmpty(mapResults)) {
return;
}
Map<String, Long> wordNatureToFrequency = terms.stream().collect(
Collectors.toMap(entry -> entry.getWord() + entry.getNature(),
term -> Long.valueOf(term.getFrequency()), (value1, value2) -> value2));
for (MapResult mapResult : mapResults) {
for (String nature : mapResult.getNatures()) {
Integer domain = NatureHelper.getDomain(nature);
@@ -61,17 +75,18 @@ public class HanlpSchemaMapper implements SchemaMapper {
if (Objects.isNull(elementType)) {
continue;
}
SchemaElementMatch schemaElementMatch = new SchemaElementMatch();
schemaElementMatch.setElementType(elementType);
BaseWordNature baseWordNature = WordNatureStrategyFactory.get(NatureType.getNatureType(nature));
Integer elementID = baseWordNature.getElementID(nature);
schemaElementMatch.setElementID(elementID);
Long frequency = baseWordNature.getFrequency(nature);
schemaElementMatch.setFrequency(frequency);
schemaElementMatch.setWord(mapResult.getName());
schemaElementMatch.setSimilarity(mapResult.getSimilarity());
schemaElementMatch.setDetectWord(mapResult.getDetectWord());
Long frequency = wordNatureToFrequency.get(mapResult.getName() + nature);
SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
.elementType(elementType)
.elementID(elementID)
.frequency(frequency)
.word(mapResult.getName())
.similarity(mapResult.getSimilarity())
.detectWord(mapResult.getDetectWord())
.build();
Map<Integer, List<SchemaElementMatch>> domainElementMatches = schemaMap.getDomainElementMatches();
List<SchemaElementMatch> schemaElementMatches = domainElementMatches.putIfAbsent(domain,

83
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/MapperHelper.java Normal file
View File

@@ -0,0 +1,83 @@
package com.tencent.supersonic.chat.application.mapper;
import com.hankcs.hanlp.algorithm.EditDistance;
import com.tencent.supersonic.chat.application.knowledge.NatureHelper;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* Mapper helper
*/
@Data
@Service
@Slf4j
public class MapperHelper {
@Value("${one.detection.size:6}")
private Integer oneDetectionSize;
@Value("${one.detection.max.size:20}")
private Integer oneDetectionMaxSize;
@Value("${metric.dimension.threshold:0.3}")
private Double metricDimensionThresholdConfig;
@Value("${dimension.value.threshold:0.5}")
private Double dimensionValueThresholdConfig;
public Integer getStepIndex(Map<Integer, Integer> regOffsetToLength, Integer index) {
Integer subRegLength = regOffsetToLength.get(index);
if (Objects.nonNull(subRegLength)) {
index = index + subRegLength;
} else {
index++;
}
return index;
}
public Integer getStepOffset(List<Integer> termList, Integer index) {
for (int j = 0; j < termList.size() - 1; j++) {
if (termList.get(j) <= index && termList.get(j + 1) > index) {
return termList.get(j);
}
}
return index;
}
public double getThresholdMatch(List<String> natures) {
if (existDimensionValues(natures)) {
return dimensionValueThresholdConfig;
}
return metricDimensionThresholdConfig;
}
/***
* exist dimension values
* @param natures
* @return
*/
public boolean existDimensionValues(List<String> natures) {
for (String nature : natures) {
if (NatureHelper.isDimensionValueClassId(nature)) {
return true;
}
}
return false;
}
/***
* get similarity
* @param detectSegment
* @param matchName
* @return
*/
public double getSimilarity(String detectSegment, String matchName) {
String detectSegmentLower = detectSegment == null ? null : detectSegment.toLowerCase();
String matchNameLower = matchName == null ? null : matchName.toLowerCase();
return 1 - (double) EditDistance.compute(detectSegmentLower, matchNameLower) / Math.max(matchName.length(),
detectSegment.length());
}
}

31
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/MatchStrategy.java
View File

@@ -1,8 +1,6 @@
package com.tencent.supersonic.chat.application.mapper;
import com.hankcs.hanlp.algorithm.EditDistance;
import com.hankcs.hanlp.seg.common.Term;
import com.tencent.supersonic.chat.application.knowledge.NatureHelper;
import com.tencent.supersonic.chat.domain.pojo.search.MatchText;
import com.tencent.supersonic.common.nlp.MapResult;
import java.util.List;
@@ -13,33 +11,6 @@ import java.util.Map;
*/
public interface MatchStrategy {
List<MapResult> match(String text, List<Term> terms, Integer detectDomainId);
Map<MatchText, List<MapResult>> match(String text, List<Term> terms, Integer detectDomainId);
Map<MatchText, List<MapResult>> matchWithMatchText(String text, List<Term> originals, Integer detectDomainId);
/***
* exist dimension values
* @param natures
* @return
*/
default boolean existDimensionValues(List<String> natures) {
for (String nature : natures) {
if (NatureHelper.isDimensionValueClassId(nature)) {
return true;
}
}
return false;
}
/***
* get similarity
* @param detectSegment
* @param matchName
* @return
*/
default double getSimilarity(String detectSegment, String matchName) {
return 1 - (double) EditDistance.compute(detectSegment, matchName) / Math.max(matchName.length(),
detectSegment.length());
}
}

50
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/QueryFilterMapper.java Normal file
View File

@@ -0,0 +1,50 @@
package com.tencent.supersonic.chat.application.mapper;
import com.google.common.collect.Lists;
import com.tencent.supersonic.chat.api.component.SchemaMapper;
import com.tencent.supersonic.chat.api.pojo.*;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import java.util.List;
@Slf4j
public class QueryFilterMapper implements SchemaMapper {
private Long FREQUENCY = 9999999L;
private double SIMILARITY = 1.0;
@Override
public void map(QueryContextReq queryContext) {
Integer domainId = queryContext.getDomainId();
if (domainId == null || domainId <= 0 || queryContext.getQueryFilter() == null) {
return;
}
QueryFilter queryFilter = queryContext.getQueryFilter();
SchemaMapInfo schemaMapInfo = queryContext.getMapInfo();
List<SchemaElementMatch> schemaElementMatches = schemaMapInfo.getMatchedElements(domainId);
convertFilterToSchemaMapInfo(queryFilter.getFilters(), schemaElementMatches);
}
private void convertFilterToSchemaMapInfo(List<Filter> filters, List<SchemaElementMatch> schemaElementMatches) {
log.info("schemaElementMatches before queryFilerMapper:{}", schemaElementMatches);
if (CollectionUtils.isEmpty(schemaElementMatches)) {
schemaElementMatches = Lists.newArrayList();
}
for (Filter filter : filters) {
SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
.elementType(SchemaElementType.VALUE)
.elementID(filter.getElementID().intValue())
.frequency(FREQUENCY)
.word(String.valueOf(filter.getValue()))
.similarity(SIMILARITY)
.detectWord(filter.getName())
.build();
schemaElementMatches.add(schemaElementMatch);
}
log.info("schemaElementMatches after queryFilerMapper:{}", schemaElementMatches);
}
}

98
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/QueryMatchStrategy.java
View File

@@ -5,42 +5,34 @@ import com.tencent.supersonic.chat.domain.pojo.search.MatchText;
import com.tencent.supersonic.common.nlp.MapResult;
import com.tencent.supersonic.common.nlp.NatureType;
import com.tencent.supersonic.knowledge.infrastructure.nlp.Suggester;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* match strategy implement
*/
@Service
@Slf4j
public class QueryMatchStrategy implements MatchStrategy {
private static final Logger LOGGER = LoggerFactory.getLogger(QueryMatchStrategy.class);
public static final double STEP = 0.1;
@Value("${one.detection.size:6}")
private Integer oneDetectionSize;
@Value("${one.detection.max.size:20}")
private Integer oneDetectionMaxSize;
@Value("${metric.dimension.threshold:0.3}")
private Double metricDimensionThresholdConfig;
@Value("${dimension.value.threshold:0.5}")
private Double dimensionValueThresholdConfig;
@Autowired
private MapperHelper mapperHelper;
@Override
public List<MapResult> match(String text, List<Term> terms, Integer detectDomainId) {
public Map<MatchText, List<MapResult>> match(String text, List<Term> terms, Integer detectDomainId) {
if (CollectionUtils.isEmpty(terms) || StringUtils.isEmpty(text)) {
return null;
}
@@ -50,17 +42,14 @@ public class QueryMatchStrategy implements MatchStrategy {
List<Integer> offsetList = terms.stream().sorted(Comparator.comparing(Term::getOffset))
.map(term -> term.getOffset()).collect(Collectors.toList());
LOGGER.debug("retryCount:{},terms:{},regOffsetToLength:{},offsetList:{},detectDomainId:{}", terms,
log.debug("retryCount:{},terms:{},regOffsetToLength:{},offsetList:{},detectDomainId:{}", terms,
regOffsetToLength, offsetList, detectDomainId);
return detect(text, regOffsetToLength, offsetList, detectDomainId);
}
@Override
public Map<MatchText, List<MapResult>> matchWithMatchText(String text, List<Term> originals,
Integer detectDomainId) {
return null;
List<MapResult> detects = detect(text, regOffsetToLength, offsetList, detectDomainId);
Map<MatchText, List<MapResult>> result = new HashMap<>();
MatchText matchText = new MatchText(text, text);
result.put(matchText, detects);
return result;
}
private List<MapResult> detect(String text, Map<Integer, Integer> regOffsetToLength, List<Integer> offsetList,
@@ -72,15 +61,15 @@ public class QueryMatchStrategy implements MatchStrategy {
Set<MapResult> mapResultRowSet = new LinkedHashSet();
for (Integer i = index; i <= text.length(); ) {
int offset = getStepOffset(offsetList, index);
i = getStepIndex(regOffsetToLength, i);
int offset = mapperHelper.getStepOffset(offsetList, index);
i = mapperHelper.getStepIndex(regOffsetToLength, i);
if (i <= text.length()) {
List<MapResult> mapResults = detectByStep(text, detectDomainId, index, i, offset);
mapResultRowSet.addAll(mapResults);
}
}
index = getStepIndex(regOffsetToLength, index);
index = mapperHelper.getStepIndex(regOffsetToLength, index);
results.addAll(mapResultRowSet);
}
return results;
@@ -88,11 +77,13 @@ public class QueryMatchStrategy implements MatchStrategy {
private List<MapResult> detectByStep(String text, Integer detectDomainId, Integer index, Integer i, int offset) {
String detectSegment = text.substring(index, i);
Integer oneDetectionSize = mapperHelper.getOneDetectionSize();
// step1. pre search
LinkedHashSet<MapResult> mapResults = Suggester.prefixSearch(detectSegment, oneDetectionMaxSize)
LinkedHashSet<MapResult> mapResults = Suggester.prefixSearch(detectSegment,
mapperHelper.getOneDetectionMaxSize())
.stream().collect(Collectors.toCollection(LinkedHashSet::new));
// step2. suffix search
LinkedHashSet<MapResult> suffixMapResults = Suggester.suffixSearch(detectSegment, oneDetectionMaxSize)
LinkedHashSet<MapResult> suffixMapResults = Suggester.suffixSearch(detectSegment, oneDetectionSize)
.stream().collect(Collectors.toCollection(LinkedHashSet::new));
mapResults.addAll(suffixMapResults);
@@ -105,7 +96,7 @@ public class QueryMatchStrategy implements MatchStrategy {
.collect(Collectors.toCollection(LinkedHashSet::new));
// step4. filter by classId
if (Objects.nonNull(detectDomainId) && detectDomainId > 0) {
LOGGER.debug("detectDomainId:{}, before parseResults:{}", mapResults);
log.debug("detectDomainId:{}, before parseResults:{}", mapResults);
mapResults = mapResults.stream().map(entry -> {
List<String> natures = entry.getNatures().stream().filter(
nature -> nature.startsWith(NatureType.NATURE_SPILT + detectDomainId) || (nature.startsWith(
@@ -114,25 +105,27 @@ public class QueryMatchStrategy implements MatchStrategy {
entry.setNatures(natures);
return entry;
}).collect(Collectors.toCollection(LinkedHashSet::new));
LOGGER.info("after domainId parseResults:{}", mapResults);
log.info("after domainId parseResults:{}", mapResults);
}
// step5. filter by similarity
mapResults = mapResults.stream()
.filter(term -> getSimilarity(detectSegment, term.getName()) >= getThresholdMatch(term.getNatures()))
.filter(term -> mapperHelper.getSimilarity(detectSegment, term.getName())
>= mapperHelper.getThresholdMatch(term.getNatures()))
.filter(term -> CollectionUtils.isNotEmpty(term.getNatures()))
.collect(Collectors.toCollection(LinkedHashSet::new));
LOGGER.debug("metricDimensionThreshold:{},dimensionValueThreshold:{},after isSimilarity parseResults:{}",
log.debug("metricDimensionThreshold:{},dimensionValueThreshold:{},after isSimilarity parseResults:{}",
mapResults);
mapResults = mapResults.stream().map(parseResult -> {
parseResult.setOffset(offset);
parseResult.setSimilarity(getSimilarity(detectSegment, parseResult.getName()));
parseResult.setSimilarity(mapperHelper.getSimilarity(detectSegment, parseResult.getName()));
return parseResult;
}).collect(Collectors.toCollection(LinkedHashSet::new));
// step6. take only one dimension or 10 metric/dimension value per rond.
List<MapResult> dimensionMetrics = mapResults.stream().filter(entry -> existDimensionValues(entry.getNatures()))
List<MapResult> dimensionMetrics = mapResults.stream()
.filter(entry -> mapperHelper.existDimensionValues(entry.getNatures()))
.collect(Collectors.toList())
.stream()
.limit(1)
@@ -144,31 +137,4 @@ public class QueryMatchStrategy implements MatchStrategy {
return mapResults.stream().limit(oneDetectionSize).collect(Collectors.toList());
}
}
private Integer getStepIndex(Map<Integer, Integer> regOffsetToLength, Integer index) {
Integer subRegLength = regOffsetToLength.get(index);
if (Objects.nonNull(subRegLength)) {
index = index + subRegLength;
} else {
index++;
}
return index;
}
private Integer getStepOffset(List<Integer> termList, Integer index) {
for (int j = 0; j < termList.size() - 1; j++) {
if (termList.get(j) <= index && termList.get(j + 1) > index) {
return termList.get(j);
}
}
return index;
}
private double getThresholdMatch(List<String> natures) {
if (existDimensionValues(natures)) {
return dimensionValueThresholdConfig;
}
return metricDimensionThresholdConfig;
}
}

9
chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/SearchMatchStrategy.java
View File

@@ -23,15 +23,8 @@ public class SearchMatchStrategy implements MatchStrategy {
private static final int SEARCH_SIZE = 3;
@Override
public List<MapResult> match(String text, List<Term> terms, Integer detectDomainId) {
return null;
}
@Override
public Map<MatchText, List<MapResult>> matchWithMatchText(String text, List<Term> originals,
public Map<MatchText, List<MapResult>> match(String text, List<Term> originals,
Integer detectDomainId) {
Map<Integer, Integer> regOffsetToLength = originals.stream()

100
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/AggregateSemanticParser.java
View File

@@ -1,59 +1,82 @@
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.component.SemanticParser;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.chat.application.parser.resolver.AggregateTypeResolver;
import com.tencent.supersonic.chat.application.query.MetricCompare;
import com.tencent.supersonic.chat.application.query.MetricFilter;
import com.tencent.supersonic.chat.application.query.EntityListFilter;
import com.tencent.supersonic.chat.application.query.MetricGroupBy;
import com.tencent.supersonic.chat.application.query.MetricOrderBy;
import com.tencent.supersonic.common.enums.AggregateTypeEnum;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import java.util.List;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import lombok.extern.slf4j.Slf4j;
@Component
@Slf4j
public class AggregateSemanticParser implements SemanticParser {
private final Logger logger = LoggerFactory.getLogger(AggregateSemanticParser.class);
public static final Integer TOPN_LIMIT = 1000;
private AggregateTypeResolver aggregateTypeResolver;
private static Map<AggregateTypeEnum, Pattern> aggregateRegexMap = new HashMap<>();
static {
aggregateRegexMap.put(AggregateTypeEnum.MAX, Pattern.compile("(?i)(最大值|最大|max|峰值|最高|最多)"));
aggregateRegexMap.put(AggregateTypeEnum.MIN, Pattern.compile("(?i)(最小值|最小|min|最低|最少)"));
aggregateRegexMap.put(AggregateTypeEnum.SUM, Pattern.compile("(?i)(汇总|总和|sum)"));
aggregateRegexMap.put(AggregateTypeEnum.AVG, Pattern.compile("(?i)(平均值|日均|平均|avg)"));
aggregateRegexMap.put(AggregateTypeEnum.TOPN, Pattern.compile("(?i)(top)"));
aggregateRegexMap.put(AggregateTypeEnum.DISTINCT, Pattern.compile("(?i)(uv)"));
aggregateRegexMap.put(AggregateTypeEnum.COUNT, Pattern.compile("(?i)(总数|pv)"));
aggregateRegexMap.put(AggregateTypeEnum.NONE, Pattern.compile("(?i)(明细)"));
}
public static AggregateTypeEnum resolveAggregateType(String queryText) {
Map<AggregateTypeEnum, Integer> aggregateCount = new HashMap<>(aggregateRegexMap.size());
for (Map.Entry<AggregateTypeEnum, Pattern> entry : aggregateRegexMap.entrySet()) {
Matcher matcher = entry.getValue().matcher(queryText);
int count = 0;
while (matcher.find()) {
count++;
}
if (count > 0) {
aggregateCount.put(entry.getKey(), count);
}
}
return aggregateCount.entrySet().stream().max(Map.Entry.comparingByValue()).map(entry -> entry.getKey())
.orElse(null);
}
@Override
public boolean parse(QueryContextReq queryContext, ChatContext chatCtx) {
aggregateTypeResolver = ContextUtils.getBean(AggregateTypeResolver.class);
public void parse(QueryContextReq queryContext, ChatContext chatContext) {
AggregateTypeEnum aggregateType = resolveAggregateType(queryContext.getQueryText());
AggregateTypeEnum aggregateType = aggregateTypeResolver.resolve(queryContext.getQueryText());
SemanticParseInfo semanticParse = queryContext.getParseInfo();
Set<SchemaItem> metrics = semanticParse.getMetrics();
semanticParse.setNativeQuery(getNativeQuery(aggregateType, queryContext));
for (SemanticQuery semanticQuery : queryContext.getCandidateQueries()) {
SemanticParseInfo semanticParse = semanticQuery.getParseInfo();
semanticParse.setNativeQuery(getNativeQuery(aggregateType, semanticParse));
semanticParse.setAggType(aggregateType);
//semanticParse.setOrders(getOrder(aggregateType, metrics));
if (Objects.isNull(semanticParse.getLimit()) || semanticParse.getLimit() <= 0) {
semanticParse.setLimit(Long.valueOf(TOPN_LIMIT));
resetQueryModeByAggregateType(queryContext, aggregateType);
return false;
}
resetQueryModeByAggregateType(semanticParse, aggregateType);
}
}
/**
* query mode reset by the AggregateType
*
* @param queryContext
* @param parseInfo
* @param aggregateType
*/
private void resetQueryModeByAggregateType(QueryContextReq queryContext, AggregateTypeEnum aggregateType) {
private void resetQueryModeByAggregateType(SemanticParseInfo parseInfo,
AggregateTypeEnum aggregateType) {
SemanticParseInfo parseInfo = queryContext.getParseInfo();
String queryMode = parseInfo.getQueryMode();
if (MetricGroupBy.QUERY_MODE.equals(queryMode) || MetricGroupBy.QUERY_MODE.equals(queryMode)) {
if (AggregateTypeEnum.MAX.equals(aggregateType) || AggregateTypeEnum.MIN.equals(aggregateType)
@@ -62,23 +85,18 @@ public class AggregateSemanticParser implements SemanticParser {
} else {
parseInfo.setQueryMode(MetricGroupBy.QUERY_MODE);
}
log.info("queryMode mode [{}]->[{}]", queryMode, parseInfo.getQueryMode());
}
if (MetricFilter.QUERY_MODE.equals(queryMode) || MetricCompare.QUERY_MODE.equals(queryMode)) {
if (aggregateTypeResolver.hasCompareIntentionalWords(queryContext.getQueryText())) {
parseInfo.setQueryMode(MetricCompare.QUERY_MODE);
} else {
parseInfo.setQueryMode(MetricFilter.QUERY_MODE);
}
}
logger.info("queryMode mode [{}]->[{}]", queryMode, parseInfo.getQueryMode());
}
private boolean getNativeQuery(AggregateTypeEnum aggregateType, QueryContextReq queryContext) {
private boolean getNativeQuery(AggregateTypeEnum aggregateType, SemanticParseInfo semanticParse) {
if (AggregateTypeEnum.TOPN.equals(aggregateType)) {
return true;
}
return queryContext.getParseInfo().getNativeQuery();
if (EntityListFilter.QUERY_MODE.equals(semanticParse.getQueryMode()) && (semanticParse.getMetrics() == null
|| semanticParse.getMetrics().isEmpty())) {
return true;
}
return semanticParse.getNativeQuery();
}
}

8
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/DomainResolver.java → chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/DomainResolver.java
View File

@@ -1,10 +1,12 @@
package com.tencent.supersonic.chat.application.parser.resolver;
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import java.util.Map;
public interface DomainResolver {
@@ -12,6 +14,6 @@ public interface DomainResolver {
Integer resolve(Map<Integer, SemanticQuery> domainQueryModes, QueryContextReq queryCtx, ChatContext chatCtx,
SchemaMapInfo schemaMap);
boolean isDomainSwitch(ChatContext chatCtx, QueryContextReq queryCtx);
boolean isDomainSwitch(ChatContext chatCtx, SemanticParseInfo semanticParseInfo);
}

334
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/DomainSemanticParser.java
View File

@@ -1,125 +1,111 @@
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticParser;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.*;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.application.parser.resolver.DomainResolver;
import com.tencent.supersonic.chat.application.parser.resolver.SemanticQueryResolver;
import com.tencent.supersonic.chat.application.query.*;
import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.utils.*;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
@Component
@Slf4j
public class DomainSemanticParser implements SemanticParser {
private final Logger logger = LoggerFactory.getLogger(DomainSemanticParser.class);
private List<DomainResolver> domainResolverList;
private SemanticQueryResolver semanticQueryResolver;
public DomainSemanticParser() {
domainResolverList = SpringFactoriesLoader.loadFactories(DomainResolver.class,
Thread.currentThread().getContextClassLoader());
}
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
@Override
public boolean parse(QueryContextReq queryContext, ChatContext chatCtx) {
DomainInfos domainInfosDb = SchemaInfoConverter.convert(
ContextUtils.getBean(SemanticLayer.class).getDomainSchemaInfo(new ArrayList<>()));
public void parse(QueryContextReq queryContext, ChatContext chatContext) {
DomainInfos domainInfosDb = SchemaInfoConverter.convert(semanticLayer.getDomainSchemaInfo(new ArrayList<>()));
Map<Integer, String> domainToName = domainInfosDb.getDomainToName();
SchemaMapInfo mapInfo = queryContext.getMapInfo();
SemanticParseInfo parseInfo = queryContext.getParseInfo();
//domainResolver = ContextUtils.getBean(DomainResolver.class);
semanticQueryResolver = ContextUtils.getBean(SemanticQueryResolver.class);
Map<Integer, SemanticQuery> domainSemanticQuery = new HashMap<>();
// Round 1: find all domains that can be resolved to any query mode
for (Integer domain : mapInfo.getMatchedDomains()) {
List<SchemaElementMatch> elementMatches = mapInfo.getMatchedElements(domain);
SemanticQuery query = semanticQueryResolver.resolve(elementMatches, queryContext);
if (Objects.nonNull(query)) {
domainSemanticQuery.put(domain, query);
// iterate all schemaElementMatches to resolve semantic query
for (Integer domainId : mapInfo.getMatchedDomains()) {
List<SchemaElementMatch> elementMatches = mapInfo.getMatchedElements(domainId);
Map<RuleSemanticQuery, List<SchemaElementMatch>> queryMatches = resolveQuery(elementMatches, queryContext);
for (Map.Entry<RuleSemanticQuery, List<SchemaElementMatch>> match : queryMatches.entrySet()) {
addCandidateQuery(queryContext, chatContext, domainId.longValue(),
domainToName.get(domainId), match.getKey(), match.getValue());
}
}
// only one domain is found, no need to rank
if (domainSemanticQuery.size() == 1) {
Optional<Map.Entry<Integer, SemanticQuery>> match = domainSemanticQuery.entrySet().stream().findFirst();
if (match.isPresent()) {
logger.info("select by only one [{}:{}]", match.get().getKey(), match.get().getValue());
parseInfo.setDomainId(Long.valueOf(match.get().getKey()));
parseInfo.setDomainName(domainToName.get(Integer.valueOf(match.get().getKey())));
parseInfo.setQueryMode(match.get().getValue().getQueryMode());
return false;
}
} else if (domainSemanticQuery.size() > 1) {
// will choose one by the domain select
Optional<Integer> domainId = domainResolverList.stream()
.map(domainResolver -> domainResolver.resolve(domainSemanticQuery, queryContext, chatCtx, mapInfo))
.filter(d -> d > 0).findFirst();
if (domainId.isPresent() && domainId.get() > 0) {
for (Map.Entry<Integer, SemanticQuery> match : domainSemanticQuery.entrySet()) {
if (match.getKey().equals(domainId.get())) {
logger.info("select by selectStrategy [{}:{}]", domainId.get(), match.getValue());
parseInfo.setDomainId(Long.valueOf(match.getKey()));
parseInfo.setDomainName(domainToName.get(Integer.valueOf(match.getKey())));
parseInfo.setQueryMode(match.getValue().getQueryMode());
return false;
}
}
}
}
// Round 2: no domains can be found yet, count in chat context
if (chatCtx.getParseInfo() != null && chatCtx.getParseInfo().getDomainId() > 0) {
Integer chatDomain = Integer.valueOf(chatCtx.getParseInfo().getDomainId().intValue());
if (mapInfo.getMatchedDomains().contains(chatDomain) || CollectionUtils.isEmpty(
mapInfo.getMatchedDomains())) {
List<SchemaElementMatch> elementMatches = mapInfo.getMatchedElements(chatDomain);
if (CollectionUtils.isEmpty(elementMatches)) {
parseInfo.setDomainId(Long.valueOf(chatDomain));
parseInfo.setDomainName(domainToName.get(chatDomain));
parseInfo.setQueryMode(chatCtx.getParseInfo().getQueryMode());
return false;
}
SemanticQuery query = tryParseByContext(elementMatches, chatCtx, queryContext);
if (Objects.nonNull(query)) {
logger.info("select by context count [{}:{}]", chatDomain, query);
parseInfo.setDomainId(Long.valueOf(chatDomain));
parseInfo.setDomainName(domainToName.get(chatDomain));
parseInfo.setQueryMode(query.getQueryMode());
return false;
// if no candidates have been found yet, count in chat context and try again
if (queryContext.getCandidateQueries().size() <= 0) {
if (chatContext.getParseInfo() != null && chatContext.getParseInfo().getDomainId() > 0) {
Integer chatDomainId = Integer.valueOf(chatContext.getParseInfo().getDomainId().intValue());
if (mapInfo.getMatchedDomains().contains(chatDomainId)) {
List<SchemaElementMatch> elementMatches = mapInfo.getMatchedElements(chatDomainId);
detectionContext(chatContext);
Map<RuleSemanticQuery, List<SchemaElementMatch>> queryMatches = tryParseByContext(elementMatches,
chatContext, queryContext);
for (Map.Entry<RuleSemanticQuery, List<SchemaElementMatch>> match : queryMatches.entrySet()) {
addCandidateQuery(queryContext, chatContext, chatDomainId.longValue(),
domainToName.get(chatDomainId), match.getKey(), match.getValue());
}
}
}
}
// Round 3: no domains can be found yet, count in default metric
return false;
}
private void addCandidateQuery(QueryContextReq queryContext, ChatContext chatContext,
Long domainId, String domainName,
RuleSemanticQuery semanticQuery, List<SchemaElementMatch> elementMatches) {
if (semanticQuery != null) {
fillParseInfo(semanticQuery, domainId, domainName, elementMatches);
// inherit from context
inheritContext(semanticQuery, chatContext);
// default metric, date, dimension
injectDefaultMetric(semanticQuery, queryContext, chatContext);
queryContext.getCandidateQueries().add(semanticQuery);
}
}
protected void inheritContext(RuleSemanticQuery semanticQuery, ChatContext chatContext) {
// is domain switch
SemanticParseInfo semanticParse = semanticQuery.getParseInfo();
DomainResolver domainResolver = ComponentFactory.getDomainResolver();
if (!domainResolver.isDomainSwitch(chatContext, semanticParse)) {
semanticQuery.inheritContext(chatContext);
}
}
protected void injectDefaultMetric(RuleSemanticQuery semanticQuery, QueryContextReq queryContext,
ChatContext chatContext) {
DefaultMetricUtils defaultMetricUtils = ContextUtils.getBean(DefaultMetricUtils.class);
defaultMetricUtils.injectDefaultMetric(semanticQuery.getParseInfo(), queryContext, chatContext);
}
/**
* get the chatContext for the tryParseByContext
*
* @param chatContext
*/
protected void detectionContext(ChatContext chatContext) {
if (chatContext.getParseInfo() != null) {
SemanticParseInfo semanticParseInfo = chatContext.getParseInfo();
if (semanticParseInfo.getQueryMode().equals(EntityDetail.QUERY_MODE)) {
// EntityDetail model will unset some items
semanticParseInfo.setDateInfo(null);
semanticParseInfo.setMetrics(new HashSet<>());
semanticParseInfo.setDimensions(new HashSet<>());
}
}
}
/**
* try to add ChatContext to SchemaElementMatch and look if match QueryMode
@@ -128,8 +114,8 @@ public class DomainSemanticParser implements SemanticParser {
* @param chatCtx
* @return
*/
private SemanticQuery tryParseByContext(List<SchemaElementMatch> elementMatches, ChatContext chatCtx,
QueryContextReq searchCt) {
private Map<RuleSemanticQuery, List<SchemaElementMatch>> tryParseByContext(List<SchemaElementMatch> elementMatches,
ChatContext chatCtx, QueryContextReq queryCtx) {
if (chatCtx.getParseInfo() != null && chatCtx.getParseInfo().getEntity() > 0) {
Long entityCount = elementMatches.stream().filter(i -> SchemaElementType.ENTITY.equals(i.getElementType()))
.count();
@@ -137,27 +123,29 @@ public class DomainSemanticParser implements SemanticParser {
.count();
if (entityCount <= 0 && metricCount <= 0 && ContextHelper.hasEntityId(chatCtx)) {
// try entity parse
SchemaElementMatch entityElementMatch = new SchemaElementMatch();
entityElementMatch.setElementType(SchemaElementType.ENTITY);
SchemaElementMatch entityElementMatch = SchemaElementMatch.builder()
.elementType(SchemaElementType.ENTITY).build();
List<SchemaElementMatch> newSchemaElementMatch = new ArrayList<>();
if (!CollectionUtils.isEmpty(elementMatches)) {
newSchemaElementMatch.addAll(elementMatches);
}
newSchemaElementMatch.add(entityElementMatch);
SemanticQuery semanticQuery = doParseByContext(newSchemaElementMatch, chatCtx, searchCt);
if (Objects.nonNull(semanticQuery)) {
return semanticQuery;
Map<RuleSemanticQuery, List<SchemaElementMatch>> queryMatches = doParseByContext(newSchemaElementMatch,
chatCtx, queryCtx);
if (queryMatches.size() > 0) {
return queryMatches;
}
}
}
return doParseByContext(elementMatches, chatCtx, searchCt);
return doParseByContext(elementMatches, chatCtx, queryCtx);
}
private SemanticQuery doParseByContext(List<SchemaElementMatch> elementMatches, ChatContext chatCtx,
QueryContextReq searchCt) {
SemanticParseInfo contextSemanticParseInfo = chatCtx.getParseInfo();
if (contextSemanticParseInfo != null) {
List<SchemaElementMatch> newSchemaElementMatch = new ArrayList<>();
private Map<RuleSemanticQuery, List<SchemaElementMatch>> doParseByContext(List<SchemaElementMatch> elementMatches,
ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo contextSemanticParse = chatCtx.getParseInfo();
if (contextSemanticParse != null) {
List<SchemaElementMatch> newElementMatches = new ArrayList<>();
List<List<SchemaElementType>> trySchemaElementTypes = new LinkedList<>();
// try DIMENSION+METRIC+VALUE
// try DIMENSION+METRIC METRIC+VALUE DIMENSION+VALUE
@@ -175,18 +163,122 @@ public class DomainSemanticParser implements SemanticParser {
trySchemaElementTypes.add(new ArrayList<>(Arrays.asList(SchemaElementType.DIMENSION)));
for (List<SchemaElementType> schemaElementTypes : trySchemaElementTypes) {
newSchemaElementMatch.clear();
newElementMatches.clear();
if (!CollectionUtils.isEmpty(elementMatches)) {
newSchemaElementMatch.addAll(elementMatches);
newElementMatches.addAll(elementMatches);
}
ContextHelper.mergeContextSchemaElementMatch(newSchemaElementMatch, elementMatches, schemaElementTypes,
contextSemanticParseInfo);
SemanticQuery semanticQuery = semanticQueryResolver.resolve(newSchemaElementMatch, searchCt);
if (semanticQuery != null) {
return semanticQuery;
ContextHelper.mergeContextSchemaElementMatch(newElementMatches, elementMatches, schemaElementTypes,
contextSemanticParse);
Map<RuleSemanticQuery, List<SchemaElementMatch>> queryMatches = resolveQuery(newElementMatches,
queryCtx);
if (queryMatches.size() > 0) {
return queryMatches;
}
}
}
return new HashMap<>();
}
private Map<RuleSemanticQuery, List<SchemaElementMatch>> resolveQuery(List<SchemaElementMatch> elementMatches,
QueryContextReq queryCtx) {
Map<RuleSemanticQuery, List<SchemaElementMatch>> matchMap = new HashMap<>();
for (RuleSemanticQuery semanticQuery : RuleSemanticQueryManager.getSemanticQueries()) {
List<SchemaElementMatch> matches = semanticQuery.match(elementMatches, queryCtx);
if (matches.size() > 0) {
log.info("resolve match [{}:{}] ", semanticQuery.getQueryMode(), matches.size());
matchMap.put(RuleSemanticQueryManager.create(semanticQuery.getQueryMode()), matches);
}
}
return matchMap;
}
public void fillParseInfo(SemanticQuery query, Long domainId, String domainName,
List<SchemaElementMatch> elementMatches) {
SemanticParseInfo parseInfo = query.getParseInfo();
parseInfo.setDomainId(domainId);
parseInfo.setDomainName(domainName);
parseInfo.setQueryMode(query.getQueryMode());
parseInfo.getElementMatches().addAll(elementMatches);
DefaultSemanticInternalUtils defaultSemanticUtils = ContextUtils.getBean(DefaultSemanticInternalUtils.class);
SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(parseInfo.getDomainId());
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(parseInfo.getDomainId());
Map<Long, DimSchemaResp> dimensionDescMap = domainSchemaDesc.getDimensions().stream()
.collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
Map<Long, MetricSchemaResp> metricDescMap = domainSchemaDesc.getMetrics().stream()
.collect(Collectors.toMap(MetricSchemaResp::getId, Function.identity()));
Map<Long, List<SchemaElementMatch>> dim2Values = new HashMap<>();
for (SchemaElementMatch schemaElementMatch : elementMatches) {
Long elementID = Long.valueOf(schemaElementMatch.getElementID());
switch (schemaElementMatch.getElementType()) {
case ID:
case VALUE:
if (dimensionDescMap.containsKey(elementID)) {
if (dim2Values.containsKey(elementID)) {
dim2Values.get(elementID).add(schemaElementMatch);
} else {
dim2Values.put(elementID, new ArrayList<>(Arrays.asList(schemaElementMatch)));
}
}
break;
case DIMENSION:
DimSchemaResp dimensionDesc = dimensionDescMap.get(elementID);
if (dimensionDesc != null) {
SchemaItem dimensionParseInfo = new SchemaItem();
dimensionParseInfo.setBizName(dimensionDesc.getBizName());
dimensionParseInfo.setName(dimensionDesc.getName());
dimensionParseInfo.setId(dimensionDesc.getId());
parseInfo.getDimensions().add(dimensionParseInfo);
}
break;
case METRIC:
MetricSchemaResp metricDesc = metricDescMap.get(elementID);
if (metricDesc != null) {
SchemaItem metricItem = new SchemaItem();
metricItem.setBizName(metricDesc.getBizName());
metricItem.setName(metricDesc.getName());
metricItem.setId(metricDesc.getId());
metricItem.setCreatedAt(null);
metricItem.setUpdatedAt(null);
parseInfo.getMetrics().add(metricItem);
}
break;
default:
}
}
if (!dim2Values.isEmpty()) {
for (Map.Entry<Long, List<SchemaElementMatch>> entry : dim2Values.entrySet()) {
DimSchemaResp dimensionDesc = dimensionDescMap.get(entry.getKey());
if (entry.getValue().size() == 1) {
SchemaElementMatch schemaElementMatch = entry.getValue().get(0);
Filter dimensionFilter = new Filter();
dimensionFilter.setValue(schemaElementMatch.getWord());
dimensionFilter.setBizName(dimensionDesc.getBizName());
dimensionFilter.setName(dimensionDesc.getName());
dimensionFilter.setOperator(FilterOperatorEnum.EQUALS);
dimensionFilter.setElementID(Long.valueOf(schemaElementMatch.getElementID()));
parseInfo.getDimensionFilters().add(dimensionFilter);
ContextHelper.setEntityId(entry.getKey(), schemaElementMatch.getWord(), chaConfigRichDesc,
parseInfo);
} else {
Filter dimensionFilter = new Filter();
List<String> vals = new ArrayList<>();
entry.getValue().stream().forEach(i -> vals.add(i.getWord()));
dimensionFilter.setValue(vals);
dimensionFilter.setBizName(dimensionDesc.getBizName());
dimensionFilter.setName(dimensionDesc.getName());
dimensionFilter.setOperator(FilterOperatorEnum.IN);
dimensionFilter.setElementID(entry.getKey());
parseInfo.getDimensionFilters().add(dimensionFilter);
}
}
}
return null;
}
}

222
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/BaseDomainResolver.java → chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/HeuristicDomainResolver.java
View File

@@ -1,36 +1,117 @@
package com.tencent.supersonic.chat.application.parser.resolver;
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.*;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public abstract class BaseDomainResolver implements DomainResolver {
import java.util.*;
import java.util.stream.Collectors;
@Override
public boolean isDomainSwitch(ChatContext chatCtx, QueryContextReq searchCtx) {
Long contextDomain = chatCtx.getParseInfo().getDomainId();
Long currentDomain = searchCtx.getParseInfo().getDomainId();
boolean noSwitch = currentDomain == null || contextDomain == null || contextDomain.equals(currentDomain);
log.info("ChatContext isDomainSwitch [{}]", !noSwitch);
return !noSwitch;
@Slf4j
public class HeuristicDomainResolver implements DomainResolver {
protected static Integer selectDomainBySchemaElementCount(Map<Integer, SemanticQuery> domainQueryModes,
SchemaMapInfo schemaMap) {
Map<Integer, QueryMatchInfo> domainTypeMap = getDomainTypeMap(schemaMap);
if (domainTypeMap.size() == 1) {
Integer domainSelect = domainTypeMap.entrySet().stream().collect(Collectors.toList()).get(0).getKey();
if (domainQueryModes.containsKey(domainSelect)) {
log.info("selectDomain from domainTypeMap not order [{}]", domainSelect);
return domainSelect;
}
} else {
Map.Entry<Integer, QueryMatchInfo> maxDomain = domainTypeMap.entrySet().stream()
.filter(entry -> domainQueryModes.containsKey(entry.getKey()))
.sorted(ContextHelper.DomainStatComparator).findFirst().orElse(null);
if (maxDomain != null) {
log.info("selectDomain from domainTypeMap order [{}]", maxDomain.getKey());
return maxDomain.getKey();
}
}
return 0;
}
public abstract Integer selectDomain(Map<Integer, SemanticQuery> domainQueryModes, QueryContextReq searchCtx,
ChatContext chatCtx, SchemaMapInfo schemaMap);
/**
* to check can switch domain if context exit domain
*
* @return false will use context domain, true will use other domain , maybe include context domain
*/
protected static boolean isAllowSwitch(Map<Integer, SemanticQuery> domainQueryModes, SchemaMapInfo schemaMap,
ChatContext chatCtx, QueryContextReq searchCtx, Integer domainId) {
if (!Objects.nonNull(domainId) || domainId <= 0) {
return true;
}
// except content domain, calculate the number of types for each domain, if numbers<=1 will not switch
Map<Integer, QueryMatchInfo> domainTypeMap = getDomainTypeMap(schemaMap);
log.info("isAllowSwitch domainTypeMap [{}]", domainTypeMap);
long otherDomainTypeNumBigOneCount = domainTypeMap.entrySet().stream()
.filter(entry -> domainQueryModes.containsKey(entry.getKey()) && !entry.getKey().equals(domainId))
.filter(entry -> entry.getValue().getCount() > 1).count();
if (otherDomainTypeNumBigOneCount >= 1) {
return true;
}
// if query text only contain time , will not switch
for (SemanticQuery semanticQuery : domainQueryModes.values()) {
SemanticParseInfo semanticParseInfo = semanticQuery.getParseInfo();
if (semanticParseInfo == null) {
continue;
}
if (searchCtx.getQueryText() != null && semanticParseInfo.getDateInfo() != null) {
if (semanticParseInfo.getDateInfo().getText() != null) {
if (semanticParseInfo.getDateInfo().getText().equalsIgnoreCase(searchCtx.getQueryText())) {
log.info("timeParseResults is not null , can not switch context , timeParseResults:{},",
semanticParseInfo.getDateInfo());
return false;
}
}
}
}
// if context domain not in schemaMap , will switch
if (schemaMap.getMatchedElements(domainId) == null || schemaMap.getMatchedElements(domainId).size() <= 0) {
log.info("domainId not in schemaMap ");
return true;
}
// other will not switch
return false;
}
public static Map<Integer, QueryMatchInfo> getDomainTypeMap(SchemaMapInfo schemaMap) {
Map<Integer, QueryMatchInfo> domainCount = new HashMap<>();
for (Map.Entry<Integer, List<SchemaElementMatch>> entry : schemaMap.getDomainElementMatches().entrySet()) {
List<SchemaElementMatch> schemaElementMatches = schemaMap.getMatchedElements(entry.getKey());
if (schemaElementMatches != null && schemaElementMatches.size() > 0) {
if (!domainCount.containsKey(entry.getKey())) {
domainCount.put(entry.getKey(), new QueryMatchInfo());
}
QueryMatchInfo queryMatchInfo = domainCount.get(entry.getKey());
Set<SchemaElementType> schemaElementTypes = new HashSet<>();
schemaElementMatches.stream()
.forEach(schemaElementMatch -> schemaElementTypes.add(schemaElementMatch.getElementType()));
SchemaElementMatch schemaElementMatchMax = schemaElementMatches.stream()
.sorted(ContextHelper.schemaElementMatchComparatorBySimilarity).findFirst().orElse(null);
if (schemaElementMatchMax != null) {
queryMatchInfo.setMaxSimilarity(schemaElementMatchMax.getSimilarity());
}
queryMatchInfo.setCount(schemaElementTypes.size());
}
}
return domainCount;
}
@Override
public boolean isDomainSwitch(ChatContext chatCtx, SemanticParseInfo semanticParseInfo) {
Long contextDomain = chatCtx.getParseInfo().getDomainId();
Long currentDomain = semanticParseInfo.getDomainId();
boolean noSwitch =
currentDomain == null || contextDomain == null || contextDomain.equals(currentDomain);
log.debug("ChatContext isDomainSwitch [{}] [{}]",
semanticParseInfo.getQueryMode(), !noSwitch);
return !noSwitch;
}
@Override
public Integer resolve(Map<Integer, SemanticQuery> domainQueryModes, QueryContextReq searchCtx,
@@ -44,88 +125,23 @@ public abstract class BaseDomainResolver implements DomainResolver {
return selectDomainBySchemaElementCount(domainQueryModes, schemaMap);
}
protected static Integer selectDomainBySchemaElementCount(Map<Integer, SemanticQuery> domainQueryModes,
public Integer selectDomain(Map<Integer, SemanticQuery> domainQueryModes, QueryContextReq searchCtx,
ChatContext chatCtx,
SchemaMapInfo schemaMap) {
Map<Integer, SchemaElementCount> domainTypeMap = getDomainTypeMap(schemaMap);
if (domainTypeMap.size() == 1) {
Integer domainSelect = domainTypeMap.entrySet().stream().collect(Collectors.toList()).get(0).getKey();
if (domainQueryModes.containsKey(domainSelect)) {
log.info("selectDomain from domainTypeMap not order [{}]", domainSelect);
return domainSelect;
// if QueryContext has domainId and in domainQueryModes
if (domainQueryModes.containsKey(searchCtx.getDomainId())) {
log.info("selectDomain from QueryContext [{}]", searchCtx.getDomainId());
return searchCtx.getDomainId();
}
} else {
Map.Entry<Integer, SchemaElementCount> maxDomain = domainTypeMap.entrySet().stream()
.filter(entry -> domainQueryModes.containsKey(entry.getKey()))
.sorted(ContextHelper.DomainStatComparator).findFirst().orElse(null);
if (maxDomain != null) {
log.info("selectDomain from domainTypeMap order [{}]", maxDomain.getKey());
return maxDomain.getKey();
// if ChatContext has domainId and in domainQueryModes
if (chatCtx.getParseInfo().getDomainId() > 0) {
Integer domainId = Integer.valueOf(chatCtx.getParseInfo().getDomainId().intValue());
if (!isAllowSwitch(domainQueryModes, schemaMap, chatCtx, searchCtx, domainId)) {
log.info("selectDomain from ChatContext [{}]", domainId);
return domainId;
}
}
// default 0
return 0;
}
/**
* to check can switch domain if context exit domain
*
* @return false will use context domain, true will use other domain , maybe include context domain
*/
protected static boolean isAllowSwitch(Map<Integer, SemanticQuery> domainQueryModes, SchemaMapInfo schemaMap,
ChatContext chatCtx, QueryContextReq searchCtx, Integer domainId) {
if (!Objects.nonNull(domainId) || domainId <= 0) {
return true;
}
// except content domain, calculate the number of types for each domain, if numbers<=1 will not switch
Map<Integer, SchemaElementCount> domainTypeMap = getDomainTypeMap(schemaMap);
log.info("isAllowSwitch domainTypeMap [{}]", domainTypeMap);
long otherDomainTypeNumBigOneCount = domainTypeMap.entrySet().stream()
.filter(entry -> domainQueryModes.containsKey(entry.getKey()) && !entry.getKey().equals(domainId))
.filter(entry -> entry.getValue().getCount() > 1).count();
if (otherDomainTypeNumBigOneCount >= 1) {
return true;
}
// if query text only contain time , will not switch
if (searchCtx.getQueryText() != null && searchCtx.getParseInfo().getDateInfo() != null) {
if (searchCtx.getParseInfo().getDateInfo().getText() != null) {
if (searchCtx.getParseInfo().getDateInfo().getText().equalsIgnoreCase(searchCtx.getQueryText())) {
log.info("timeParseResults is not null , can not switch context , timeParseResults:{},",
searchCtx.getParseInfo().getDateInfo());
return false;
}
}
}
// if context domain not in schemaMap , will switch
if (schemaMap.getMatchedElements(domainId) == null || schemaMap.getMatchedElements(domainId).size() <= 0) {
log.info("domainId not in schemaMap ");
return true;
}
// other will not switch
return false;
}
protected static Map<Integer, SchemaElementCount> getDomainTypeMap(SchemaMapInfo schemaMap) {
Map<Integer, SchemaElementCount> domainCount = new HashMap<>();
for (Map.Entry<Integer, List<SchemaElementMatch>> entry : schemaMap.getDomainElementMatches().entrySet()) {
List<SchemaElementMatch> schemaElementMatches = schemaMap.getMatchedElements(entry.getKey());
if (schemaElementMatches != null && schemaElementMatches.size() > 0) {
if (!domainCount.containsKey(entry.getKey())) {
domainCount.put(entry.getKey(), new SchemaElementCount());
}
SchemaElementCount schemaElementCount = domainCount.get(entry.getKey());
Set<SchemaElementType> schemaElementTypes = new HashSet<>();
schemaElementMatches.stream()
.forEach(schemaElementMatch -> schemaElementTypes.add(schemaElementMatch.getElementType()));
SchemaElementMatch schemaElementMatchMax = schemaElementMatches.stream()
.sorted(ContextHelper.schemaElementMatchComparatorBySimilarity).findFirst().orElse(null);
if (schemaElementMatchMax != null) {
schemaElementCount.setMaxSimilarity(schemaElementMatchMax.getSimilarity());
}
schemaElementCount.setCount(schemaElementTypes.size());
}
}
return domainCount;
}
}

148
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/LLMSemanticParser.java Normal file
View File

@@ -0,0 +1,148 @@
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.component.SemanticParser;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.application.knowledge.WordNatureService;
import com.tencent.supersonic.chat.application.query.LLMSemanticQuery;
import com.tencent.supersonic.chat.domain.config.LLMConfig;
import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
import com.tencent.supersonic.chat.domain.pojo.chat.LLMReq;
import com.tencent.supersonic.chat.domain.pojo.chat.LLMResp;
import com.tencent.supersonic.chat.domain.pojo.chat.LLMSchema;
import com.tencent.supersonic.chat.domain.utils.DslToSemanticInfo;
import com.tencent.supersonic.chat.domain.utils.SemanticSatisfactionChecker;
import com.tencent.supersonic.common.nlp.ItemDO;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.common.util.json.JsonUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
@Slf4j
public class LLMSemanticParser implements SemanticParser {
@Override
public void parse(QueryContextReq queryContext, ChatContext chatCtx) {
if (SemanticSatisfactionChecker.check(queryContext)) {
log.info("There is no need parse by llm , queryText:{}", queryContext.getQueryText());
return;
}
Integer domainId = getDomainId(queryContext, chatCtx);
LLMResp llmResp = requestLLM(queryContext, domainId);
if (Objects.isNull(llmResp)) {
return;
}
LLMSemanticQuery semanticQuery = new LLMSemanticQuery();
SemanticParseInfo parseInfo = semanticQuery.getParseInfo();
String sql = convertToSql(llmResp, parseInfo);
parseInfo.setDomainId(Long.valueOf(domainId));
parseInfo.setBonus(queryContext.getQueryText().length() * 1.0);
parseInfo.setQueryMode(LLMSemanticQuery.QUERY_MODE);
parseInfo.setInfo(sql);
queryContext.getCandidateQueries().add(semanticQuery);
return;
}
protected String convertToSql(LLMResp llmResp, SemanticParseInfo parseInfo) {
return DslToSemanticInfo.convert(parseInfo, llmResp);
}
protected LLMResp requestLLM(QueryContextReq queryContext, Integer domainId) {
try {
final LLMConfig llmConfig = ContextUtils.getBean(LLMConfig.class);
DomainInfos domainInfos = ContextUtils.getBean(WordNatureService.class).getCache().getUnchecked("");
Map<Integer, String> domainIdToName = domainInfos.getDomains().stream()
.collect(Collectors.toMap(ItemDO::getDomain, a -> a.getName(), (k1, k2) -> k1));
Map<Integer, String> itemIdToName = domainInfos.getDimensions().stream()
.filter(entry -> domainId.equals(entry.getDomain()))
.collect(Collectors.toMap(ItemDO::getItemId, ItemDO::getName, (value1, value2) -> value2));
String domainName = domainIdToName.get(domainId);
LLMReq llmReq = new LLMReq();
llmReq.setQueryText(queryContext.getQueryText());
List<SchemaElementMatch> matchedElements = queryContext.getMapInfo().getMatchedElements(domainId);
List<String> fieldNameList = matchedElements.stream()
.filter(schemaElementMatch ->
SchemaElementType.METRIC.equals(schemaElementMatch.getElementType()) ||
SchemaElementType.DIMENSION.equals(schemaElementMatch.getElementType()) ||
SchemaElementType.VALUE.equals(schemaElementMatch.getElementType()))
.map(schemaElementMatch -> {
if (!SchemaElementType.VALUE.equals(schemaElementMatch.getElementType())) {
return schemaElementMatch.getWord();
}
return itemIdToName.get(schemaElementMatch.getElementID());
})
.filter(name -> StringUtils.isNotEmpty(name) && !name.contains("%"))
.collect(Collectors.toList());
LLMSchema llmSchema = new LLMSchema();
llmSchema.setDomainName(domainName);
llmSchema.setFieldNameList(fieldNameList);
llmReq.setSchema(llmSchema);
log.info("domainId:{},llmReq:{}", domainId, llmReq);
String questUrl = llmConfig.getUrl() + llmConfig.getQueryToSqlPath();
RestTemplate restTemplate = ContextUtils.getBean(RestTemplate.class);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<String> entity = new HttpEntity<>(JsonUtil.toString(llmReq), headers);
log.info("requestLLM request:{},entity:{}", questUrl, entity);
ResponseEntity<LLMResp> responseEntity = restTemplate.exchange(questUrl, HttpMethod.POST, entity,
LLMResp.class);
log.info("requestLLM result:{}", responseEntity);
return responseEntity.getBody();
} catch (Exception e) {
log.error("requestLLM error", e);
}
return null;
}
protected Integer getDomainId(QueryContextReq queryContext, ChatContext chatCtx) {
SchemaMapInfo mapInfo = queryContext.getMapInfo();
Set<Integer> matchedDomains = mapInfo.getMatchedDomains();
Map<Integer, SemanticQuery> domainQueryModes = new HashMap<>();
for (Integer matchedDomain : matchedDomains) {
domainQueryModes.put(matchedDomain, new LLMSemanticQuery());
}
List<DomainResolver> domainResolverList = SpringFactoriesLoader.loadFactories(DomainResolver.class,
Thread.currentThread().getContextClassLoader());
Optional<Integer> domainId = domainResolverList.stream()
.map(domainResolver -> domainResolver.resolve(domainQueryModes, queryContext, chatCtx,
queryContext.getMapInfo())).filter(d -> d > 0).findFirst();
if (domainId.isPresent()) {
return domainId.get();
}
return 0;
}
}

130
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/ListFilterParser.java
View File

@@ -1,130 +0,0 @@
package com.tencent.supersonic.chat.application.parser;
import static com.tencent.supersonic.common.constant.Constants.DAY;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.chat.application.query.EntityListFilter;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.common.constant.Constants;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.Order;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Component
public class ListFilterParser implements SemanticParser {
private DefaultSemanticInternalUtils defaultSemanticUtils;
@Override
public boolean parse(QueryContextReq queryContext, ChatContext chatCtx) {
defaultSemanticUtils = ContextUtils.getBean(DefaultSemanticInternalUtils.class);
String queryMode = queryContext.getParseInfo().getQueryMode();
if (!EntityListFilter.QUERY_MODE.equals(queryMode)) {
return false;
}
this.fillDateEntityFilter(queryContext.getParseInfo());
this.addEntityDetailAndOrderByMetric(queryContext, chatCtx);
this.dealNativeQuery(queryContext, true);
return true;
}
private void fillDateEntityFilter(SemanticParseInfo semanticParseInfo) {
DateConf dateInfo = new DateConf();
dateInfo.setDateMode(DateConf.DateMode.RECENT_UNITS);
dateInfo.setUnit(1);
dateInfo.setPeriod(DAY);
dateInfo.setText(String.format("近1天"));
semanticParseInfo.setDateInfo(dateInfo);
}
private void addEntityDetailAndOrderByMetric(QueryContextReq queryContext, ChatContext chatCtx) {
if (queryContext.getParseInfo().getDomainId() > 0L) {
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(
queryContext.getParseInfo().getDomainId());
if (chaConfigRichDesc != null) {
SemanticParseInfo semanticParseInfo = queryContext.getParseInfo();
Set<SchemaItem> dimensions = new LinkedHashSet();
Set<String> primaryDimensions = this.addPrimaryDimension(chaConfigRichDesc.getEntity(), dimensions);
Set<SchemaItem> metrics = new LinkedHashSet();
if (chaConfigRichDesc.getEntity() != null
&& chaConfigRichDesc.getEntity().getEntityInternalDetailDesc() != null) {
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getMetricList().stream()
.forEach((m) -> metrics.add(this.getMetric(m)));
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getDimensionList().stream()
.filter((m) -> !primaryDimensions.contains(m.getBizName()))
.forEach((m) -> dimensions.add(this.getDimension(m)));
}
semanticParseInfo.setDimensions(dimensions);
semanticParseInfo.setMetrics(metrics);
Set<Order> orders = new LinkedHashSet();
if (chaConfigRichDesc.getEntity() != null
&& chaConfigRichDesc.getEntity().getEntityInternalDetailDesc() != null) {
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getMetricList().stream()
.forEach((metric) -> orders.add(new Order(metric.getBizName(), Constants.DESC_UPPER)));
}
semanticParseInfo.setOrders(orders);
}
}
}
private Set<String> addPrimaryDimension(EntityRichInfo entity, Set<SchemaItem> dimensions) {
Set<String> primaryDimensions = new HashSet();
if (!Objects.isNull(entity) && !CollectionUtils.isEmpty(entity.getEntityIds())) {
entity.getEntityIds().stream().forEach((dimSchemaDesc) -> {
SchemaItem dimension = new SchemaItem();
BeanUtils.copyProperties(dimSchemaDesc, dimension);
dimensions.add(dimension);
primaryDimensions.add(dimSchemaDesc.getBizName());
});
return primaryDimensions;
} else {
return primaryDimensions;
}
}
private SchemaItem getMetric(MetricSchemaResp metricSchemaDesc) {
SchemaItem queryMeta = new SchemaItem();
queryMeta.setId(metricSchemaDesc.getId());
queryMeta.setBizName(metricSchemaDesc.getBizName());
queryMeta.setName(metricSchemaDesc.getName());
return queryMeta;
}
private SchemaItem getDimension(DimSchemaResp dimSchemaDesc) {
SchemaItem queryMeta = new SchemaItem();
queryMeta.setId(dimSchemaDesc.getId());
queryMeta.setBizName(dimSchemaDesc.getBizName());
queryMeta.setName(dimSchemaDesc.getName());
return queryMeta;
}
private void dealNativeQuery(QueryContextReq queryContext, boolean isNativeQuery) {
if (Objects.nonNull(queryContext) && Objects.nonNull(queryContext.getParseInfo())) {
queryContext.getParseInfo().setNativeQuery(isNativeQuery);
}
}
}

78
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/TimeSemanticParser.java
View File

@@ -1,22 +1,30 @@
package com.tencent.supersonic.chat.application.parser;
import com.tencent.supersonic.chat.api.component.SemanticParser;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.chat.application.query.MetricSemanticQuery;
import com.tencent.supersonic.chat.application.query.RuleSemanticQuery;
import com.tencent.supersonic.chat.application.query.RuleSemanticQueryManager;
import com.tencent.supersonic.common.constant.Constants;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.semantic.api.core.enums.TimeDimensionEnum;
import java.time.LocalDate;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.collections.CollectionUtils;
import org.apache.logging.log4j.util.Strings;
import org.springframework.stereotype.Component;
@Component
public class TimeSemanticParser implements SemanticParser {
public TimeSemanticParser() {
}
private static final Pattern recentPeriodPattern = Pattern.compile(
".*(?<periodStr>(近|过去)((?<enNum>\\d+)|(?<zhNum>[一二三四五六七八九十百千万亿]+))个?(?<zhPeriod>[天周月年])).*");
private int zhNumParse(String zhNumStr) {
Stack<Integer> stack = new Stack<>();
@@ -42,11 +50,8 @@ public class TimeSemanticParser implements SemanticParser {
return stack.stream().mapToInt(s -> s).sum();
}
private static final Pattern recentPeriodPattern = Pattern.compile(
".*(?<periodStr>(近|过去)((?<enNum>\\d+)|(?<zhNum>[一二三四五六七八九十百千万亿]+))个?(?<zhPeriod>[天周月年])).*");
@Override
public boolean parse(QueryContextReq queryContext, ChatContext chatCtx) {
public void parse(QueryContextReq queryContext, ChatContext chatContext) {
Matcher m = recentPeriodPattern.matcher(queryContext.getQueryText());
if (m.matches()) {
int num = 0;
@@ -61,18 +66,19 @@ public class TimeSemanticParser implements SemanticParser {
DateConf info = new DateConf();
String zhPeriod = m.group("zhPeriod");
int days;
info.setPeriod(Constants.DAY);
switch (zhPeriod) {
case "周":
days = 7;
info.setPeriod(Constants.WEEK);
//info.setPeriod(Constants.WEEK);
break;
case "月":
days = 30;
info.setPeriod(Constants.MONTH);
//info.setPeriod(Constants.MONTH);
break;
case "年":
days = 365;
info.setPeriod(Constants.YEAR);
//info.setPeriod(Constants.YEAR);
break;
default:
days = 1;
@@ -87,9 +93,53 @@ public class TimeSemanticParser implements SemanticParser {
info.setText(text);
info.setStartDate(LocalDate.now().minusDays(days).toString());
info.setUnit(days);
queryContext.getParseInfo().setDateInfo(info);
//queryContext.getParseInfo().setDateInfo(info);
for (SemanticQuery query : queryContext.getCandidateQueries()) {
if (query instanceof MetricSemanticQuery) {
query.getParseInfo().setDateInfo(info);
}
}
doParseOnlyTime(queryContext, chatContext, info);
}
}
}
protected void doParseOnlyTime(QueryContextReq queryContext, ChatContext chatContext, DateConf info) {
if (!queryContext.getCandidateQueries().isEmpty() || chatContext.getParseInfo() == null || Objects.isNull(
info.getText())) {
return;
}
if (info.getText().equals(queryContext.getQueryText()) && queryContext.getMapInfo().getDomainElementMatches()
.isEmpty()
) {
if (Objects.nonNull(chatContext.getParseInfo().getQueryMode()) && Objects.nonNull(
chatContext.getParseInfo().getDomainId()) && chatContext.getParseInfo().getDomainId() > 0) {
if (Objects.nonNull(chatContext.getParseInfo().getDateInfo()) && !chatContext.getParseInfo()
.getDateInfo().getPeriod().equals(info.getPeriod())) {
if (!CollectionUtils.isEmpty(chatContext.getParseInfo().getDimensions())) {
String dateField = TimeDimensionEnum.DAY.getName();
if (Constants.MONTH.equals(chatContext.getParseInfo().getDateInfo().getPeriod())) {
dateField = TimeDimensionEnum.MONTH.getName();
}
if (Constants.WEEK.equals(chatContext.getParseInfo().getDateInfo().getPeriod())) {
dateField = TimeDimensionEnum.WEEK.getName();
}
Set<SchemaItem> dimensions = new HashSet<>();
for (SchemaItem schemaItem : chatContext.getParseInfo().getDimensions()) {
if (schemaItem.getBizName().equals(dateField)) {
continue;
}
dimensions.add(schemaItem);
}
chatContext.getParseInfo().setDimensions(dimensions);
}
}
chatContext.getParseInfo().setDateInfo(info);
RuleSemanticQuery semanticQuery = RuleSemanticQueryManager.create(
chatContext.getParseInfo().getQueryMode());
semanticQuery.setParseInfo(chatContext.getParseInfo());
queryContext.getCandidateQueries().add(semanticQuery);
}
}
return false;
}
}

14
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/AggregateTypeResolver.java
View File

@@ -1,14 +0,0 @@
package com.tencent.supersonic.chat.application.parser.resolver;
import com.tencent.supersonic.common.enums.AggregateTypeEnum;
/***
* aggregate parser
*/
public interface AggregateTypeResolver {
AggregateTypeEnum resolve(String queryText);
boolean hasCompareIntentionalWords(String queryText);
}

45
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/DomainSemanticQueryResolver.java
View File

@@ -1,45 +0,0 @@
package com.tencent.supersonic.chat.application.parser.resolver;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.application.query.SemanticQueryFactory;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Component
public class DomainSemanticQueryResolver implements SemanticQueryResolver {
private static final Logger LOGGER = LoggerFactory.getLogger(DomainSemanticQueryResolver.class);
@Override
public SemanticQuery resolve(List<SchemaElementMatch> elementMatches, QueryContextReq queryCtx) {
Map<SemanticQuery, SchemaElementCount> matchMap = new HashMap<>();
for (SemanticQuery semanticQuery : SemanticQueryFactory.getSemanticQueries()) {
SchemaElementCount match = semanticQuery.match(elementMatches, queryCtx);
if (match != null && match.getCount() > 0 && match.getMaxSimilarity() > 0) {
LOGGER.info("resolve match [{}:{}] ", semanticQuery.getQueryMode(), match);
matchMap.put(semanticQuery, match);
}
}
// get the similarity max
Map.Entry<SemanticQuery, SchemaElementCount> matchMax = matchMap.entrySet().stream()
.sorted(ContextHelper.SemanticQueryStatComparator).findFirst().orElse(null);
if (matchMax != null) {
LOGGER.info("resolve max [{}:{}] ", matchMax.getKey().getQueryMode(), matchMax.getValue());
return matchMax.getKey();
}
return null;
}
}

50
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/HeuristicDomainResolver.java
View File

@@ -1,50 +0,0 @@
package com.tencent.supersonic.chat.application.parser.resolver;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
@Service("DomainResolver")
@Slf4j
public class HeuristicDomainResolver extends BaseDomainResolver {
@Override
public Integer selectDomain(Map<Integer, SemanticQuery> domainQueryModes, QueryContextReq searchCtx,
ChatContext chatCtx,
SchemaMapInfo schemaMap) {
// if QueryContext has domainId and in domainQueryModes
if (domainQueryModes.containsKey(searchCtx.getDomainId())) {
log.info("selectDomain from QueryContext [{}]", searchCtx.getDomainId());
return searchCtx.getDomainId();
}
// if ChatContext has domainId and in domainQueryModes
if (chatCtx.getParseInfo().getDomainId() > 0) {
Integer domainId = Integer.valueOf(chatCtx.getParseInfo().getDomainId().intValue());
if (!isAllowSwitch(domainQueryModes, schemaMap, chatCtx, searchCtx, domainId)) {
log.info("selectDomain from ChatContext [{}]", domainId);
return domainId;
}
}
// default 0
return 0;
}
}

55
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/RegexAggregateTypeResolver.java
View File

@@ -1,55 +0,0 @@
package com.tencent.supersonic.chat.application.parser.resolver;
import com.tencent.supersonic.common.enums.AggregateTypeEnum;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
@Service
@Slf4j
@Primary
public class RegexAggregateTypeResolver implements AggregateTypeResolver {
private static Map<AggregateTypeEnum, Pattern> aggregateRegexMap = new HashMap<>();
private static Pattern compareIntentionalWord = Pattern.compile("(?i)(比较|对比)");
static {
aggregateRegexMap.put(AggregateTypeEnum.MAX, Pattern.compile("(?i)(最大值|最大|max|峰值|最高)"));
aggregateRegexMap.put(AggregateTypeEnum.MIN, Pattern.compile("(?i)(最小值|最小|min|最低)"));
aggregateRegexMap.put(AggregateTypeEnum.SUM, Pattern.compile("(?i)(汇总|总和|sum)"));
aggregateRegexMap.put(AggregateTypeEnum.AVG, Pattern.compile("(?i)(平均值|日均|平均|avg)"));
aggregateRegexMap.put(AggregateTypeEnum.TOPN, Pattern.compile("(?i)(top)"));
aggregateRegexMap.put(AggregateTypeEnum.DISTINCT, Pattern.compile("(?i)(uv)"));
aggregateRegexMap.put(AggregateTypeEnum.COUNT, Pattern.compile("(?i)(总数|pv)"));
aggregateRegexMap.put(AggregateTypeEnum.NONE, Pattern.compile("(?i)(明细)"));
}
@Override
public AggregateTypeEnum resolve(String text) {
Map<AggregateTypeEnum, Integer> aggregateCount = new HashMap<>(aggregateRegexMap.size());
for (Entry<AggregateTypeEnum, Pattern> entry : aggregateRegexMap.entrySet()) {
Matcher matcher = entry.getValue().matcher(text);
int count = 0;
while (matcher.find()) {
count++;
}
if (count > 0) {
aggregateCount.put(entry.getKey(), count);
}
}
return aggregateCount.entrySet().stream().max(Map.Entry.comparingByValue()).map(entry -> entry.getKey())
.orElse(null);
}
@Override
public boolean hasCompareIntentionalWords(String queryText) {
return compareIntentionalWord.matcher(queryText).find();
}
}

14
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/resolver/SemanticQueryResolver.java
View File

@@ -1,14 +0,0 @@
package com.tencent.supersonic.chat.application.parser.resolver;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import java.util.List;
/**
* Base interface for resolving query mode.
*/
public interface SemanticQueryResolver {
SemanticQuery resolve(List<SchemaElementMatch> elementMatches, QueryContextReq queryCtx);
}

123
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/BaseSemanticQuery.java
View File

@@ -1,123 +0,0 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.EntityInfo;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.semantic.api.core.pojo.QueryColumn;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.chat.application.DomainEntityService;
import com.tencent.supersonic.chat.application.parser.resolver.DomainResolver;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.search.QueryState;
import com.tencent.supersonic.chat.domain.service.ChatService;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.util.context.ContextUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public abstract class BaseSemanticQuery implements SemanticQuery {
protected QueryModeOption queryModeOption = QueryModeOption.build();
private static final Logger LOGGER = LoggerFactory.getLogger(BaseSemanticQuery.class);
@Override
public QueryResultResp execute(QueryContextReq queryCtx, ChatContext chatCtx) {
DomainResolver domainResolver = ContextUtils.getBean(DomainResolver.class);
ChatService chatService = ContextUtils.getBean(ChatService.class);
SemanticLayer semanticLayer = ContextUtils.getBean(SemanticLayer.class);
SemanticParseInfo semanticParse = queryCtx.getParseInfo();
String queryMode = semanticParse.getQueryMode();
if (semanticParse.getDomainId() < 0 || StringUtils.isEmpty(queryMode)) {
// reach here some error may happen
LOGGER.error("not find QueryMode");
throw new RuntimeException("not find QueryMode");
}
supplyMetadata(semanticLayer, queryCtx);
// is domain switch
if (domainResolver.isDomainSwitch(chatCtx, queryCtx)) {
chatService.switchContext(chatCtx);
}
// submit semantic query based on the result of semantic parsing
SemanticParseInfo semanticParseInfo = getContext(chatCtx, queryCtx);
QueryResultResp queryResponse = new QueryResultResp();
QueryResultWithSchemaResp queryResult = semanticLayer.queryByStruct(
SchemaInfoConverter.convertTo(semanticParseInfo), queryCtx.getUser());
if (queryResult != null) {
queryResponse.setQueryAuthorization(queryResult.getQueryAuthorization());
}
String sql = queryResult == null ? null : queryResult.getSql();
List<Map<String, Object>> resultList = queryResult == null ? new ArrayList<>()
: queryResult.getResultList();
List<QueryColumn> columns = queryResult == null ? new ArrayList<>() : queryResult.getColumns();
queryResponse.setQuerySql(sql);
queryResponse.setQueryResults(resultList);
queryResponse.setQueryColumns(columns);
queryResponse.setQueryMode(queryMode);
// add domain info
EntityInfo entityInfo = ContextUtils.getBean(DomainEntityService.class)
.getEntityInfo(queryCtx, chatCtx, queryCtx.getUser());
queryResponse.setEntityInfo(entityInfo);
return queryResponse;
}
private void supplyMetadata(SemanticLayer semanticLayer, QueryContextReq queryCtx) {
DefaultSemanticInternalUtils defaultSemanticUtils = ContextUtils.getBean(DefaultSemanticInternalUtils.class);
SchemaMapInfo mapInfo = queryCtx.getMapInfo();
SemanticParseInfo semanticParse = queryCtx.getParseInfo();
Long domain = semanticParse.getDomainId();
List<SchemaElementMatch> schemaElementMatches = mapInfo.getMatchedElements(domain.intValue());
DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(domain);
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(domain);
// supply metadata
if (!CollectionUtils.isEmpty(schemaElementMatches)) {
this.queryModeOption.addQuerySemanticParseInfo(schemaElementMatches, domainSchemaDesc,
chaConfigRichDesc, semanticParse);
}
}
@Override
public void updateContext(QueryResultResp queryResponse, ChatContext chatCtx, QueryContextReq queryCtx) {
if (queryCtx.isSaveAnswer() && queryResponse != null
&& queryResponse.getQueryState() == QueryState.NORMAL.getState()) {
chatCtx.setParseInfo(getParseInfo(queryCtx, chatCtx));
chatCtx.setQueryText(queryCtx.getQueryText());
ContextUtils.getBean(ChatService.class).updateContext(chatCtx);
}
queryResponse.setChatContext(queryCtx.getParseInfo());
}
public abstract SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx);
@Override
public SchemaElementCount match(List<SchemaElementMatch> elementMatches, QueryContextReq queryCtx) {
return queryModeOption.match(elementMatches, queryCtx);
}
}

46
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/EntityDetail.java
View File

@@ -1,26 +1,22 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.*;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
@Service
public class EntityDetail extends BaseSemanticQuery {
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Component;
@Component
public class EntityDetail extends EntitySemanticQuery {
public static String QUERY_MODE = "ENTITY_DETAIL";
public EntityDetail() {
queryModeOption.setAggregation(QueryModeElementOption.unused());
queryModeOption.setDate(QueryModeElementOption.unused());
queryModeOption.setDimension(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST,
1);
queryModeOption.setFilter(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setMetric(QueryModeElementOption.unused());
queryModeOption.setEntity(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_MOST, 1);
queryModeOption.setDomain(QueryModeElementOption.optional());
super();
queryMatcher.addOption(DIMENSION, REQUIRED, AT_LEAST, 1)
.addOption(VALUE, REQUIRED, AT_LEAST, 1);
}
@Override
@@ -29,21 +25,9 @@ public class EntityDetail extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getDimensionFilters(),
semanticParseInfo.getDimensionFilters());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensionFilters(), semanticParseInfo.getDimensionFilters());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
ContextHelper.addIfEmpty(chatContext.getParseInfo().getDimensionFilters(),
parseInfo.getDimensionFilters());
}
}

145
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/EntityListFilter.java
View File

@@ -1,26 +1,42 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.VALUE;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
import static com.tencent.supersonic.common.constant.Constants.DAY;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.common.constant.Constants;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.Order;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Set;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Service
public class EntityListFilter extends BaseSemanticQuery {
@Slf4j
@Component
public class EntityListFilter extends EntitySemanticQuery {
public static String QUERY_MODE = "ENTITY_LIST_FILTER";
private static Long entityListLimit = 200L;
public EntityListFilter() {
queryModeOption.setAggregation(QueryModeElementOption.unused());
queryModeOption.setDate(QueryModeElementOption.unused());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setMetric(QueryModeElementOption.unused());
queryModeOption.setEntity(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setDomain(QueryModeElementOption.optional());
super();
queryMatcher.addOption(VALUE, REQUIRED, AT_LEAST, 1);
}
@Override
@@ -28,23 +44,98 @@ public class EntityListFilter extends BaseSemanticQuery {
return QUERY_MODE;
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getDimensionFilters(),
semanticParseInfo.getDimensionFilters());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensionFilters(), semanticParseInfo.getDimensionFilters());
semanticParseInfo.setLimit(entityListLimit);
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.addIfEmpty(chatParseInfo.getDimensionFilters(), parseInfo.getDimensionFilters());
parseInfo.setLimit(entityListLimit);
this.fillDateEntityFilter(parseInfo);
this.addEntityDetailAndOrderByMetric(parseInfo);
this.dealNativeQuery(parseInfo, true);
}
private void fillDateEntityFilter(SemanticParseInfo semanticParseInfo) {
DateConf dateInfo = new DateConf();
dateInfo.setDateMode(DateConf.DateMode.RECENT_UNITS);
dateInfo.setUnit(1);
dateInfo.setPeriod(DAY);
dateInfo.setText(String.format("近1天"));
semanticParseInfo.setDateInfo(dateInfo);
}
private void addEntityDetailAndOrderByMetric(SemanticParseInfo semanticParseInfo) {
if (semanticParseInfo.getDomainId() > 0L) {
DefaultSemanticInternalUtils defaultSemanticUtils = ContextUtils.getBean(
DefaultSemanticInternalUtils.class);
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(
semanticParseInfo.getDomainId());
if (chaConfigRichDesc != null) {
//SemanticParseInfo semanticParseInfo = queryContext.getParseInfo();
Set<SchemaItem> dimensions = new LinkedHashSet();
Set<String> primaryDimensions = this.addPrimaryDimension(chaConfigRichDesc.getEntity(), dimensions);
Set<SchemaItem> metrics = new LinkedHashSet();
if (chaConfigRichDesc.getEntity() != null
&& chaConfigRichDesc.getEntity().getEntityInternalDetailDesc() != null) {
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getMetricList().stream()
.forEach((m) -> metrics.add(this.getMetric(m)));
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getDimensionList().stream()
.filter((m) -> !primaryDimensions.contains(m.getBizName()))
.forEach((m) -> dimensions.add(this.getDimension(m)));
}
semanticParseInfo.setDimensions(dimensions);
semanticParseInfo.setMetrics(metrics);
Set<Order> orders = new LinkedHashSet();
if (chaConfigRichDesc.getEntity() != null
&& chaConfigRichDesc.getEntity().getEntityInternalDetailDesc() != null) {
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getMetricList().stream()
.forEach((metric) -> orders.add(new Order(metric.getBizName(), Constants.DESC_UPPER)));
}
semanticParseInfo.setOrders(orders);
}
}
}
private Set<String> addPrimaryDimension(EntityRichInfo entity, Set<SchemaItem> dimensions) {
Set<String> primaryDimensions = new HashSet();
if (!Objects.isNull(entity) && !CollectionUtils.isEmpty(entity.getEntityIds())) {
entity.getEntityIds().stream().forEach((dimSchemaDesc) -> {
SchemaItem dimension = new SchemaItem();
BeanUtils.copyProperties(dimSchemaDesc, dimension);
dimensions.add(dimension);
primaryDimensions.add(dimSchemaDesc.getBizName());
});
return primaryDimensions;
} else {
return primaryDimensions;
}
}
private SchemaItem getMetric(MetricSchemaResp metricSchemaDesc) {
SchemaItem queryMeta = new SchemaItem();
queryMeta.setId(metricSchemaDesc.getId());
queryMeta.setBizName(metricSchemaDesc.getBizName());
queryMeta.setName(metricSchemaDesc.getName());
return queryMeta;
}
private SchemaItem getDimension(DimSchemaResp dimSchemaDesc) {
SchemaItem queryMeta = new SchemaItem();
queryMeta.setId(dimSchemaDesc.getId());
queryMeta.setBizName(dimSchemaDesc.getBizName());
queryMeta.setName(dimSchemaDesc.getName());
return queryMeta;
}
private void dealNativeQuery(SemanticParseInfo semanticParseInfo, boolean isNativeQuery) {
if (Objects.nonNull(semanticParseInfo)) {
semanticParseInfo.setNativeQuery(isNativeQuery);
}
}
}

44
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/EntityListTopN.java
View File

@@ -1,27 +1,23 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.METRIC;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class EntityListTopN extends BaseSemanticQuery {
@Component
public class EntityListTopN extends EntitySemanticQuery {
public static String QUERY_MODE = "ENTITY_LIST_TOPN";
public EntityListTopN() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(QueryModeElementOption.unused());
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setDomain(QueryModeElementOption.optional());
queryModeOption.setSupportOrderBy(true);
super();
queryMatcher.addOption(METRIC, REQUIRED, AT_LEAST, 1)
.setSupportOrderBy(true);
}
@Override
@@ -30,22 +26,10 @@ public class EntityListTopN extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
}
}

42
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/EntityMetricFilter.java
View File

@@ -1,26 +1,24 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.METRIC;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.VALUE;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class EntityMetricFilter extends BaseSemanticQuery {
@Component
public class EntityMetricFilter extends EntitySemanticQuery {
public static String QUERY_MODE = "ENTITY_METRIC_FILTER";
public EntityMetricFilter() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setDomain(QueryModeElementOption.optional());
super();
queryMatcher.addOption(METRIC, REQUIRED, AT_LEAST, 1)
.addOption(VALUE, REQUIRED, AT_LEAST, 1);
}
@Override
@@ -29,21 +27,9 @@ public class EntityMetricFilter extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getDimensionFilters(),
semanticParseInfo.getDimensionFilters());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensionFilters(), semanticParseInfo.getDimensionFilters());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.addIfEmpty(chatParseInfo.getDimensionFilters(), parseInfo.getDimensionFilters());
}
}

13
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/EntitySemanticQuery.java Normal file
View File

@@ -0,0 +1,13 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.ENTITY;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
public abstract class EntitySemanticQuery extends RuleSemanticQuery {
public EntitySemanticQuery() {
super();
queryMatcher.addOption(ENTITY, REQUIRED, AT_LEAST, 1);
}
}

63
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/HeuristicQuerySelector.java Normal file
View File

@@ -0,0 +1,63 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.common.constant.Constants;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class HeuristicQuerySelector implements QuerySelector {
@Override
public SemanticQuery select(List<SemanticQuery> candidateQueries) {
double maxScore = 0;
SemanticQuery pickedQuery = null;
for (SemanticQuery query : candidateQueries) {
if (query instanceof LLMSemanticQuery) {
log.info("force to use LLM if existed");
return query;
}
SemanticParseInfo semanticParse = query.getParseInfo();
double score = computeScore(semanticParse);
if (score > maxScore) {
maxScore = score;
pickedQuery = query;
}
log.info("candidate query (domain={}, queryMode={}) with score={}",
semanticParse.getDomainName(), semanticParse.getQueryMode(), score);
}
return pickedQuery;
}
private double computeScore(SemanticParseInfo semanticParse) {
double score = 0;
Map<SchemaElementType, SchemaElementMatch> maxSimilarityMatch = new HashMap<>();
for (SchemaElementMatch match : semanticParse.getElementMatches()) {
SchemaElementType type = match.getElementType();
if (!maxSimilarityMatch.containsKey(type) ||
match.getSimilarity() > maxSimilarityMatch.get(type).getSimilarity()) {
maxSimilarityMatch.put(type, match);
}
}
for (SchemaElementMatch match : maxSimilarityMatch.values()) {
score +=
Optional.ofNullable(match.getDetectWord()).orElse(Constants.EMPTY).length() * match.getSimilarity();
}
// bonus is a special construct to control the final score
score += semanticParse.getBonus();
return score;
}
}

71
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/LLMSemanticQuery.java Normal file
View File

@@ -0,0 +1,71 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.EntityInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import com.tencent.supersonic.chat.application.DomainEntityService;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.semantic.api.core.pojo.QueryColumn;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Slf4j
public class LLMSemanticQuery implements SemanticQuery {
public static String QUERY_MODE = "DSL";
private SemanticParseInfo semanticParse = new SemanticParseInfo();
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
@Override
public String getQueryMode() {
return QUERY_MODE;
}
@Override
public QueryResultResp execute(User user) {
String queryMode = semanticParse.getQueryMode();
if (semanticParse.getDomainId() < 0 || StringUtils.isEmpty(queryMode)) {
// reach here some error may happen
log.error("not find QueryMode");
throw new RuntimeException("not find QueryMode");
}
QueryResultResp queryResponse = new QueryResultResp();
QueryResultWithSchemaResp queryResult = semanticLayer.queryBySql(
SchemaInfoConverter.convertToQuerySqlReq(semanticParse), user);
if (queryResult != null) {
queryResponse.setQueryAuthorization(queryResult.getQueryAuthorization());
}
String sql = queryResult == null ? null : queryResult.getSql();
List<Map<String, Object>> resultList = queryResult == null ? new ArrayList<>()
: queryResult.getResultList();
List<QueryColumn> columns = queryResult == null ? new ArrayList<>() : queryResult.getColumns();
queryResponse.setQuerySql(sql);
queryResponse.setQueryResults(resultList);
queryResponse.setQueryColumns(columns);
queryResponse.setQueryMode(queryMode);
// add domain info
EntityInfo entityInfo = ContextUtils.getBean(DomainEntityService.class)
.getEntityInfo(semanticParse, user);
queryResponse.setEntityInfo(entityInfo);
return queryResponse;
}
@Override
public SemanticParseInfo getParseInfo() {
return semanticParse;
}
}

64
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricCompare.java
View File

@@ -1,39 +1,43 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.ENTITY;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.VALUE;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_MOST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.OPTIONAL;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.Filter;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
@Slf4j
public class MetricCompare extends BaseSemanticQuery {
@Component
public class MetricCompare extends MetricSemanticQuery {
public static String QUERY_MODE = "METRIC_COMPARE";
public static Pattern intentWordPattern = Pattern.compile("(?i)(比较|对比)");
public MetricCompare() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(QueryModeElementOption.unused());
queryModeOption.setDomain(QueryModeElementOption.optional());
queryModeOption.setSupportCompare(true);
queryModeOption.setSupportOrderBy(true);
super();
queryMatcher.addOption(VALUE, REQUIRED, AT_LEAST, 2)
.addOption(ENTITY, OPTIONAL, AT_MOST, 1);
queryMatcher.setSupportCompare(true);
queryMatcher.setSupportOrderBy(true);
}
@Override
@@ -42,26 +46,22 @@ public class MetricCompare extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCt) {
SemanticParseInfo semanticParseInfo = chatCt.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(queryCtx.getParseInfo().getDimensionFilters(),
semanticParseInfo.getDimensionFilters());
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
public List<SchemaElementMatch> match(List<SchemaElementMatch> candidateElementMatches, QueryContextReq queryCtx) {
if (intentWordPattern.matcher(queryCtx.getQueryText()).find()) {
return super.match(candidateElementMatches, queryCtx);
} else {
return new ArrayList<>();
}
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
mergeAppend(chatCtx.getParseInfo().getDimensionFilters(), semanticParseInfo.getDimensionFilters());
addCompareDimension(semanticParseInfo);
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
mergeAppend(chatParseInfo.getDimensionFilters(), parseInfo.getDimensionFilters());
addCompareDimension(parseInfo);
parseInfo.setBonus(2 * 1.0);
}
private void addCompareDimension(SemanticParseInfo semanticParseInfo) {

43
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricDomain.java
View File

@@ -1,26 +1,23 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class MetricDomain extends BaseSemanticQuery {
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.*;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.*;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.*;
@Component
public class MetricDomain extends MetricSemanticQuery {
public static String QUERY_MODE = "METRIC_DOMAIN";
public MetricDomain() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(QueryModeElementOption.unused());
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(QueryModeElementOption.unused());
queryModeOption.setDomain(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
super();
queryMatcher.addOption(DOMAIN, REQUIRED, AT_LEAST, 1);
}
@Override
@@ -29,22 +26,10 @@ public class MetricDomain extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
}
}

49
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricFilter.java
View File

@@ -1,25 +1,25 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class MetricFilter extends BaseSemanticQuery {
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.*;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.*;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.*;
@Component
public class MetricFilter extends MetricSemanticQuery {
public static String QUERY_MODE = "METRIC_FILTER";
public MetricFilter() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(QueryModeElementOption.unused());
queryModeOption.setFilter(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(QueryModeElementOption.unused());
queryModeOption.setDomain(QueryModeElementOption.optional());
super();
queryMatcher.addOption(VALUE, REQUIRED, AT_LEAST, 1)
.addOption(ENTITY, OPTIONAL, AT_MOST, 1);
}
@Override
@@ -28,25 +28,10 @@ public class MetricFilter extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getDimensionFilters(),
semanticParseInfo.getDimensionFilters());
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensionFilters(), semanticParseInfo.getDimensionFilters());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
ContextHelper.addIfEmpty(chatParseInfo.getDimensionFilters(), parseInfo.getDimensionFilters());
}
}

46
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricGroupBy.java
View File

@@ -2,26 +2,21 @@ package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class MetricGroupBy extends BaseSemanticQuery {
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.*;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.*;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.*;
@Component
public class MetricGroupBy extends MetricSemanticQuery {
public static String QUERY_MODE = "METRIC_GROUPBY";
public MetricGroupBy() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST,
1);
queryModeOption.setFilter(QueryModeElementOption.unused());
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(QueryModeElementOption.unused());
queryModeOption.setDomain(QueryModeElementOption.optional());
super();
queryMatcher.addOption(DIMENSION, REQUIRED, AT_LEAST, 1);
}
@Override
@@ -30,24 +25,11 @@ public class MetricGroupBy extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateList(queryCtx.getParseInfo().getDimensions(), semanticParseInfo.getDimensions());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensions(), semanticParseInfo.getDimensions());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
ContextHelper.addIfEmpty(chatParseInfo.getDimensions(), parseInfo.getDimensions());
}
}

43
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricOrderBy.java
View File

@@ -1,27 +1,18 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import org.springframework.stereotype.Service;
import org.springframework.stereotype.Component;
@Service
public class MetricOrderBy extends BaseSemanticQuery {
@Component
public class MetricOrderBy extends RuleSemanticQuery {
public static String QUERY_MODE = "METRIC_ORDERBY";
public MetricOrderBy() {
queryModeOption.setAggregation(QueryModeElementOption.optional());
queryModeOption.setDate(QueryModeElementOption.optional());
queryModeOption.setDimension(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST,
1);
queryModeOption.setFilter(QueryModeElementOption.optional());
queryModeOption.setMetric(SchemaElementOption.REQUIRED, QueryModeElementOption.RequireNumberType.AT_LEAST, 1);
queryModeOption.setEntity(QueryModeElementOption.unused());
queryModeOption.setDomain(QueryModeElementOption.optional());
queryModeOption.setSupportOrderBy(true);
super();
}
@Override
@@ -30,24 +21,12 @@ public class MetricOrderBy extends BaseSemanticQuery {
}
@Override
public SemanticParseInfo getParseInfo(QueryContextReq queryCtx, ChatContext chatCtx) {
SemanticParseInfo semanticParseInfo = chatCtx.getParseInfo();
ContextHelper.updateTime(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateDomain(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateSemanticQuery(queryCtx.getParseInfo(), semanticParseInfo);
ContextHelper.updateList(queryCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.updateList(queryCtx.getParseInfo().getDimensions(), semanticParseInfo.getDimensions());
ContextHelper.updateEntity(queryCtx.getParseInfo(), semanticParseInfo);
return semanticParseInfo;
}
@Override
public SemanticParseInfo getContext(ChatContext chatCtx, QueryContextReq queryCtx) {
SemanticParseInfo semanticParseInfo = queryCtx.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatCtx.getParseInfo(), semanticParseInfo);
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getMetrics(), semanticParseInfo.getMetrics());
ContextHelper.addIfEmpty(chatCtx.getParseInfo().getDimensions(), semanticParseInfo.getDimensions());
return semanticParseInfo;
public void inheritContext(ChatContext chatContext) {
SemanticParseInfo chatParseInfo = chatContext.getParseInfo();
ContextHelper.updateTimeIfEmpty(chatParseInfo, parseInfo);
ContextHelper.addIfEmpty(chatParseInfo.getMetrics(), parseInfo.getMetrics());
ContextHelper.addIfEmpty(chatParseInfo.getDimensions(), parseInfo.getDimensions());
ContextHelper.addIfEmpty(chatParseInfo.getDimensionFilters(), parseInfo.getDimensionFilters());
}
}

13
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/MetricSemanticQuery.java Normal file
View File

@@ -0,0 +1,13 @@
package com.tencent.supersonic.chat.application.query;
import static com.tencent.supersonic.chat.api.pojo.SchemaElementType.METRIC;
import static com.tencent.supersonic.chat.application.query.QueryMatchOption.RequireNumberType.AT_LEAST;
import static com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption.REQUIRED;
public abstract class MetricSemanticQuery extends RuleSemanticQuery {
public MetricSemanticQuery() {
super();
queryMatcher.addOption(METRIC, REQUIRED, AT_LEAST, 1);
}
}

43
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/QueryMatchOption.java Normal file
View File

@@ -0,0 +1,43 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import lombok.Data;
@Data
public class QueryMatchOption {
private SchemaElementOption schemaElementOption;
private RequireNumberType requireNumberType;
private Integer requireNumber;
public static QueryMatchOption build(SchemaElementOption schemaElementOption,
RequireNumberType requireNumberType, Integer requireNumber) {
QueryMatchOption queryMatchOption = new QueryMatchOption();
queryMatchOption.requireNumber = requireNumber;
queryMatchOption.requireNumberType = requireNumberType;
queryMatchOption.schemaElementOption = schemaElementOption;
return queryMatchOption;
}
public static QueryMatchOption optional() {
QueryMatchOption queryMatchOption = new QueryMatchOption();
queryMatchOption.setSchemaElementOption(SchemaElementOption.OPTIONAL);
queryMatchOption.setRequireNumber(0);
queryMatchOption.setRequireNumberType(RequireNumberType.AT_LEAST);
return queryMatchOption;
}
public static QueryMatchOption unused() {
QueryMatchOption queryMatchOption = new QueryMatchOption();
queryMatchOption.setSchemaElementOption(SchemaElementOption.UNUSED);
queryMatchOption.setRequireNumber(0);
queryMatchOption.setRequireNumberType(RequireNumberType.EQUAL);
return queryMatchOption;
}
public enum RequireNumberType {
AT_MOST, AT_LEAST, EQUAL
}
}

113
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/QueryMatcher.java Normal file
View File

@@ -0,0 +1,113 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.common.enums.AggregateTypeEnum;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class QueryMatcher {
private HashMap<SchemaElementType, QueryMatchOption> elementOptionMap = new HashMap<>();
private boolean supportCompare;
private boolean supportOrderBy;
private List<AggregateTypeEnum> orderByTypes = Arrays.asList(AggregateTypeEnum.MAX, AggregateTypeEnum.MIN,
AggregateTypeEnum.TOPN);
public QueryMatcher() {
for (SchemaElementType type : SchemaElementType.values()) {
if (type.equals(SchemaElementType.DOMAIN)) {
elementOptionMap.put(type, QueryMatchOption.optional());
} else {
elementOptionMap.put(type, QueryMatchOption.unused());
}
}
}
public QueryMatcher addOption(SchemaElementType type, SchemaElementOption option,
QueryMatchOption.RequireNumberType requireNumberType, Integer requireNumber) {
elementOptionMap.put(type, QueryMatchOption.build(option, requireNumberType, requireNumber));
return this;
}
/**
* Match schema element with current query according to the options.
*
* @param candidateElementMatches
* @return a list of all matched schema elements,
* empty list if no matches can be found
*/
public List<SchemaElementMatch> match(List<SchemaElementMatch> candidateElementMatches) {
List<SchemaElementMatch> elementMatches = new ArrayList<>();
HashMap<SchemaElementType, Integer> schemaElementTypeCount = new HashMap<>();
for (SchemaElementMatch schemaElementMatch : candidateElementMatches) {
SchemaElementType schemaElementType = schemaElementMatch.getElementType();
if (schemaElementTypeCount.containsKey(schemaElementType)) {
schemaElementTypeCount.put(schemaElementType, schemaElementTypeCount.get(schemaElementType) + 1);
} else {
schemaElementTypeCount.put(schemaElementType, 1);
}
}
// check if current query options are satisfied, return immediately if not
for (Map.Entry<SchemaElementType, QueryMatchOption> e : elementOptionMap.entrySet()) {
SchemaElementType elementType = e.getKey();
QueryMatchOption elementOption = e.getValue();
if (!isMatch(elementOption, getCount(schemaElementTypeCount, elementType))) {
return new ArrayList<>();
}
}
// add element match if its element type is not declared as unused
for (SchemaElementMatch elementMatch : candidateElementMatches) {
QueryMatchOption elementOption = elementOptionMap.get(elementMatch.getElementType());
if (Objects.nonNull(elementOption) && !elementOption.getSchemaElementOption()
.equals(SchemaElementOption.UNUSED)) {
elementMatches.add(elementMatch);
}
}
return elementMatches;
}
private int getCount(HashMap<SchemaElementType, Integer> schemaElementTypeCount,
SchemaElementType schemaElementType) {
if (schemaElementTypeCount.containsKey(schemaElementType)) {
return schemaElementTypeCount.get(schemaElementType);
}
return 0;
}
private boolean isMatch(QueryMatchOption queryMatchOption, int count) {
// check if required but empty
if (queryMatchOption.getSchemaElementOption().equals(SchemaElementOption.REQUIRED) && count <= 0) {
return false;
}
if (queryMatchOption.getRequireNumberType().equals(QueryMatchOption.RequireNumberType.AT_LEAST)
&& count < queryMatchOption.getRequireNumber()) {
return false;
}
if (queryMatchOption.getRequireNumberType().equals(QueryMatchOption.RequireNumberType.AT_MOST)
&& count > queryMatchOption.getRequireNumber()) {
return false;
}
return true;
}
}

43
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/QueryModeElementOption.java
View File

@@ -1,43 +0,0 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import lombok.Data;
@Data
public class QueryModeElementOption {
public enum RequireNumberType {
AT_MOST, AT_LEAST, EQUAL
}
private SchemaElementOption schemaElementOption;
private RequireNumberType requireNumberType;
private Integer requireNumber;
public static QueryModeElementOption build(SchemaElementOption schemaElementOption,
RequireNumberType requireNumberType, Integer requireNumber) {
QueryModeElementOption queryModeElementOption = new QueryModeElementOption();
queryModeElementOption.requireNumber = requireNumber;
queryModeElementOption.requireNumberType = requireNumberType;
queryModeElementOption.schemaElementOption = schemaElementOption;
return queryModeElementOption;
}
public static QueryModeElementOption optional() {
QueryModeElementOption queryModeElementOption = new QueryModeElementOption();
queryModeElementOption.setSchemaElementOption(SchemaElementOption.OPTIONAL);
queryModeElementOption.setRequireNumber(0);
queryModeElementOption.setRequireNumberType(RequireNumberType.AT_LEAST);
return queryModeElementOption;
}
public static QueryModeElementOption unused() {
QueryModeElementOption queryModeElementOption = new QueryModeElementOption();
queryModeElementOption.setSchemaElementOption(SchemaElementOption.UNUSED);
queryModeElementOption.setRequireNumber(0);
queryModeElementOption.setRequireNumberType(RequireNumberType.EQUAL);
return queryModeElementOption;
}
}

307
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/QueryModeOption.java
View File

@@ -1,307 +0,0 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.pojo.Filter;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import com.tencent.supersonic.chat.application.parser.resolver.AggregateTypeResolver;
import com.tencent.supersonic.chat.domain.pojo.chat.SchemaElementOption;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.utils.ContextHelper;
import com.tencent.supersonic.common.enums.AggregateTypeEnum;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.Data;
import lombok.ToString;
@Data
@ToString
public class QueryModeOption {
private QueryModeElementOption domain;
private QueryModeElementOption entity;
private QueryModeElementOption metric;
private QueryModeElementOption dimension;
private QueryModeElementOption filter;
private QueryModeElementOption date;
private QueryModeElementOption aggregation;
private boolean supportCompare = false;
private boolean supportOrderBy = false;
List<AggregateTypeEnum> orderByTypes = Arrays.asList(AggregateTypeEnum.MAX, AggregateTypeEnum.MIN,
AggregateTypeEnum.TOPN);
public static QueryModeOption build() {
return new QueryModeOption();
}
public QueryModeOption setDimension(SchemaElementOption dimension,
QueryModeElementOption.RequireNumberType requireNumberType, Integer requireNumber) {
this.dimension = QueryModeElementOption.build(dimension, requireNumberType, requireNumber);
return this;
}
public QueryModeOption setDomain(SchemaElementOption domain,
QueryModeElementOption.RequireNumberType requireNumberType, Integer requireNumber) {
this.domain = QueryModeElementOption.build(domain, requireNumberType, requireNumber);
return this;
}
public QueryModeOption setEntity(SchemaElementOption entity,
QueryModeElementOption.RequireNumberType requireNumberType, Integer requireNumber) {
this.entity = QueryModeElementOption.build(entity, requireNumberType, requireNumber);
return this;
}
public QueryModeOption setFilter(SchemaElementOption filter,
QueryModeElementOption.RequireNumberType requireNumberType, Integer requireNumber) {
this.filter = QueryModeElementOption.build(filter, requireNumberType, requireNumber);
return this;
}
public QueryModeOption setMetric(SchemaElementOption metric,
QueryModeElementOption.RequireNumberType requireNumberType, Integer requireNumber) {
this.metric = QueryModeElementOption.build(metric, requireNumberType, requireNumber);
return this;
}
/**
* add query semantic parse info
* @param schemaElementMatches
* @param domainSchemaDesc
* @param chaConfigRichDesc
* @param semanticParseInfo
*/
public void addQuerySemanticParseInfo(List<SchemaElementMatch> schemaElementMatches,
DomainSchemaResp domainSchemaDesc, ChatConfigRichInfo chaConfigRichDesc,
SemanticParseInfo semanticParseInfo) {
Map<Long, DimSchemaResp> dimensionDescMap = domainSchemaDesc.getDimensions().stream()
.collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
Map<Long, MetricSchemaResp> metricDescMap = domainSchemaDesc.getMetrics().stream()
.collect(Collectors.toMap(MetricSchemaResp::getId, Function.identity()));
Map<Long, List<SchemaElementMatch>> values = getLinkSchemaElementMatch(schemaElementMatches, dimensionDescMap,
semanticParseInfo, metricDescMap);
if (!values.isEmpty()) {
for (Map.Entry<Long, List<SchemaElementMatch>> entry : values.entrySet()) {
DimSchemaResp dimensionDesc = dimensionDescMap.get(entry.getKey());
if (entry.getValue().size() == 1) {
SchemaElementMatch schemaElementMatch = entry.getValue().get(0);
Filter chatFilter = new Filter();
chatFilter.setValue(schemaElementMatch.getWord());
chatFilter.setBizName(dimensionDesc.getBizName());
chatFilter.setName(dimensionDesc.getName());
chatFilter.setOperator(FilterOperatorEnum.EQUALS);
chatFilter.setElementID(Long.valueOf(schemaElementMatch.getElementID()));
semanticParseInfo.getDimensionFilters().add(chatFilter);
ContextHelper.setEntityId(entry.getKey(), schemaElementMatch.getWord(), chaConfigRichDesc,
semanticParseInfo);
} else {
Filter chatFilter = new Filter();
List<String> vals = new ArrayList<>();
entry.getValue().stream().forEach(i -> vals.add(i.getWord()));
chatFilter.setValue(vals);
chatFilter.setBizName(dimensionDesc.getBizName());
chatFilter.setName(dimensionDesc.getName());
chatFilter.setOperator(FilterOperatorEnum.IN);
chatFilter.setElementID(entry.getKey());
semanticParseInfo.getDimensionFilters().add(chatFilter);
}
}
}
}
private Map<Long, List<SchemaElementMatch>> getLinkSchemaElementMatch(List<SchemaElementMatch> schemaElementMatches,
Map<Long, DimSchemaResp> dimensionDescMap, SemanticParseInfo semanticParseInfo,
Map<Long, MetricSchemaResp> metricDescMap) {
Map<Long, List<SchemaElementMatch>> values = new HashMap<>();
for (SchemaElementMatch schemaElementMatch : schemaElementMatches) {
Long elementID = Long.valueOf(schemaElementMatch.getElementID());
switch (schemaElementMatch.getElementType()) {
case DATE:
case DOMAIN:
case ENTITY:
break;
case ID:
case VALUE:
case DIMENSION:
if (dimensionDescMap.containsKey(elementID)) {
DimSchemaResp dimensionDesc = dimensionDescMap.get(elementID);
SchemaItem dimensionParseInfo = new SchemaItem();
dimensionParseInfo.setBizName(dimensionDesc.getBizName());
dimensionParseInfo.setName(dimensionDesc.getName());
dimensionParseInfo.setId(dimensionDesc.getId());
if (!dimension.getSchemaElementOption().equals(SchemaElementOption.UNUSED)
&& schemaElementMatch.getElementType().equals(SchemaElementType.DIMENSION)) {
semanticParseInfo.getDimensions().add(dimensionParseInfo);
}
if (!filter.getSchemaElementOption().equals(SchemaElementOption.UNUSED) && (
schemaElementMatch.getElementType().equals(SchemaElementType.VALUE)
|| schemaElementMatch.getElementType().equals(SchemaElementType.ID))) {
if (values.containsKey(elementID)) {
values.get(elementID).add(schemaElementMatch);
} else {
values.put(elementID, new ArrayList<>(Arrays.asList(schemaElementMatch)));
}
}
}
break;
case METRIC:
if (!metric.getSchemaElementOption().equals(SchemaElementOption.UNUSED)) {
if (metricDescMap.containsKey(elementID)) {
MetricSchemaResp metricDesc = metricDescMap.get(elementID);
SchemaItem metric = new SchemaItem();
metric.setBizName(metricDesc.getBizName());
metric.setName(metricDesc.getName());
metric.setId(metricDesc.getId());
semanticParseInfo.getMetrics().add(metric);
}
}
break;
default:
}
}
return values;
}
/**
* math
* @param elementMatches
* @param queryCtx
* @return
*/
public SchemaElementCount match(List<SchemaElementMatch> elementMatches, QueryContextReq queryCtx) {
AggregateTypeResolver aggregateTypeResolver = ContextUtils.getBean(AggregateTypeResolver.class);
boolean isCompareType = aggregateTypeResolver.hasCompareIntentionalWords(queryCtx.getQueryText());
boolean isOrderByType = orderByTypes.contains(aggregateTypeResolver.resolve(queryCtx.getQueryText()));
if ((isOrderByType && !supportOrderBy) || (isCompareType && !supportCompare)) {
return new SchemaElementCount();
}
SchemaElementCount schemaElementCount = new SchemaElementCount();
schemaElementCount.setCount(0);
schemaElementCount.setMaxSimilarity(0);
HashMap<SchemaElementType, Integer> schemaElementTypeCount = new HashMap<>();
for (SchemaElementMatch schemaElementMatch : elementMatches) {
SchemaElementType schemaElementType = schemaElementMatch.getElementType();
if (schemaElementTypeCount.containsKey(schemaElementType)) {
schemaElementTypeCount.put(schemaElementType, schemaElementTypeCount.get(schemaElementType) + 1);
} else {
schemaElementTypeCount.put(schemaElementType, 1);
}
}
// test each element
if (!isMatch(domain, getCount(schemaElementTypeCount, SchemaElementType.DOMAIN))) {
return schemaElementCount;
}
if (!isMatch(dimension, getCount(schemaElementTypeCount, SchemaElementType.DIMENSION))) {
return schemaElementCount;
}
if (!isMatch(metric, getCount(schemaElementTypeCount, SchemaElementType.METRIC))) {
return schemaElementCount;
}
int filterCount = getCount(schemaElementTypeCount, SchemaElementType.VALUE) + getCount(schemaElementTypeCount,
SchemaElementType.ID);
if (!isMatch(filter, filterCount)) {
return schemaElementCount;
}
if (!isMatch(entity, getCount(schemaElementTypeCount, SchemaElementType.ENTITY))) {
return schemaElementCount;
}
if (!isMatch(date, getCount(schemaElementTypeCount, SchemaElementType.DATE))) {
return schemaElementCount;
}
// count the max similarity
double similarity = 0;
Set<SchemaElementType> schemaElementTypeSet = new HashSet<>();
for (SchemaElementMatch schemaElementMatch : elementMatches) {
double schemaElementMatchSimilarity = getSimilarity(schemaElementMatch);
if (schemaElementMatchSimilarity > similarity) {
similarity = schemaElementMatchSimilarity;
}
schemaElementTypeSet.add(schemaElementMatch.getElementType());
}
schemaElementCount.setCount(schemaElementTypeSet.size());
schemaElementCount.setMaxSimilarity(similarity);
return schemaElementCount;
}
private int getCount(HashMap<SchemaElementType, Integer> schemaElementTypeCount,
SchemaElementType schemaElementType) {
if (schemaElementTypeCount.containsKey(schemaElementType)) {
return schemaElementTypeCount.get(schemaElementType);
}
return 0;
}
private double getSimilarity(SchemaElementMatch schemaElementMatch) {
switch (schemaElementMatch.getElementType()) {
case DATE:
return getSimilarity(date, schemaElementMatch.getSimilarity());
case DOMAIN:
return getSimilarity(domain, schemaElementMatch.getSimilarity());
case ENTITY:
return getSimilarity(entity, schemaElementMatch.getSimilarity());
case DIMENSION:
return getSimilarity(dimension, schemaElementMatch.getSimilarity());
case METRIC:
return getSimilarity(metric, schemaElementMatch.getSimilarity());
case ID:
case VALUE:
return getSimilarity(filter, schemaElementMatch.getSimilarity());
default:
return 0;
}
}
private double getSimilarity(QueryModeElementOption queryModeElementOption, double similarity) {
if (queryModeElementOption.getSchemaElementOption().equals(SchemaElementOption.REQUIRED)) {
return similarity;
}
return 0;
}
private boolean isMatch(QueryModeElementOption queryModeElementOption, int count) {
// first find if unused but not empty
if (queryModeElementOption.getSchemaElementOption().equals(SchemaElementOption.UNUSED) && count > 0) {
return false;
}
// find if required but empty
if (queryModeElementOption.getSchemaElementOption().equals(SchemaElementOption.REQUIRED) && count <= 0) {
return false;
}
// find if count no satisfy
if (queryModeElementOption.getRequireNumberType().equals(QueryModeElementOption.RequireNumberType.EQUAL)
&& queryModeElementOption.getRequireNumber() != count) {
return false;
}
if (queryModeElementOption.getRequireNumberType().equals(QueryModeElementOption.RequireNumberType.AT_LEAST)
&& count < queryModeElementOption.getRequireNumber()) {
return false;
}
if (queryModeElementOption.getRequireNumberType().equals(QueryModeElementOption.RequireNumberType.AT_MOST)
&& count > queryModeElementOption.getRequireNumber()) {
return false;
}
// here default satisfy
return true;
}
}

13
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/QuerySelector.java Normal file
View File

@@ -0,0 +1,13 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import java.util.List;
/**
* This interface defines the contract for a selector that picks the most suitable semantic query.
**/
public interface QuerySelector {
SemanticQuery select(List<SemanticQuery> candidateQueries);
}

87
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/RuleSemanticQuery.java Normal file
View File

@@ -0,0 +1,87 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.chat.api.pojo.*;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import com.tencent.supersonic.chat.application.DomainEntityService;
import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.semantic.api.core.pojo.QueryColumn;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.io.Serializable;
import java.util.*;
@Slf4j
@ToString
public abstract class RuleSemanticQuery implements SemanticQuery, Serializable {
protected SemanticParseInfo parseInfo = new SemanticParseInfo();
protected List<SchemaElementMatch> schemaElementMatches = new ArrayList<>();
protected QueryMatcher queryMatcher = new QueryMatcher();
protected SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
public RuleSemanticQuery() {
RuleSemanticQueryManager.register(this);
}
public List<SchemaElementMatch> match(List<SchemaElementMatch> candidateElementMatches, QueryContextReq queryCtx) {
return queryMatcher.match(candidateElementMatches);
}
public abstract void inheritContext(ChatContext chatContext);
@Override
public QueryResultResp execute(User user) {
String queryMode = parseInfo.getQueryMode();
if (parseInfo.getDomainId() < 0 || StringUtils.isEmpty(queryMode)) {
// reach here some error may happen
log.error("not find QueryMode");
throw new RuntimeException("not find QueryMode");
}
List<String> semanticQueryModes = RuleSemanticQueryManager.getSemanticQueryModes();
if (!semanticQueryModes.contains(parseInfo.getQueryMode())) {
return null;
}
QueryResultResp queryResponse = new QueryResultResp();
QueryResultWithSchemaResp queryResult = semanticLayer.queryByStruct(
SchemaInfoConverter.convertTo(parseInfo), user);
if (queryResult != null) {
queryResponse.setQueryAuthorization(queryResult.getQueryAuthorization());
}
String sql = queryResult == null ? null : queryResult.getSql();
List<Map<String, Object>> resultList = queryResult == null ? new ArrayList<>()
: queryResult.getResultList();
List<QueryColumn> columns = queryResult == null ? new ArrayList<>() : queryResult.getColumns();
queryResponse.setQuerySql(sql);
queryResponse.setQueryResults(resultList);
queryResponse.setQueryColumns(columns);
queryResponse.setQueryMode(queryMode);
// add domain info
EntityInfo entityInfo = ContextUtils.getBean(DomainEntityService.class)
.getEntityInfo(parseInfo, user);
queryResponse.setEntityInfo(entityInfo);
return queryResponse;
}
@Override
public SemanticParseInfo getParseInfo() {
return parseInfo;
}
public void setParseInfo(SemanticParseInfo parseInfo) {
this.parseInfo = parseInfo;
}
}

39
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/RuleSemanticQueryManager.java Normal file
View File

@@ -0,0 +1,39 @@
package com.tencent.supersonic.chat.application.query;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
/**
* RuleSemanticQueryManager
*/
public class RuleSemanticQueryManager {
private static Map<String, RuleSemanticQuery> semanticQueryMap = new ConcurrentHashMap<>();
public static RuleSemanticQuery create(String queryMode) {
RuleSemanticQuery semanticQuery = semanticQueryMap.get(queryMode);
if (Objects.isNull(semanticQuery)) {
throw new RuntimeException("no supported queryMode :" + queryMode);
}
try {
return semanticQuery.getClass().getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException("no supported queryMode :" + queryMode);
}
}
public static void register(RuleSemanticQuery query) {
semanticQueryMap.put(query.getQueryMode(), query);
}
public static List<RuleSemanticQuery> getSemanticQueries() {
return new ArrayList<>(semanticQueryMap.values());
}
public static List<String> getSemanticQueryModes() {
return new ArrayList<>(semanticQueryMap.keySet());
}
}

46
chat/core/src/main/java/com/tencent/supersonic/chat/application/query/SemanticQueryFactory.java
View File

@@ -1,46 +0,0 @@
package com.tencent.supersonic.chat.application.query;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.util.CollectionUtils;
/**
* SemanticQueryFactory
*/
public class SemanticQueryFactory {
private static Map<String, SemanticQuery> strategyFactory = new ConcurrentHashMap<>();
private static List<SemanticQuery> semanticQueries;
public static SemanticQuery get(String queryMode) {
if (CollectionUtils.isEmpty(strategyFactory)) {
init();
}
SemanticQuery semanticQuery = strategyFactory.get(queryMode);
if (Objects.isNull(semanticQuery)) {
throw new RuntimeException("not support queryMode :" + queryMode);
}
return semanticQuery;
}
private static void init() {
for (SemanticQuery semanticQuery : getSemanticQueries()) {
strategyFactory.put(semanticQuery.getQueryMode(), semanticQuery);
}
}
public static List<SemanticQuery> getSemanticQueries() {
if (CollectionUtils.isEmpty(semanticQueries)) {
semanticQueries = SpringFactoriesLoader.loadFactories(SemanticQuery.class,
Thread.currentThread().getContextClassLoader());
}
return semanticQueries;
}
}

23
chat/core/src/main/java/com/tencent/supersonic/chat/domain/config/LLMConfig.java Normal file
View File

@@ -0,0 +1,23 @@
package com.tencent.supersonic.chat.domain.config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
@Configuration
@Data
public class LLMConfig {
@Value("${llm.url:}")
private String url;
@Value("${query2sql.path:query2sql}")
private String queryToSqlPath;
@Value("${query2sql.endpoint:}")
private String endpoint;
}

90
chat/core/src/main/java/com/tencent/supersonic/chat/domain/dataobject/ChatQueryDOExample.java
View File

@@ -5,6 +5,7 @@ import java.util.Date;
import java.util.List;
public class ChatQueryDOExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
@@ -15,23 +16,22 @@ public class ChatQueryDOExample {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public boolean isDistinct() {
return distinct;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
@@ -65,22 +65,22 @@ public class ChatQueryDOExample {
distinct = false;
}
public void setLimitStart(Integer limitStart) {
this.limitStart = limitStart;
}
public Integer getLimitStart() {
return limitStart;
}
public void setLimitEnd(Integer limitEnd) {
this.limitEnd = limitEnd;
public void setLimitStart(Integer limitStart) {
this.limitStart = limitStart;
}
public Integer getLimitEnd() {
return limitEnd;
}
public void setLimitEnd(Integer limitEnd) {
this.limitEnd = limitEnd;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
@@ -589,38 +589,6 @@ public class ChatQueryDOExample {
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
@@ -656,5 +624,37 @@ public class ChatQueryDOExample {
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
}
}

6
chat/core/src/main/java/com/tencent/supersonic/chat/domain/dataobject/QueryDO.java
View File

@@ -5,6 +5,9 @@ import lombok.Data;
@Data
public class QueryDO {
public String aggregator = "trend";
public String startTime;
public String endTime;
private long id;
private long questionId;
private String createTime;
@@ -19,10 +22,7 @@ public class QueryDO {
private int isDeleted;
private String module;
private long chatId;
public String aggregator = "trend";
private int topNum;
public String startTime;
public String endTime;
private String querySql;
private Object queryColumn;
private Object entityInfo;

11
chat/core/src/main/java/com/tencent/supersonic/chat/domain/pojo/chat/LLMReq.java Normal file
View File

@@ -0,0 +1,11 @@
package com.tencent.supersonic.chat.domain.pojo.chat;
import lombok.Data;
@Data
public class LLMReq {
private String queryText;
private LLMSchema schema;
}

20
chat/core/src/main/java/com/tencent/supersonic/chat/domain/pojo/chat/LLMResp.java Normal file
View File

@@ -0,0 +1,20 @@
package com.tencent.supersonic.chat.domain.pojo.chat;
import java.util.List;
import lombok.Data;
@Data
public class LLMResp {
private String query;
private String domainName;
private String sqlOutput;
private List<String> fields;
private String schemaLinkingOutput;
private String schemaLinkStr;
}

13
chat/core/src/main/java/com/tencent/supersonic/chat/domain/pojo/chat/LLMSchema.java Normal file
View File

@@ -0,0 +1,13 @@
package com.tencent.supersonic.chat.domain.pojo.chat;
import java.util.List;
import lombok.Data;
@Data
public class LLMSchema {
private String domainName;
private List<String> fieldNameList;
}

12
chat/core/src/main/java/com/tencent/supersonic/chat/domain/pojo/chat/PageQueryInfoReq.java
View File

@@ -15,20 +15,20 @@ public class PageQueryInfoReq {
return pageSize;
}
public int getCurrent() {
return current;
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public String getUserName() {
return userName;
public int getCurrent() {
return current;
}
public void setCurrent(int current) {
this.current = current;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {

3
chat/core/src/main/java/com/tencent/supersonic/chat/domain/pojo/config/KnowledgeInfo.java
View File

@@ -1,8 +1,10 @@
package com.tencent.supersonic.chat.domain.pojo.config;
import com.tencent.supersonic.common.enums.TypeEnums;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.Data;
/**
@@ -17,6 +19,7 @@ public class KnowledgeInfo {
*/
private Long itemId;
private String bizName;
/**
* type: IntentionTypeEnum
* temporarily only supports dimension-related information

2
chat/core/src/main/java/com/tencent/supersonic/chat/domain/repository/ChatRepository.java
View File

@@ -12,6 +12,8 @@ public interface ChatRepository {
Boolean updateChatName(Long chatId, String chatName, String lastTime, String creator);
Boolean updateLastQuestion(Long chatId, String lastQuestion, String lastTime);
Boolean updateConversionIsTop(Long chatId, int isTop);
boolean updateFeedback(QueryDO queryDO);

3
chat/core/src/main/java/com/tencent/supersonic/chat/domain/service/ChatService.java
View File

@@ -3,6 +3,7 @@ package com.tencent.supersonic.chat.domain.service;
import com.github.pagehelper.PageInfo;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.response.QueryResultResp;
import com.tencent.supersonic.chat.domain.dataobject.ChatDO;
@@ -24,6 +25,8 @@ public interface ChatService {
public void updateContext(ChatContext chatCtx);
public void updateContext(ChatContext chatCtx, QueryContextReq queryCtx, SemanticParseInfo semanticParseInfo);
public void switchContext(ChatContext chatCtx);
public Boolean addChat(User user, String chatName);

2
chat/core/src/main/java/com/tencent/supersonic/chat/domain/service/ConfigService.java
View File

@@ -18,4 +18,6 @@ public interface ConfigService {
List<ChatConfigInfo> search(ChatConfigFilter filter, User user);
ChatConfigRichInfo getConfigRichInfo(Long domainId);
List<ChatConfigRichInfo> getAllChatRichConfig();
}

6
chat/core/src/main/java/com/tencent/supersonic/chat/domain/service/QueryService.java
View File

@@ -11,9 +11,9 @@ import com.tencent.supersonic.chat.domain.pojo.chat.QueryData;
*/
public interface QueryService {
public QueryResultResp executeQuery(QueryContextReq queryCtx) throws Exception;
QueryResultResp executeQuery(QueryContextReq queryCtx) throws Exception;
public SemanticParseInfo queryContext(QueryContextReq queryCtx);
SemanticParseInfo queryContext(QueryContextReq queryCtx);
QueryResultResp queryData(QueryData queryData, User user) throws Exception;
QueryResultResp executeDirectQuery(QueryData queryData, User user) throws Exception;
}

3
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/ChatConfigUtils.java
View File

@@ -118,6 +118,9 @@ public class ChatConfigUtils {
}
public List<Long> generateAllMetricIdList(DomainSchemaResp domainSchemaDesc) {
if (Objects.isNull(domainSchemaDesc) || CollectionUtils.isEmpty(domainSchemaDesc.getMetrics())) {
return new ArrayList<>();
}
Map<Long, List<MetricSchemaResp>> metricIdAndDescPair = domainSchemaDesc.getMetrics()
.stream().collect(Collectors.groupingBy(MetricSchemaResp::getId));
return new ArrayList<>(metricIdAndDescPair.keySet());

67
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/ComponentFactory.java Normal file
View File

@@ -0,0 +1,67 @@
package com.tencent.supersonic.chat.domain.utils;
import com.tencent.supersonic.chat.api.component.SchemaMapper;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticParser;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import com.tencent.supersonic.chat.application.parser.DomainResolver;
import com.tencent.supersonic.chat.application.query.QuerySelector;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.core.io.support.SpringFactoriesLoader;
public class ComponentFactory {
private static List<SchemaMapper> schemaMappers = new ArrayList<>();
private static List<SemanticParser> semanticParsers = new ArrayList<>();
private static SemanticLayer semanticLayer;
private static QuerySelector querySelector;
private static DomainResolver domainResolver;
public static List<SchemaMapper> getSchemaMappers() {
return CollectionUtils.isEmpty(schemaMappers) ? init(SchemaMapper.class, schemaMappers) : schemaMappers;
}
public static List<SemanticParser> getSemanticParsers() {
return CollectionUtils.isEmpty(semanticParsers) ? init(SemanticParser.class, semanticParsers) : semanticParsers;
}
public static SemanticLayer getSemanticLayer() {
if (Objects.isNull(semanticLayer)) {
semanticLayer = init(SemanticLayer.class);
}
return semanticLayer;
}
public static void setSemanticLayer(SemanticLayer layer) {
semanticLayer = layer;
}
public static QuerySelector getQuerySelector() {
if (Objects.isNull(querySelector)) {
querySelector = init(QuerySelector.class);
}
return querySelector;
}
public static DomainResolver getDomainResolver() {
if (Objects.isNull(domainResolver)) {
domainResolver = init(DomainResolver.class);
}
return domainResolver;
}
private static <T> List<T> init(Class<T> factoryType, List list) {
list.addAll(SpringFactoriesLoader.loadFactories(factoryType,
Thread.currentThread().getContextClassLoader()));
return list;
}
private static <T> T init(Class<T> factoryType) {
return SpringFactoriesLoader.loadFactories(factoryType,
Thread.currentThread().getContextClassLoader()).get(0);
}
}

88
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/ContextHelper.java
View File

@@ -2,11 +2,11 @@ package com.tencent.supersonic.chat.domain.utils;
import com.tencent.supersonic.chat.api.pojo.ChatContext;
import com.tencent.supersonic.chat.api.pojo.Filter;
import com.tencent.supersonic.chat.api.pojo.SchemaElementCount;
import com.tencent.supersonic.chat.api.pojo.QueryMatchInfo;
import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.service.SemanticQuery;
import com.tencent.supersonic.chat.api.component.SemanticQuery;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.common.pojo.SchemaItem;
@@ -22,6 +22,21 @@ import java.util.Optional;
public class ContextHelper {
public static Comparator<Map.Entry<Integer, QueryMatchInfo>> DomainStatComparator
= (o1, o2) -> domainSchemaElementCountComparator(o1.getValue(), o2.getValue());
public static Comparator<Map.Entry<SemanticQuery, QueryMatchInfo>> SemanticQueryStatComparator
= (o1, o2) -> domainSchemaElementCountComparator(o1.getValue(), o2.getValue());
/**
* similarity desc
*/
public static Comparator<SchemaElementMatch> schemaElementMatchComparatorBySimilarity
= new Comparator<SchemaElementMatch>() {
@Override
public int compare(SchemaElementMatch o1, SchemaElementMatch o2) {
return (int) ((o2.getSimilarity() - o1.getSimilarity()) * 100);
}
};
public static void updateDomain(SemanticParseInfo from, SemanticParseInfo to) {
if (from != null && from.getDomainId() != null) {
to.setDomainId(from.getDomainId());
@@ -65,6 +80,15 @@ public class ContextHelper {
}
}
public static void updateDomainIfEmpty(SemanticParseInfo from, SemanticParseInfo to) {
if (from != null && from.getDomainId() != null && to.getDomainId() == null) {
to.setDomainId(from.getDomainId());
}
if (from != null && from.getDomainName() != null && to.getDomainName() == null) {
to.setDomainName(from.getDomainName());
}
}
/**
* add from to list if list is empty and from is not empty
@@ -105,7 +129,7 @@ public class ContextHelper {
/**
* count desc > similarity desc
*/
public static int domainSchemaElementCountComparator(SchemaElementCount o1, SchemaElementCount o2) {
public static int domainSchemaElementCountComparator(QueryMatchInfo o1, QueryMatchInfo o2) {
int difference = o1.getCount() - o2.getCount();
if (difference == 0) {
return (int) ((o1.getMaxSimilarity() - o2.getMaxSimilarity()) * 100);
@@ -113,22 +137,6 @@ public class ContextHelper {
return difference;
}
public static Comparator<Map.Entry<Integer, SchemaElementCount>> DomainStatComparator
= (o1, o2) -> domainSchemaElementCountComparator(o1.getValue(), o2.getValue());
public static Comparator<Map.Entry<SemanticQuery, SchemaElementCount>> SemanticQueryStatComparator
= (o1, o2) -> domainSchemaElementCountComparator(o1.getValue(), o2.getValue());
/**
* similarity desc
*/
public static Comparator<SchemaElementMatch> schemaElementMatchComparatorBySimilarity
= new Comparator<SchemaElementMatch>() {
@Override
public int compare(SchemaElementMatch o1, SchemaElementMatch o2) {
return (int) ((o2.getSimilarity() - o1.getSimilarity()) * 100);
}
};
public static void setEntityId(Long dimensionId, String value, ChatConfigRichInfo chaConfigRichDesc,
SemanticParseInfo semanticParseInfo) {
if (chaConfigRichDesc != null && chaConfigRichDesc.getEntity() != null) {
@@ -152,35 +160,42 @@ public class ContextHelper {
* @param toSchemaElementMatch
* @param elementMatches
* @param schemaElementTypes
* @param contextSemanticParseInfo
* @param contextSemanticParse
*/
public static void mergeContextSchemaElementMatch(List<SchemaElementMatch> toSchemaElementMatch,
List<SchemaElementMatch> elementMatches, List<SchemaElementType> schemaElementTypes,
SemanticParseInfo contextSemanticParseInfo) {
SemanticParseInfo contextSemanticParse) {
SchemaElementMatch domainMatch = SchemaElementMatch.builder()
.elementType(SchemaElementType.DOMAIN)
.elementID(contextSemanticParse.getDomainId().intValue())
.similarity(1.0)
.word(contextSemanticParse.getDomainName())
.detectWord(contextSemanticParse.getDomainName())
.build();
toSchemaElementMatch.add(domainMatch);
for (SchemaElementType schemaElementType : schemaElementTypes) {
switch (schemaElementType) {
case DIMENSION:
if (contextSemanticParseInfo.getDimensions() != null
&& contextSemanticParseInfo.getDimensions().size() > 0) {
for (SchemaItem dimension : contextSemanticParseInfo.getDimensions()) {
if (contextSemanticParse.getDimensions().size() > 0) {
for (SchemaItem dimension : contextSemanticParse.getDimensions()) {
addSchemaElementMatch(toSchemaElementMatch, elementMatches, SchemaElementType.DIMENSION,
dimension);
}
}
break;
case METRIC:
if (contextSemanticParseInfo.getMetrics() != null
&& contextSemanticParseInfo.getMetrics().size() > 0) {
for (SchemaItem metric : contextSemanticParseInfo.getMetrics()) {
if (contextSemanticParse.getMetrics().size() > 0) {
for (SchemaItem metric : contextSemanticParse.getMetrics()) {
addSchemaElementMatch(toSchemaElementMatch, elementMatches, SchemaElementType.METRIC,
metric);
}
}
break;
case VALUE:
if (contextSemanticParseInfo.getDimensionFilters() != null
&& contextSemanticParseInfo.getDimensionFilters().size() > 0) {
for (Filter chatFilter : contextSemanticParseInfo.getDimensionFilters()) {
if (contextSemanticParse.getDimensionFilters().size() > 0) {
for (Filter chatFilter : contextSemanticParse.getDimensionFilters()) {
if (!isInSchemaElementMatchList(elementMatches, SchemaElementType.VALUE,
chatFilter.getValue().toString())) {
toSchemaElementMatch.add(
@@ -228,13 +243,12 @@ public class ContextHelper {
private static SchemaElementMatch getSchemaElementMatchByContext(int id, String word,
SchemaElementType schemaElementType) {
SchemaElementMatch schemaElementMatch = new SchemaElementMatch();
schemaElementMatch.setElementID(id);
schemaElementMatch.setElementType(schemaElementType);
schemaElementMatch.setWord(word);
// todo default similarity
schemaElementMatch.setSimilarity(0.5);
return schemaElementMatch;
return SchemaElementMatch.builder()
.elementID(id)
.elementType(schemaElementType)
.word(word)
.similarity(0.5)
.build();
}
}

208
chat/core/src/main/java/com/tencent/supersonic/chat/application/parser/DefaultMetricSemanticParser.java → chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/DefaultMetricUtils.java
View File

@@ -1,4 +1,4 @@
package com.tencent.supersonic.chat.application.parser;
package com.tencent.supersonic.chat.domain.utils;
import static java.time.LocalDate.now;
@@ -8,22 +8,21 @@ import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.api.request.QueryContextReq;
import com.tencent.supersonic.chat.api.service.SemanticParser;
import com.tencent.supersonic.chat.application.parser.resolver.DomainResolver;
import com.tencent.supersonic.chat.application.parser.DomainResolver;
import com.tencent.supersonic.chat.application.query.EntityDetail;
import com.tencent.supersonic.chat.application.query.EntityListFilter;
import com.tencent.supersonic.chat.application.query.EntityListTopN;
import com.tencent.supersonic.chat.application.query.EntityMetricFilter;
import com.tencent.supersonic.chat.application.query.MetricDomain;
import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichInfo;
import com.tencent.supersonic.chat.domain.pojo.config.DefaultMetric;
import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
import com.tencent.supersonic.chat.domain.service.ChatService;
import com.tencent.supersonic.chat.domain.utils.DefaultSemanticInternalUtils;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.SchemaItem;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
@@ -31,99 +30,129 @@ import java.util.Objects;
import java.util.Set;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Slf4j
@Component
public class DefaultMetricSemanticParser implements SemanticParser {
public class DefaultMetricUtils {
private final Logger logger = LoggerFactory.getLogger(DefaultMetricSemanticParser.class);
private DomainResolver selectStrategy;
private ChatService chatService;
private DefaultSemanticInternalUtils defaultSemanticUtils;
@Override
public boolean parse(QueryContextReq queryContext, ChatContext chatCtx) {
selectStrategy = ContextUtils.getBean(DomainResolver.class);
chatService = ContextUtils.getBean(ChatService.class);
defaultSemanticUtils = ContextUtils.getBean(DefaultSemanticInternalUtils.class);
String queryMode = queryContext.getParseInfo().getQueryMode();
/**
* supplementary default metric date dimension
*/
public void injectDefaultMetric(SemanticParseInfo semanticParseInfo, QueryContextReq queryContext,
ChatContext chatContext) {
String queryMode = semanticParseInfo.getQueryMode();
ChatConfigRichInfo chaConfigRichDesc = null;
if (StringUtils.isNotEmpty(queryMode)) {
// QueryMode Selected
if (semanticParseInfo == null) {
return;
}
if (!EntityListFilter.QUERY_MODE.equals(queryMode)) {
boolean isFillThemeDefaultMetricLogic = false;
boolean isAddEntityDetailDimensionMetric = false;
Integer domainId = queryContext.getDomainId().intValue();
List<SchemaElementMatch> matchedElements = queryContext.getMapInfo().getMatchedElements(domainId);
if (!CollectionUtils.isEmpty(matchedElements)) {
long metricCount = matchedElements.stream()
.filter(schemaElementMatch -> schemaElementMatch.getElementType()
.equals(SchemaElementType.METRIC)).count();
if (metricCount <= 0) {
if (chatCtx.getParseInfo() == null
|| chatCtx.getParseInfo().getMetrics() == null
|| chatCtx.getParseInfo().getMetrics().size() <= 0) {
logger.info("fillThemeDefaultMetricLogic");
fillThemeDefaultMetricLogic(queryContext.getParseInfo());
if (chatContext.getParseInfo() == null
|| chatContext.getParseInfo().getMetrics() == null
|| chatContext.getParseInfo().getMetrics().size() <= 0) {
log.info("fillThemeDefaultMetricLogic");
isFillThemeDefaultMetricLogic = true;
}
}
} else {
log.info("fillThemeDefaultMetricLogic for empty matchedElements ");
isFillThemeDefaultMetricLogic = true;
}
fillDateDomain(chatCtx, queryContext);
}
}
defaultQueryMode(queryContext, chatCtx);
if (EntityDetail.QUERY_MODE.equals(queryMode) || EntityMetricFilter.QUERY_MODE.equals(queryMode)) {
addEntityDetailDimensionMetric(queryContext, chatCtx);
dealNativeQuery(queryContext, true);
isAddEntityDetailDimensionMetric = true;
dealNativeQuery(semanticParseInfo, queryContext, true);
}
return false;
if (isFillThemeDefaultMetricLogic) {
if (chaConfigRichDesc == null) {
chaConfigRichDesc = getChatConfigRichInfo(semanticParseInfo.getDomainId());
}
private void dealNativeQuery(QueryContextReq queryContext, boolean isNativeQuery) {
if (Objects.nonNull(queryContext) && Objects.nonNull(queryContext.getParseInfo())) {
queryContext.getParseInfo().setNativeQuery(isNativeQuery);
fillThemeDefaultMetricLogic(semanticParseInfo, chaConfigRichDesc, queryContext);
}
if (isAddEntityDetailDimensionMetric) {
if (chaConfigRichDesc == null) {
chaConfigRichDesc = getChatConfigRichInfo(semanticParseInfo.getDomainId());
}
addEntityDetailDimensionMetric(semanticParseInfo, chaConfigRichDesc, queryContext, chatContext);
}
fillDateDomain(semanticParseInfo, chatContext, chaConfigRichDesc, queryContext);
}
defaultQueryMode(semanticParseInfo, queryContext, chatContext);
addEntityTopDimension(semanticParseInfo, chaConfigRichDesc);
}
}
private Set<String> addPrimaryDimension(EntityRichInfo entity, List<SchemaItem> dimensions) {
public void dealNativeQuery(SemanticParseInfo semanticParseInfo, QueryContextReq queryContext,
boolean isNativeQuery) {
if (Objects.nonNull(queryContext) && Objects.nonNull(semanticParseInfo)) {
semanticParseInfo.setNativeQuery(isNativeQuery);
}
}
public Set<String> addPrimaryDimension(EntityRichInfo entity, List<SchemaItem> dimensions) {
Set<String> primaryDimensions = new HashSet<>();
if (Objects.isNull(entity) || CollectionUtils.isEmpty(entity.getEntityIds())) {
return primaryDimensions;
}
entity.getEntityIds().stream().forEach(dimSchemaDesc -> {
SchemaItem dimension = new SchemaItem();
BeanUtils.copyProperties(dimSchemaDesc, dimension);
//BeanUtils.copyProperties(dimSchemaDesc, dimension);
dimension.setName(dimSchemaDesc.getName());
dimension.setBizName(dimSchemaDesc.getBizName());
dimension.setId(dimSchemaDesc.getId());
dimensions.add(dimension);
primaryDimensions.add(dimSchemaDesc.getBizName());
});
return primaryDimensions;
}
protected void addEntityDetailDimensionMetric(QueryContextReq queryContext, ChatContext chatCtx) {
if (queryContext.getParseInfo().getDomainId() > 0) {
Long domainId = queryContext.getParseInfo().getDomainId();
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(domainId);
public void addEntityTopDimension(SemanticParseInfo semanticParseInfo, ChatConfigRichInfo chaConfigRichDesc) {
if (!semanticParseInfo.getQueryMode().equals(EntityListTopN.QUERY_MODE) || !semanticParseInfo.getDimensions()
.isEmpty()) {
return;
}
if (semanticParseInfo.getDomainId() > 0) {
Long domainId = semanticParseInfo.getDomainId();
if (chaConfigRichDesc == null) {
chaConfigRichDesc = getChatConfigRichInfo(domainId);
}
if (chaConfigRichDesc != null && chaConfigRichDesc.getEntity() != null) {
List<SchemaItem> dimensions = new ArrayList<>();
addPrimaryDimension(chaConfigRichDesc.getEntity(), dimensions);
semanticParseInfo.setDimensions(new HashSet<>(dimensions));
semanticParseInfo.setLimit(1L);
}
}
}
public void addEntityDetailDimensionMetric(SemanticParseInfo semanticParseInfo,
ChatConfigRichInfo chaConfigRichDesc, QueryContextReq queryContext,
ChatContext chatCtx) {
if (semanticParseInfo.getDomainId() > 0) {
Long domainId = semanticParseInfo.getDomainId();
if (chaConfigRichDesc != null) {
if (chaConfigRichDesc.getEntity() == null
|| chaConfigRichDesc.getEntity().getEntityInternalDetailDesc() == null) {
return;
}
SemanticParseInfo semanticParseInfo = queryContext.getParseInfo();
Set<SchemaItem> metrics = new LinkedHashSet();
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getMetricList().stream()
.forEach(m -> metrics.add(getMetric(m)));
semanticParseInfo.setMetrics(metrics);
List<SchemaElementMatch> schemaElementMatches = queryContext.getMapInfo()
.getMatchedElements(domainId.intValue());
if (CollectionUtils.isEmpty(schemaElementMatches) || schemaElementMatches.stream()
.filter(s -> SchemaElementType.DIMENSION.equals(s.getElementType())).count() <= 0) {
logger.info("addEntityDetailDimensionMetric catch");
log.info("addEntityDetailDimensionMetric catch");
Set<SchemaItem> dimensions = new LinkedHashSet();
chaConfigRichDesc.getEntity().getEntityInternalDetailDesc().getDimensionList().stream()
.forEach(m -> dimensions.add(getDimension(m)));
@@ -134,10 +163,10 @@ public class DefaultMetricSemanticParser implements SemanticParser {
}
}
protected void defaultQueryMode(QueryContextReq queryContext, ChatContext chatCtx) {
public void defaultQueryMode(SemanticParseInfo semanticParseInfo, QueryContextReq queryContext,
ChatContext chatCtx) {
SchemaMapInfo schemaMap = queryContext.getMapInfo();
SemanticParseInfo parseInfo = queryContext.getParseInfo();
if (StringUtils.isEmpty(parseInfo.getQueryMode())) {
if (StringUtils.isEmpty(semanticParseInfo.getQueryMode())) {
if (chatCtx.getParseInfo() != null && chatCtx.getParseInfo().getDomainId() > 0) {
//
Long domain = chatCtx.getParseInfo().getDomainId();
@@ -154,9 +183,9 @@ public class DefaultMetricSemanticParser implements SemanticParser {
.filter(e -> e.getElementType().equals(SchemaElementType.METRIC)).count();
if (filterNUm > 0 && dimensionNUm > 0 && metricrNUm > 0) {
// default as entity detail queryMode
logger.info("defaultQueryMode [{}]", EntityDetail.QUERY_MODE);
parseInfo.setQueryMode(EntityDetail.QUERY_MODE);
parseInfo.setDomainId(domain);
log.info("defaultQueryMode [{}]", EntityDetail.QUERY_MODE);
semanticParseInfo.setQueryMode(EntityDetail.QUERY_MODE);
semanticParseInfo.setDomainId(domain);
return;
}
Long entityNUm = elementMatches.stream()
@@ -165,21 +194,21 @@ public class DefaultMetricSemanticParser implements SemanticParser {
// default as metric domain
if (metricrNUm > 0 || MetricDomain.QUERY_MODE.equals(queryMode)) {
// default as entity detail queryMode
logger.info("defaultQueryMode [{}]", MetricDomain.QUERY_MODE);
parseInfo.setQueryMode(MetricDomain.QUERY_MODE);
parseInfo.setDomainId(domain);
log.info("defaultQueryMode [{}]", MetricDomain.QUERY_MODE);
semanticParseInfo.setQueryMode(MetricDomain.QUERY_MODE);
semanticParseInfo.setDomainId(domain);
return;
}
}
}
if (CollectionUtils.isEmpty(schemaMap.getMatchedDomains()) && parseInfo != null
&& parseInfo.getDateInfo() != null) {
if (CollectionUtils.isEmpty(schemaMap.getMatchedDomains()) && semanticParseInfo != null
&& semanticParseInfo.getDateInfo() != null) {
// only query time
if (MetricDomain.QUERY_MODE.equals(queryMode)) {
// METRIC_DOMAIN context
logger.info("defaultQueryMode [{}]", MetricDomain.QUERY_MODE);
parseInfo.setQueryMode(MetricDomain.QUERY_MODE);
parseInfo.setDomainId(domain);
log.info("defaultQueryMode [{}]", MetricDomain.QUERY_MODE);
semanticParseInfo.setQueryMode(MetricDomain.QUERY_MODE);
semanticParseInfo.setDomainId(domain);
return;
}
}
@@ -188,12 +217,14 @@ public class DefaultMetricSemanticParser implements SemanticParser {
}
private void fillDateDomain(ChatContext chatCtx, QueryContextReq queryContext) {
SemanticParseInfo parseInfo = queryContext.getParseInfo();
public void fillDateDomain(SemanticParseInfo parseInfo, ChatContext chatCtx, ChatConfigRichInfo chaConfigRichDesc,
QueryContextReq queryContext) {
//SemanticParseInfo parseInfo = queryContext.getParseInfo();
if (parseInfo == null || parseInfo.getDateInfo() == null) {
DomainResolver selectStrategy = ComponentFactory.getDomainResolver();
boolean isUpdateTime = false;
if (selectStrategy.isDomainSwitch(chatCtx, queryContext)) {
if (selectStrategy.isDomainSwitch(chatCtx, parseInfo)) {
isUpdateTime = true;
}
if (chatCtx.getParseInfo() == null
@@ -201,23 +232,31 @@ public class DefaultMetricSemanticParser implements SemanticParser {
isUpdateTime = true;
}
if (isUpdateTime && parseInfo != null && parseInfo.getDomainId() > 0) {
logger.info("fillThemeDefaultTime");
fillThemeDefaultTime(parseInfo.getDomainId(), parseInfo);
fillThemeDefaultTime(parseInfo.getDomainId(), chaConfigRichDesc, parseInfo);
}
}
}
private void fillThemeDefaultMetricLogic(SemanticParseInfo semanticParseInfo) {
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(
semanticParseInfo.getDomainId());
public void fillThemeDefaultMetricLogic(SemanticParseInfo semanticParseInfo, ChatConfigRichInfo chaConfigRichDesc,
QueryContextReq queryContext) {
//SemanticParseInfo semanticParseInfo = queryContext.getParseInfo();
if (Objects.isNull(chaConfigRichDesc) || CollectionUtils.isEmpty(chaConfigRichDesc.getDefaultMetrics())) {
log.info("there is no defaultMetricIds info");
return;
}
if (CollectionUtils.isEmpty(semanticParseInfo.getMetrics()) && CollectionUtils.isEmpty(
semanticParseInfo.getDimensions())) {
if (queryContext.getMapInfo() == null || !queryContext.getMapInfo().getMatchedDomains()
.contains(chaConfigRichDesc.getDomainId().intValue())) {
return;
}
List<SchemaElementMatch> schemaElementMatches = queryContext.getMapInfo()
.getMatchedElements(chaConfigRichDesc.getDomainId().intValue());
long metricNum = schemaElementMatches.stream().filter(e -> e.getElementType().equals(SchemaElementType.METRIC))
.count();
long dimensionNum = schemaElementMatches.stream()
.filter(e -> e.getElementType().equals(SchemaElementType.DIMENSION)).count();
if (metricNum <= 0 && dimensionNum <= 0) {
Set<SchemaItem> metrics = new LinkedHashSet();
chaConfigRichDesc.getDefaultMetrics().stream().forEach(metric -> {
SchemaItem metricTmp = new SchemaItem();
@@ -240,9 +279,15 @@ public class DefaultMetricSemanticParser implements SemanticParser {
}
private void fillThemeDefaultTime(Long domain, SemanticParseInfo semanticParseInfo) {
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(
semanticParseInfo.getDomainId());
public void fillThemeDefaultTime(Long domain, ChatConfigRichInfo chaConfigRichDesc,
SemanticParseInfo semanticParseInfo) {
if (!Objects.isNull(semanticParseInfo.getDateInfo()) && !Objects.isNull(
semanticParseInfo.getDateInfo().getDateMode())) {
return;
}
if (chaConfigRichDesc == null) {
chaConfigRichDesc = getChatConfigRichInfo(semanticParseInfo.getDomainId());
}
if (!Objects.isNull(chaConfigRichDesc) && !CollectionUtils.isEmpty(chaConfigRichDesc.getDefaultMetrics())) {
DefaultMetric defaultMetricInfo = chaConfigRichDesc.getDefaultMetrics().get(0);
DateConf dateInfo = new DateConf();
@@ -252,9 +297,16 @@ public class DefaultMetricSemanticParser implements SemanticParser {
dateInfo.setEndDate(now().minusDays(1).toString());
dateInfo.setPeriod(defaultMetricInfo.getPeriod());
semanticParseInfo.setDateInfo(dateInfo);
log.info("fillThemeDefaultTime");
}
}
public ChatConfigRichInfo getChatConfigRichInfo(Long domain) {
DefaultSemanticInternalUtils defaultSemanticUtils = ContextUtils.getBean(DefaultSemanticInternalUtils.class);
ChatConfigRichInfo chaConfigRichDesc = defaultSemanticUtils.getChatConfigRichInfo(domain);
return chaConfigRichDesc;
}
private SchemaItem getMetric(MetricSchemaResp metricSchemaDesc) {
SchemaItem queryMeta = new SchemaItem();
queryMeta.setId(metricSchemaDesc.getId());

8
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/DefaultSemanticInternalUtils.java
View File

@@ -19,10 +19,12 @@ import com.tencent.supersonic.common.result.ReturnCode;
import com.tencent.supersonic.common.util.context.S2ThreadContext;
import com.tencent.supersonic.common.util.context.ThreadContext;
import com.tencent.supersonic.common.util.json.JsonUtil;
import java.net.URI;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Objects;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.BeanUtils;
@@ -139,13 +141,13 @@ public class DefaultSemanticInternalUtils {
headers.set(authenticationConfig.getTokenHttpHeaderKey(), threadContext.getToken());
}
} else {
log.info("threadContext is null:{}", Objects.isNull(threadContext));
log.debug("threadContext is null:{}", Objects.isNull(threadContext));
}
}
public List<DomainResp> getDomainListForUser(User user) {
public List<DomainResp> getDomainListForAdmin() {
Object domainDescListObject = fetchHttpResult(semanticUrl + fetchDomainListPath, null, HttpMethod.GET);
List<DomainResp> domainDescList = (List<DomainResp>) domainDescListObject;
List<DomainResp> domainDescList = JsonUtil.toList(JsonUtil.toString(domainDescListObject), DomainResp.class);
return domainDescList;
}
}

11
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/DictMetaUtils.java
View File

@@ -3,7 +3,7 @@ package com.tencent.supersonic.chat.domain.utils;
import static com.tencent.supersonic.common.constant.Constants.DAY;
import static com.tencent.supersonic.common.constant.Constants.UNDERLINE;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
import com.tencent.supersonic.chat.domain.dataobject.DimValueDO;
@@ -32,15 +32,12 @@ import org.springframework.util.CollectionUtils;
@Component
public class DictMetaUtils {
private final DefaultSemanticInternalUtils defaultSemanticUtils;
@Value("${model.internal.metric.suffix:internal_cnt}")
private String internalMetricNameSuffix;
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
private final SemanticLayer semanticLayer;
private final DefaultSemanticInternalUtils defaultSemanticUtils;
public DictMetaUtils(SemanticLayer semanticLayer,
DefaultSemanticInternalUtils defaultSemanticUtils) {
this.semanticLayer = semanticLayer;
public DictMetaUtils(DefaultSemanticInternalUtils defaultSemanticUtils) {
this.defaultSemanticUtils = defaultSemanticUtils;
}

12
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/DictQueryUtils.java
View File

@@ -6,7 +6,7 @@ import static com.tencent.supersonic.common.constant.Constants.COMMA;
import static com.tencent.supersonic.common.constant.Constants.UNDERLINE_DOUBLE;
import com.tencent.supersonic.auth.api.authentication.pojo.User;
import com.tencent.supersonic.chat.api.service.SemanticLayer;
import com.tencent.supersonic.chat.api.component.SemanticLayer;
import com.tencent.supersonic.semantic.api.core.pojo.QueryColumn;
import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
@@ -19,6 +19,7 @@ import com.tencent.supersonic.common.enums.AggOperatorEnum;
import com.tencent.supersonic.common.pojo.Aggregator;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.pojo.Order;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
@@ -26,6 +27,7 @@ import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringJoiner;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Value;
@@ -36,9 +38,8 @@ import org.springframework.util.CollectionUtils;
@Component
public class DictQueryUtils {
private final SemanticLayer semanticLayer;
Long frequencyMax = 99999999L;
private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
@Value("${dimension.multi.value.split:#}")
private String dimMultiValueSplit;
@@ -48,11 +49,6 @@ public class DictQueryUtils {
@Value("${dimension.max.limit:3000000}")
private Long dimMaxLimit;
public DictQueryUtils(SemanticLayer semanticLayer) {
this.semanticLayer = semanticLayer;
}
public List<String> fetchDimValueSingle(Long domainId, DefaultMetric defaultMetricDesc, Dim4Dict dim4Dict,
User user) {
List<String> data = new ArrayList<>();

89
chat/core/src/main/java/com/tencent/supersonic/chat/domain/utils/DslToSemanticInfo.java Normal file
View File

@@ -0,0 +1,89 @@
package com.tencent.supersonic.chat.domain.utils;
import static java.time.LocalDate.now;
import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
import com.tencent.supersonic.chat.application.knowledge.WordNatureService;
import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
import com.tencent.supersonic.chat.domain.pojo.chat.LLMResp;
import com.tencent.supersonic.common.nlp.ItemDO;
import com.tencent.supersonic.common.pojo.DateConf;
import com.tencent.supersonic.common.util.calcite.SqlParseUtils;
import com.tencent.supersonic.common.util.calcite.SqlParserInfo;
import com.tencent.supersonic.common.util.context.ContextUtils;
import com.tencent.supersonic.semantic.api.core.enums.TimeDimensionEnum;
import java.text.MessageFormat;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DslToSemanticInfo {
public static final String SUB_TABLE = " ( select * from t_{0} where {1} >= ''{2}'' and {1} <= ''{3}'' ) as t_sub_{0}";
private static final Logger LOG = LoggerFactory.getLogger(DslToSemanticInfo.class);
public static String convert(SemanticParseInfo parseInfo, LLMResp llmResp) {
String sqlOutput = llmResp.getSqlOutput();
String domainName = llmResp.getDomainName();
DomainInfos domainInfos = ContextUtils.getBean(WordNatureService.class).getCache().getUnchecked("");
SqlParserInfo sqlParseInfo = SqlParseUtils.getSqlParseInfo(sqlOutput);
String tableName = sqlParseInfo.getTableName();
if (StringUtils.isEmpty(domainName)) {
domainName = tableName;
}
List<String> allFields = sqlParseInfo.getAllFields();
Map<String, Integer> domainNameToId = domainInfos.getDomains().stream()
.collect(Collectors.toMap(ItemDO::getName, a -> a.getDomain(), (k1, k2) -> k1));
Integer domainId = domainNameToId.get(domainName);
LOG.info("sqlParseInfo:{} ,domainName:{},domainId:{}", sqlParseInfo, domainName, domainId);
List<ItemDO> fieldList = domainInfos.getMetrics();
fieldList.addAll(domainInfos.getDimensions());
Map<String, String> fieldToBizName = getMapInfo(domainId, fieldList);
for (String fieldName : allFields) {
String fieldBizName = fieldToBizName.get(fieldName);
if (StringUtils.isNotEmpty(fieldBizName)) {
sqlOutput = sqlOutput.replaceAll(fieldName, fieldBizName);
}
}
DateConf dateInfo = new DateConf();
if (Objects.nonNull(parseInfo) && Objects.nonNull(parseInfo.getDateInfo())) {
dateInfo = parseInfo.getDateInfo();
} else {
String startDate = now().plusDays(-4).toString();
String endDate = now().plusDays(-4).toString();
dateInfo.setStartDate(startDate);
dateInfo.setEndDate(endDate);
}
String startDate = dateInfo.getStartDate();
String endDate = dateInfo.getEndDate();
String period = dateInfo.getPeriod();
TimeDimensionEnum timeDimension = TimeDimensionEnum.valueOf(period);
String dayField = timeDimension.getName();
// add dayno
String subTable = MessageFormat.format(SUB_TABLE, domainId, dayField, startDate, endDate);
String querySql = sqlOutput.replaceAll(tableName, subTable);
LOG.info("querySql:{},sqlOutput:{},dateInfo:{}", querySql, sqlOutput, dateInfo);
return querySql;
}
private static Map<String, String> getMapInfo(Integer domainId, List<ItemDO> metrics) {
return metrics.stream().filter(entry -> entry.getDomain().equals(domainId))
.collect(Collectors.toMap(ItemDO::getName, a -> a.getBizName(), (k1, k2) -> k1));
}
}

Some files were not shown because too many files have changed in this diff Show More