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

(improvement)(chat) support llm default modelId and fix delete agent tool error (#73)

Browse Source
This commit is contained in:
lexluo09
2023-09-11 23:46:08 +08:00
committed by GitHub
parent eca92d2493
commit 8aedfbb6a0
16 changed files with 480 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
chat/core/src/main/java/com/tencent/supersonic/chat/agent/tool/AgentTool.java
View File

@@ -9,6 +9,8 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor @AllArgsConstructor
public class AgentTool { public class AgentTool {
private String id;
private String name; private String name;
private AgentToolType type; private AgentToolType type;

8
chat/core/src/main/java/com/tencent/supersonic/chat/mapper/MapperHelper.java
View File

@@ -14,7 +14,6 @@ import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import lombok.Data; import lombok.Data;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@@ -91,7 +90,7 @@ public class MapperHelper {
Set<Long> detectModelIds = agentService.getDslToolsModelIds(request.getAgentId(), null); Set<Long> detectModelIds = agentService.getDslToolsModelIds(request.getAgentId(), null);
//contains all //contains all
if (isContainsAllModel(detectModelIds)) { if (agentService.containsAllModel(detectModelIds)) {
if (Objects.nonNull(modelId) && modelId > 0) { if (Objects.nonNull(modelId) && modelId > 0) {
Set<Long> result = new HashSet<>(); Set<Long> result = new HashSet<>();
result.add(modelId); result.add(modelId);
@@ -113,9 +112,4 @@ public class MapperHelper {
} }
return detectModelIds; return detectModelIds;
} }
private boolean isContainsAllModel(Set<Long> detectModelIds) {
return CollectionUtils.isNotEmpty(detectModelIds) && detectModelIds.contains(-1L);
}
} }

25
chat/core/src/main/java/com/tencent/supersonic/chat/parser/llm/dsl/LLMDslParser.java
View File

@@ -40,6 +40,7 @@ import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
@@ -66,8 +67,12 @@ public class LLMDslParser implements SemanticParser {
public void parse(QueryContext queryCtx, ChatContext chatCtx) { public void parse(QueryContext queryCtx, ChatContext chatCtx) {
QueryReq request = queryCtx.getRequest(); QueryReq request = queryCtx.getRequest();
LLMConfig llmConfig = ContextUtils.getBean(LLMConfig.class); LLMConfig llmConfig = ContextUtils.getBean(LLMConfig.class);
if (StringUtils.isEmpty(llmConfig.getUrl()) || SatisfactionChecker.check(queryCtx)) { if (StringUtils.isEmpty(llmConfig.getUrl())) {
log.info("llmConfig:{}, skip dsl parser, queryText:{}", llmConfig, request.getQueryText()); log.info("llm url is empty, skip dsl parser, llmConfig:{}", llmConfig);
return;
}
if (SatisfactionChecker.check(queryCtx)) {
log.info("skip dsl parser, queryText:{}", request.getQueryText());
return; return;
} }
try { try {
@@ -88,8 +93,8 @@ public class LLMDslParser implements SemanticParser {
if (Objects.isNull(llmResp)) { if (Objects.isNull(llmResp)) {
return; return;
} }
DSLParseResult dslParseResult = DSLParseResult.builder().request(request).dslTool(dslTool).llmReq(llmReq) DSLParseResult dslParseResult = DSLParseResult.builder().request(request)
.llmResp(llmResp).build(); .dslTool(dslTool).llmReq(llmReq).llmResp(llmResp).build();
SemanticParseInfo parseInfo = getParseInfo(queryCtx, modelId, dslTool, dslParseResult); SemanticParseInfo parseInfo = getParseInfo(queryCtx, modelId, dslTool, dslParseResult);
@@ -287,7 +292,14 @@ public class LLMDslParser implements SemanticParser {
private DslTool getDslTool(QueryReq request, Long modelId) { private DslTool getDslTool(QueryReq request, Long modelId) {
AgentService agentService = ContextUtils.getBean(AgentService.class); AgentService agentService = ContextUtils.getBean(AgentService.class);
List<DslTool> dslTools = agentService.getDslTools(request.getAgentId(), AgentToolType.DSL); List<DslTool> dslTools = agentService.getDslTools(request.getAgentId(), AgentToolType.DSL);
Optional<DslTool> dslToolOptional = dslTools.stream().filter(tool -> tool.getModelIds().contains(modelId)) Optional<DslTool> dslToolOptional = dslTools.stream()
.filter(tool -> {
List<Long> modelIds = tool.getModelIds();
if (agentService.containsAllModel(new HashSet<>(modelIds))) {
return true;
}
return modelIds.contains(modelId);
})
.findFirst(); .findFirst();
return dslToolOptional.orElse(null); return dslToolOptional.orElse(null);
} }
@@ -295,6 +307,9 @@ public class LLMDslParser implements SemanticParser {
private Long getModelId(QueryContext queryCtx, ChatContext chatCtx, Integer agentId) { private Long getModelId(QueryContext queryCtx, ChatContext chatCtx, Integer agentId) {
AgentService agentService = ContextUtils.getBean(AgentService.class); AgentService agentService = ContextUtils.getBean(AgentService.class);
Set<Long> distinctModelIds = agentService.getDslToolsModelIds(agentId, AgentToolType.DSL); Set<Long> distinctModelIds = agentService.getDslToolsModelIds(agentId, AgentToolType.DSL);
if (agentService.containsAllModel(distinctModelIds)) {
distinctModelIds = new HashSet<>();
}
ModelResolver modelResolver = ComponentFactory.getModelResolver(); ModelResolver modelResolver = ComponentFactory.getModelResolver();
Long modelId = modelResolver.resolve(queryCtx, chatCtx, distinctModelIds); Long modelId = modelResolver.resolve(queryCtx, chatCtx, distinctModelIds);
log.info("resolve modelId:{},dslModels:{}", modelId, distinctModelIds); log.info("resolve modelId:{},dslModels:{}", modelId, distinctModelIds);

17
chat/core/src/main/java/com/tencent/supersonic/chat/parser/plugin/function/HeuristicModelResolver.java
View File

@@ -24,7 +24,7 @@ import org.apache.commons.collections.CollectionUtils;
public class HeuristicModelResolver implements ModelResolver { public class HeuristicModelResolver implements ModelResolver {
protected static Long selectModelBySchemaElementCount(Map<Long, SemanticQuery> modelQueryModes, protected static Long selectModelBySchemaElementCount(Map<Long, SemanticQuery> modelQueryModes,
SchemaMapInfo schemaMap) { SchemaMapInfo schemaMap) {
Map<Long, ModelMatchResult> modelTypeMap = getModelTypeMap(schemaMap); Map<Long, ModelMatchResult> modelTypeMap = getModelTypeMap(schemaMap);
if (modelTypeMap.size() == 1) { if (modelTypeMap.size() == 1) {
Long modelSelect = modelTypeMap.entrySet().stream().collect(Collectors.toList()).get(0).getKey(); Long modelSelect = modelTypeMap.entrySet().stream().collect(Collectors.toList()).get(0).getKey();
@@ -57,8 +57,8 @@ public class HeuristicModelResolver implements ModelResolver {
* @return false will use context Model, true will use other Model , maybe include context Model * @return false will use context Model, true will use other Model , maybe include context Model
*/ */
protected static boolean isAllowSwitch(Map<Long, SemanticQuery> modelQueryModes, SchemaMapInfo schemaMap, protected static boolean isAllowSwitch(Map<Long, SemanticQuery> modelQueryModes, SchemaMapInfo schemaMap,
ChatContext chatCtx, QueryReq searchCtx, ChatContext chatCtx, QueryReq searchCtx,
Long modelId, Set<Long> restrictiveModels) { Long modelId, Set<Long> restrictiveModels) {
if (!Objects.nonNull(modelId) || modelId <= 0) { if (!Objects.nonNull(modelId) || modelId <= 0) {
return true; return true;
} }
@@ -137,7 +137,10 @@ public class HeuristicModelResolver implements ModelResolver {
public Long resolve(QueryContext queryContext, ChatContext chatCtx, Set<Long> restrictiveModels) { public Long resolve(QueryContext queryContext, ChatContext chatCtx, Set<Long> restrictiveModels) {
Long modelId = queryContext.getRequest().getModelId(); Long modelId = queryContext.getRequest().getModelId();
if (Objects.nonNull(modelId) && modelId > 0) { if (Objects.nonNull(modelId) && modelId > 0) {
if (CollectionUtils.isNotEmpty(restrictiveModels) && restrictiveModels.contains(modelId)) { if (CollectionUtils.isEmpty(restrictiveModels)) {
return modelId;
}
if (restrictiveModels.contains(modelId)) {
return modelId; return modelId;
} else { } else {
return null; return null;
@@ -162,7 +165,7 @@ public class HeuristicModelResolver implements ModelResolver {
} }
public Long resolve(Map<Long, SemanticQuery> modelQueryModes, QueryContext queryContext, public Long resolve(Map<Long, SemanticQuery> modelQueryModes, QueryContext queryContext,
ChatContext chatCtx, SchemaMapInfo schemaMap, Set<Long> restrictiveModels) { ChatContext chatCtx, SchemaMapInfo schemaMap, Set<Long> restrictiveModels) {
Long selectModel = selectModel(modelQueryModes, queryContext.getRequest(), Long selectModel = selectModel(modelQueryModes, queryContext.getRequest(),
chatCtx, schemaMap, restrictiveModels); chatCtx, schemaMap, restrictiveModels);
if (selectModel > 0) { if (selectModel > 0) {
@@ -174,8 +177,8 @@ public class HeuristicModelResolver implements ModelResolver {
} }
public Long selectModel(Map<Long, SemanticQuery> modelQueryModes, QueryReq queryContext, public Long selectModel(Map<Long, SemanticQuery> modelQueryModes, QueryReq queryContext,
ChatContext chatCtx, ChatContext chatCtx,
SchemaMapInfo schemaMap, Set<Long> restrictiveModels) { SchemaMapInfo schemaMap, Set<Long> restrictiveModels) {
// if QueryContext has modelId and in ModelQueryModes // if QueryContext has modelId and in ModelQueryModes
if (modelQueryModes.containsKey(queryContext.getModelId())) { if (modelQueryModes.containsKey(queryContext.getModelId())) {
log.info("selectModel from QueryContext [{}]", queryContext.getModelId()); log.info("selectModel from QueryContext [{}]", queryContext.getModelId());

1
chat/core/src/main/java/com/tencent/supersonic/chat/service/AgentService.java
View File

@@ -23,4 +23,5 @@ public interface AgentService {
Set<Long> getDslToolsModelIds(Integer agentId, AgentToolType agentToolType); Set<Long> getDslToolsModelIds(Integer agentId, AgentToolType agentToolType);
boolean containsAllModel(Set<Long> detectModelIds);
} }

5
chat/core/src/main/java/com/tencent/supersonic/chat/service/impl/AgentServiceImpl.java
View File

@@ -109,4 +109,9 @@ public class AgentServiceImpl implements AgentService {
.flatMap(Collection::stream) .flatMap(Collection::stream)
.collect(Collectors.toSet()); .collect(Collectors.toSet());
} }
@Override
public boolean containsAllModel(Set<Long> detectModelIds) {
return !CollectionUtils.isEmpty(detectModelIds) && detectModelIds.contains(-1L);
}
} }

31
chat/core/src/main/python/llm/api_service.py
View File

@@ -25,20 +25,31 @@ app = FastAPI()
@app.post("/query2sql/") @app.post("/query2sql/")
async def din_query2sql(query_body: Mapping[str, Any]): async def din_query2sql(query_body: Mapping[str, Any]):
if 'queryText' not in query_body: if 'queryText' not in query_body:
raise HTTPException(status_code=400, raise HTTPException(status_code=400,
detail="query_text is not in query_body") detail="query_text is not in query_body")
else: else:
query_text = query_body['queryText'] query_text = query_body['queryText']
if 'schema' not in query_body: if 'schema' not in query_body:
raise HTTPException(status_code=400, detail="schema is not in query_body") raise HTTPException(status_code=400, detail="schema is not in query_body")
else: else:
schema = query_body['schema'] schema = query_body['schema']
resp = query2sql(query_text=query_text, schema=schema) if 'currentDate' not in query_body:
raise HTTPException(status_code=400, detail="currentDate is not in query_body")
else:
current_date = query_body['currentDate']
return resp if 'linking' not in query_body:
linking = None
else:
linking = query_body['linking']
resp = query2sql(query_text=query_text,
schema=schema, current_date=current_date, linking=linking)
return resp
@app.post("/preset_query_retrival/") @app.post("/preset_query_retrival/")

349
chat/core/src/main/python/llm/few_shot_example/sql_exampler.py
View File

@@ -1,147 +1,296 @@
examplars= [ examplars= [
{ { "current_date":"2020-12-01",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长"]""", "fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长", "数据日期"]""",
"question":"比较jerry和tom在内容库的访问次数", "question":"比较jackjchen和robinlee在内容库的访问次数",
"analysis": """让我们一步一步地思考。在问题“比较jerry和tom在内容库的访问次数“中，我们被问： "prior_schema_links":"""['jackjchen'->用户名, 'robinlee'->用户名]""",
“内容库的访问次数”，所以我们需要column=[访问次数] "analysis": """让我们一步一步地思考。在问题“比较jackjchen和robinlee在内容库的访问次数“中，我们被问：
”比较jerry和tom“，所以我们需要column=[用户名] “比较jackjchen和robinlee”，所以我们需要column=[用户名]
基于table和columns，可能的cell values 是 = ['jerry', 'tom']。""", ”内容库的访问次数“，所以我们需要column=[访问次数]
"schema_links":"""["访问次数", "用户名", "'jerry'", "'tom'"]""", 基于table和columns，可能的cell values 是 = ['jackjchen', 'robinlee']。""",
"sql":"""select 用户名, 访问次数 from 内容库产品 where 用户名 in ('jerry', 'tom')""" "schema_links":"""["用户名", "访问次数", "'jackjchen'", "'robinlee'"]""",
}, "sql":"""select 用户名, 访问次数 from 内容库产品 where 用户名 in ('jackjchen', 'robinlee') and 数据日期 = '2020-12-01' """
{ },
{ "current_date":"2022-11-06",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长"]""", "fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长", "数据日期"]""",
"question":"内容库近12个月访问人数 按部门", "question":"内容库近12个月访问人数 按部门",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“内容库近12个月访问人数 按部门“中，我们被问： "analysis": """让我们一步一步地思考。在问题“内容库近12个月访问人数 按部门“中，我们被问：
“内容库近12个月访问人数”，所以我们需要column=[访问人数] ”内容库近12个月“，所以我们需要column=[数据日期]
“访问人数”，所以我们需要column=[访问人数]
”按部门“，所以我们需要column=[部门] ”按部门“，所以我们需要column=[部门]
基于table和columns，可能的cell values 是 = []。""", 基于table和columns，可能的cell values 是 = [12]。""",
"schema_links":"""["访问人数", "部门"]""", "schema_links":"""["访问人数", "部门", "数据日期", 12]""",
"sql":"""select 部门, sum(访问人数) from 内容库产品 where 部门 group by 部门""" "sql":"""select 部门, 数据日期, 访问人数 from 内容库产品 where datediff('month', 数据日期, '2022-11-06') <= 12 """
}, },
{ { "current_date":"2023-04-21",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长"]""", "fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长", "数据日期"]""",
"question":"内容库编辑部、美术部的访问时长", "question":"内容库美术部、技术研发部的访问时长",
"analysis": """让我们一步一步地思考。在问题“内容库编辑部、美术部的访问时长“中，我们被问： "prior_schema_links":"""['美术部'->部门, '技术研发部'->部门]""",
"analysis": """让我们一步一步地思考。在问题“内容库美术部、技术研发部的访问时长“中，我们被问：
“访问时长”，所以我们需要column=[访问时长] “访问时长”，所以我们需要column=[访问时长]
”内容库编辑部、美术部“，所以我们需要column=[部门] ”内容库美术部、技术研发部“，所以我们需要column=[部门]
基于table和columns，可能的cell values 是 = ['编辑部', '美术部']。""", 基于table和columns，可能的cell values 是 = ['美术部', '技术研发部']。""",
"schema_links":"""["访问时长", "部门", "'编辑部'", "'美术部'"]""", "schema_links":"""["访问时长", "部门", "'美术部'", "'技术研发部'"]""",
"sql":"""select 部门, 访问时长 from 内容库产品 where 部门 in ('编辑部', '美术部')""" "sql":"""select 部门, 访问时长 from 内容库产品 where 部门 in ('美术部', '技术研发部') and 数据日期 = '2023-04-21' """
}, },
{ { "current_date":"2023-08-21",
"table_name":"精选", "table_name":"严选",
"fields_list":"""['归属系', '付费模式', '结算播放份额', '付费用户结算播放份额']""", "fields_list":"""["严选版权归属系", "付费模式", "结算播放份额", "付费用户结算播放份额", "数据日期"]""",
"question":"近3天飞天系结算播放份额", "question":"近3天海田飞系MPPM结算播放份额",
"analysis": """让我们一步一步地思考。在问题“近3天飞天系结算播放份额“中，我们被问： "prior_schema_links":"""['海田飞系'->严选版权归属系]""",
“结算播放份额”，所以我们需要column=[结算播放份额] "analysis": """让我们一步一步地思考。在问题“近3天海田飞系MPPM结算播放份额“中，我们被问：
”飞天系“，所以我们需要column=[归属系] “MPPM结算播放份额”，所以我们需要column=[结算播放份额]
基于table和columns，可能的cell values 是 = ['飞天系']。""", ”海田飞系“，所以我们需要column=[严选版权归属系]
"schema_links":"""["结算播放份额", "归属系", "'飞天系'"]""", ”近3天“，所以我们需要column=[数据日期]
"sql":"""select 归属系, 结算播放份额 from 精选 where 归属系 in ('飞天系')""" 基于table和columns，可能的cell values 是 = ['海田飞系', 3]。""",
}, "schema_links":"""["结算播放份额", "严选版权归属系", "数据日期", "'海田飞系'", 3]""",
{ "sql":"""select 严选版权归属系, 结算播放份额 from 严选 where 严选版权归属系 = '海田飞系' and datediff('day', 数据日期, '2023-08-21') <= 3 """
},
{ "current_date":"2023-05-22",
"table_name":"歌曲库", "table_name":"歌曲库",
"fields_list":"""['歌曲ID', '歌曲MID', '歌曲名', '歌曲版本', '歌曲类型', '翻唱类型', '结算播放量', '运营播放量', '付费用户结算播放量', '历史累计结算播放量', '运营搜播量', '结算搜播量', '运营完播量', '运营推播量', '近7日复播率', '日均搜播量']""", "fields_list":"""["是否潮流人歌曲", "C音歌曲ID", "C音歌曲MID", "歌曲名", "歌曲版本", "语种", "歌曲类型", "翻唱类型", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "结算播放量", "运营播放量", "付费用户结算播放量", "历史累计结算播放量", "运营搜播量", "结算搜播量", "运营完播量", "运营推播量", "近7日复播率", "日均搜播量", "数据日期"]""",
"question":"对比近3天翻唱版和纯音乐的歌曲播放量", "question":"对比近7天翻唱版和纯音乐的歌曲播放量",
"prior_schema_links":"""['纯音乐'->语种, '翻唱版'->歌曲版本]""",
"analysis": """让我们一步一步地思考。在问题“对比近3天翻唱版和纯音乐的歌曲播放量“中，我们被问： "analysis": """让我们一步一步地思考。在问题“对比近3天翻唱版和纯音乐的歌曲播放量“中，我们被问：
“歌曲播放量”，所以我们需要column=[结算播放量] “歌曲播放量”，所以我们需要column=[结算播放量]
”翻唱版和纯音乐“，所以我们需要column=[歌曲类型] ”翻唱版“，所以我们需要column=[歌曲版本]
基于table和columns，可能的cell values 是 = ['翻唱版', '纯音乐']。""", ”和纯音乐的歌曲“，所以我们需要column=[语种]
"schema_links":"""["结算播放量", "歌曲类型", "'翻唱版'", "'纯音乐'"]""", ”近7天“，所以我们需要column=[数据日期]
"sql":"""select 歌曲类型, 结算播放量 from 歌曲库 where 歌曲类型 in ('翻唱版', '纯音乐')""" 基于table和columns，可能的cell values 是 = ['翻唱版', '纯音乐', 7]。""",
}, "schema_links":"""["结算播放量", "歌曲版本", "语种", "数据日期", "'翻唱版'", "'纯音乐'", 7]""",
{ "sql":"""select 歌曲版本, 语种, 结算播放量 from 歌曲库 where 歌曲版本 = '翻唱版' and 语种 = '纯音乐' and datediff('day', 数据日期, '2023-05-22') <= 7 """
},
{ "current_date":"2023-05-31",
"table_name":"艺人库", "table_name":"艺人库",
"fields_list":"""['上下架状态', '歌手名', '歌手等级', '歌手类型', '歌手来源', '活跃区域', '年龄', '歌手才能', '歌手风格', '粉丝数', '在架歌曲数', '有播放量歌曲数']""", "fields_list":"""["上下架状态", "歌手名", "歌手等级", "歌手类型", "歌手来源", "MPPM潮流人等级", "活跃区域", "年龄", "歌手才能", "歌手风格", "粉丝数", "潮音粉丝数", "超声波粉丝数", "推博粉丝数", "超声波歌曲数", "在架歌曲数", "超声波分享数", "独占歌曲数", "超声波在架歌曲评论数", "有播放量歌曲数", "数据日期"]""",
"question":"对比一下流得滑、锅富程、章雪友的粉丝数", "question":"对比一下陈拙悬、孟梅琦、赖媚韵的粉丝数",
"analysis": """让我们一步一步地思考。在问题“对比一下流得滑、锅富程、章雪友的粉丝数“中，我们被问： "prior_schema_links":"""['1527896'->MPPM歌手ID, '1565463'->MPPM歌手ID, '2141459'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“对比一下陈拙悬、孟梅琦、赖媚韵的粉丝数“中，我们被问：
“粉丝数”，所以我们需要column=[粉丝数] “粉丝数”，所以我们需要column=[粉丝数]
”流得滑、锅富程、章雪友“，所以我们需要column=[歌手名] ”陈拙悬、孟梅琦、赖媚韵“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['流得滑', '锅富程', '章雪友']。""", 基于table和columns，可能的cell values 是 = ['陈拙悬', '孟梅琦', '赖媚韵']。""",
"schema_links":"""["粉丝数", "歌手名", "'流得滑'", "'锅富程'", "'章雪友'"]""", "schema_links":"""["粉丝数", "歌手名", "'陈拙悬'", "'孟梅琦'", "'赖媚韵'"]""",
"sql":"""select 歌手名, 粉丝数 from 艺人库 where 歌手名 in ('流得滑', '锅富程', '章雪友')""" "sql":"""select 歌手名, 粉丝数 from 艺人库 where 歌手名 in ('陈拙悬', '孟梅琦', '赖媚韵') and 数据日期 = '2023-05-31' """
}, },
{ { "current_date":"2023-07-31",
"table_name":"歌曲库", "table_name":"歌曲库",
"fields_list":"""['歌曲ID', '歌曲MID', '歌曲名', '歌曲版本', '歌曲类型', '翻唱类型', '结算播放量', '运营播放量', '付费用户结算播放量', '历史累计结算播放量', '运营搜播量', '结算搜播量', '运营完播量', '运营推播量', '近7日复播率', '日均搜播量']""", "fields_list":"""["歌曲名", "歌曲版本", "歌曲类型", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"播放量大于1万的歌曲有多少", "question":"播放量大于1万的歌曲有多少",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“播放量大于1万的歌曲有多少“中，我们被问： "analysis": """让我们一步一步地思考。在问题“播放量大于1万的歌曲有多少“中，我们被问：
“歌曲有多少”，所以我们需要column=[歌曲名] “歌曲有多少”，所以我们需要column=[歌曲名]
”播放量大于1万“，所以我们需要column=[结算播放量] ”播放量大于1万的“，所以我们需要column=[结算播放量]
基于table和columns，可能的cell values 是 = [10000]。""", 基于table和columns，可能的cell values 是 = [10000]。""",
"schema_links":"""["歌曲名", "结算播放量", 10000]""", "schema_links":"""["歌曲名", "结算播放量", 10000]""",
"sql":"""select 歌曲名 from 歌曲库 where 结算播放量 > 10000""" "sql":"""select 歌曲名 from 歌曲库 where 结算播放量 > 10000 and 数据日期 = '2023-07-31' """
}, },
{ { "current_date":"2023-07-31",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""['用户名', '部门', '模块', '访问时长', '访问次数', '访问人数']""", "fields_list":"""["用户名", "部门", "模块", "访问时长", "访问次数", "访问人数", "数据日期"]""",
"question":"内容库访问时长小于1小时，且来自美术部的用户是哪些", "question":"内容库访问时长小于1小时，且来自美术部的用户是哪些",
"prior_schema_links":"""['美术部'->部门]""",
"analysis": """让我们一步一步地思考。在问题“内容库访问时长小于1小时，且来自美术部的用户是哪些“中，我们被问： "analysis": """让我们一步一步地思考。在问题“内容库访问时长小于1小时，且来自美术部的用户是哪些“中，我们被问：
“用户是哪些”，所以我们需要column=[用户名] “用户是哪些”，所以我们需要column=[用户名]
”美术部的“，所以我们需要column=[部门] ”美术部的“，所以我们需要column=[部门]
”访问时长小于1小时“，所以我们需要column=[访问时长] ”访问时长小于1小时“，所以我们需要column=[访问时长]
基于table和columns，可能的cell values 是 = ['美术部', 1]。""", 基于table和columns，可能的cell values 是 = ['美术部', 1]。""",
"schema_links":"""["用户名", "部门", "访问时长", "'美术部'", 1]""", "schema_links":"""["用户名", "部门", "访问时长", "'美术部'", 1]""",
"sql":"""select 用户名 from 内容库产品 where 部门 = '美术部' and 访问时长 < 1""" "sql":"""select 用户名 from 内容库产品 where 部门 = '美术部' and 访问时长 < 1 and 数据日期 = '2023-07-31' """
}, },
{ { "current_date":"2023-08-31",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""['用户名', '部门', '模块', '访问次数', '访问人数', '访问时长']""", "fields_list":"""["用户名", "部门", "模块", "访问时长", "访问次数", "访问人数", "数据日期"]""",
"question":"内容库pv最高的用户有哪些", "question":"内容库pv最高的用户有哪些",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“内容库pv最高的用户有哪些“中，我们被问： "analysis": """让我们一步一步地思考。在问题“内容库pv最高的用户有哪些“中，我们被问：
“用户有哪些”，所以我们需要column=[用户名] “用户有哪些”，所以我们需要column=[用户名]
”pv最高的“，所以我们需要column=[访问次数] ”pv最高的“，所以我们需要column=[访问次数]
基于table和columns，可能的cell values 是 = []。""", 基于table和columns，可能的cell values 是 = []。""",
"schema_links":"""["用户名", "访问次数"]""", "schema_links":"""["用户名", "访问次数"]""",
"sql":"""select 用户名 from 内容库产品 order by 访问次数 desc limit 10""" "sql":"""select 用户名 from 内容库产品 where 数据日期 = '2023-08-31' order by 访问次数 desc limit 10 """
}, },
{ { "current_date":"2023-08-31",
"table_name":"艺人库", "table_name":"艺人库",
"fields_list":"""['歌手名', '歌手等级', '歌手类型', '歌手来源', '结算播放量', '运营播放量', '历史累计结算播放量', '有播放量歌曲数', '历史累计运营播放量', '付费用户结算播放量', '结算播放量占比', '运营播放份额', '完播量']""", "fields_list":"""["播放量层级", "播放量单调性", "播放量方差", "播放量突增类型", "播放量集中度", "歌手名", "歌手等级", "歌手类型", "歌手来源", "MPPM潮流人等级", "结算播放量", "运营播放量", "历史累计结算播放量", "有播放量歌曲数", "历史累计运营播放量", "付费用户结算播放量", "结算播放量占比", "运营播放份额", "免费用户结算播放占比", "完播量", "数据日期"]""",
"question":"近90天袁呀味播放量平均值是多少", "question":"近90天袁亚伟播放量平均值是多少",
"analysis": """让我们一步一步地思考。在问题“近90天袁呀味播放量平均值是多少“中，我们被问： "prior_schema_links":"""['152789226'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“近90天袁亚伟播放量平均值是多少“中，我们被问：
“播放量平均值是多少”，所以我们需要column=[结算播放量] “播放量平均值是多少”，所以我们需要column=[结算播放量]
”袁呀味“，所以我们需要column=[歌手名] ”袁亚伟“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['袁呀味']。""", ”近90天“，所以我们需要column=[数据日期]
"schema_links":"""["结算播放量", "歌手名", "'袁呀味'"]""", 基于table和columns，可能的cell values 是 = ['袁亚伟', 90]。""",
"sql":"""select avg(结算播放量) from 艺人库 where 歌手名 = '袁呀味'""" "schema_links":"""["结算播放量", "歌手名", "数据日期", "'袁亚伟'", 90]""",
}, "sql":"""select avg(结算播放量) from 艺人库 where 歌手名 = '袁亚伟' and datediff('day', 数据日期, '2023-08-31') <= 90 """
{ },
{ "current_date":"2023-08-31",
"table_name":"艺人库", "table_name":"艺人库",
"fields_list":"""['歌手名', '歌手等级', '歌手类型', '歌手来源', '结算播放量', '运营播放量', '历史累计结算播放量', '有播放量歌曲数', '历史累计运营播放量', '付费用户结算播放量', '结算播放量占比', '运营播放份额', '完播量']""", "fields_list":"""["播放量层级", "播放量单调性", "播放量方差", "播放量突增类型", "播放量集中度", "歌手名", "歌手等级", "歌手类型", "歌手来源", "MPPM潮流人等级", "结算播放量", "运营播放量", "历史累计结算播放量", "有播放量歌曲数", "历史累计运营播放量", "付费用户结算播放量", "结算播放量占比", "运营播放份额", "免费用户结算播放占比", "完播量", "数据日期"]""",
"question":"周浅近7天结算播放量总和是多少", "question":"周倩倩近7天结算播放量总和是多少",
"analysis": """让我们一步一步地思考。在问题“周浅近7天结算播放量总和是多少“中，我们被问： "prior_schema_links":"""['199509'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“周倩倩近7天结算播放量总和是多少“中，我们被问：
“结算播放量总和是多少”，所以我们需要column=[结算播放量] “结算播放量总和是多少”，所以我们需要column=[结算播放量]
”周浅“，所以我们需要column=[歌手名] ”周倩倩“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['周浅']。""", ”近7天“，所以我们需要column=[数据日期]
"schema_links":"""["结算播放量", "歌手名", "'周浅'"]""", 基于table和columns，可能的cell values 是 = ['周倩倩', 7]。""",
"sql":"""select sum(结算播放量) from 艺人库 where 歌手名 = '周浅'""" "schema_links":"""["结算播放量", "歌手名", "数据日期", "'周倩倩'", 7]""",
}, "sql":"""select sum(结算播放量) from 艺人库 where 歌手名 = '周倩倩' and datediff('day', 数据日期, '2023-08-31') <= 7 """
{ },
{ "current_date":"2023-09-14",
"table_name":"内容库产品", "table_name":"内容库产品",
"fields_list":"""['部门', '模块', '用户名', '访问次数', '访问人数', '访问时长']""", "fields_list":"""["部门", "模块", "用户名", "访问次数", "访问人数", "访问时长", "数据日期"]""",
"question":"内容库访问次数大于1k的部门是哪些", "question":"内容库访问次数大于1k的部门是哪些",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“内容库访问次数大于1k的部门是哪些“中，我们被问： "analysis": """让我们一步一步地思考。在问题“内容库访问次数大于1k的部门是哪些“中，我们被问：
“部门是哪些”，所以我们需要column=[部门] “部门是哪些”，所以我们需要column=[部门]
”访问次数大于1k的“，所以我们需要column=[访问次数] ”访问次数大于1k的“，所以我们需要column=[访问次数]
基于table和columns，可能的cell values 是 = [1000]。""", 基于table和columns，可能的cell values 是 = [1000]。""",
"schema_links":"""["部门", "访问次数", 1000]""", "schema_links":"""["部门", "访问次数", 1000]""",
"sql":"""select 部门 from 内容库产品 where 访问次数 > 1000""" "sql":"""select 部门 from 内容库产品 where 访问次数 > 1000 and 数据日期 = '2023-09-14' """
}, },
{ { "current_date":"2023-09-18",
"table_name":"歌曲库", "table_name":"歌曲库",
"fields_list":"""['歌曲ID', '歌曲MID', '歌曲名', '歌曲版本', '歌曲类型', '翻唱类型', '结算播放量', '运营播放量', '付费用户结算播放量', '历史累计结算播放量', '运营搜播量', '结算搜播量', '运营完播量', '运营推播量', '近7日复播率', '日均搜播量']""", "fields_list":"""["歌曲名", "MPPM歌手ID", "歌曲版本", "歌曲类型", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"陈奕迅唱的所有的播放量大于20k的雇佣者有哪些", "question":"陈亿训唱的所有的播放量大于20k的孤勇者有哪些",
"analysis": """让我们一步一步地思考。在问题“陈易迅唱的所有的播放量大于20k的雇佣者有哪些“中，我们被问： "prior_schema_links":"""['199509'->MPPM歌手ID, '1527123'->MPPM歌曲ID]""",
“雇佣者有哪些”，所以我们需要column=[歌曲名] "analysis": """让我们一步一步地思考。在问题“陈亿训唱的所有的播放量大于20k的孤勇者有哪些“中，我们被问：
“孤勇者有哪些”，所以我们需要column=[歌曲名]
”播放量大于20k的“，所以我们需要column=[结算播放量] ”播放量大于20k的“，所以我们需要column=[结算播放量]
”陈易迅唱的“，所以我们需要column=[歌手名] ”陈亿训唱的“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = [20000, '陈易迅']。""", 基于table和columns，可能的cell values 是 = [20000, '陈亿训', '孤勇者']。""",
"schema_links":"""["歌曲名", "结算播放量", "歌手名", 20000, "'陈易迅'"]""", "schema_links":"""["歌曲名", "结算播放量", "歌手名", 20000, "'陈亿训'", "'孤勇者'"]""",
"sql":"""select 歌曲名 from 歌曲库 where 结算播放量 > 20000 and 歌手名 = '陈易迅'""" "sql":"""select 歌曲名 from 歌曲库 where 结算播放量 > 20000 and 歌手名 = '陈亿训' and 歌曲名 = '孤勇者' and 数据日期 = '2023-09-18' """
} },
{ "current_date":"2023-09-18",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"周洁轮去年发布的歌曲有哪些",
"prior_schema_links":"""['23109'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“周洁轮去年发布的歌曲有哪些“中，我们被问：
“歌曲有哪些”，所以我们需要column=[歌曲名]
”去年发布的“，所以我们需要column=[发布时间]
”周洁轮“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['周洁轮', 1]。""",
"schema_links":"""["歌曲名", "发布时间", "歌手名", 1, "'周洁轮'"]""",
"sql":"""select 歌曲名 from 歌曲库 where datediff('year', 发布时间, '2023-09-18') <= 1 and 歌手名 = '周洁轮' and 数据日期 = '2023-09-18' """
},
{ "current_date":"2023-09-11",
"table_name":"艺人库",
"fields_list":"""["播放量层级", "播放量单调性", "播放量方差", "播放量突增类型", "播放量集中度", "歌手名", "歌手等级", "歌手类型", "歌手来源", "签约日期", "MPPM潮流人等级", "结算播放量", "运营播放量", "历史累计结算播放量", "有播放量歌曲数", "历史累计运营播放量", "付费用户结算播放量", "结算播放量占比", "运营播放份额", "免费用户结算播放占比", "完播量", "数据日期"]""",
"question":"我想要近半年签约的播放量前十的歌手有哪些",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“我想要近半年签约的播放量前十的歌手“中，我们被问：
“歌手有哪些”，所以我们需要column=[歌手名]
”播放量前十的“，所以我们需要column=[结算播放量]
”近半年签约的“，所以我们需要column=[签约日期]
基于table和columns，可能的cell values 是 = [0.5, 10]。""",
"schema_links":"""["歌手名", "结算播放量", "签约日期", 0.5, 10]""",
"sql":"""select 歌手名 from 艺人库 where datediff('year', 签约日期, '2023-09-11') <= 0.5 and 数据日期 = '2023-09-11' order by 结算播放量 desc limit 10"""
},
{ "current_date":"2023-08-12",
"table_name":"歌曲库",
"fields_list": """["发行日期", "歌曲语言", "歌曲来源", "歌曲流派", "歌曲名", "歌曲版本", "歌曲类型", "发行时间", "数据日期"]""",
"question":"最近一年发行的歌曲中，有哪些在近7天播放超过一千万的",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“最近一年发行的歌曲中，有哪些在近7天播放超过一千万的“中，我们被问：
“发行的歌曲中，有哪些”，所以我们需要column=[歌曲名]
”最近一年发行的“，所以我们需要column=[发行日期]
”在近7天播放超过一千万的“，所以我们需要column=[数据日期, 结算播放量]
基于table和columns，可能的cell values 是 = [1, 10000000]""",
"schema_links":"""["歌曲名", "发行日期", "数据日期", "结算播放量", 1, 10000000]""",
"sql":"""select 歌曲名 from 歌曲库 where datediff('year', 发行日期, '2023-08-12') <= 1 and datediff('day', 数据日期, '2023-08-12') <= 7 and 结算播放量 > 10000000"""
},
{ "current_date":"2023-08-12",
"table_name":"歌曲库",
"fields_list": """["发行日期", "歌曲语言", "歌曲来源", "歌曲流派", "歌曲名", "歌曲版本", "歌曲类型", "发行时间", "数据日期"]""",
"question":"今年以来发行的歌曲中，有哪些在近7天播放超过一千万的",
"prior_schema_links":"""[]""",
"analysis": """让我们一步一步地思考。在问题“今年以来发行的歌曲中，有哪些在近7天播放超过一千万的“中，我们被问：
“发行的歌曲中，有哪些”，所以我们需要column=[歌曲名]
”今年以来发行的“，所以我们需要column=[发行日期]
”在近7天播放超过一千万的“，所以我们需要column=[数据日期, 结算播放量]
基于table和columns，可能的cell values 是 = [0, 7, 10000000]""",
"schema_links":"""["歌曲名", "发行日期", "数据日期", "结算播放量", 0, 7, 10000000]""",
"sql":"""select 歌曲名 from 歌曲库 where datediff('year', 发行日期, '2023-08-12') <= 0 and datediff('day', 数据日期, '2023-08-12') <= 7 and 结算播放量 > 10000000"""
},
{ "current_date":"2023-08-12",
"table_name":"歌曲库",
"fields_list": """["发行日期", "歌曲语言", "歌曲来源", "歌曲流派", "歌曲名", "歌曲版本", "歌曲类型", "发行时间", "数据日期"]""",
"question":"2023年以来发行的歌曲中，有哪些在近7天播放超过一千万的",
"prior_schema_links":"""['514129144'->MPPM歌曲ID]""",
"analysis": """让我们一步一步地思考。在问题“2023年以来发行的歌曲中，有哪些在近7天播放超过一千万的“中，我们被问：
“发行的歌曲中，有哪些”，所以我们需要column=[歌曲名]
”2023年以来发行的“，所以我们需要column=[发行日期]
”在近7天播放超过一千万的“，所以我们需要column=[数据日期, 结算播放量]
基于table和columns，可能的cell values 是 = [2023, 7, 10000000]""",
"schema_links":"""["歌曲名", "发行日期", "数据日期", "结算播放量", 2023, 7, 10000000]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(发行日期) >= 2023 and datediff('day', 数据日期, '2023-08-12') <= 7 and 结算播放量 > 10000000"""
},
{ "current_date":"2023-08-01",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"周洁轮2023年6月之后发布的歌曲有哪些",
"prior_schema_links":"""['23109'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“周洁轮2023年6月之后发布的歌曲有哪些“中，我们被问：
“歌曲有哪些”，所以我们需要column=[歌曲名]
”2023年6月之后发布的“，所以我们需要column=[发布时间]
”周洁轮“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['周洁轮', 2023, 6]。""",
"schema_links":"""["歌曲名", "发布时间", "歌手名", "周洁轮", 2023, 6]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(发布时间) >= 2023 and MONTH(发布时间) >= 6 and 歌手名 = '周洁轮' and 数据日期 = '2023-08-01' """
},
{ "current_date":"2023-08-01",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"邓梓琦在2023年1月5日之后发布的歌曲中，有哪些播放量大于500W的？",
"prior_schema_links":"""['2312311'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“邓梓琦在2023年1月5日之后发布的歌曲中，有哪些播放量大于500W的？“中，我们被问：
“播放量大于500W的”，所以我们需要column=[结算播放量]
”邓梓琦在2023年1月5日之后发布的“，所以我们需要column=[发布时间]
”邓梓琦“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['邓梓琦', 2023, 1, 5, 5000000]。""",
"schema_links":"""["结算播放量", "发布时间", "歌手名", "邓梓琦", 2023, 1, 5, 5000000]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(发布时间) >= 2023 and MONTH(发布时间) >= 1 and DAY(发布时间) >= 5 and 歌手名 = '邓梓琦' and 结算播放量 > 5000000 and 数据日期 = '2023-08-01'"""
},
{ "current_date":"2023-09-17",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"2023年6月以后，张亮英播放量大于200万的歌曲有哪些？",
"prior_schema_links":"""['45453'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“2023年6月以后，张亮英播放量大于200万的歌曲有哪些？“中，我们被问：
“播放量大于200万的”，所以我们需要column=[结算播放量]
”2023年6月以后，张亮英“，所以我们需要column=[数据日期, 歌手名]
”歌曲有哪些“，所以我们需要column=[歌曲名]
基于table和columns，可能的cell values 是 = ['张亮英', 2023, 6, 2000000]。""",
"schema_links":"""["结算播放量", "数据日期", "歌手名", "张亮英", 2023, 6, 2000000]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(数据日期) >= 2023 and MONTH(数据日期) >= 6 and 歌手名 = '张亮英' and 结算播放量 > 2000000 """
},
{ "current_date":"2023-08-16",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"2021年6月以后发布的李雨纯的播放量大于20万的歌曲有哪些",
"prior_schema_links":"""['23109'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“2021年6月以后发布的李雨纯的播放量大于20万的歌曲有哪些“中，我们被问：
“播放量大于20万的”，所以我们需要column=[结算播放量]
”2021年6月以后发布的“，所以我们需要column=[发布时间]
”李雨纯“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['李雨纯', 2021, 6, 200000]。""",
"schema_links":"""["结算播放量", "发布时间", "歌手名", "李雨纯", 2021, 6, 200000]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(发布时间) >= 2021 and MONTH(发布时间) >= 6 and 歌手名 = '李雨纯' and 结算播放量 > 200000 and 数据日期 = '2023-08-16'"""
},
{ "current_date":"2023-08-16",
"table_name":"歌曲库",
"fields_list":"""["歌曲名", "歌曲版本", "歌手名", "歌曲类型", "发布时间", "MPPM歌曲ID", "是否严选窄口径歌曲", "是否严选宽口径歌曲", "是否潮流人歌曲", "超声波歌曲ID", "C音歌曲ID", "C音歌曲MID", "结算播放量", "运营播放量", "分享量", "收藏量", "运营搜播量", "结算搜播量", "拉新用户数", "拉活用户数", "分享率", "结算播放份额", "数据日期"]""",
"question":"刘锝桦在1992年4月2日到2020年5月2日之间发布的播放量大于20万的歌曲有哪些",
"prior_schema_links":"""['4234234'->MPPM歌手ID]""",
"analysis": """让我们一步一步地思考。在问题“刘锝桦在1992年4月2日到2020年5月2日之间发布的播放量大于20万的歌曲有哪些“中，我们被问：
“播放量大于20万的”，所以我们需要column=[结算播放量]
”1992年4月2日到2020年5月2日之间发布的“，所以我们需要column=[发布时间]
”刘锝桦“，所以我们需要column=[歌手名]
基于table和columns，可能的cell values 是 = ['刘锝桦', 1992, 4, 2, 2020, 5, 2, 200000]。""",
"schema_links":"""["结算播放量", "发布时间", "歌手名", "刘锝桦", 1992, 4, 2, 2020, 5, 2, 200000]""",
"sql":"""select 歌曲名 from 歌曲库 where YEAR(发布时间) >= 1992 and MONTH(发布时间) >= 4 and DAY(发布时间) >= 2 and YEAR(发布时间) <= 2020 and MONTH(发布时间) <= 5 and DAY(发布时间) <= 2 and 歌手名 = '刘锝桦' and 结算播放量 > 200000 and 数据日期 = '2023-08-16'"""
}
] ]

11
chat/core/src/main/python/llm/preset_retrieval/run.py
View File

@@ -8,8 +8,7 @@ from typing import Any, List, Mapping, Optional, Union
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(os.path.dirname(os.path.abspath(__file__))) sys.path.append(os.path.dirname(os.path.abspath(__file__)))
import chromadb
from chromadb.config import Settings
from chromadb.api import Collection, Documents, Embeddings from chromadb.api import Collection, Documents, Embeddings
from langchain.llms import OpenAI from langchain.llms import OpenAI
@@ -21,13 +20,9 @@ from preset_query_db import (get_ids, add2preset_query_collection,
from util.text2vec import Text2VecEmbeddingFunction from util.text2vec import Text2VecEmbeddingFunction
from run_config import CHROMA_DB_PERSIST_PATH, PRESET_QUERY_COLLECTION_NAME from run_config import CHROMA_DB_PERSIST_PATH, PRESET_QUERY_COLLECTION_NAME
from util.chromadb_instance import client
client = chromadb.Client(Settings(
chroma_db_impl="duckdb+parquet",
persist_directory=CHROMA_DB_PERSIST_PATH # Optional, defaults to .chromadb/ in the current directory
))
emb_func = Text2VecEmbeddingFunction() emb_func = Text2VecEmbeddingFunction()
collection = client.get_or_create_collection(name=PRESET_QUERY_COLLECTION_NAME, collection = client.get_or_create_collection(name=PRESET_QUERY_COLLECTION_NAME,
@@ -35,6 +30,8 @@ collection = client.get_or_create_collection(name=PRESET_QUERY_COLLECTION_NAME,
metadata={"hnsw:space": "cosine"} metadata={"hnsw:space": "cosine"}
) # Get a collection object from an existing collection, by name. If it doesn't exist, create it. ) # Get a collection object from an existing collection, by name. If it doesn't exist, create it.
print("init_preset_query_collection_size: ", preset_query_collection_size(collection))
def preset_query_retrieval_run(collection:Collection, query_texts_list:List[str], n_results:int=5): def preset_query_retrieval_run(collection:Collection, query_texts_list:List[str], n_results:int=5):
retrieval_res = query2preset_query_collection(collection=collection, retrieval_res = query2preset_query_collection(collection=collection,

1
chat/core/src/main/python/llm/run_config.py
View File

@@ -9,6 +9,7 @@ TEMPERATURE = 0.0
CHROMA_DB_PERSIST_DIR = 'chm_db' CHROMA_DB_PERSIST_DIR = 'chm_db'
PRESET_QUERY_COLLECTION_NAME = "preset_query_collection" PRESET_QUERY_COLLECTION_NAME = "preset_query_collection"
TEXT2DSL_COLLECTION_NAME = "text2dsl_collection"
CHROMA_DB_PERSIST_PATH = os.path.join(PROJECT_DIR_PATH, CHROMA_DB_PERSIST_DIR) CHROMA_DB_PERSIST_PATH = os.path.join(PROJECT_DIR_PATH, CHROMA_DB_PERSIST_DIR)

53
chat/core/src/main/python/llm/sql/constructor.py Normal file
View File

@@ -0,0 +1,53 @@
# -*- coding:utf-8 -*-
import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from langchain.prompts.few_shot import FewShotPromptTemplate
from langchain.prompts import PromptTemplate
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings, HuggingFaceEmbeddings
from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
import chromadb
from chromadb.config import Settings
from few_shot_example.sql_exampler import examplars as din_sql_examplars
from util.text2vec import Text2VecEmbeddingFunction, hg_embedding
from util.chromadb_instance import client as chromadb_client
from run_config import TEXT2DSL_COLLECTION_NAME
vectorstore = Chroma(collection_name=TEXT2DSL_COLLECTION_NAME,
embedding_function=hg_embedding,
client=chromadb_client)
example_nums = 15
schema_linking_example_selector = SemanticSimilarityExampleSelector(vectorstore=vectorstore, k=example_nums,
input_keys=["question"],
example_keys=["table_name", "fields_list", "prior_schema_links", "question", "analysis", "schema_links"])
sql_example_selector = SemanticSimilarityExampleSelector(vectorstore=vectorstore, k=example_nums,
input_keys=["question"],
example_keys=["question", "current_date", "table_name", "schema_links", "sql"])
if vectorstore._collection.count() > 0:
print("examples already in din_sql_vectorstore")
print("init din_sql_vectorstore size:", vectorstore._collection.count())
if vectorstore._collection.count() < len(din_sql_examplars):
print("din_sql_examplars size:", len(din_sql_examplars))
vectorstore._collection.delete()
print("empty din_sql_vectorstore")
for example in din_sql_examplars:
schema_linking_example_selector.add_example(example)
print("added din_sql_vectorstore size:", vectorstore._collection.count())
else:
for example in din_sql_examplars:
schema_linking_example_selector.add_example(example)
print("added din_sql_vectorstore size:", vectorstore._collection.count())

18
chat/core/src/main/python/llm/sql/output_parser.py
View File

@@ -1,15 +1,13 @@
# -*- coding:utf-8 -*- # -*- coding:utf-8 -*-
import re import re
def schema_link_parse(schema_link_output): def schema_link_parse(schema_link_output):
try: try:
schema_link_output = schema_link_output.strip() schema_link_output = schema_link_output.strip()
pattern = r'Schema_links:(.*)' pattern = r'Schema_links:(.*)'
schema_link_output = re.findall(pattern, schema_link_output, re.DOTALL)[ schema_link_output = re.findall(pattern, schema_link_output, re.DOTALL)[0].strip()
0].strip() except Exception as e:
except Exception as e: print(e)
print(e) schema_link_output = None
schema_link_output = None
return schema_link_output return schema_link_output

111
chat/core/src/main/python/llm/sql/prompt_maker.py
View File

@@ -1,8 +1,5 @@
# -*- coding:utf-8 -*- # -*- coding:utf-8 -*-
from typing import Any, List, Mapping, Optional, Union from typing import Any, List, Mapping, Optional, Union
import requests
import logging
import json
import os import os
import sys import sys
@@ -11,78 +8,68 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from langchain.prompts import PromptTemplate from langchain.prompts import PromptTemplate
from langchain.prompts.few_shot import FewShotPromptTemplate from langchain.prompts.few_shot import FewShotPromptTemplate
from langchain.llms import OpenAI from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from few_shot_example.sql_exampler import examplars
from output_parser import schema_link_parse
def schema_linking_prompt_maker(user_query: str, model_name: str,
fields_list: List[str],
few_shots_example: str):
instruction = "# 根据数据库的表结构,找出为每个问题生成SQL查询语句的schema_links\n"
schema_linking_prompt = "Table {table_name}, columns = {fields_list}\n问题:{user_query}\n分析: 让我们一步一步地思考。".format(
table_name=model_name,
fields_list=fields_list,
user_query=user_query)
return instruction + few_shots_example + schema_linking_prompt
def schema_linking_exampler(user_query: str, def schema_linking_exampler(user_query: str,
model_name: str, domain_name: str,
fields_list: List[str] fields_list: List[str],
) -> str: prior_schema_links: Mapping[str,str],
example_prompt_template = PromptTemplate( example_selector: SemanticSimilarityExampleSelector,
input_variables=["table_name", "fields_list", "question", "analysis", ) -> str:
"schema_links"],
template="Table {table_name}, columns = {fields_list}\n问题:{question}\n分析:{analysis} 所以Schema_links是:\nSchema_links:{schema_links}")
instruction = "# 根据数据库的表结构,找出为每个问题生成SQL查询语句的schema_links" prior_schema_links_str = '['+ ','.join(["""'{}'->{}""".format(k,v) for k,v in prior_schema_links.items()]) + ']'
schema_linking_prompt = "Table {table_name}, columns = {fields_list}\n问题:{question}\n分析: 让我们一步一步地思考。" example_prompt_template = PromptTemplate(input_variables=["table_name", "fields_list", "prior_schema_links", "question", "analysis", "schema_links"],
template="Table {table_name}, columns = {fields_list}, prior_schema_links = {prior_schema_links}\n问题:{question}\n分析:{analysis} 所以Schema_links是:\nSchema_links:{schema_links}")
schema_linking_example_prompt_template = FewShotPromptTemplate( instruction = "# 根据数据库的表结构,参考先验信息,找出为每个问题生成SQL查询语句的schema_links"
examples=examplars,
example_prompt=example_prompt_template,
example_separator="\n\n",
prefix=instruction,
input_variables=["table_name", "fields_list", "question"],
suffix=schema_linking_prompt
)
schema_linking_example_prompt = schema_linking_example_prompt_template.format( schema_linking_prompt = "Table {table_name}, columns = {fields_list}, prior_schema_links = {prior_schema_links}\n问题:{question}\n分析: 让我们一步一步地思考。"
table_name=model_name,
fields_list=fields_list,
question=user_query)
return schema_linking_example_prompt schema_linking_example_prompt_template = FewShotPromptTemplate(
example_selector=example_selector,
example_prompt=example_prompt_template,
example_separator="\n\n",
prefix=instruction,
input_variables=["table_name", "fields_list", "prior_schema_links", "question"],
suffix=schema_linking_prompt
)
schema_linking_example_prompt = schema_linking_example_prompt_template.format(table_name=domain_name,
fields_list=fields_list,
prior_schema_links=prior_schema_links_str,
question=user_query)
return schema_linking_example_prompt
def sql_exampler(user_query: str, def sql_exampler(user_query: str,
model_name: str, domain_name: str,
schema_link_str: str schema_link_str: str,
) -> str: data_date: str,
instruction = "# 根据schema_links为每个问题生成SQL查询语句" example_selector: SemanticSimilarityExampleSelector,
) -> str:
instruction = "# 根据schema_links为每个问题生成SQL查询语句"
sql_example_prompt_template = PromptTemplate( sql_example_prompt_template = PromptTemplate(input_variables=["question", "current_date", "table_name", "schema_links", "sql"],
input_variables=["question", "table_name", "schema_links", "sql"], template="问题:{question}\nCurrent_date:{current_date}\nTable {table_name}\nSchema_links:{schema_links}\nSQL:{sql}")
template="问题:{question}\nTable {table_name}\nSchema_links:{schema_links}\nSQL:{sql}")
sql_prompt = "问题:{question}\nTable {table_name}\nSchema_links:{schema_links}\nSQL:" sql_prompt = "问题:{question}\nCurrent_date:{current_date}\nTable {table_name}\nSchema_links:{schema_links}\nSQL:"
sql_example_prompt_template = FewShotPromptTemplate( sql_example_prompt_template = FewShotPromptTemplate(
examples=examplars, example_selector=example_selector,
example_prompt=sql_example_prompt_template, example_prompt=sql_example_prompt_template,
example_separator="\n\n", example_separator="\n\n",
prefix=instruction, prefix=instruction,
input_variables=["question", "table_name", "schema_links"], input_variables=["question", "current_date", "table_name", "schema_links"],
suffix=sql_prompt suffix=sql_prompt
) )
sql_example_prompt = sql_example_prompt_template.format(question=user_query, sql_example_prompt = sql_example_prompt_template.format(question=user_query,
table_name=model_name, current_date=data_date,
schema_links=schema_link_str) table_name=domain_name,
schema_links=schema_link_str)
return sql_example_prompt return sql_example_prompt

65
chat/core/src/main/python/llm/sql/run.py
View File

@@ -1,6 +1,4 @@
# -*- coding:utf-8 -*- from typing import List, Union, Mapping
from typing import List, Union
import logging import logging
import json import json
import os import os
@@ -9,33 +7,54 @@ import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(os.path.dirname(os.path.abspath(__file__))) sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from sql.prompt_maker import schema_linking_exampler, schema_link_parse, \ from sql.prompt_maker import schema_linking_exampler, sql_exampler
sql_exampler from sql.constructor import schema_linking_example_selector, sql_example_selector
from sql.output_parser import schema_link_parse
from util.llm_instance import llm from util.llm_instance import llm
def query2sql(query_text: str, schema: dict):
print("schema: ", schema)
model_name = schema['modelName'] def query2sql(query_text: str,
fields_list = schema['fieldNameList'] schema : Union[dict, None] = None,
current_date: str = None,
linking: Union[List[Mapping[str, str]], None] = None
):
print("query_text: ", query_text)
print("schema: ", schema)
print("current_date: ", current_date)
print("prior_schema_links: ", linking)
schema_linking_prompt = schema_linking_exampler(query_text, model_name, if linking is not None:
fields_list) prior_schema_links = {item['fieldValue']:item['fieldName'] for item in linking}
schema_link_output = llm(schema_linking_prompt) else:
schema_link_str = schema_link_parse(schema_link_output) prior_schema_links = {}
sql_prompt = sql_exampler(query_text, model_name, schema_link_str) model_name = schema['modelName']
sql_output = llm(sql_prompt) fields_list = schema['fieldNameList']
resp = dict() schema_linking_prompt = schema_linking_exampler(query_text, model_name, fields_list, prior_schema_links, schema_linking_example_selector)
resp['query'] = query_text print("schema_linking_prompt->", schema_linking_prompt)
resp['model'] = model_name schema_link_output = llm(schema_linking_prompt)
resp['fields'] = fields_list schema_link_str = schema_link_parse(schema_link_output)
sql_prompt = sql_exampler(query_text, model_name, schema_link_str, current_date, sql_example_selector)
print("sql_prompt->", sql_prompt)
sql_output = llm(sql_prompt)
resp['schemaLinkingOutput'] = schema_link_output resp = dict()
resp['schemaLinkStr'] = schema_link_str resp['query'] = query_text
resp['model'] = model_name
resp['fields'] = fields_list
resp['priorSchemaLinking'] = linking
resp['dataDate'] = current_date
resp['sqlOutput'] = sql_output resp['schemaLinkingOutput'] = schema_link_output
resp['schemaLinkStr'] = schema_link_str
resp['sqlOutput'] = sql_output
print("resp: ", resp)
return resp
return resp

10
chat/core/src/main/python/llm/util/chromadb_instance.py Normal file
View File

@@ -0,0 +1,10 @@
# -*- coding:utf-8 -*-
import chromadb
from chromadb.config import Settings
from run_config import CHROMA_DB_PERSIST_PATH
client = chromadb.Client(Settings(
chroma_db_impl="duckdb+parquet",
persist_directory=CHROMA_DB_PERSIST_PATH # Optional, defaults to .chromadb/ in the current directory
))

4
launchers/standalone/src/main/java/com/tencent/supersonic/ConfigureDemo.java
View File

@@ -220,6 +220,7 @@ public class ConfigureDemo implements ApplicationListener<ApplicationReadyEvent>
AgentConfig agentConfig = new AgentConfig(); AgentConfig agentConfig = new AgentConfig();
RuleQueryTool ruleQueryTool = new RuleQueryTool(); RuleQueryTool ruleQueryTool = new RuleQueryTool();
ruleQueryTool.setType(AgentToolType.RULE); ruleQueryTool.setType(AgentToolType.RULE);
ruleQueryTool.setId("0");
ruleQueryTool.setModelIds(Lists.newArrayList(-1L)); ruleQueryTool.setModelIds(Lists.newArrayList(-1L));
ruleQueryTool.setQueryModes(Lists.newArrayList( ruleQueryTool.setQueryModes(Lists.newArrayList(
"METRIC_ENTITY", "METRIC_FILTER", "METRIC_GROUPBY", "METRIC_ENTITY", "METRIC_FILTER", "METRIC_GROUPBY",
@@ -228,6 +229,7 @@ public class ConfigureDemo implements ApplicationListener<ApplicationReadyEvent>
agentConfig.getTools().add(ruleQueryTool); agentConfig.getTools().add(ruleQueryTool);
DslTool dslTool = new DslTool(); DslTool dslTool = new DslTool();
dslTool.setId("1");
dslTool.setType(AgentToolType.DSL); dslTool.setType(AgentToolType.DSL);
dslTool.setModelIds(Lists.newArrayList(-1L)); dslTool.setModelIds(Lists.newArrayList(-1L));
agentConfig.getTools().add(dslTool); agentConfig.getTools().add(dslTool);
@@ -246,6 +248,7 @@ public class ConfigureDemo implements ApplicationListener<ApplicationReadyEvent>
agent.setExamples(Lists.newArrayList("国风风格艺人", "港台地区的艺人", "风格为流行的艺人")); agent.setExamples(Lists.newArrayList("国风风格艺人", "港台地区的艺人", "风格为流行的艺人"));
AgentConfig agentConfig = new AgentConfig(); AgentConfig agentConfig = new AgentConfig();
RuleQueryTool ruleQueryTool = new RuleQueryTool(); RuleQueryTool ruleQueryTool = new RuleQueryTool();
ruleQueryTool.setId("0");
ruleQueryTool.setType(AgentToolType.RULE); ruleQueryTool.setType(AgentToolType.RULE);
ruleQueryTool.setModelIds(Lists.newArrayList(-1L)); ruleQueryTool.setModelIds(Lists.newArrayList(-1L));
ruleQueryTool.setQueryModes(Lists.newArrayList( ruleQueryTool.setQueryModes(Lists.newArrayList(
@@ -253,6 +256,7 @@ public class ConfigureDemo implements ApplicationListener<ApplicationReadyEvent>
agentConfig.getTools().add(ruleQueryTool); agentConfig.getTools().add(ruleQueryTool);
DslTool dslTool = new DslTool(); DslTool dslTool = new DslTool();
dslTool.setId("1");
dslTool.setType(AgentToolType.DSL); dslTool.setType(AgentToolType.DSL);
dslTool.setModelIds(Lists.newArrayList(-1L)); dslTool.setModelIds(Lists.newArrayList(-1L));
agentConfig.getTools().add(dslTool); agentConfig.getTools().add(dslTool);