public ICommand TranslateFrom(RawCommand rawCommand)
{
var splittedData = rawCommand?
.ToString()
.SplitBy(_separator)
.ToList() ?? throw new ArgumentNullException(nameof(rawCommand));
var partsEnumerator = _requiredParts.GetEnumerator();
var dataEnumerator = splittedData.GetEnumerator();
var parts = new Dictionary <PartType, IPart>();
while (partsEnumerator.MoveNext())
{
parts.Add(partsEnumerator.Current, dataEnumerator.MoveNext()
? _factory.GetPart(partsEnumerator.Current, dataEnumerator.Current)
: _factory.GetPart(PartType.Empty, string.Empty));
}
partsEnumerator.Dispose();
dataEnumerator.Dispose();
return(_commandFactory.GetCommand(parts[PartType.ID],
parts[PartType.HostID],
parts[PartType.Target],
parts[PartType.Order],
parts[PartType.Data],
TimestampFactory.Timestamp));
}
protected static T Parse <T>(string header, string message) where T : ICommand
{
var command = RawCommand.TryMatch(header);
command.TraceMessage = message;
return((T)(object)new Parser().Parse(command));
}
private void singleExecute()
{
// Get new raw command if nothing is running at the moment
if (rawCommand == null)
{
// If there isn't anything in queue, nothing to do
if (commands.Count == 0)
{
timeToConsume = 0f;
return;
}
// Get command
AbsCmd command = commands[0];
commands.RemoveAt(0);
rawCommand = command.getRawCommand(dotMatrix, displayModel, this);
// Possibly add back to queue
if (command.Repeat)
{
commands.Add(command);
}
}
// Run raw command
timeToConsume = rawCommand.runStep(displayModel, timeToConsume);
// Clear raw command if finished
if (rawCommand.isFinished(displayModel))
{
rawCommand = null;
}
}
public IMessage ParseData(byte[] data)
{
RawCommand cmd = new RawCommand();
cmd.Data = data;
return(cmd);
}
protected ArduinoCommand AddRawCommand(String commandAlias, RawCommand rcmd)
{
ArduinoCommand command = AddCommand(commandAlias, ArduinoCommand.CommandType.SEND);
command.AddArgument((int)rcmd); //which raw command do we want to send
command.AddArgument(0); //this is normally the 'bits' field so it isn't used
command.AddArgument((int)IRProtocol.UNKNOWN); //this is how the board-side identifies it as
return(command);
}
public async Task ReceiveMessageAsync(ILazySocketMessage message, ulong botCurrentUserId)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
//var content = await message.GetContentAsync();
//ConsoleEx.WriteReceivedMessage(content);
await _basicMachines.Scan.TryUpdateScansAsync();
var author = await message.GetAuthorAsync();
if (await author.GetIsBotAsync())
{
return;
}
var(nonCommandResponse, executesCommand) = await ProcessNonCommandAsync(message, botCurrentUserId);
if (nonCommandResponse.Type != ResponseType.None)
{
_manualResponseSent.OnNext(nonCommandResponse);
}
if (!executesCommand)
{
return;
}
var rawCommand = await RawCommand.CreateFromSocketMessageOrDefaultAsync(message, botCurrentUserId);
if (rawCommand == null || rawCommand.Body == null)
{
return;
}
if (rawCommand.HasMentions && !rawCommand.IsMentioned)
{
return;
}
var channel = await message.GetChannelAsync();
var allCommands = CreateAllCommands();
if (allCommands.TryGetValue(rawCommand.Body, out var command))
{
_manualResponseSent.OnNext(await command.InvokeAsync(rawCommand, _client, await channel.GetIdAsync(), await author.GetIdAsync()));
return;
}
//{
// var response = await Response.TryCreateCautionAsync(_client, Texts.Error.Commands.NotFound(rawCommand.Value.Body), await channel.GetIdAsync(), await author.GetIdAsync()) ?? Response.None;
// _manualResponseSent.OnNext(response);
//}
}
public override int GetHashCode()
{
const int prime = 31;
int hashcode = 1;
hashcode = hashcode * prime + RawCommand?.GetHashCode() ?? 0;
hashcode = hashcode * prime + RawArguments?.GetHashCode() ?? 0;
hashcode = hashcode * prime + KeepFile.GetHashCode();
return(hashcode);
}
internal Controller(DotMatrix dotMatrix, DisplayModel displayModel)
{
this.dotMatrix = dotMatrix;
this.displayModel = displayModel;
commands = new List <AbsCmd>();
rawCommand = null;
timeToConsume = 0f;
defaultSpeedDotsPerSecond = 42;
defaultTextFont = TextCommand.Fonts.Normal;
}
public void Header()
{
var header = "2021-03-31T19:47:25.7120 (3148:0000000064148C40) EXECUTE_STATEMENT_START";
var command = RawCommand.TryMatch(header);
Assert.NotNull(command);
Assert.AreEqual(new DateTime(2021, 03, 31, 19, 47, 25, 712), command.TimeStamp);
Assert.AreEqual(3148, command.ServerProcessId);
Assert.AreEqual(1679068224, command.InternalTraceId);
Assert.AreEqual("EXECUTE_STATEMENT_START", command.Command);
}
public static IScriptCommand BuildCommand(RawCommand command)
{
if (command.GetType() == typeof(BasicCommand))
{
return(BuildBasicCommand((BasicCommand)command));
}
if (command.GetType() == typeof(BasicCommand))
{
return(BuildComplexCommand((ComplexCommand)command));
}
return(null);
}
private void FillQuantityNumber()
{
decimal quantity;
string number = RawCommand.Substring(1);
bool valid = decimal.TryParse(number, out quantity);
if (!valid)
{
throw new Exception($"Número (${number}) inválido.");
}
Quantity = quantity;
}
public void Trigger(string filePath)
{
// TODO Use smart proccess running (output errors, wait for exit with a timeout)
var command = RawCommand.Replace(DownloadedFilePathPlaceholder, filePath);
var arguments = RawArguments.Replace(DownloadedFilePathPlaceholder, filePath);
var startInfo = new ProcessStartInfo(command, arguments)
{
WindowStyle = ProcessWindowStyle.Hidden
};
using (var process = Process.Start(startInfo)) {
process.WaitForExit(Convert.ToInt32(TimeSpan.FromMinutes(10).TotalMilliseconds));
}
if (!KeepFile)
{
File.Delete(filePath);
}
}
static Script ParseScript(string BaseDir, string ScriptName)
{
List <IScriptCommand> Commands = new List <IScriptCommand>();
string UnparsedCommand;
System.IO.StreamReader file =
new System.IO.StreamReader(String.Format(@"{0}\{1}", BaseDir, ScriptName));
while ((UnparsedCommand = file.ReadLine()) != null)
{
if (UnparsedCommand.StartsWith("//"))
{
continue;
}
RawCommand Raw = ParseScriptLine(UnparsedCommand);
IScriptCommand Command = CommandFactory.BuildCommand(Raw);
Commands.Add(Command);
}
return(BuildScriptTree(Commands));
}
/// <summary>
/// Validates the specified command by checking a number of arguments and their types.
/// </summary>
/// <param name="command">The command to validate.</param>
/// <param name="definition">The container of command definitions.</param>
/// <returns>True if the command is valid, otherwise false.</returns>
public bool Validate(RawCommand command, CommandDefinition definition)
{
if (command.Arguments.Count != definition.Arguments.Count)
{
return(false);
}
for (var i = 0; i < command.Arguments.Count; i++)
{
var commandArgument = command.Arguments[i];
var definitionArgument = definition.Arguments[i];
if (!TryParseToType(commandArgument, definitionArgument.Type))
{
return(false);
}
}
return(true);
}
public string[] ParseCommandList(LauncherCommandInfo CommandInfo)
{
string[] Commands = CommandInfo.Command.Split(new string[] { "&&" }, StringSplitOptions.RemoveEmptyEntries);
int CommandCount = Commands.Count();
List <string> FormattedCommands = new List <string>();
bool IsArg = false;
foreach (string RawCommand in Commands)
{
if (IsArg)
{
FormattedCommands[FormattedCommands.Count - 1] += " " + RawCommand.TrimStart();
}
else
{
FormattedCommands.Add(RawCommand.TrimStart());
}
IsArg = System.IO.Path.HasExtension(RawCommand) && System.IO.Path.GetExtension(RawCommand).Contains(ExeExtension);
}
return(FormattedCommands.ToArray());
}
// 创建 SELECT 命令
RawCommand ResolveSelectCommandImpl(IDbQueryableInfo_Select dbQuery, int indent, bool isOuter, ResolveToken token)
{
// 说明：
// 1.OFFSET 前必须要有 'ORDER BY'，即 'Skip' 子句前必须使用 'OrderBy' 子句
// 2.在有聚合函数的<MAX,MIN...>情况下，如果有 'Distinct' 'GroupBy' 'Skip' 'Take' 子句，则需要使用嵌套查询
// 3.'Any' 子句将翻译成 IF EXISTS...
// 4.分组再分页时需要使用嵌套查询，此时子查询不需要 'OrderBy' 子句，但最外层则需要
// 5.'Skip' 'Take' 子句视为语义结束符，在其之后的子句将使用嵌套查询
// 6.导航属性中有 1:n 关系的，需要使用嵌套查询，否则分页查询会有问题
// 导航属性中有1:n关系，只统计主表
// 例：AccountList = a.Client.AccountList,
var subQuery = dbQuery.Subquery as IDbQueryableInfo_Select;
if (dbQuery.HasMany && subQuery != null && subQuery.Aggregate != null)
{
dbQuery = subQuery;
}
bool useStatis = dbQuery.Aggregate != null;
bool useNesting = dbQuery.HasDistinct || dbQuery.GroupBy != null || dbQuery.Skip > 0 || dbQuery.Take > 0;
string alias0 = token != null && !string.IsNullOrEmpty(token.AliasPrefix) ? (token.AliasPrefix + "0") : "t0";
// 没有聚合函数或者使用 'Skip' 子句，则解析OrderBy
// 导航属性如果使用嵌套，除非有 TOP 或者 OFFSET 子句，否则不能用ORDER BY
bool useOrderBy = (!useStatis || dbQuery.Skip > 0) && !dbQuery.HasAny && (!dbQuery.IsParsedByMany || (dbQuery.Skip > 0 || dbQuery.Take > 0));
TableAlias aliases = this.PrepareTableAlias(dbQuery, token);
var result = new MappingCommand(this, aliases, token)
{
HasMany = dbQuery.HasMany
};
ISqlBuilder jf = result.JoinFragment;
ISqlBuilder wf = result.WhereFragment;
jf.Indent = indent;
#region 嵌套查询
if (useStatis && useNesting)
{
// SELECT
jf.Append("SELECT ");
jf.AppendNewLine();
// SELECT COUNT(1)
var visitor_ = new AggregateExpressionVisitor(this, aliases, dbQuery.Aggregate, dbQuery.GroupBy, alias0);
visitor_.Write(jf);
result.AddNavMembers(visitor_.NavMembers);
// SELECT COUNT(1) FROM
jf.AppendNewLine();
jf.Append("FROM ( ");
indent += 1;
jf.Indent = indent;
}
#endregion
#region 择子句
// SELECT 子句
if (jf.Indent > 0)
{
jf.AppendNewLine();
}
jf.Append("SELECT ");
if (dbQuery.HasAny)
{
jf.Append("CASE WHEN COUNT(1) = 1 THEN 1 ELSE 0 END FROM (");
indent += 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append("SELECT 1 ");
}
if (useStatis && !useNesting)
{
// 如果有聚合函数，并且不是嵌套的话，则直接使用SELECT <MAX,MIN...>，不需要解析选择的字段
jf.AppendNewLine();
var visitor_ = new AggregateExpressionVisitor(this, aliases, dbQuery.Aggregate, dbQuery.GroupBy);
visitor_.Write(jf);
result.AddNavMembers(visitor_.NavMembers);
}
else
{
// DISTINCT 子句
if (dbQuery.HasDistinct)
{
jf.Append("DISTINCT ");
}
#region 择字段
if (!dbQuery.HasAny)
{
// SELECT 范围
var visitor2 = new SQLiteColumnExpressionVisitor(this, aliases, dbQuery);
visitor2.Write(jf);
result.PickColumns = visitor2.PickColumns;
result.PickColumnText = visitor2.PickColumnText;
result.PickNavDescriptors = visitor2.PickNavDescriptors;
result.AddNavMembers(visitor2.NavMembers);
}
#endregion
}
#endregion
#region 顺序解析
// FROM 子句
jf.AppendNewLine();
jf.Append("FROM ");
if (dbQuery.Subquery != null)
{
// 子查询
jf.Append('(');
RawCommand cmd = this.ResolveSelectCommandImpl(dbQuery.Subquery, indent + 1, false, token);
jf.Append(cmd.CommandText);
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
jf.Append(' ');
}
else
{
var typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo(dbQuery.FromType);
jf.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
jf.Append(' ');
jf.Append(alias0);
jf.Append(' ');
}
// LEFT<INNER> JOIN 子句
ExpressionVisitorBase visitor = new JoinExpressionVisitor(this, aliases, dbQuery.Joins);
visitor.Write(jf);
wf.Indent = jf.Indent;
// WHERE 子句
visitor = new WhereExpressionVisitor(this, aliases, dbQuery.Where);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// GROUP BY 子句
visitor = new GroupByExpressionVisitor(this, aliases, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// HAVING 子句
visitor = new HavingExpressionVisitor(this, aliases, dbQuery.Having, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// ORDER 子句
if (dbQuery.OrderBys.Count > 0 && useOrderBy)
{
visitor = new OrderByExpressionVisitor(this, aliases, dbQuery.OrderBys, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
}
#endregion
#region 分页查询
if (dbQuery.Take > 0)
{
wf.AppendNewLine().AppendFormat("LIMIT {0}", this.DbValue.GetSqlValue(dbQuery.Take, token));
}
else if (dbQuery.Take == 0 && dbQuery.Skip > 0)
{
wf.AppendNewLine().AppendFormat("LIMIT {0}", this.DbValue.GetSqlValue(-1, token));
}
if (dbQuery.Skip > 0)
{
wf.AppendFormat(" OFFSET {0}", this.DbValue.GetSqlValue(dbQuery.Skip, token));
}
#endregion
#region 嵌套查询
if (useStatis && useNesting)
{
result.CombineFragments();
indent -= 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
}
#endregion
#region 嵌套导航
// TODO Include 从表，没分页，OrderBy 报错
if (dbQuery.HasMany && subQuery != null && subQuery.OrderBys.Count > 0 && subQuery.Aggregate == null && !(subQuery.Skip > 0 || subQuery.Take > 0))
{
result.CombineFragments();
visitor = new OrderByExpressionVisitor(this, aliases, subQuery.OrderBys);//, null, "t0");
visitor.Write(jf);
}
#endregion
#region 并集查询
// UNION 子句
if (dbQuery.Unions != null && dbQuery.Unions.Count > 0)
{
result.CombineFragments();
for (int index = 0; index < dbQuery.Unions.Count; index++)
{
jf.AppendNewLine();
jf.Append("UNION ALL");
if (indent == 0)
{
jf.AppendNewLine();
}
RawCommand cmd = this.ResolveSelectCommand(dbQuery.Unions[index], indent, isOuter, token);
jf.Append(cmd.CommandText);
}
}
#endregion
#region Any 子句
// 'Any' 子句
if (dbQuery.HasAny)
{
// 产生 WHERE 子句
result.CombineFragments();
// 如果没有分页，则显式指定只查一笔记录
if (dbQuery.Take == 0 && dbQuery.Skip == 0)
{
jf.AppendNewLine();
jf.Append("LIMIT 1");
}
indent -= 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
}
#endregion
return(result);
}
public ParseFunctionStart(RawCommand rawCommand)
: base(rawCommand)
{
}
public ParseStatementFree(RawCommand rawCommand)
: base(rawCommand)
{
}
public ParseTraceEnd(RawCommand rawCommand)
: base(rawCommand)
{
}
public string GetParameter(string parameterName)
{
return(RawCommand == null ? null : HttpUtility.ParseQueryString(RawCommand.Split('?')[1])[parameterName]);
}
protected ParseProcedure(RawCommand rawCommand)
: base(rawCommand)
{
}
public ParseTriggerEnd(RawCommand rawCommand)
: base(rawCommand)
{
}
RawCommand ResolveSelectCommandImpl(IDbQueryableInfo_Select dbQuery, int indent, bool isOuter, ResolveToken token)
{
// 说明：
// 1.OFFSET 前必须要有 'ORDER BY'，即 'Skip' 子句前必须使用 'OrderBy' 子句
// 2.在有聚合函数的<MAX,MIN...>情况下，如果有 'Distinct' 'GroupBy' 'Skip' 'Take' 子句，则需要使用嵌套查询
// 3.'Any' 子句将翻译成 IF EXISTS...
// 4.分组再分页时需要使用嵌套查询，此时子查询不需要 'OrderBy' 子句，但最外层则需要
// 5.'Skip' 'Take' 子句视为语义结束符，在其之后的子句将使用嵌套查询
// 6.导航属性中有 1:n 关系的，需要使用嵌套查询，否则分页查询会有问题
// 8.如果只有 Skip 没有 Take，则使用 Row_Number() Over()分页语法，其它使用 LIMIT ## OFFSET 语法
// 导航属性中有1:n关系，只统计主表
// 例：AccountList = a.Client.AccountList,
var subQuery = dbQuery.Subquery as IDbQueryableInfo_Select;
if (dbQuery.HasMany && subQuery != null && subQuery.Aggregate != null)
{
dbQuery = subQuery;
}
bool useStatis = dbQuery.Aggregate != null;
// 没有聚合函数或者使用 'Skip' 子句，则解析OrderBy
// 导航属性如果使用嵌套，除非有 TOP 或者 OFFSET 子句，否则不能用ORDER BY
string alias0 = token != null && !string.IsNullOrEmpty(token.AliasPrefix) ? (token.AliasPrefix + "0") : "t0";
bool useSubquery = dbQuery.HasDistinct || dbQuery.GroupBy != null || dbQuery.Skip > 0 || dbQuery.Take > 0;
bool useOrderBy = (!useStatis || dbQuery.Skip > 0) && !dbQuery.HasAny && (!dbQuery.IsParsedByMany || (dbQuery.Skip > 0 || dbQuery.Take > 0));
TableAlias aliases = this.PrepareTableAlias(dbQuery, token);
var result = new MappingCommand(this, aliases, token)
{
HasMany = dbQuery.HasMany
};
ISqlBuilder jf = result.JoinFragment;
ISqlBuilder wf = result.WhereFragment;
ISqlBuilder sf = null;
jf.Indent = indent;
#region 嵌套查询
if (useStatis && useSubquery)
{
// SELECT
jf.Append("SELECT ");
jf.AppendNewLine();
// SELECT COUNT(1)
var visitor_ = new AggregateExpressionVisitor(this, aliases, dbQuery.Aggregate, dbQuery.GroupBy, alias0);
visitor_.Write(jf);
result.AddNavMembers(visitor_.NavMembers);
// SELECT COUNT(1) FROM
jf.AppendNewLine();
jf.Append("FROM ( ");
indent += 1;
jf.Indent = indent;
}
#endregion
#region 择子句
// SELECT 子句
if (jf.Indent > 0)
{
jf.AppendNewLine();
}
jf.Append("SELECT ");
if (dbQuery.HasAny)
{
jf.Append("CASE WHEN COUNT(1) = 1 THEN 1 ELSE 0 END FROM (");
indent += 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append("SELECT 1 ");
}
if (useStatis && !useSubquery)
{
// 如果有聚合函数，并且不是嵌套的话，则直接使用SELECT <MAX,MIN...>，不需要解析选择的字段
jf.AppendNewLine();
var visitor_ = new AggregateExpressionVisitor(this, aliases, dbQuery.Aggregate, dbQuery.GroupBy);
visitor_.Write(jf);
result.AddNavMembers(visitor_.NavMembers);
}
else
{
// DISTINCT 子句
if (dbQuery.HasDistinct)
{
jf.Append("DISTINCT ");
}
#region 择字段
if (!dbQuery.HasAny)
{
// SELECT 范围
var visitor_ = new ColumnExpressionVisitor(this, aliases, dbQuery);
if (dbQuery.Skip > 0 && dbQuery.Take == 0)
{
sf = this.CreateSqlBuilder(token);
sf.Indent = jf.Indent + 1;
visitor_.Write(sf);
}
else
{
visitor_.Write(jf);
}
result.PickColumns = visitor_.PickColumns;
result.PickColumnText = visitor_.PickColumnText;
result.PickNavDescriptors = visitor_.PickNavDescriptors;
result.AddNavMembers(visitor_.NavMembers);
if (sf != null)
{
// 第一层嵌套
int index = 0;
jf.AppendNewLine();
foreach (var column in result.PickColumns)
{
jf.AppendMember(alias0, column.Name);
jf.AppendAs(column.NewName);
index += 1;
if (index < result.PickColumns.Count)
{
jf.Append(',');
jf.AppendNewLine();
}
}
jf.AppendNewLine();
jf.Append("FROM(");
// 第二层嵌套
indent += 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append("SELECT");
jf.Append(sf);
jf.Append(',');
jf.AppendNewLine();
if (dbQuery.OrderBys.Count == 0)
{
throw new XFrameworkException("The method 'OrderBy' must be called before 'Skip'.");
}
jf.Append("ROW_NUMBER() OVER(");
var visitor3 = new OrderByExpressionVisitor(this, aliases, dbQuery.OrderBys, dbQuery.GroupBy);
visitor3.Write(jf, false);
result.AddNavMembers(visitor3.NavMembers);
jf.Append(") Row_Number0");
}
}
#endregion
}
#endregion
#region 顺序解析
// FROM 子句
jf.AppendNewLine();
jf.Append("FROM ");
if (dbQuery.Subquery != null)
{
// 子查询
jf.Append("(");
var cmd = this.ResolveSelectCommandImpl(dbQuery.Subquery, indent + 1, false, token);
jf.Append(cmd.CommandText);
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
jf.Append(' ');
}
else
{
var typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo(dbQuery.FromType);
jf.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
jf.Append(' ');
jf.Append(alias0);
jf.Append(' ');
}
// LEFT<INNER> JOIN 子句
ExpressionVisitorBase visitor = new JoinExpressionVisitor(this, aliases, dbQuery.Joins);
visitor.Write(jf);
wf.Indent = jf.Indent;
// WHERE 子句
visitor = new WhereExpressionVisitor(this, aliases, dbQuery.Where);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// GROUP BY 子句
visitor = new GroupByExpressionVisitor(this, aliases, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// HAVING 子句
visitor = new HavingExpressionVisitor(this, aliases, dbQuery.Having, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
// ORDER 子句
if (dbQuery.OrderBys.Count > 0 && useOrderBy)// && !groupByPaging)
{
visitor = new OrderByExpressionVisitor(this, aliases, dbQuery.OrderBys, dbQuery.GroupBy);
visitor.Write(wf);
result.AddNavMembers(visitor.NavMembers);
}
#endregion
#region 分页查询
// LIMIT 子句可以被用于强制 SELECT 语句返回指定的记录数。
// LIMIT 接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。
// 初始记录行的偏移量是 0(而不是 1)： 为了与 PostgreSQL 兼容，MySQL 也支持句法： LIMIT # OFFSET #。
// Limit n,-1 语法不支持，使用ROW_Number()语法代替
if (dbQuery.Take > 0)
{
wf.AppendNewLine().AppendFormat("LIMIT {0}", this.DbValue.GetSqlValue(dbQuery.Take, token));
wf.AppendFormat(" OFFSET {0}", this.DbValue.GetSqlValue(dbQuery.Skip, token));
}
#endregion
#region 嵌套查询
if (useStatis && useSubquery)
{
result.CombineFragments();
indent -= 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
}
#endregion
#region 嵌套导航
// TODO Include 从表，没分页，OrderBy 报错
if (dbQuery.HasMany && subQuery != null && subQuery.OrderBys.Count > 0 && subQuery.Aggregate == null && !(subQuery.Skip > 0 || subQuery.Take > 0))
{
result.CombineFragments();
visitor = new OrderByExpressionVisitor(this, aliases, subQuery.OrderBys);//, null, "t0");
visitor.Write(jf);
}
#endregion
#region 并集查询
// UNION 子句
if (dbQuery.Unions != null && dbQuery.Unions.Count > 0)
{
result.CombineFragments();
for (int index = 0; index < dbQuery.Unions.Count; index++)
{
jf.AppendNewLine();
jf.Append("UNION ALL");
if (indent == 0)
{
jf.AppendNewLine();
}
RawCommand cmd = this.ResolveSelectCommandImpl(dbQuery.Unions[index], indent, isOuter, token);
jf.Append(cmd.CommandText);
}
}
#endregion
#region 分页查询
if (sf != null)
{
// 合并 WHERE
result.CombineFragments();
indent -= 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
jf.AppendNewLine();
jf.Append("WHERE ");
if (dbQuery.Skip > 0)
{
jf.AppendMember(alias0, "Row_Number0");
jf.Append(" > ");
jf.Append(this.DbValue.GetSqlValue(dbQuery.Skip, token));
}
}
#endregion
#region Any 子句
// 'Any' 子句
if (dbQuery.HasAny)
{
// 产生 WHERE 子句
result.CombineFragments();
// 如果没有分页，则显式指定只查一笔记录
if (dbQuery.Take == 0 && dbQuery.Skip == 0)
{
jf.AppendNewLine();
jf.Append("LIMIT 0,1");
}
indent -= 1;
jf.Indent = indent;
jf.AppendNewLine();
jf.Append(") ");
jf.Append(alias0);
}
#endregion
return(result);
}
public static void CommandNotFoundError(RawCommand command)
{
Logger.Error($"Command '{command.Name}' not found");
}
protected ParseStatementTransaction(RawCommand rawCommand)
: base(rawCommand)
{
}
protected ParseStatementAttachment(RawCommand rawCommand)
: base(rawCommand)
{
}
/// <summary>
/// 创建 INSRT 命令
/// </summary>
/// <param name="dbQuery">查询语义</param>
/// <param name="token">解析上下文</param>
/// <returns></returns>
protected override RawCommand ResolveInsertCommand <T>(IDbQueryableInfo_Insert dbQuery, ResolveToken token)
{
ISqlBuilder builder = this.CreateSqlBuilder(token);
TableAlias aliases = new TableAlias();
var typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo <T>();
if (dbQuery.Entity != null)
{
// 如果没有Sequence列，使用 INSERT ALL INTO 语法，否则就一条一条逐行写入~~
// 批量 INSERT，自增列不会自动赋值
object entity = dbQuery.Entity;
ISqlBuilder seg_Columns = this.CreateSqlBuilder(token);
ISqlBuilder seg_Values = this.CreateSqlBuilder(token);
// 指定插入列
MemberAccessorCollection memberAccessors = typeRuntime.Members;
if (dbQuery.EntityColumns != null && dbQuery.EntityColumns.Count > 0)
{
memberAccessors = new MemberAccessorCollection();
for (int i = 0; i < dbQuery.EntityColumns.Count; i++)
{
Expression curExpr = dbQuery.EntityColumns[i];
if (curExpr.NodeType == ExpressionType.Lambda)
{
curExpr = (curExpr as LambdaExpression).Body.ReduceUnary();
}
if (curExpr.NodeType != ExpressionType.MemberAccess)
{
throw new XFrameworkException("Can't read field name from expression {0}", dbQuery.EntityColumns[i]);
}
MemberExpression member = curExpr as MemberExpression;
string name = member.Member.Name;
memberAccessors[name] = typeRuntime.Members[name];
}
}
// 自增列参数
IDbDataParameter seqParameter = null;
// 自增列标记
ColumnAttribute seqColumn = null;
foreach (var m in memberAccessors)
{
var column = m.Column;
if (column != null && column.NoMapped)
{
continue;
}
if (m.ForeignKey != null)
{
continue;
}
if (m.Member.MemberType == System.Reflection.MemberTypes.Method)
{
continue;
}
seg_Columns.AppendMember(m.Member.Name);
seg_Columns.Append(',');
if (m == typeRuntime.Identity)
{
seqColumn = column;
if (dbQuery.Bulk == null)
{
// 非批量INSERT，产生一个 OUTPUT 类型的参数
string pName = string.Format("{0}p{1}", this.ParameterPrefix, token.Parameters.Count);
var database = token.DbContext.Database;
seqParameter = database.CreateParameter(pName, -1, direction: ParameterDirection.Output);
token.Parameters.Add(seqParameter);
seg_Values.Append(seqParameter.ParameterName);
seg_Values.Append(',');
}
else
{
seg_Values.Append(((OracleColumnAttribute)column).SEQName);
seg_Values.Append(".NEXTVAL");
seg_Values.Append(',');
}
}
else
{
var value = m.Invoke(entity);
string seg = this.DbValue.GetSqlValueWidthDefault(value, token, column);
seg_Values.Append(seg);
seg_Values.Append(',');
}
}
seg_Columns.Length -= 1;
seg_Values.Length -= 1;
if (dbQuery.Bulk == null)
{
// 非批量INSERT，产生一个 OUTPUT 类型的参数
if (seqParameter != null)
{
seqParameter.Direction = ParameterDirection.Output;
seqParameter.DbType = DbType.Int64;
builder.Append("SELECT ");
builder.Append(((OracleColumnAttribute)seqColumn).SEQName);
builder.Append(".NEXTVAL INTO ");
builder.Append(seqParameter.ParameterName);
builder.Append(" FROM DUAL;");
builder.AppendNewLine();
//useSEQ = true;
}
builder.Append("INSERT ");
}
else
{
// 批量 INSERT
if (!dbQuery.Bulk.OnlyValue || seqColumn != null)
{
builder.Append("INSERT ");
}
// 如果有自增列则不使用 INSERT ALL INTO 语法
if (!dbQuery.Bulk.OnlyValue && seqColumn == null)
{
builder.Append("ALL ");
}
}
builder.Append("INTO ");
builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
builder.Append('(');
builder.Append(seg_Columns);
builder.Append(')');
builder.AppendNewLine();
builder.AppendTab();
builder.Append("VALUES");
builder.Append('(');
builder.Append(seg_Values);
builder.Append(')');
if (dbQuery.Bulk == null)
{
builder.Append(';');
}
else
{
if (seqColumn != null)
{
if (dbQuery.Bulk.IsEndPos)
{
builder.Append(";");
}
else
{
builder.AppendNewLine(";");
}
}
else
{
builder.AppendNewLine();
if (dbQuery.Bulk.IsEndPos)
{
builder.Append("SELECT 1 FROM DUAL;");
}
}
}
}
else if (dbQuery.Query != null)
{
builder.Append("INSERT INTO ");
builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
builder.Append('(');
int i = 0;
MappingCommand cmd = this.ResolveSelectCommand(dbQuery.Query, 0, false, token) as MappingCommand;
foreach (var column in cmd.PickColumns)
{
builder.AppendMember(column.Name);
if (i < cmd.PickColumns.Count - 1)
{
builder.Append(',');
}
i++;
}
builder.Append(')');
builder.AppendNewLine();
builder.Append(cmd.CommandText);
builder.Append(';');
}
var result = new RawCommand(builder.ToString(), builder.Token != null ? builder.Token.Parameters : null, System.Data.CommandType.Text);
return(result);
}
public ParseAttachmentStart(RawCommand rawCommand)
: base(rawCommand)
{
}
public ParseProcedureEnd(RawCommand rawCommand)
: base(rawCommand)
{
}
/// <summary>
/// 解析 SQL 命令
/// <para>
/// 返回的已经解析语义中执行批次用 null 分开
/// </para>
/// </summary>
/// <param name="dbQueryables">查询语句</param>
/// <returns></returns>
public override List <RawCommand> Resolve(List <object> dbQueryables)
{
bool haveBegin = false;
ResolveToken token = null;
List <RawCommand> sqlList = new List <RawCommand>();
for (int i = 0; i < dbQueryables.Count; i++)
{
object obj = dbQueryables[i];
if (obj == null)
{
continue;
}
if (obj is IDbQueryable)
{
IDbQueryable dbQueryable = (IDbQueryable)obj;
dbQueryable.Parameterized = true;
if (token == null)
{
token = new ResolveToken();
}
if (token.Parameters == null)
{
token.Parameters = new List <IDbDataParameter>(8);
}
var cmd2 = dbQueryable.Resolve(0, true, token);
if (cmd2 is MappingCommand)
{
// 查询单独执行
if (sqlList.Count > 0 && (i - 1) >= 0 && sqlList[sqlList.Count - 1] != null)
{
sqlList.Add(null);
}
sqlList.Add(cmd2);
sqlList.Add(null);
token = new ResolveToken();
token.Parameters = new List <IDbDataParameter>(8);
}
else
{
// 增删改
if (!haveBegin)
{
sqlList.Add(new RawCommand("BEGIN"));
haveBegin = true;
}
sqlList.Add(cmd2);
if (cmd2.Parameters != null && cmd2.Parameters.Count > 1000)
{
// 1000个参数，就要重新分批
if (haveBegin)
{
sqlList.Add(new RawCommand("END;"));
haveBegin = false;
sqlList.Add(null);
}
token = new ResolveToken();
token.Parameters = new List <IDbDataParameter>(8);
}
if (i + 1 < dbQueryables.Count)
{
// 检查下一条是否是选择语句
bool isQuery = false;
if (dbQueryables[i + 1] is IDbQueryable)
{
var queryInfo = ((IDbQueryable)dbQueryables[i + 1]).Parse();
isQuery = queryInfo is IDbQueryableInfo_Select;
}
else if ((dbQueryables[i + 1] is string))
{
string sql = dbQueryables[i + 1].ToString();
string method = string.Empty;
if (sql.Length > 6)
{
method = sql.Substring(0, 6).Trim().ToUpper();
}
isQuery = method == "SELECT";
}
else if (dbQueryables[i + 1] is RawSql)
{
string sql = ((RawSql)dbQueryables[i + 1]).CommandText;
string method = string.Empty;
if (sql.Length > 6)
{
method = sql.Substring(0, 6).Trim().ToUpper();
}
isQuery = method == "SELECT";
}
// 如果下一条是SELECT 语句，则需要结束当前语句块
if (isQuery)
{
if (haveBegin)
{
sqlList.Add(new RawCommand("END;"));
haveBegin = false;
sqlList.Add(null);
}
token = new ResolveToken();
token.Parameters = new List <IDbDataParameter>(8);
}
}
}
}
else if (obj is RawSql || obj is string)
{
string sql = string.Empty;
if (obj is string)
{
sql = obj.ToString();
}
else
{
RawSql rawSql = (RawSql)obj;
// 解析参数
object[] args = null;
if (rawSql.Parameters != null)
{
args = rawSql.Parameters.Select(x => this.DbValue.GetSqlValue(x, token)).ToArray();
}
sql = rawSql.CommandText;
if (args != null && args.Length > 0)
{
sql = string.Format(sql, args);
}
}
string methodName = string.Empty;
if (sql.Length > 6)
{
methodName = sql.Substring(0, 6).Trim().ToUpper();
}
if (methodName == "SELECT")
{
if (sqlList.Count > 0 && (i - 1) >= 0 && sqlList[sqlList.Count - 1] != null)
{
sqlList.Add(null);
}
}
var cmd2 = new RawCommand(sql, token.Parameters, CommandType.Text);
sqlList.Add(cmd2);
if (methodName == "SELECT")
{
sqlList.Add(cmd2);
sqlList.Add(null);
token = new ResolveToken();
token.Parameters = new List <IDbDataParameter>(8);
}
else if (cmd2.Parameters != null && cmd2.Parameters.Count > 1000)
{
// 1000个参数，就要重新分批
if (haveBegin)
{
sqlList.Add(new RawCommand("END;"));
sqlList.Add(null);
haveBegin = false;
}
token = new ResolveToken();
token.Parameters = new List <IDbDataParameter>(8);
}
}
else
{
if (!haveBegin)
{
sqlList.Add(new RawCommand("BEGIN"));
haveBegin = true;
}
// 解析批量插入操作
List <IDbQueryable> bulkList = obj as List <IDbQueryable>;
if (bulkList != null && bulkList.Count > 0)
{
this.ResolveBulk(sqlList, bulkList);
}
}
if (haveBegin && i == dbQueryables.Count - 1)
{
sqlList.Add(new RawCommand("END;"));
}
}
return(sqlList);
}
