public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, UpdateTableNameStateFunction> dfa)
{
UpdateTableName deleteFrom = dfa as UpdateTableName;
switch (Func)
{
case UpdateTableNameStateFunction.Name:
deleteFrom.Name = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, ExecParameterFunction> dfa)
{
ExecParameter selectField = dfa as ExecParameter;
switch (Func)
{
case ExecParameterFunction.Value:
selectField.Value = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, InsertFieldFunction> dfa)
{
InsertField insertField = dfa as InsertField;
switch (Func)
{
case InsertFieldFunction.Name:
insertField.Name = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, CreateTableFieldFunction> dfa)
{
switch (Func)
{
case CreateTableFieldFunction.Name:
((CreateTableField)dfa).FieldName = dfa.CurrentToken.Text;
break;
case CreateTableFieldFunction.Type:
((CreateTableField)dfa).DataType = GetDataType(dfa.CurrentToken.Text);
break;
case CreateTableFieldFunction.Length:
if (dfa.CurrentToken.SyntaxType == SyntaxType.MAX)
{
((CreateTableField)dfa).DataLength = -1;
}
else
{
((CreateTableField)dfa).DataLength = int.Parse(dfa.CurrentToken.Text);
}
break;
case CreateTableFieldFunction.Tokenized:
((CreateTableField)dfa).IndexType = GetIndexType(dfa.CurrentToken.SyntaxType);
break;
case CreateTableFieldFunction.FASTEST:
((CreateTableField)dfa).IndexMode = Hubble.Core.Data.Field.IndexMode.Simple;
break;
case CreateTableFieldFunction.Analyzer:
((CreateTableField)dfa).AnalyzerName = dfa.CurrentToken.Text;
break;
case CreateTableFieldFunction.DEAFAULT:
((CreateTableField)dfa).Default = dfa.CurrentToken.Text;
break;
case CreateTableFieldFunction.NULL:
((CreateTableField)dfa).CanNull = true;
break;
case CreateTableFieldFunction.NOTNULL:
((CreateTableField)dfa).CanNull = false;
break;
case CreateTableFieldFunction.PRIMARYKEY:
((CreateTableField)dfa).PrimaryKey = true;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, CreateTableFunction> dfa)
{
switch (Func)
{
case CreateTableFunction.TableName:
((CreateTable)dfa).TableName = dfa.CurrentToken.Text;
break;
case CreateTableFunction.Field:
((CreateTable)dfa).CurrentSyntax = new CreateTableField();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, ExecFunction> dfa)
{
switch (Func)
{
case ExecFunction.Name:
((Exec)dfa).StoredProcedureName = dfa.CurrentToken.Text;
break;
case ExecFunction.Para:
((Exec)dfa).CurrentSyntax = new ExecParameter();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, DeleteFunction> dfa)
{
switch (Func)
{
case DeleteFunction.From:
((Delete)dfa).CurrentSyntax = new DeleteFrom();
break;
case DeleteFunction.Where:
((Delete)dfa).CurrentSyntax = new Where();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, SelectFieldFunction> dfa)
{
SelectField selectField = dfa as SelectField;
switch (Func)
{
case SelectFieldFunction.Name:
selectField.Name = dfa.CurrentToken.Text;
selectField.Alias = selectField.Name;
break;
case SelectFieldFunction.Alias:
selectField.Alias = dfa.CurrentToken.Text;
break;
case SelectFieldFunction.Top:
if (!selectField.BetweenRecord)
{
selectField.IsTop = true;
}
break;
case SelectFieldFunction.End:
if (dfa.CurrentToken.SyntaxType == SyntaxType.Numeric)
{
selectField.BetweenRecord = true;
selectField.End = int.Parse(dfa.CurrentToken.Text);
if (selectField.IsTop)
{
if (selectField.End <= 0)
{
selectField.End = 0;
selectField.Begin = -1;
}
else
{
selectField.End--;
}
}
}
break;
case SelectFieldFunction.Begin:
selectField.BetweenRecord = true;
selectField.Begin = int.Parse(dfa.CurrentToken.Text);
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, TSFQLAttrFunction> dfa)
{
TSFQLAttribute sfqlAttr = dfa as TSFQLAttribute;
switch (Func)
{
case TSFQLAttrFunction.Name:
sfqlAttr.Name = dfa.CurrentToken.Text;
break;
case TSFQLAttrFunction.Parameter:
sfqlAttr.Parameters.Add(dfa.CurrentToken.Text);
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, UpdateFieldFunction> dfa)
{
UpdateField selectField = dfa as UpdateField;
switch (Func)
{
case UpdateFieldFunction.Name:
selectField.Name = dfa.CurrentToken.Text;
break;
case UpdateFieldFunction.Value:
selectField.Value = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, SelectFromStateFunction> dfa)
{
SelectFrom selectFrom = dfa as SelectFrom;
switch (Func)
{
case SelectFromStateFunction.Name:
selectFrom.Name = dfa.CurrentToken.Text;
selectFrom.Alias = selectFrom.Name;
break;
case SelectFromStateFunction.Alias:
selectFrom.Alias = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, OrderByStateFunction> dfa)
{
OrderBy orderby = dfa as OrderBy;
switch (Func)
{
case OrderByStateFunction.Name:
orderby.Name = dfa.CurrentToken.Text;
orderby.Order = "asc";
break;
case OrderByStateFunction.Order:
orderby.Order = dfa.CurrentToken.Text;
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, InsertFunction> dfa)
{
switch (Func)
{
case InsertFunction.Table:
((Insert)dfa).CurrentSyntax = new InsertTableName();
break;
case InsertFunction.Field:
((Insert)dfa).CurrentSyntax = new InsertField();
break;
case InsertFunction.Value:
((Insert)dfa).CurrentSyntax = new InsertValue();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, UpdateFunction> dfa)
{
switch (Func)
{
case UpdateFunction.Table:
((Update)dfa).CurrentSyntax = new UpdateTableName();
break;
case UpdateFunction.Field:
((Update)dfa).CurrentSyntax = new UpdateField();
break;
case UpdateFunction.Where:
((Update)dfa).CurrentSyntax = new Where();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, InsertValueFunction> dfa)
{
InsertValue insertField = dfa as InsertValue;
switch (Func)
{
case InsertValueFunction.Value:
if (dfa.CurrentToken.SyntaxType == SyntaxType.NULL)
{
insertField.Value = null;
}
else
{
insertField.Value = dfa.CurrentToken.Text;
}
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, SelectFunction> dfa)
{
switch (Func)
{
case SelectFunction.SelectField:
((Select)dfa).CurrentSyntax = new SelectField();
break;
case SelectFunction.From:
((Select)dfa).CurrentSyntax = new SelectFrom();
break;
case SelectFunction.OrderBy:
((Select)dfa).CurrentSyntax = new OrderBy();
break;
case SelectFunction.Where:
((Select)dfa).CurrentSyntax = new Where();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, TSFQLSentenceFunction> dfa)
{
switch (Func)
{
case TSFQLSentenceFunction.Attribute:
((TSFQLSentence)dfa).CurrentSyntax = new TSFQLAttribute();
break;
case TSFQLSentenceFunction.Select:
((TSFQLSentence)dfa).SentenceType = SentenceType.SELECT;
((TSFQLSentence)dfa).CurrentSyntax = new Select.Select();
break;
case TSFQLSentenceFunction.Delete:
((TSFQLSentence)dfa).SentenceType = SentenceType.DELETE;
((TSFQLSentence)dfa).CurrentSyntax = new Delete.Delete();
break;
case TSFQLSentenceFunction.Update:
((TSFQLSentence)dfa).SentenceType = SentenceType.UPDATE;
((TSFQLSentence)dfa).CurrentSyntax = new Update.Update();
break;
case TSFQLSentenceFunction.Insert:
((TSFQLSentence)dfa).SentenceType = SentenceType.INSERT;
((TSFQLSentence)dfa).CurrentSyntax = new Insert.Insert();
break;
case TSFQLSentenceFunction.Exec:
((TSFQLSentence)dfa).SentenceType = SentenceType.EXEC;
((TSFQLSentence)dfa).CurrentSyntax = new Exec.Exec();
break;
case TSFQLSentenceFunction.CreateTable:
((TSFQLSentence)dfa).SentenceType = SentenceType.CREATETABLE;
((TSFQLSentence)dfa).CurrentSyntax = new CreateTable.CreateTable();
break;
}
}
public override void DoThings(int action, Hubble.Framework.DataStructure.DFA <Hubble.Core.SFQL.LexicalAnalysis.Lexical.Token, WhereStateFunction> dfa)
{
Where where = dfa as Where;
switch (Func)
{
case WhereStateFunction.LBracket:
where.LastLogicFunc = LogicFunc.None;
where.ExpressionTreeStack.Push(where.CurrentExpressionTree);
where.CurrentExpressionTree = new ExpressionTree(null);
break;
case WhereStateFunction.RBracket:
where.LastLogicFunc = LogicFunc.None;
if (where.ExpressionTreeStack.Count <= 0)
{
throw new SyntaxException("Half-baked bracket", where,
new Hubble.Framework.DataStructure.DFAException("Half-baked bracket",
action, -1), dfa.CurrentToken);
}
ExpressionTree upTree = where.ExpressionTreeStack.Pop();
while (where.CurrentExpressionTree.Parent != null)
{
where.CurrentExpressionTree = where.CurrentExpressionTree.Parent;
}
upTree.Expression = where.CurrentExpressionTree;
where.CurrentExpressionTree = upTree;
break;
case WhereStateFunction.Left:
if (where.CurrentExpressionTree.Expression == null)
{
where.CurrentExpressionTree.Expression = new Expression();
}
((Expression) where.CurrentExpressionTree.Expression).Left.Add(dfa.CurrentToken);
break;
case WhereStateFunction.Right:
((Expression) where.CurrentExpressionTree.Expression).Right.Add(dfa.CurrentToken);
break;
case WhereStateFunction.Operator:
((Expression) where.CurrentExpressionTree.Expression).Operator = dfa.CurrentToken;
break;
case WhereStateFunction.AndOr:
switch (dfa.CurrentToken.SyntaxType)
{
case SyntaxType.AND:
if (where.LastLogicFunc == LogicFunc.Or)
{
throw new SyntaxException("And Or can't in same short sentence without bracket. Eg. a > 0 and c < 10 or b > 0 must be a > 0 and c < 10 or (b > 0) ",
where, new Hubble.Framework.DataStructure.DFAException("Half-baked bracket",
action, -1), dfa.CurrentToken);
}
where.LastLogicFunc = LogicFunc.And;
where.CurrentExpressionTree.AndChild = new ExpressionTree(where.CurrentExpressionTree);
where.CurrentExpressionTree = where.CurrentExpressionTree.AndChild;
break;
case SyntaxType.OR:
if (where.LastLogicFunc == LogicFunc.And)
{
throw new SyntaxException("And Or can't in same short sentence without bracket. Eg. a > 0 and c < 10 or b > 0 must be a > 0 and c < 10 or (b > 0) ",
where, new Hubble.Framework.DataStructure.DFAException("Half-baked bracket",
action, -1), dfa.CurrentToken);
}
where.LastLogicFunc = LogicFunc.Or;
where.CurrentExpressionTree.OrChild = new ExpressionTree(where.CurrentExpressionTree);
where.CurrentExpressionTree = where.CurrentExpressionTree.OrChild;
break;
}
break;
case WhereStateFunction.Quit:
if (where.ExpressionTreeStack.Count > 0)
{
throw new SyntaxException("Half-baked bracket", where,
new Hubble.Framework.DataStructure.DFAException("Half-baked bracket",
action, -1), dfa.CurrentToken);
}
break;
}
}
