public CreateIndex GenerateCreateIndexStatement(Index i)
{
CreateIndex ci = new CreateIndex();
ci.Index = i;
return(ci);
}
public List <string> GenerateCreateIndexStatement(CreateIndex statement)
{
StringBuilder columnList = new StringBuilder();
foreach (CreateIndex.Column col in statement.Columns)
{
if (columnList.Length > 0)
{
columnList.Append(", ");
}
columnList.Append(col.Name);
}
/*
* CREATE INDEX idx_greylisting_triplets ON hm_greylisting_triplets (glipaddress, glsenderaddress, glrecipientaddress);
*/
StringBuilder sb = new StringBuilder();
sb.AppendFormat("CREATE {0} INDEX {1} ON {2} ({3})",
statement.Unique ? "UNIQUE" : "",
statement.Name,
statement.Table,
columnList.ToString());
return(new List <string>()
{
sb.ToString()
});
}
private IStatement ParseCreateIndexStatement(XmlNode statement)
{
CreateIndex createIndexStatement = new CreateIndex();
createIndexStatement.Name = statement.Attributes["Name"].Value;
createIndexStatement.Table = statement.Attributes["Table"].Value;
createIndexStatement.Unique = Convert.ToBoolean(statement.Attributes["Unique"].Value);
createIndexStatement.Clustered = Convert.ToBoolean(statement.Attributes["Clustered"].Value);
foreach (XmlNode childNode in statement.ChildNodes)
{
if (!(statement is System.Xml.XmlElement))
{
continue;
}
CreateIndex.Column col = new CreateIndex.Column();
col.Name = childNode.Attributes["Name"].Value;
XmlAttribute attribute = childNode.Attributes["MaxLength"];
if (attribute != null)
{
col.MaxLength = Convert.ToInt32(attribute.Value.Length);
}
createIndexStatement.Columns.Add(col);
}
return(createIndexStatement);
}
public List <string> GenerateCreateIndexStatement(CreateIndex statement)
{
StringBuilder columnList = new StringBuilder();
foreach (CreateIndex.Column col in statement.Columns)
{
if (columnList.Length > 0)
{
columnList.Append(", ");
}
columnList.Append(col.Name);
}
/*
* ALTER TABLE hm_accounts ADD CONSTRAINT test1 UNIQUE NONCLUSTERED (accountid)
* ALTER TABLE hm_accounts ADD CONSTRAINT test2 UNIQUE CLUSTERED (accountid)
*/
StringBuilder sb = new StringBuilder();
sb.AppendFormat("CREATE {0} {1} INDEX {2} ON {3} ({4})",
statement.Unique ? "UNIQUE" : "",
statement.Clustered ? "CLUSTERED" : "NONCLUSTERED",
statement.Name,
statement.Table,
columnList.ToString());
return(new List <string>()
{
sb.ToString()
});
}
/// <summary>
/// Tries to parse a script node.
/// </summary>
/// <param name="Parser">Custom parser.</param>
/// <param name="Result">Parsed Script Node.</param>
/// <returns>If successful in parsing a script node.</returns>
public bool TryParse(ScriptParser Parser, out ScriptNode Result)
{
Result = null;
try
{
string s = Parser.NextToken().ToUpper();
if (s != "INDEX")
{
return(false);
}
ScriptNode Name = Parser.ParseNoWhiteSpace();
s = Parser.NextToken().ToUpper();
if (s != "ON")
{
return(false);
}
if (!SelectParser.TryParseSources(Parser, out SourceDefinition Source))
{
return(false);
}
s = Parser.NextToken();
if (s != "(")
{
return(false);
}
this.ParseList(Parser, out ScriptNode[] Columns, out bool[] Ascending);
if (Columns.Length == 0)
{
return(false);
}
if (Parser.NextToken() != ")")
{
return(false);
}
Result = new CreateIndex(Name, Source, Columns, Ascending, Parser.Start, Parser.Length, Parser.Expression);
return(true);
}
catch (Exception)
{
return(false);
}
}
public override IQueryElement VisitCreate_index([NotNull] QueryGrammarParser.Create_indexContext context)
{
CreateIndex createIndex = new CreateIndex();
createIndex.Add(Visit(context.index_definition().class_name()));
createIndex.Add(Visit(context.index_name()));
context.index_definition().index_attribute()
.Select(VisitIndex_attribute)
.ToList()
.ForEach(createIndex.Add);
return(createIndex);
}
public string GenerateCreateIndexScript(CreateIndex CreateIndexStatement)
{
string TmpScript = "";
TmpScript += "create " + PegarUnique(CreateIndexStatement.Index.Unique) + "index " + CreateIndexStatement.Index.IndexName + " on " + CreateIndexStatement.Index.TableName + " (" + Environment.NewLine;
foreach (IndexColumn c in CreateIndexStatement.Index.Columns)
{
TmpScript += " " + c.Column;
if (CreateIndexStatement.Index.Columns.IndexOf(c) != (CreateIndexStatement.Index.Columns.Count - 1))
{
TmpScript += "," + Environment.NewLine;
}
else
{
TmpScript += Environment.NewLine + ")" + Environment.NewLine;
}
}
return(TmpScript);
}
/// <summary>
/// Renders the object model in it's EPL syntax textual representation, using a whitespace-formatter as provided.
/// </summary>
/// <param name="formatter">the formatter to use</param>
/// <param name="writer">writer to use</param>
/// <throws>IllegalStateException if required clauses do not exist</throws>
public void ToEPL(
EPStatementFormatter formatter,
TextWriter writer)
{
AnnotationPart.ToEPL(writer, Annotations, formatter);
ExpressionDeclaration.ToEPL(writer, ExpressionDeclarations, formatter);
ScriptExpression.ToEPL(writer, ScriptExpressions, formatter);
ClassProvidedExpression.ToEPL(writer, ClassProvidedExpressions, formatter);
if (ContextName != null)
{
formatter.BeginContext(writer);
writer.Write("context ");
writer.Write(ContextName);
}
if (CreateIndex != null)
{
formatter.BeginCreateIndex(writer);
CreateIndex.ToEPL(writer);
return;
}
if (CreateSchema != null)
{
formatter.BeginCreateSchema(writer);
CreateSchema.ToEPL(writer);
return;
}
if (CreateExpression != null)
{
formatter.BeginCreateExpression(writer);
CreateExpression.ToEPL(writer);
return;
}
if (CreateClass != null)
{
formatter.BeginCreateExpression(writer);
CreateClass.ToEPL(writer);
return;
}
if (CreateContext != null)
{
formatter.BeginCreateContext(writer);
CreateContext.ToEPL(writer, formatter);
return;
}
if (CreateWindow != null)
{
formatter.BeginCreateWindow(writer);
CreateWindow.ToEPL(writer);
writer.Write(" as ");
if (SelectClause == null || SelectClause.SelectList.IsEmpty() && !CreateWindow.Columns.IsEmpty())
{
CreateWindow.ToEPLCreateTablePart(writer);
}
else
{
SelectClause.ToEPL(writer, formatter, false, false);
if (CreateWindow.AsEventTypeName != null)
{
writer.Write(" from ");
writer.Write(CreateWindow.AsEventTypeName);
}
CreateWindow.ToEPLInsertPart(writer);
}
return;
}
if (CreateVariable != null)
{
formatter.BeginCreateVariable(writer);
CreateVariable.ToEPL(writer);
return;
}
if (CreateTable != null)
{
formatter.BeginCreateTable(writer);
CreateTable.ToEPL(writer);
return;
}
if (CreateDataFlow != null)
{
formatter.BeginCreateDataFlow(writer);
CreateDataFlow.ToEPL(writer, formatter);
return;
}
var displayWhereClause = true;
if (UpdateClause != null)
{
formatter.BeginUpdate(writer);
UpdateClause.ToEPL(writer);
}
else if (OnExpr != null)
{
formatter.BeginOnTrigger(writer);
writer.Write("on ");
FromClause.Streams[0].ToEPL(writer, formatter);
if (OnExpr is OnDeleteClause onDeleteClause)
{
formatter.BeginOnDelete(writer);
writer.Write("delete from ");
onDeleteClause.ToEPL(writer);
}
else if (OnExpr is OnUpdateClause onUpdateClause)
{
formatter.BeginOnUpdate(writer);
writer.Write("update ");
onUpdateClause.ToEPL(writer);
}
else if (OnExpr is OnSelectClause onSelectClause)
{
InsertInto?.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, onSelectClause.IsDeleteAndSelect);
writer.Write(" from ");
onSelectClause.ToEPL(writer);
}
else if (OnExpr is OnSetClause onSetClause)
{
onSetClause.ToEPL(writer, formatter);
}
else if (OnExpr is OnMergeClause onMergeClause)
{
onMergeClause.ToEPL(writer, WhereClause, formatter);
displayWhereClause = false;
}
else
{
var split = (OnInsertSplitStreamClause)OnExpr;
InsertInto.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, false);
if (WhereClause != null)
{
writer.Write(" where ");
WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
split.ToEPL(writer, formatter);
displayWhereClause = false;
}
}
else
{
IntoTableClause?.ToEPL(writer);
if (SelectClause == null)
{
throw new IllegalStateException("Select-clause has not been defined");
}
if (FromClause == null)
{
throw new IllegalStateException("From-clause has not been defined");
}
if (FireAndForgetClause is FireAndForgetUpdate fireAndForgetUpdate)
{
writer.Write("update ");
FromClause.ToEPLOptions(writer, formatter, false);
writer.Write(" ");
UpdateClause.RenderEPLAssignments(writer, fireAndForgetUpdate.Assignments);
}
else if (FireAndForgetClause is FireAndForgetInsert fireAndForgetInsert)
{
InsertInto.ToEPL(writer, formatter, true);
if (fireAndForgetInsert.IsUseValuesKeyword)
{
writer.Write(" values (");
var delimiter = "";
foreach (var element in SelectClause.SelectList)
{
writer.Write(delimiter);
element.ToEPLElement(writer);
delimiter = ", ";
}
writer.Write(")");
}
else
{
SelectClause.ToEPL(writer, formatter, true, false);
}
}
else if (FireAndForgetClause is FireAndForgetDelete)
{
writer.Write("delete ");
FromClause.ToEPLOptions(writer, formatter, true);
}
else
{
InsertInto?.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, false);
FromClause.ToEPLOptions(writer, formatter, true);
}
}
MatchRecognizeClause?.ToEPL(writer);
if (WhereClause != null && displayWhereClause)
{
formatter.BeginWhere(writer);
writer.Write("where ");
WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
if (GroupByClause != null)
{
formatter.BeginGroupBy(writer);
writer.Write("group by ");
GroupByClause.ToEPL(writer);
}
if (HavingClause != null)
{
formatter.BeginHaving(writer);
writer.Write("having ");
HavingClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
if (OutputLimitClause != null)
{
formatter.BeginOutput(writer);
writer.Write("output ");
OutputLimitClause.ToEPL(writer);
}
if (OrderByClause != null)
{
formatter.BeginOrderBy(writer);
writer.Write("order by ");
OrderByClause.ToEPL(writer);
}
if (RowLimitClause != null)
{
formatter.BeginLimit(writer);
writer.Write("limit ");
RowLimitClause.ToEPL(writer);
}
if (ForClause != null)
{
formatter.BeginFor(writer);
ForClause.ToEPL(writer);
}
}
/// <summary>
/// LUA结构支持
/// </summary>
/// <returns></returns>
public override void GetLuaStruct(StringBuilder code)
{
base.GetLuaStruct(code);
int idx;
if (!string.IsNullOrWhiteSpace(PropertyName))
{
code.AppendLine($@"['PropertyName'] = '{PropertyName.ToLuaString()}',");
}
else
{
code.AppendLine($@"['PropertyName'] = nil,");
}
code.AppendLine($@"['IsCaption'] ={(IsCaption.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(Alias))
{
code.AppendLine($@"['Alias'] = '{Alias.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Alias'] = nil,");
}
if (!string.IsNullOrWhiteSpace(Group))
{
code.AppendLine($@"['Group'] = '{Group.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Group'] = nil,");
}
code.AppendLine($@"['CreateIndex'] ={(CreateIndex.ToString().ToLower())},");
code.AppendLine($@"['IsPrimaryKey'] ={(IsPrimaryKey.ToString().ToLower())},");
code.AppendLine($@"['IsExtendKey'] ={(IsExtendKey.ToString().ToLower())},");
code.AppendLine($@"['IsIdentity'] ={(IsIdentity.ToString().ToLower())},");
code.AppendLine($@"['IsGlobalKey'] ={(IsGlobalKey.ToString().ToLower())},");
code.AppendLine($@"['UniqueIndex'] ={UniqueIndex},");
code.AppendLine($@"['IsRequired'] ={(IsRequired.ToString().ToLower())},");
code.AppendLine($@"['IsUserReadOnly'] ={(IsUserReadOnly.ToString().ToLower())},");
code.AppendLine($@"['IsMemo'] ={(IsMemo.ToString().ToLower())},");
code.AppendLine($@"['DenyClient'] ={(DenyClient.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(Prefix))
{
code.AppendLine($@"['Prefix'] = '{Prefix.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Prefix'] = nil,");
}
if (!string.IsNullOrWhiteSpace(Suffix))
{
code.AppendLine($@"['Suffix'] = '{Suffix.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Suffix'] = nil,");
}
if (!string.IsNullOrWhiteSpace(InputType))
{
code.AppendLine($@"['InputType'] = '{InputType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['InputType'] = nil,");
}
if (!string.IsNullOrWhiteSpace(ComboBoxUrl))
{
code.AppendLine($@"['ComboBoxUrl'] = '{ComboBoxUrl.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ComboBoxUrl'] = nil,");
}
code.AppendLine($@"['IsMoney'] ={(IsMoney.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(GridAlign))
{
code.AppendLine($@"['GridAlign'] = '{GridAlign.ToLuaString()}',");
}
else
{
code.AppendLine($@"['GridAlign'] = nil,");
}
if (!string.IsNullOrWhiteSpace(DataFormater))
{
code.AppendLine($@"['DataFormater'] = '{DataFormater.ToLuaString()}',");
}
else
{
code.AppendLine($@"['DataFormater'] = nil,");
}
code.AppendLine($@"['DenyClient'] ={(DenyClient.ToString().ToLower())},");
code.AppendLine($@"['GridDetails'] ={(GridDetails.ToString().ToLower())},");
code.AppendLine($@"['NoneGrid'] ={(NoneGrid.ToString().ToLower())},");
code.AppendLine($@"['NoneDetails'] ={(NoneDetails.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(GridDetailsCode))
{
code.AppendLine($@"['GridDetailsCode'] = '{GridDetailsCode.ToLuaString()}',");
}
else
{
code.AppendLine($@"['GridDetailsCode'] = nil,");
}
if (!string.IsNullOrWhiteSpace(CppType))
{
code.AppendLine($@"['CppType'] = '{CppType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['CppType'] = nil,");
}
if (CppTypeObject != null)
{
code.AppendLine($@"['CppTypeObject'] ='{CppTypeObject}',");
}
if (!string.IsNullOrWhiteSpace(CppName))
{
code.AppendLine($@"['CppName'] = '{CppName.ToLuaString()}',");
}
else
{
code.AppendLine($@"['CppName'] = nil,");
}
if (!string.IsNullOrWhiteSpace(CppLastType))
{
code.AppendLine($@"['CppLastType'] = '{CppLastType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['CppLastType'] = nil,");
}
code.AppendLine($@"['IsIntDecimal'] ={(IsIntDecimal.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(CsType))
{
code.AppendLine($@"['CsType'] = '{CsType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['CsType'] = nil,");
}
if (!string.IsNullOrWhiteSpace(CustomType))
{
code.AppendLine($@"['CustomType'] = '{CustomType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['CustomType'] = nil,");
}
if (!string.IsNullOrWhiteSpace(LastCsType))
{
code.AppendLine($@"['LastCsType'] = '{LastCsType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['LastCsType'] = nil,");
}
if (EnumConfig != null)
{
code.AppendLine($@"['EnumConfig'] = {EnumConfig.GetLuaStruct()},");
}
code.AppendLine($@"['IsCompute'] ={(IsCompute.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(ComputeGetCode))
{
code.AppendLine($@"['ComputeGetCode'] = '{ComputeGetCode.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ComputeGetCode'] = nil,");
}
if (!string.IsNullOrWhiteSpace(ComputeSetCode))
{
code.AppendLine($@"['ComputeSetCode'] = '{ComputeSetCode.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ComputeSetCode'] = nil,");
}
code.AppendLine($@"['IsMiddleField'] ={(IsMiddleField.ToString().ToLower())},");
code.AppendLine($@"['InnerField'] ={(InnerField.ToString().ToLower())},");
code.AppendLine($@"['IsSystemField'] ={(IsSystemField.ToString().ToLower())},");
code.AppendLine($@"['IsInterfaceField'] ={(IsInterfaceField.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(Initialization))
{
code.AppendLine($@"['Initialization'] = '{Initialization.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Initialization'] = nil,");
}
if (!string.IsNullOrWhiteSpace(EmptyValue))
{
code.AppendLine($@"['EmptyValue'] = '{EmptyValue.ToLuaString()}',");
}
else
{
code.AppendLine($@"['EmptyValue'] = nil,");
}
code.AppendLine($@"['DenyScope'] ='{DenyScope}',");
code.AppendLine($@"['Nullable'] ={(Nullable.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(Max))
{
code.AppendLine($@"['Max'] = '{Max.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Max'] = nil,");
}
if (!string.IsNullOrWhiteSpace(Min))
{
code.AppendLine($@"['Min'] = '{Min.ToLuaString()}',");
}
else
{
code.AppendLine($@"['Min'] = nil,");
}
code.AppendLine($@"['UniqueString'] ={(UniqueString.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(ColumnName))
{
code.AppendLine($@"['ColumnName'] = '{ColumnName.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ColumnName'] = nil,");
}
code.AppendLine($@"['DbNullable'] ={(DbNullable.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(DbType))
{
code.AppendLine($@"['DbType'] = '{DbType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['DbType'] = nil,");
}
code.AppendLine($@"['Precision'] ={Datalen},");
if (!string.IsNullOrWhiteSpace(ArrayLen))
{
code.AppendLine($@"['ArrayLen'] = '{ArrayLen.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ArrayLen'] = nil,");
}
code.AppendLine($@"['Scale'] ={Scale},");
code.AppendLine($@"['DbIndex'] ={DbIndex},");
code.AppendLine($@"['Unicode'] ={(Unicode.ToString().ToLower())},");
code.AppendLine($@"['FixedLength'] ={(FixedLength.ToString().ToLower())},");
code.AppendLine($@"['IsBlob'] ={(IsBlob.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(StorageProperty))
{
code.AppendLine($@"['StorageProperty'] = '{StorageProperty.ToLuaString()}',");
}
else
{
code.AppendLine($@"['StorageProperty'] = nil,");
}
code.AppendLine($@"['DbInnerField'] ={(DbInnerField.ToString().ToLower())},");
code.AppendLine($@"['NoStorage'] ={(NoStorage.ToString().ToLower())},");
code.AppendLine($@"['KeepStorageScreen'] ='{KeepStorageScreen}',");
code.AppendLine($@"['CustomWrite'] ={(CustomWrite.ToString().ToLower())},");
code.AppendLine($@"['IsLinkField'] ={(IsLinkField.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(LinkTable))
{
code.AppendLine($@"['LinkTable'] = '{LinkTable.ToLuaString()}',");
}
else
{
code.AppendLine($@"['LinkTable'] = nil,");
}
code.AppendLine($@"['IsLinkKey'] ={(IsLinkKey.ToString().ToLower())},");
code.AppendLine($@"['IsLinkCaption'] ={(IsLinkCaption.ToString().ToLower())},");
code.AppendLine($@"['IsUserId'] ={(IsUserId.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(LinkField))
{
code.AppendLine($@"['LinkField'] = '{LinkField.ToLuaString()}',");
}
else
{
code.AppendLine($@"['LinkField'] = nil,");
}
code.AppendLine($@"['IsCustomCompute'] ={(IsCustomCompute.ToString().ToLower())},");
code.AppendLine($@"['CanGet'] ={(CanGet.ToString().ToLower())},");
code.AppendLine($@"['CanSet'] ={(CanSet.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(AccessType))
{
code.AppendLine($@"['AccessType'] = '{AccessType.ToLuaString()}',");
}
else
{
code.AppendLine($@"['AccessType'] = nil,");
}
code.AppendLine($@"['ReadOnly'] ={(ReadOnly.ToString().ToLower())},");
code.AppendLine($@"['CanInput'] ={(CanUserInput.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(ExtendRole))
{
code.AppendLine($@"['ExtendRole'] = '{ExtendRole.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ExtendRole'] = nil,");
}
if (!string.IsNullOrWhiteSpace(ValueSeparate))
{
code.AppendLine($@"['ValueSeparate'] = '{ValueSeparate.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ValueSeparate'] = nil,");
}
if (!string.IsNullOrWhiteSpace(ArraySeparate))
{
code.AppendLine($@"['ArraySeparate'] = '{ArraySeparate.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ArraySeparate'] = nil,");
}
code.AppendLine($@"['ExtendArray'] ={(ExtendArray.ToString().ToLower())},");
code.AppendLine($@"['IsKeyValueArray'] ={(IsKeyValueArray.ToString().ToLower())},");
code.AppendLine($@"['IsRelation'] ={(IsRelation.ToString().ToLower())},");
if (!string.IsNullOrWhiteSpace(ExtendPropertyName))
{
code.AppendLine($@"['ExtendPropertyName'] = '{ExtendPropertyName.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ExtendPropertyName'] = nil,");
}
if (!string.IsNullOrWhiteSpace(ExtendClassName))
{
code.AppendLine($@"['ExtendClassName'] = '{ExtendClassName.ToLuaString()}',");
}
else
{
code.AppendLine($@"['ExtendClassName'] = nil,");
}
code.AppendLine($@"['ExtendClassIsPredestinate'] ={(ExtendClassIsPredestinate.ToString().ToLower())},");
code.AppendLine($@"['IsRelationField'] ={(IsRelationField.ToString().ToLower())},");
code.AppendLine($@"['IsRelationValue'] ={(IsRelationValue.ToString().ToLower())},");
code.AppendLine($@"['IsRelationArray'] ={(IsRelationArray.ToString().ToLower())},");
code.AppendLine($@"['IsExtendArray'] ={(IsExtendArray.ToString().ToLower())},");
code.AppendLine($@"['IsExtendValue'] ={(IsExtendValue.ToString().ToLower())},");
}
public virtual IInMemoryIndex <TValue> Create <TValue>(EntityType entityType, IndexModel indexModel) => CreateIndex <TValue>(entityType, indexModel)();
public Expression GetNode(ExpressionParser parser)
{
Lexem lex = parser.Collection.CurrentLexem();
Expression res = null;
if (lex.LexemType == LexType.Command)
{
string lowerLexem = lex.LexemText.ToLower();
if (ParserUtils.ParseCommandPhrase(parser.Collection, "create view", false, false))
{
res = new CreateView();
}
if (ParserUtils.ParseCommandPhrase(parser.Collection, "create table", false, false))
{
res = new CreateTable();
}
if (res == null && ParserUtils.ParseCommandPhrase(parser.Collection, "alter table", false, false))
{
res = new AlterTable();
}
if (res == null && ParserUtils.ParseCommandPhrase(parser.Collection, "drop table", false, false))
{
res = new DropTable();
}
if (res == null && ParserUtils.ParseCommandPhrase(parser.Collection, "drop index", false, false))
{
res = new DropIndex();
}
if (res == null && (ParserUtils.ParseCommandPhrase(parser.Collection, "create unique index", false, false) ||
ParserUtils.ParseCommandPhrase(parser.Collection, "create index", false, false)))
{
res = new CreateIndex();
}
if (res == null)
{
if (parser.Collection.GetNext() != null && parser.Collection.GetNext().IsSkobraOpen())
{
switch (lowerLexem)
{
case "count":
res = new CountExpr();
break;
case "sum":
res = new SumExpr();
break;
case "min":
res = new MinExpr();
break;
case "max":
res = new MaxExpr();
break;
case "avg":
res = new AvgExpr();
break;
case "lastinsertrowid":
res = new LastInsertRowidExpr();
break;
case "exists":
res = new ExistsExpr();
break;
case "any":
res = new AnyExpr();
break;
}
}
switch (lowerLexem)
{
case "between": //не функция
res = new Between();
break;
case "select":
res = new SelectExpresion();
break;
case "update":
res = new UpdateStatement();
break;
case "insert":
res = new InsertStatement();
break;
case "delete":
res = new DeleteStatement();
break;
}
}
}
if (res != null)
{
return(res);
}
return(res);
}
private async void toolStripMenuItem2_Click(object sender, EventArgs e)
{
var node = (TreeNode)this.menuMenus.Tag;
if (node == null)
{
return;
}
if (node.Text.Equals("TABLES"))
{
this.TableCreate = new TableCreate(true, string.Empty);
if (TableCreate.ShowDialog() == DialogResult.OK)
{
try
{
var result = await this.controller.ExecuteConsult(TableCreate.Query);
if (result == 0)
{
this.treeViewDataConecction.Nodes.Clear();
var nodes = (await this.controller.GethTreeNodes()).ToArray();
this.treeViewDataConecction.Nodes.AddRange(nodes);
MessageBox.Show("The table was crate suscefully");
}
else
{
MessageBox.Show("Not was create the table");
}
}
catch (Exception exc)
{
MessageBox.Show("Internal error:" + exc.Message);
}
}
}
else if (node.Text.Equals("VIEWS"))
{
this.CreateView = new CreateView(true, string.Empty);
if (this.CreateView.ShowDialog() == DialogResult.OK)
{
try
{
var query = this.CreateView.Sql;
var result = await this.controller.ExecuteConsult(query);
if (result == 0)
{
this.treeViewDataConecction.Nodes.Clear();
var nodes = (await this.controller.GethTreeNodes()).ToArray();
this.treeViewDataConecction.Nodes.AddRange(nodes);
MessageBox.Show("The view was crate suscefully");
}
else
{
MessageBox.Show("Not was create the view");
}
}
catch (Exception)
{
MessageBox.Show("Internal error");
}
}
}
else if (node.Text.Equals("TRIGGERS"))
{
this.CreateTrigger = new CreateTrigger(true, string.Empty, this.controller.datab);
if (this.CreateTrigger.ShowDialog() == DialogResult.OK)
{
try
{
var query = this.CreateTrigger.Sql;
var result = await this.controller.ExecuteConsult(query);
if (result == 0)
{
this.treeViewDataConecction.Nodes.Clear();
var nodes = (await this.controller.GethTreeNodes()).ToArray();
this.treeViewDataConecction.Nodes.AddRange(nodes);
MessageBox.Show("The trigger was crate suscefully");
}
else
{
MessageBox.Show("Not was create the trigger");
}
}
catch (Exception exc)
{
MessageBox.Show("Internal error:" + exc.Message);
}
}
}
else if (node.Text.Equals("INDEXS"))
{
var nodeP = node.Parent;
if (nodeP == null)
{
return;
}
this.CreateIndex = new CreateIndex(true, "", this.controller.datab, nodeP.Text);
if (this.CreateIndex.ShowDialog() == DialogResult.OK)
{
try
{
var query = this.CreateIndex.Sql;
var result = await this.controller.ExecuteConsult(query);
if (result == 0)
{
this.treeViewDataConecction.Nodes.Clear();
var nodes = (await this.controller.GethTreeNodes()).ToArray();
this.treeViewDataConecction.Nodes.AddRange(nodes);
MessageBox.Show("The index was crate suscefully");
}
else
{
MessageBox.Show("Not was create the index");
}
}
catch (Exception esx)
{
MessageBox.Show("Internal error:" + esx.Message);
}
}
}
}
public string visit(CreateIndex ddl)
{
return "";
}
