package com.smtaiserver.smtaiserver.javaai.qwen.agent;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
|
import org.dom4j.Document;
|
import org.dom4j.Element;
|
import org.dom4j.Node;
|
import org.dom4j.tree.DefaultCDATA;
|
import org.dom4j.tree.DefaultText;
|
|
import com.smtaiserver.smtaiserver.core.SMTAIServerRequest;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecord;
|
import com.smtaiserver.smtaiserver.database.SMTDatabase.DBRecords;
|
import com.smtaiserver.smtaiserver.javaai.SMTJavaAIError;
|
import com.smtaiserver.smtaiserver.javaai.ast.ASTDBMap;
|
import com.smtaiserver.smtaiserver.javaai.llm.core.SMTLLMConnect;
|
import com.smtservlet.util.Json;
|
import com.smtservlet.util.SMTJsonWriter;
|
import com.smtservlet.util.SMTStatic;
|
|
public class SMTQwenAgentSummaryAMIS extends SMTQwenAgent
|
{
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLExecArg
|
{
|
public Json _toolArguments = null;
|
public StringBuilder _sbSQLText = null;
|
public Map<String, String> _mapAmisData = new HashMap<>();
|
public List<Object> _sqlParams = new ArrayList<>();
|
public Map<String, DBRecords> _mapId2Recs = new HashMap<>();
|
public SMTAIServerRequest _tranReq;
|
public Map<String, Object> _mapAmisPath2Replace = new LinkedHashMap<>();
|
public ASTDBMap _dbMap = new ASTDBMap();
|
public SMTDatabase _curDB = null;
|
public DBRecords _curRecs = null;
|
|
|
public SQLXMLExecArg(Json toolArguments, SMTJsonWriter jsonWr, SMTAIServerRequest tranReq)
|
{
|
_toolArguments = toolArguments;
|
_tranReq = tranReq;
|
}
|
|
public void close()
|
{
|
_dbMap.close();
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static abstract class SQLXMLNode
|
{
|
public abstract SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception;
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
private static class SQLXMLNodeAMIS_DATA extends SQLXMLNode
|
{
|
private String _keyField;
|
private String _valueField;
|
private String _databaseId;
|
private List<Object> _listChildren = new ArrayList<>();
|
|
public SQLXMLNodeAMIS_DATA(Element xmlRoot) throws Exception
|
{
|
_databaseId = SMTStatic.getXmlAttr(xmlRoot, "database", "");
|
_keyField = SMTStatic.getXmlAttr(xmlRoot, "key_field");
|
_valueField = SMTStatic.getXmlAttr(xmlRoot, "value_field");
|
|
for (Iterator<Node> iterInner = xmlRoot.nodeIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE || nodeInner instanceof DefaultCDATA)
|
{
|
String text;
|
|
if(nodeInner instanceof DefaultCDATA)
|
text = ((DefaultCDATA)nodeInner).getText();
|
else
|
text = ((DefaultText)nodeInner).getText();
|
int lastPos = _listChildren.size() - 1;
|
if(lastPos >= 0 && _listChildren.get(lastPos) instanceof String)
|
{
|
_listChildren.set(lastPos, (String)_listChildren.get(lastPos) + text);
|
}
|
else
|
{
|
_listChildren.add(text);
|
}
|
}
|
else
|
{
|
_listChildren.add(createSQLXMLNode((Element)nodeInner));
|
}
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
StringBuilder orgSQLText = execArg._sbSQLText;
|
List<Object> orgSqlParams = execArg._sqlParams;
|
SMTDatabase orgDB = execArg._curDB;
|
try
|
{
|
// 生成查询SQL
|
execArg._sbSQLText = new StringBuilder();
|
execArg._sqlParams = new ArrayList<>();
|
execArg._curDB = execArg._dbMap.getDatabase(_databaseId);
|
|
for(Object oxmlNode : _listChildren)
|
{
|
if(oxmlNode instanceof String)
|
{
|
execArg._sbSQLText.append(oxmlNode);
|
}
|
else if(oxmlNode instanceof SQLXMLNode)
|
{
|
((SQLXMLNode)oxmlNode).execute(execArg);
|
}
|
}
|
|
// 执行查询SQL
|
DBRecords recs = execArg._curRecs;
|
if(recs == null)
|
recs = execArg._curDB.querySQL(execArg._sbSQLText.toString(), execArg._sqlParams.toArray(new Object[execArg._sqlParams.size()]));
|
|
// 设置值
|
for(DBRecord rec : recs.getRecords())
|
{
|
execArg._mapAmisData.put(rec.getString(_keyField), rec.getString(_valueField));
|
}
|
}
|
finally
|
{
|
execArg._curDB = orgDB;
|
execArg._sbSQLText = orgSQLText;
|
execArg._sqlParams = orgSqlParams;
|
}
|
return null;
|
}
|
}
|
|
private static class SQLXMLNodeAMIS_FOREACH_TABLE extends SQLXMLNode
|
{
|
private String _noRecErrFmt = null;
|
private String _databaseId = "";
|
private String _loopDatabaseId = "";
|
private List<Object> _listChildren = new ArrayList<>();
|
private List<Object> _listSQL = new ArrayList<>();
|
|
public SQLXMLNodeAMIS_FOREACH_TABLE(Element xmlRoot) throws Exception
|
{
|
Element nodeChild = (Element)xmlRoot.selectSingleNode("LOOP");
|
_loopDatabaseId = SMTStatic.getXmlAttr(nodeChild, "database", "");
|
|
for (Iterator<Node> iterInner = nodeChild.nodeIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE || nodeInner instanceof DefaultCDATA)
|
{
|
String text;
|
|
if(nodeInner instanceof DefaultCDATA)
|
text = ((DefaultCDATA)nodeInner).getText();
|
else
|
text = ((DefaultText)nodeInner).getText();
|
int lastPos = _listChildren.size() - 1;
|
if(lastPos >= 0 && _listChildren.get(lastPos) instanceof String)
|
{
|
_listChildren.set(lastPos, (String)_listChildren.get(lastPos) + text);
|
}
|
else
|
{
|
_listChildren.add(text);
|
}
|
}
|
else
|
{
|
_listChildren.add(createSQLXMLNode((Element)nodeInner));
|
}
|
}
|
|
Element nodeSQL = (Element)xmlRoot.selectSingleNode("QUERY");
|
_noRecErrFmt = SMTStatic.getXmlAttr(nodeSQL, "no_rec_error", null);
|
|
for (Iterator<Node> iterInner = nodeSQL.nodeIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE || nodeInner instanceof DefaultCDATA)
|
{
|
String text;
|
|
if(nodeInner instanceof DefaultCDATA)
|
text = ((DefaultCDATA)nodeInner).getText();
|
else
|
text = ((DefaultText)nodeInner).getText();
|
int lastPos = _listSQL.size() - 1;
|
if(lastPos >= 0 && _listSQL.get(lastPos) instanceof String)
|
{
|
_listSQL.set(lastPos, (String)_listSQL.get(lastPos) + text);
|
}
|
else
|
{
|
_listSQL.add(text);
|
}
|
}
|
else
|
{
|
_listSQL.add(createSQLXMLNode((Element)nodeInner));
|
}
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
StringBuilder orgSQLText = execArg._sbSQLText;
|
List<Object> orgSqlParams = execArg._sqlParams;
|
SMTDatabase orgDB = execArg._curDB;
|
try
|
{
|
// 生成查询SQL
|
execArg._sbSQLText = new StringBuilder();
|
execArg._sqlParams = new ArrayList<>();
|
execArg._curDB = execArg._dbMap.getDatabase(_databaseId);
|
|
for(Object oxmlNode : _listSQL)
|
{
|
if(oxmlNode instanceof String)
|
{
|
execArg._sbSQLText.append(oxmlNode);
|
}
|
else if(oxmlNode instanceof SQLXMLNode)
|
{
|
((SQLXMLNode)oxmlNode).execute(execArg);
|
}
|
}
|
|
// 执行查询SQL
|
DBRecords recs = execArg._curRecs;
|
if(recs == null)
|
recs = execArg._curDB.querySQL(execArg._sbSQLText.toString(), execArg._sqlParams.toArray(new Object[execArg._sqlParams.size()]));
|
|
// 如果查不到数据，且设置了错误信息，则返回错误信息
|
if(recs.getRowCount() == 0 && !SMTStatic.isNullOrEmpty(_noRecErrFmt))
|
{
|
String errMsg = SMTStatic.stringFormat(_noRecErrFmt, new SMTStatic.StringNamedNotify() {
|
|
@Override
|
public Object getNamedValue(String name, Object[] args) throws Exception {
|
|
String value = execArg._toolArguments.safeGetStr(name, "");
|
|
return value;
|
}
|
|
});
|
|
return new SMTJavaAIError(errMsg);
|
}
|
|
// 遍历查询SQL，并执行子查询
|
for(DBRecord rec : recs.getRecords())
|
{
|
// 设置当前参数
|
for(Entry<String, Integer> entry : rec.getFieldMap().entrySet())
|
{
|
execArg._toolArguments.set(entry.getKey().toLowerCase(), rec.getString(entry.getValue()));
|
}
|
|
// 解析子SQL
|
StringBuilder orgSQLText1 = execArg._sbSQLText;
|
List<Object> orgSqlParams1 = execArg._sqlParams;
|
SMTDatabase orgDB1 = execArg._curDB;
|
|
try
|
{
|
execArg._curDB = execArg._dbMap.getDatabase(_loopDatabaseId);
|
execArg._sbSQLText = new StringBuilder();
|
execArg._sqlParams = new ArrayList<>();
|
|
for(Object oxmlNode : _listChildren)
|
{
|
if(oxmlNode instanceof String)
|
{
|
execArg._sbSQLText.append(oxmlNode);
|
}
|
else if(oxmlNode instanceof SQLXMLNode)
|
{
|
((SQLXMLNode)oxmlNode).execute(execArg);
|
}
|
}
|
|
// 执行查询SQL
|
// 如果当前不存在记录集，则将此查询作为新记录集
|
if(execArg._curRecs == null)
|
{
|
execArg._curRecs = execArg._curDB.querySQL(execArg._sbSQLText.toString(), execArg._sqlParams.toArray(new Object[execArg._sqlParams.size()]));
|
}
|
// 如果当前存在记录集，则确保两组记录集字段个数相同，并合并
|
else
|
{
|
DBRecords recsNew = execArg._curDB.querySQL(execArg._sbSQLText.toString(), execArg._sqlParams.toArray(new Object[execArg._sqlParams.size()]));
|
if(execArg._curRecs.getColCount() != recsNew.getColCount())
|
throw new Exception("megre record field count is different");
|
|
// 合并记录集
|
for(DBRecord recNew : recsNew.getRecords())
|
{
|
execArg._curRecs.addRecord(recNew.getValues());
|
}
|
|
}
|
}
|
finally
|
{
|
execArg._curDB = orgDB1;
|
execArg._sbSQLText = orgSQLText1;
|
execArg._sqlParams = orgSqlParams1;
|
}
|
|
}
|
}
|
finally
|
{
|
execArg._curDB = orgDB;
|
execArg._sbSQLText = orgSQLText;
|
execArg._sqlParams = orgSqlParams;
|
}
|
|
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeAMIS_JSON extends SQLXMLNode
|
{
|
private List<Object> _listChildren = new ArrayList<>();
|
|
public SQLXMLNodeAMIS_JSON(Element xmlRoot) throws Exception
|
{
|
for (Iterator<Node> iterInner = xmlRoot.nodeIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE || nodeInner instanceof DefaultCDATA)
|
{
|
String text;
|
|
if(nodeInner instanceof DefaultCDATA)
|
text = ((DefaultCDATA)nodeInner).getText();
|
else
|
text = ((DefaultText)nodeInner).getText();
|
int lastPos = _listChildren.size() - 1;
|
if(lastPos >= 0 && _listChildren.get(lastPos) instanceof String)
|
{
|
_listChildren.set(lastPos, (String)_listChildren.get(lastPos) + text);
|
}
|
else
|
{
|
_listChildren.add(text);
|
}
|
}
|
else
|
{
|
_listChildren.add(createSQLXMLNode((Element)nodeInner));
|
}
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
SMTJavaAIError error;
|
execArg._sbSQLText = new StringBuilder();
|
execArg._sqlParams = new ArrayList<>();
|
|
for(Object oxmlNode : _listChildren)
|
{
|
if(oxmlNode instanceof String)
|
{
|
execArg._sbSQLText.append(oxmlNode);
|
}
|
else if(oxmlNode instanceof SQLXMLNode)
|
{
|
if((error = ((SQLXMLNode)oxmlNode).execute(execArg)) != null)
|
return error;
|
}
|
}
|
|
if(execArg._mapAmisPath2Replace.size() > 0)
|
{
|
Json jsonAMISRoot = Json.read(execArg._sbSQLText.toString());
|
for(Entry<String, Object> entry : execArg._mapAmisPath2Replace.entrySet())
|
{
|
Json jsonAMIS = jsonAMISRoot;
|
String[] pathList = entry.getKey().split("/");
|
for(int i = 0; i < (pathList.length - 1); i ++)
|
{
|
String path = pathList[i];
|
|
if(jsonAMIS.isObject())
|
{
|
jsonAMIS = jsonAMIS.getJson(path);
|
}
|
else if(jsonAMIS.isArray())
|
{
|
jsonAMIS = jsonAMIS.at(SMTStatic.toInt(path));
|
}
|
else
|
{
|
throw new Exception("json path error");
|
}
|
}
|
|
String lastPath = pathList[pathList.length - 1];
|
|
if(jsonAMIS.isObject())
|
{
|
jsonAMIS.set(lastPath, entry.getValue());
|
}
|
else
|
{
|
throw new Exception("json path error");
|
}
|
}
|
execArg._sbSQLText.setLength(0);
|
execArg._sbSQLText.append(jsonAMISRoot.toString());
|
}
|
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeRECORDS extends SQLXMLNode
|
{
|
private List<SQLXMLNodeSQL> _listChildren = new ArrayList<>();
|
|
public SQLXMLNodeRECORDS(Element xmlRoot) throws Exception
|
{
|
for(Node nodeSQL : xmlRoot.selectNodes("SQL"))
|
{
|
SQLXMLNodeSQL sqlxmlSQL = new SQLXMLNodeSQL((Element)nodeSQL);
|
_listChildren.add(sqlxmlSQL);
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
SMTJavaAIError error;
|
for(SQLXMLNodeSQL sqlxmlSQL : _listChildren)
|
{
|
if((error = sqlxmlSQL.execute(execArg)) != null)
|
return error;
|
}
|
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeAMIS_ASYNCS extends SQLXMLNode
|
{
|
private List<SQLXMLNodeAMIS_ASYNC_RS> _listChildren = new ArrayList<>();
|
|
public SQLXMLNodeAMIS_ASYNCS(Element xmlRoot) throws Exception
|
{
|
for(Node nodeSQL : xmlRoot.selectNodes("AMIS_ASYNC"))
|
{
|
SQLXMLNodeAMIS_ASYNC_RS sqlxmlSQL = new SQLXMLNodeAMIS_ASYNC_RS((Element)nodeSQL);
|
_listChildren.add(sqlxmlSQL);
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
SMTJavaAIError error;
|
for(SQLXMLNodeAMIS_ASYNC_RS sqlxmlRS : _listChildren)
|
{
|
if((error = sqlxmlRS.execute(execArg)) != null)
|
return error;
|
}
|
|
return null;
|
}
|
}
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeSQL extends SQLXMLNode
|
{
|
private String _id;
|
private String _databaseId;
|
private List<Object> _listChildren = new ArrayList<>();
|
|
public SQLXMLNodeSQL(Element xmlRoot) throws Exception
|
{
|
_id = SMTStatic.getXmlAttr(xmlRoot, "id", null);
|
_databaseId = SMTStatic.getXmlAttr(xmlRoot, "database");
|
|
for (Iterator<Node> iterInner = xmlRoot.nodeIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE)
|
{
|
String text = ((DefaultText)nodeInner).getText();
|
int lastPos = _listChildren.size() - 1;
|
if(lastPos >= 0 && _listChildren.get(lastPos) instanceof String)
|
{
|
_listChildren.set(lastPos, (String)_listChildren.get(lastPos) + text);
|
}
|
else
|
{
|
_listChildren.add(text);
|
}
|
}
|
else if(nodeInner instanceof DefaultCDATA)
|
{
|
String text = ((DefaultCDATA)nodeInner).getText();
|
int lastPos = _listChildren.size() - 1;
|
if(lastPos >= 0 && _listChildren.get(lastPos) instanceof String)
|
{
|
_listChildren.set(lastPos, (String)_listChildren.get(lastPos) + text);
|
}
|
else
|
{
|
_listChildren.add(text);
|
}
|
}
|
else
|
{
|
_listChildren.add(createSQLXMLNode((Element)nodeInner));
|
}
|
}
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
if(SMTStatic.isNullOrEmpty(_id))
|
return null;
|
|
SMTDatabase orgDB = execArg._curDB;
|
DBRecords orgRecs = execArg._curRecs;
|
try
|
{
|
execArg._tranReq.setAsynProcessText("正在查询" + _id);
|
|
execArg._sbSQLText = new StringBuilder();
|
execArg._sqlParams = new ArrayList<>();
|
execArg._curDB = execArg._dbMap.getDatabase(_databaseId);
|
execArg._curRecs = null;
|
|
|
for(Object oxmlNode : _listChildren)
|
{
|
if(oxmlNode instanceof String)
|
{
|
execArg._sbSQLText.append(oxmlNode);
|
}
|
else if(oxmlNode instanceof SQLXMLNode)
|
{
|
SMTJavaAIError error = ((SQLXMLNode)oxmlNode).execute(execArg);
|
if(error != null)
|
return error;
|
}
|
}
|
|
DBRecords recs = execArg._curRecs;
|
if(recs == null)
|
recs = execArg._curDB.querySQL(execArg._sbSQLText.toString(), execArg._sqlParams.toArray(new Object[execArg._sqlParams.size()]));
|
execArg._mapId2Recs.put(_id, recs);
|
}
|
finally
|
{
|
execArg._curDB = orgDB;
|
execArg._curRecs = orgRecs;
|
|
}
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeAMIS_ASYNC_RS extends SQLXMLNode
|
{
|
private String _recId;
|
private String _asyncId;
|
private String _amisPath;
|
|
public SQLXMLNodeAMIS_ASYNC_RS(Element xmlRoot) throws Exception
|
{
|
_recId = SMTStatic.getXmlAttr(xmlRoot, "rec_id");
|
_asyncId = SMTStatic.getXmlAttr(xmlRoot, "async_id");
|
_amisPath = SMTStatic.getXmlAttr(xmlRoot, "amis_path");
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
execArg._mapAmisPath2Replace.put(_amisPath, "/chat/chat_async_query?rec_id=" + _asyncId + "&history_id=" + (execArg._tranReq.isAgentCheckMode() ? "__AGENT_CHECK_MODE__" : execArg._tranReq.getChatHistoryId()));
|
|
SMTJsonWriter jsonWrAsync = execArg._tranReq.prepareAsyncQueryJson();
|
|
DBRecords recs = execArg._mapId2Recs.get(_recId);
|
if(recs == null)
|
return new SMTJavaAIError("未配置id为[" + _recId + "]的SQL查询");
|
|
jsonWrAsync.beginMap(_asyncId);
|
{
|
// 加入列状态
|
jsonWrAsync.beginArray("columns");
|
for(String colName : recs.getFieldMap().keySet())
|
{
|
jsonWrAsync.addKeyValue(null, colName);
|
}
|
jsonWrAsync.endArray();
|
|
// 加入值
|
int colCount = recs.getColCount();
|
jsonWrAsync.beginArray("values");
|
for(DBRecord rec : recs.getRecords())
|
{
|
jsonWrAsync.beginArray(null);
|
for(int i = 0; i < colCount; i ++)
|
{
|
jsonWrAsync.addKeyValue(null, rec.getValue(i));
|
}
|
jsonWrAsync.endArray();
|
}
|
jsonWrAsync.endArray();
|
}
|
jsonWrAsync.endMap();
|
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodePARAM extends SQLXMLNode
|
{
|
private String _key;
|
|
public SQLXMLNodePARAM(Element xmlRoot) throws Exception
|
{
|
_key = SMTStatic.getXmlAttr(xmlRoot, "key");
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
execArg._sbSQLText.append("?");
|
execArg._sqlParams.add(execArg._toolArguments.getJson(_key).asString());
|
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
private static class SQLXMLNodeJSON_URL extends SQLXMLNode
|
{
|
private String _recId;
|
|
public SQLXMLNodeJSON_URL(Element xmlRoot) throws Exception
|
{
|
_recId = SMTStatic.getXmlAttr(xmlRoot, "rec_id");
|
}
|
|
@Override
|
public SMTJavaAIError execute(SQLXMLExecArg execArg) throws Exception
|
{
|
execArg._sbSQLText.append("/chat/chat_async_query?rec_id=" + _recId + "&history_id=" + execArg._tranReq.getChatHistoryId());
|
|
return null;
|
}
|
}
|
|
|
private List<SQLXMLNode> _listSQLXMLNode = new ArrayList<>();
|
private SQLXMLNodeAMIS_JSON _sqlxmlAmisJson = null;
|
|
private static SQLXMLNode createSQLXMLNode(Element xmlRoot) throws Exception
|
{
|
String name = xmlRoot.getName().toUpperCase();
|
if("SQL".equals(name))
|
return new SQLXMLNodeSQL(xmlRoot);
|
else if("PARAM".equals(name))
|
return new SQLXMLNodePARAM(xmlRoot);
|
else if("AMIS_JSON".equals(name))
|
return new SQLXMLNodeAMIS_JSON(xmlRoot);
|
else if("AMIS_DATA".equals(name))
|
return new SQLXMLNodeAMIS_DATA(xmlRoot);
|
else if("JSON_URL".equals(name))
|
return new SQLXMLNodeJSON_URL(xmlRoot);
|
else if("AMIS_ASYNC".equals(name) || "AMIS_ASYNC_RS".equals(name))
|
return new SQLXMLNodeAMIS_ASYNC_RS(xmlRoot);
|
else if("RECORDS".equals(name))
|
return new SQLXMLNodeRECORDS(xmlRoot);
|
else if("AMIS_ASYNCS".equals(name))
|
return new SQLXMLNodeAMIS_ASYNCS(xmlRoot);
|
else if("FOREACH_TABLE".equals(name))
|
return new SQLXMLNodeAMIS_FOREACH_TABLE(xmlRoot);
|
else
|
throw new Exception("unknow SQLXML : " + name);
|
|
}
|
|
@Override
|
public void initInstance(DBRecord rec) throws Exception
|
{
|
super.initInstance(rec);
|
Document doc = SMTStatic.convStrToXmlDoc("<ROOT>" + rec.getString("clz_arguments") + "</ROOT>");
|
|
// 读取根节点
|
Element rootElement=doc.getRootElement();
|
|
// 读取所有子节点
|
for (Iterator<Element> iterInner = rootElement.elementIterator(); iterInner.hasNext();)
|
{
|
Node nodeInner = iterInner.next();
|
if(nodeInner.getNodeType() == Node.TEXT_NODE)
|
{
|
}
|
else
|
{
|
String tagName = ((Element)nodeInner).getName();
|
if("AMIS_JSON".equals(tagName))
|
_sqlxmlAmisJson = new SQLXMLNodeAMIS_JSON((Element)nodeInner);
|
else
|
_listSQLXMLNode.add(createSQLXMLNode((Element)nodeInner));
|
}
|
|
}
|
|
}
|
|
@Override
|
public SMTJavaAIError callAgents(String jsonPath, Json jsonArgs, SMTLLMConnect llm, String question, SMTAIServerRequest tranReq) throws Exception
|
{
|
SMTJsonWriter jsonWrResult = tranReq.getResultJsonWr();
|
|
// 生成json
|
SQLXMLExecArg execArg = new SQLXMLExecArg(jsonArgs, jsonWrResult, tranReq);
|
|
try
|
{
|
for(SQLXMLNode xmlNode : _listSQLXMLNode)
|
{
|
SMTJavaAIError error = xmlNode.execute(execArg);
|
if(error != null)
|
return error;
|
}
|
|
_sqlxmlAmisJson.execute(execArg);
|
|
// 输出json
|
jsonWrResult.addKeyValue("answer_type", "summary");
|
jsonWrResult.beginArray("summary");
|
{
|
jsonWrResult.beginMap(null);
|
{
|
jsonWrResult.addKeyValue("type", "amis_page");
|
jsonWrResult.addKeyValue("title", "");
|
jsonWrResult.addKeyRaw("amis_json", execArg._sbSQLText.toString());
|
jsonWrResult.beginMap("amis_data");
|
{
|
for(Entry<String, Json> entry : jsonArgs.asJsonMap().entrySet())
|
{
|
jsonWrResult.addKeyValue(entry.getKey(), entry.getValue().asString());
|
}
|
|
for(Entry<String, String> entry : execArg._mapAmisData.entrySet())
|
{
|
jsonWrResult.addKeyValue(entry.getKey(), entry.getValue());
|
}
|
}
|
jsonWrResult.endMap();
|
}
|
jsonWrResult.endMap();
|
}
|
jsonWrResult.endArray();
|
}
|
finally
|
{
|
execArg.close();
|
}
|
return null;
|
}
|
|
}
|
