/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public date(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
}
public void xqderiveMst権限マスタList(String function, SubQuery <Mst権限マスタCB> subQuery, String operand, Object value)
{
assertObjectNotNull("subQuery<Mst権限マスタCB>", subQuery);
Mst権限マスタCB cb = new Mst権限マスタCB(); cb.xsetupForDerivedReferrer(this); subQuery.Invoke(cb);
String subQueryPropertyName = keep画面コード_QueryDerivedReferrer_Mst権限マスタList(cb.Query()); // for saving query-value.
String parameterPropertyName = keep画面コード_QueryDerivedReferrer_Mst権限マスタListParameter(value);
registerQueryDerivedReferrer(function, cb.Query(), "画面コード", "画面コード", subQueryPropertyName, operand, value, parameterPropertyName);
}
public void Update()
{
using (var context = DbContextFactory.GetDbContext())
{
//reset where
context.From <Student>()
.Where(a => a.Version == "12" && a.Id == 12)
.Update(new Student()
{
Version = "14",
Age = 20,
Id = 14
});
//param
var age = 20;
DateTime?time = null;
var sid = 1;
//subquery
var subquery = new SubQuery <School>()
.Where(a => a.Id == sid)
.Select(s => s.Name);
var row1 = context.From <Student>()
.Set(a => a.Age, a => a.Age + age)
.Set(a => a.Name, subquery)
.Set(a => a.CreateTime, time, time != null)
.Where(a => a.Id == 16)
.Update();
//function
context.From <Student>()
.Set(a => a.Name, a => MysqlFun.REPLACE(a.Name, "a", "b"))
.Where(a => a.Id == 14)
.Update();
//lock
var student = context.From <Student>()
.Where(a => a.Id == 16)
.Single();
var row2 = context.From <Student>()
.Set(a => a.Age, 80)
.Set(a => a.Version, Guid.NewGuid().ToString())
.Where(a => a.Id == 16 && a.Version == student.Version)
.Update();
//entity
var row3 = context.From <Student>()
.Filter(a => a.SchoolId)
.Update(new Student()
{
Id = 2,
CreateTime = DateTime.Now
});
}
}
public AIMLDictSubstFormatingTagHandler(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
IsStarAtomically = true;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="Proc">The Proc involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public root(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, ParentProvider pp)
: base(bot, user, query, request, result, templateNode)
{
GetTargetSettings = pp ?? (() => this.query.TargetSettings);
}
public override SqlInfo[] ConvertToSql(Expression expression, int level, ConvertFlags flags)
{
return(SubQuery
.ConvertToIndex(expression, level, flags)
.Select(idx => new SqlInfo((idx.Members))
{
Sql = SubQuery.SelectQuery.Select.Columns[idx.Index]
})
.ToArray());
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public aimlexec(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
isRecursive = false;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public think(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
IsStarAtomically = false;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public template(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
SelfProcessing = true;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public cycrandom(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
// this.isRecursive = false;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public thatstar(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode, 1)
{
StarDict = () => CurrentQuery.ThatStars;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public sr(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
IsDeterministic = false;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public StarTagHandler(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, int idx)
: base(bot, user, query, request, result, templateNode)
{
DefaultIndex = idx;
}
public input(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, int offset)
: base(bot, user, query, request, result, templateNode, offset)
{
offetFrom = offset;
}
private static void Main()
{
/*dotnet ef dbcontext Scaffold "Server=127.0.0.1,1433;Initial Catalog=AdventureWorks2017; \n
* Persist Security Info=False;User ID=sa;Password=myNiceSQLPassword123;" Microsoft.EntityFrameworkCore.SqlServer -o Model*/
//SelectQuery.Execute();
//JoinQuery.Execute();
//GroupByQuery.Execute();
//OrderBy.Execute();
SubQuery.Execute();
}
/// <summary>
/// Given a request containing user input, produces a result from the bot
/// </summary>
/// <param name="request">the request from the user</param>
/// <returns>the result to be output to the user</returns>
public Result Chat(Request request)
{
Result result = new Result(request.user, this, request);
if (this.isAcceptingUserInput)
{
// Normalize the input
AIMLLoader loader = new AIMLLoader(this);
AIMLbot.Normalize.SplitIntoSentences splitter = new AIMLbot.Normalize.SplitIntoSentences(this);
string[] rawSentences = splitter.Transform(request.rawInput);
foreach (string sentence in rawSentences)
{
result.InputSentences.Add(sentence);
string path = loader.generatePath(sentence, request.user.getLastBotOutput(), request.user.Topic, true);
result.NormalizedPaths.Add(path);
}
// grab the templates for the various sentences from the graphmaster
foreach (string path in result.NormalizedPaths)
{
Utils.SubQuery query = new SubQuery(path);
query.Template = this.Graphmaster.evaluate(path, query, request, MatchState.UserInput, new StringBuilder());
result.SubQueries.Add(query);
}
// process the templates into appropriate output
foreach (SubQuery query in result.SubQueries)
{
if (query.Template.Length > 0)
{
try {
XmlNode templateNode = AIMLTagHandler.getNode(query.Template);
string outputSentence = this.processNode(templateNode, query, request, result, request.user);
if (outputSentence.Length > 0)
{
result.OutputSentences.Add(outputSentence);
}
} catch (Exception e) {
this.writeToLog("WARNING! A problem was encountered when trying to process the input: " + request.rawInput + " with the template: \"" + query.Template + "\"");
}
}
}
}
else
{
result.OutputSentences.Add(this.NotAcceptingUserInputMessage);
}
// populate the Result object
result.Duration = DateTime.Now - request.StartedOn;
request.user.addResult(result);
return(result);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public lazyClosure(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
isRecursive = false;
IsTraced = true;
}
public format(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, Func <string, string> formatter, Func <string, string> formattereach)
: base(bot, user, query, request, result, templateNode)
{
SFormatter = formatter;
SFormatterE = formattereach;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public format(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, Func <Unifiable, Unifiable> formatter, Func <Unifiable, Unifiable> formattereach)
: base(bot, user, query, request, result, templateNode)
{
UFormatter = formatter;
UFormatterE = formattereach;
}
public AIMLConstraintTagHandler(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, int offset)
: base(bot, user, query, request, result, templateNode)
{
offetFrom = offset;
IsStarAtomically = false;
}
public override bool WillMatch0(string word, SubQuery query)
{
foreach (Unifiable u in List)
{
if (u.WillMatch0(word, query))
{
return(true);
}
}
return(false);
}
public void Other()
{
using (var context = DbContextFactory.GetDbContext())
{
//limit 0,10
var students1 = context.From <Student>()
.Take(10)
.Select();
//limit 10,20
var students2 = context.From <Student>()
.Skip(10, 20)
.Select();
//Calling functions in expressions is not recommended, but n-tier attribute access is supported
var student3 = context.From <Student>()
.Where(a => a.CreateTime == DateTime.Now.Date)
.Select();
//lock
var students4 = context.From <Student>()
.With(LockType.FOR_UPADTE)
.Select();
//exists1
var flag1 = context.From <Student>()
.Where(a => a.Id > 50)
.Exists();
//exists2
var subquery = new SubQuery <School>()
.Where(a => a.Id >= 2)
.Select(a => a.Id);
var flag2 = context.From <Student>()
.Where(a => Operator.Exists(subquery))
.Count();
//count
var count = context.From <Student>()
.Where(a => a.Id > 50)
.Count();
//sum
var sum = context.From <Student>()
.Where(a => a.Id > 50)
.Sum(s => s.Id * s.Age);
//distinct
var disinct = context.From <Student>()
.Distinct()
.Select(s => s.Name);
}
}
public SubQuery ToSubQuery()
{
DbCommand cmd = PrepareCommand();
SubQuery expr = new SubQuery(this.db);
expr.Sql = "(" + cmd.CommandText + ")";
for (int i = 0; i < cmd.Parameters.Count; ++i)
{
expr.Parameters.Add('@' + cmd.Parameters[i].ParameterName.TrimStart(SqlQueryUtils.PrefixCharArray), new KeyValuePair <DbType, object>(cmd.Parameters[i].DbType, cmd.Parameters[i].Value));
}
return(expr);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public recursiveVerbatum(XmlNode show, AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode, bool isRecurse)
: base(bot, user, query, request, result, templateNode)
{
data = show;
//RecurseResult = data;
this.isRecursive = isRecurse;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public srai_odd(AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
throw bot.RaiseError("wrong SRAI!");
mybot = bot;
IsDeterministic = false;
}
public override Unifiable Frozen(SubQuery subquery)
{
string str0 = ToValue(subquery);
return(str0);
/*
* var u = new StringAppendableUnifiableImpl();
* u.str = str0;
* return u;
*/
}
public override void Compile(Session session, ISchemaObject parentObject)
{
using (Scanner scanner = new Scanner(this.statement))
{
ParserDQL rdql = new ParserDQL(session, scanner);
rdql.Read();
this.ViewSubQuery = rdql.XreadViewSubquery(this);
base.queryExpression = this.ViewSubQuery.queryExpression;
if (base.GetColumnCount() == 0)
{
if (this.ColumnNames == null)
{
this.ColumnNames = this.ViewSubQuery.queryExpression.GetResultColumnNames();
}
if (this.ColumnNames.Length != this.ViewSubQuery.queryExpression.GetColumnCount())
{
throw Error.GetError(0x15d9, this.GetName().StatementName);
}
TableUtil.SetColumnsInSchemaTable(this, this.ColumnNames, base.queryExpression.GetColumnTypes(), base.queryExpression.GetColumnNullability());
}
OrderedHashSet <SubQuery> set = OrderedHashSet <SubQuery> .AddAll(OrderedHashSet <SubQuery> .Add(base.queryExpression.GetSubqueries(), this.ViewSubQuery), this.ViewSubQuery.GetExtraSubqueries());
this.ViewSubqueries = new SubQuery[set.Size()];
set.ToArray(this.ViewSubqueries);
ArraySort.Sort <SubQuery>(this.ViewSubqueries, 0, this.ViewSubqueries.Length, this.ViewSubqueries[0]);
foreach (SubQuery query in this.ViewSubqueries)
{
if (query.ParentView == null)
{
query.ParentView = this;
}
query.PrepareTable(session);
}
this.ViewSubQuery.GetTable().view = this;
this.ViewSubQuery.GetTable().ColumnList = base.ColumnList;
this._schemaObjectNames = rdql.compileContext.GetSchemaObjectNames();
this._baseTable = base.queryExpression.GetBaseTable();
}
if (this._baseTable != null)
{
switch (this._check)
{
case 0:
case 2:
return;
case 1:
base.queryExpression.GetCheckCondition();
return;
}
throw Error.RuntimeError(0xc9, "View");
}
}
public void MaterializeSubQueries(Session session)
{
HashSet <SubQuery> set = new HashSet <SubQuery>();
for (int i = 0; i < this.Subqueries.Length; i++)
{
SubQuery item = this.Subqueries[i];
if (set.Add(item) && !item.IsCorrelated())
{
item.Materialise(session);
}
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="bot">The bot involved in this request</param>
/// <param name="user">The user making the request</param>
/// <param name="query">The query that originated this node</param>
/// <param name="request">The request inputted into the system</param>
/// <param name="result">The result to be passed to the user</param>
/// <param name="templateNode">The node to be Processed</param>
public verbatum(String show, AltBot bot,
User user,
SubQuery query,
Request request,
Result result,
XmlNode templateNode)
: base(bot, user, query, request, result, templateNode)
{
data = show;
FinalResult = data;
isRecursive = false;
SelfProcessing = true;
}
public override SqlInfo[] ConvertToSql(Expression?expression, int level, ConvertFlags flags)
{
expression = SequenceHelper.CorrectExpression(expression, this, Context);
var indexes = SubQuery
.ConvertToIndex(expression, level, flags)
.ToArray();
var result = indexes
.Select(idx => new SqlInfo(idx.MemberChain, idx.Index < 0 ? idx.Sql : SubQuery.SelectQuery.Select.Columns[idx.Index], idx.Index))
.ToArray();
return(result);
}
/// <summary>
/// Builds and evaluates a sub query for the request given the specified path.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="sentence">The sentence.</param>
/// <returns>The SubQuery.</returns>
private SubQuery EvaluateSubQuery([NotNull] Request request, [NotNull] string sentence)
{
// Build out a query based on the path
var query = new SubQuery();
// Search the node tree for the template most closely matched to this request
var evaluator = _chatEngine.RootNode.Evaluator;
// Build out the template
query.Template = evaluator.Evaluate(sentence,
query,
request,
MatchState.UserInput,
new StringBuilder());
// Set the input from the sentence, leaving off the path portion
var thatIndex = sentence.IndexOf("<that>", StringComparison.OrdinalIgnoreCase);
if (thatIndex > 0)
{
sentence = sentence.Substring(0, thatIndex - 1);
}
query.InputText = sentence;
return query;
}
public SubQueryList GetSubQueries(string query, int position)
{
ISimpleHQLLexer syntax = GetLexer( query );
int numericId = -1;
List<SubQuery> subQueries = new List<SubQuery>();
int depth = 0;
int caretDepth = 0;
IDictionary<int,SubQuery> level2SubQuery = new Dictionary<int,SubQuery>();
SubQuery current = null;
while ((numericId = syntax.NextTokenId()) != HqlLexer.EOF)
{
bool tokenAdded = false;
if (numericId == HqlLexer.OPEN)
{
depth++;
if (position > syntax.GetTokenOffset())
{
caretDepth = depth;
}
if (!level2SubQuery.ContainsKey(depth))
{
current = new SubQuery();
current.depth = depth;
current.startOffset = syntax.GetTokenOffset();
level2SubQuery[depth] = current;
}
}
else if (numericId == HqlLexer.CLOSE)
{
SubQuery currentDepthQuery = null;
level2SubQuery.TryGetValue(depth,out currentDepthQuery);
// We check if we have a query on the current depth.
// If yes, we'll have to close it
if (currentDepthQuery != null && currentDepthQuery.depth == depth)
{
currentDepthQuery.endOffset = syntax.GetTokenOffset();
currentDepthQuery.tokenIds.Add(numericId);
currentDepthQuery.tokenText.Add(query.Substring(syntax.GetTokenOffset(), syntax.GetTokenLength()));
subQueries.Add(currentDepthQuery);
level2SubQuery.Remove(depth);
tokenAdded = true;
}
depth--;
if (position > syntax.GetTokenOffset()) {
caretDepth = depth;
}
}
switch (numericId)
{
case HqlLexer.FROM:
case HqlLexer.UPDATE:
case HqlLexer.DELETE:
case HqlLexer.SELECT:
if (!level2SubQuery.ContainsKey(depth))
{
current = new SubQuery();
current.depth = depth;
current.startOffset = syntax.GetTokenOffset();
level2SubQuery[depth]= current;
}
current.tokenIds.Add(numericId);
current.tokenText.Add(query.Substring(syntax.GetTokenOffset(), syntax.GetTokenLength()));
break;
default:
if (!tokenAdded && level2SubQuery.ContainsKey(depth))
{
SubQuery sq = (SubQuery) level2SubQuery[depth];
int i = depth;
while (sq == null && i >= 0)
{
sq = (SubQuery) level2SubQuery[i--];
}
if (sq != null)
{
sq.tokenIds.Add(numericId);
sq.tokenText.Add(query.Substring(syntax.GetTokenOffset(), syntax.GetTokenLength()));
}
}
break;
}
}
foreach (var sq in level2SubQuery.Values)
{
sq.endOffset = syntax.GetTokenOffset() + syntax.GetTokenLength();
subQueries.Add(sq);
}
subQueries.Sort();
SubQueryList sql = new SubQueryList();
sql.caretDepth = caretDepth;
sql.subQueries = subQueries;
return sql;
}
