public override void ParseInside(ExpressionParser parser) { var collection = parser.Collection; var lex = collection.CurrentLexem(); if (lex.LexemText.ToLower() != "insert") { throw new Exception("Not INSERT statment"); } lex = collection.GotoNextMust(); if (lex.LexemText.ToLower() != "into") { throw new Exception("INTO keyword is not found"); } lex = collection.GotoNextMust(); string[] tablename = CommonParserFunc.ReadTableName(collection); TableClause = TableClause.CreateByTable(tablename, collection.TableGetter.GetTableByName(tablename, collection.TableGetterUseCache)); lex = collection.GotoNextMust(); if (lex.IsSkobraOpen()) { while (true) { lex = collection.GotoNextMust(); //пропускаем SET или ',' //lex = collection.CurrentLexem(); var col = CommonParserFunc.ReadColumn(collection); ColumnOfValues.Add(col); lex = collection.GotoNextMust(); if (lex == null) { break; } if (lex.LexemType == LexType.Zpt) { continue; } if (lex.IsSkobraClose()) { break; } collection.Error("Unknow lexem", collection.CurrentLexem()); } //пропускаем ')' lex = collection.GotoNextMust(); } else { if (lex.LexemType == LexType.Command && lex.LexemText.ToLower() == "default") { lex = collection.GotoNextMust(); if (lex.LexemType == LexType.Command && lex.LexemText.ToLower() == "values") { DefaultValues = true; return; } else { collection.Error("Expected keyword VALUES", lex); } } } if (lex == null) { return; } if (lex.LexemText.ToLower() == "values") { lex = collection.GotoNextMust(); if (!lex.IsSkobraOpen()) { collection.Error("'(' not found", lex); } while (true) { SubExpression sub = new SubExpression(); sub.MultiValues = true; while (true) { lex = collection.GotoNextMust(); //пропускаем SET или ',' //lex = collection.CurrentLexem(); ExpressionParser e = new ExpressionParser(collection); e.Parse(); sub.AddChild(e.Single()); lex = collection.CurrentLexem(); if (lex == null) { break; } if (lex.LexemType == LexType.Zpt) { continue; } if (lex.IsSkobraClose()) { break; } collection.Error("Unknow lexem", collection.CurrentLexem()); } Values.Add(sub); lex = collection.GotoNext(); if (lex != null && lex.LexemType == LexType.Zpt) { lex = collection.GotoNextMust(); if (!lex.IsSkobraOpen()) { collection.ErrorWaitKeyWord("(", lex); } continue; } else { break; } } } else if (lex.LexemText.ToLower() == "select" || lex.IsSkobraOpen()) { ExpressionParser e = new ExpressionParser(collection); e.Parse(); var expr = e.Single(); var sel = ParserUtils.FindSelect(expr); if (sel == null) { throw new Exception("Values in INSERT not found"); } Select = sel; } ParseReturining(parser); }
public virtual void ParseInside(ExpressionParser parser) { parser.Collection.GotoNext(); }
public Expression GetNode(ExpressionParser parser) { var collection = parser.Collection; Lexem lex = parser.Collection.CurrentLexem(); bool uniar = parser.waitValue; Expression res = null; if (lex.LexemType == LexType.Arfimetic) { switch (lex.LexemText) { case "+": if (uniar) { res = new UniarPlus_BoolExpr(); } else { res = new Plus_Arifmetic(); } break; case "-": if (uniar) { res = new UniarMinus_BoolExpr(); } else { res = new Minus_Arifmetic(); } break; case "*": if (uniar) { res = new AllColumnExpr(); } else { res = new Multi_Arifmetic(); } break; case "/": res = new Div_Arifmetic(); break; case "<": res = new Less_CompExpr(); break; case "<=": res = new LessOrEqual_CompExpr(); break; case ">=": res = new GreatOrEqual_CompExpr(); break; case ">": res = new Great_CompExpr(); break; case "=": res = new Equal_CompExpr(); break; case "<>": case "!=": res = new NotEqual_CompExpr(); break; } } if (lex.LexemType == LexType.Number) { res = new ConstExpr(); if (lex.LexemText.Contains('.')) { (res as ConstExpr).Init(lex.LexemText.ParseDouble(), SimpleTypes.Float); } else { (res as ConstExpr).Init(long.Parse(lex.LexemText), SimpleTypes.Integer); } } if (lex.LexemType == LexType.Text) { if (lex.LexemText.StartsWith("'")) { res = new ConstExpr(); (res as ConstExpr).Init(ParserUtils.StandartDecodeEscape(lex.LexemText), SimpleTypes.String); } } if (lex.LexemType == LexType.Command) { switch (lex.LexemText.ToLower()) { case "not": res = new Not_BoolExpr(); break; case "and": res = new And_BoolExpr(); break; case "or": res = new Or_BoolExpr(); break; case "true": res = new ConstExpr(); (res as ConstExpr).Init(true, SimpleTypes.Boolean); break; case "false": res = new ConstExpr(); (res as ConstExpr).Init(false, SimpleTypes.Boolean); break; case "date": if (collection.GetNext() != null) { var c = collection.GetNext(); if (c.LexemType == LexType.Text && c.LexemText.StartsWith("'")) { res = new ConstExpr(); string s = ParserUtils.StandartDecodeEscape(c.LexemText); var dt = CommonUtils.ParseDateTime(s); if (dt != null) { collection.GotoNext(); ((ConstExpr)res).Init(dt.Value, SimpleTypes.Date); } else { collection.Error("Can not parse date lexem", lex); } } } break; case "datetime": case "timestamp": if (collection.GetNext() != null) { var c = collection.GetNext(); if (c.LexemType == LexType.Text && c.LexemText.StartsWith("'")) { res = new ConstExpr(); string s = ParserUtils.StandartDecodeEscape(c.LexemText); var dt = CommonUtils.ParseDateTime(s); if (dt != null) { collection.GotoNext(); ((ConstExpr)res).Init(dt.Value, SimpleTypes.DateTime); } else { collection.Error("Can not parse datetime lexem", lex); } } } break; case "time": if (collection.GetNext() != null) { var c = collection.GetNext(); if (c.LexemType == LexType.Text && c.LexemText.StartsWith("'")) { res = new ConstExpr(); string s = ParserUtils.StandartDecodeEscape(c.LexemText); DateTime dt; var r = CommonUtils.ParseDateTime(s, out dt); if (r == ParserDateTimeStatus.Time) { collection.GotoNext(); ((ConstExpr)res).Init(dt.TimeOfDay, SimpleTypes.Time); } else { collection.Error("Can not parse time lexem", lex); } } } break; } } return(res); }
public override void ParseInside(ExpressionParser parser) { var collection = parser.Collection; var lex = collection.CurrentLexem(); if (lex.LexemText.ToLower() != "update") { throw new Exception("Not UPDATE statment"); } lex = collection.GotoNextMust(); FromParser fc = new FromParser(); fc.Parse(collection); if (fc.Tables.Count > 1) { collection.Error("Multi tables in update", collection.CurrentLexem()); } if (fc.Tables.Count == 0) { collection.Error("Not table clause", collection.CurrentLexem()); } TableClause = fc.Tables[0]; //string[] tablename = CommonParserFunc.ReadTableName(collection); //TableClause = TableClause.CreateByTable(tablename, collection.TableGetter.GetTableByName(tablename)); //lex = collection.GotoNextMust(); lex = collection.CurrentLexem(); if (lex.LexemText.ToLower() != "set") { collection.Error("SET keyword is not found", collection.CurrentLexem()); } while (true) { lex = collection.GotoNextMust();//пропускаем SET или ',' //lex = collection.CurrentLexem(); SetClause sc = new SetClause(); sc.Column = CommonParserFunc.ReadColumn(collection); lex = collection.GotoNextMust(); if (lex.LexemText != "=") { collection.Error("Operator '=' is not found", collection.CurrentLexem()); } lex = collection.GotoNextMust(); ExpressionParser e = new ExpressionParser(parser.Collection); e.Parse(); sc.Value = e.Single(); Set.Add(sc); lex = collection.CurrentLexem(); if (lex == null) { break; } if (lex.LexemType == LexType.Zpt) { continue; } break; } if (lex == null) { return; } if (lex.LexemText.ToLower() == "where") { collection.GotoNextMust(); ExpressionParser e = new ExpressionParser(parser.Collection); e.Parse(); Where = e.Single(); } ParseReturining(parser); }
public Expression GetNode(ExpressionParser parser) { Lexem lex = parser.Collection.CurrentLexem(); Expression ex = null; bool uniar = parser.waitValue; if (lex.LexemType == LexType.Arfimetic) { switch (lex.LexemText) { case "+": if (uniar) { ex = new UniarPlus_BoolExpr(); } else { ex = new Plus_Arifmetic(); } break; case "-": if (uniar) { ex = new UniarMinus_BoolExpr(); } else { ex = new Minus_Arifmetic(); } break; case "*": if (uniar) { ex = new AllColumnExpr(); } else { ex = new Multi_Arifmetic(); } break; case "/": ex = new Div_Arifmetic(); break; case "<": ex = new Less_CompExpr(); break; case "<=": ex = new LessOrEqual_CompExpr(); break; case ">=": ex = new GreatOrEqual_CompExpr(); break; case ">": ex = new Great_CompExpr(); break; case "=": ex = new Equal_CompExpr(); break; case "<>": case "!=": ex = new NotEqual_CompExpr(); break; } } if (lex.LexemType == LexType.Number) { ex = new ConstExpr(); if (lex.LexemText.Contains('.')) { (ex as ConstExpr).Init(lex.LexemText.ParseDouble(), SimpleTypes.Float); } else { (ex as ConstExpr).Init(long.Parse(lex.LexemText), SimpleTypes.Integer); } } if (lex.LexemType == LexType.Text) { if (lex.LexemText.StartsWith("'")) { ex = new ConstExpr(); (ex as ConstExpr).Init(ParserUtils.StandartDecodeEscape(lex.LexemText), SimpleTypes.String); } } Lexem n1; if (lex.LexemType == LexType.Command) { switch (lex.LexemText.ToLower()) { case "not": n1 = parser.Collection.GetNext(); if (n1 != null && n1.LexemType == LexType.Command && n1.LexemText.ToLower() == "in") { ex = new NotInExpr(); parser.Collection.GotoNext(); break; } ex = new Not_BoolExpr(); break; case "case": ex = new CaseExpr(); break; case "contains": ex = new Contains(); break; case "containsic": //ic = ignore case case "containscase": ex = new ContainsIgnoreCase(); break; case "startwith": case "startswith": ex = new StartsWith(); break; case "endwith": case "endswith": ex = new EndsWith(); break; } if (parser.Collection.GetNext() != null && parser.Collection.GetNext().IsSkobraOpen()) { switch (lex.LexemText.ToLower()) { case "cast": ex = new Cast(); break; case "in": ex = new InExpr(); break; case "abs": ex = new Abs(); break; case "substring": ex = new SubString(); break; case "position": ex = new Position(); break; case "ltrim": ex = new LTrim(); break; case "rtrim": ex = new RTrim(); break; case "trim": ex = new Trim(); break; case "length": ex = new Length(); break; case "upper": ex = new Upper_operation(); break; case "lower": ex = new Lower_operation(); break; case "left": ex = new Left(); break; case "right": ex = new Right(); break; case "replace": ex = new Replace(); break; case "now": ex = new Now(); break; case "tostr": ex = new ToString(); break; case "strtotime": ex = new StrToTime(); break; case "strtodatetime": ex = new StrToDateTime(); break; case "addseconds": ex = new AddSeconds(); break; case "addminutes": ex = new AddMinutes(); break; case "addhours": ex = new AddHours(); break; case "adddays": ex = new AddDays(); break; case "day": ex = new Day(); break; case "month": ex = new Month(); break; case "year": ex = new Year(); break; case "round": ex = new ParserCore.Expr.Extend.Math.Round(); break; case "ceiling": ex = new ParserCore.Expr.Extend.Math.Ceiling(); break; case "floor": ex = new ParserCore.Expr.Extend.Math.Floor(); break; case "pi": ex = new ParserCore.Expr.Extend.Math.Pi(); break; case "tan": ex = new ParserCore.Expr.Extend.Math.Tan(); break; case "log": ex = new ParserCore.Expr.Extend.Math.Log(); break; } } } return(ex); }
public static Expression AddFiled(string fieldAlias, string tableAlias, string schema, Lexem lexem, ExpressionParser parser) { if (fieldAlias == "*") { if (schema != null) { parser.Collection.Error("Can not use schema in * expression", lexem); } AllColumnExpr a = new AllColumnExpr(); a.Prefix = tableAlias; return(a); } FieldExpr res = new FieldExpr(); res.FieldName = fieldAlias; res.TableAlias = tableAlias; res.Schema = schema; res.Lexem = lexem; return(res); }
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 TableClause Read_table_reference(LexemCollection collection, bool isFirst) { var lex = collection.CurrentLexem(); if (lex == null) { return(null); } //+left join //+left outer join //+inner join //+cross join //+join //+right join //+right outer join // full join JoinType jt = JoinType.Cross; if (!isFirst) { string s1 = collection.CurrentLexem().LexemText.ToLower(); string s2 = null; string s3 = null; if (joinStrings.Contains(s1)) { lex = collection.GotoNext(); if (lex != null && joinStrings.Contains(lex.LexemText.ToLower())) { s2 = lex.LexemText.ToLower(); lex = collection.GotoNext(); if (lex != null && joinStrings.Contains(lex.LexemText.ToLower())) { s3 = lex.LexemText.ToLower(); lex = collection.GotoNext(); } } } if (!joinStrings.Contains(s1))// случай "," { jt = JoinType.Cross; } else if ((s3 == null && s2 == null && s1 == "join") || (s3 == null && s1 == "cross" && s2 == "join")) { jt = JoinType.Cross; } else if ((s3 == null && s1 == "left" && s2 == "join") || (s1 == "left" && s2 == "outer" && s3 == "join")) { jt = JoinType.Left; } else if ((s3 == null && s1 == "right" && s2 == "join") || (s1 == "right" && s2 == "outer" && s3 == "join")) { jt = JoinType.Left; } else if (s3 == null && s1 == "inner" && s2 == "join") { jt = JoinType.Inner; } else if (s3 == null && s1 == "full" && s2 == "join") { jt = JoinType.Full; } else { collection.Error("Unknow JOIN clause", collection.CurrentLexem()); } } TableClause st = null; if (lex == null) { collection.Error("Error in table clause", collection.GetPrev()); } if (!lex.IsSkobraOpen()) { string[] tableName = CommonParserFunc.ReadTableName(collection); var v = collection.TableGetter.GetTableByName(tableName, collection.TableGetterUseCache); st = TableClause.CreateByTable(tableName, v); lex = collection.GotoNext(); } else { lex = collection.GotoNext(); if (lex == null) { collection.Error("Expression is not found", collection.GetLast()); } //подзапрос var idx = collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } lex = collection.CurrentLexem(); if (lex == null || !lex.IsSkobraClose()) { collection.Error("Expression is not closed", collection.CurrentLexem()); } lex = collection.GotoNext(); //ITableDesc subselect = CommonUtils.FindParentSelect(tonode.Single()); Это штука работает не правильно ITableDesc subselect = (ITableDesc)tonode.Single(); if (subselect == null) { collection.Error("Subselect not found", collection.Get(idx)); } st = TableClause.CreateBySelect(subselect); } st.Join = jt; if (lex == null) { return(st); } if (lex.LexemText.ToLower() == "as") { collection.GotoNext(); if (lex == null) { collection.Error("Alias not found", collection.GetPrev()); } st.Alias = CommonParserFunc.ReadAlias(collection); if (st.Alias == null) { collection.Error("Alias not found", collection.GetPrev()); } lex = collection.GotoNext(); } else { if (lex.LexemType == LexType.Text) { st.Alias = CommonParserFunc.ReadAlias(collection); if (st.Alias == null) { collection.Error("Alias not found", collection.GetPrev()); } lex = collection.GotoNext(); } else if (lex.LexemType == LexType.Command && !nextStrings.Contains(lex.LexemText.ToLower()) && !joinStrings.Contains(lex.LexemText.ToLower()) && lex.LexemText.ToLower() != "on") { st.Alias = CommonParserFunc.ReadAlias(collection); if (st.Alias == null) { collection.Error("Alias not found", collection.GetPrev()); } lex = collection.GotoNext(); } } lex = collection.CurrentLexem(); if (lex == null) { return(st); } if (lex.LexemType == LexType.Command && lex.LexemText.ToLower() == "on") { lex = collection.GotoNext(); var idx = collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } st.OnExpression = tonode.Single(); } return(st); }
public override void ParseInside(ExpressionParser parser) { var collection = parser.Collection; var le = collection.GotoNextMust(); if (le.LexemType != LexType.Command || le.LexemText.ToLower() != "when") { int idx = collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } CaseArg = tonode.Single(); le = collection.CurrentLexem(); } if (le.LexemType != LexType.Command || le.LexemText.ToLower() != "when") { collection.Error("Ожидалось WHEN", collection.CurrentOrLast()); } while (le.LexemType == LexType.Command && le.LexemText.ToLower() == "when") { WhenThen wt = new WhenThen(); collection.GotoNextMust(); int idx = collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } wt.When = tonode.Single(); le = collection.CurrentLexem(); if (le == null || le.LexemType != LexType.Command || le.LexemText.ToLower() != "then") { collection.Error("ожидалось THEN", collection.CurrentOrLast()); } le = collection.GotoNextMust(); idx = collection.IndexLexem; tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } wt.Then = tonode.Single(); ListWhenThen.Add(wt); le = collection.CurrentLexem(); if (le == null) { collection.Error("Не найден END", collection.GetLast()); } if (le.LexemText.ToLower() == "end") { break; } if (le.LexemText.ToLower() == "when") { continue; } if (le.LexemText.ToLower() == "else") { le = collection.GotoNextMust(); idx = collection.IndexLexem; tonode = new ExpressionParser(collection); tonode.Parse(); if (tonode.Results.Count != 1) { collection.Error("не верное число параметров", collection.Get(idx)); } Else = tonode.Single(); le = collection.CurrentLexem(); if (le == null || le.LexemText.ToLower() != "end") { collection.Error("Ожидался END", collection.CurrentOrLast()); } break; } collection.Error("Не ожиданный конец", collection.CurrentOrLast()); } base.ParseInside(parser); }
public override void Parse() { //текщая лексема SELECT var le = Collection.GotoNext(); if (le == null) Collection.Error("неожиданный конец", Collection.GetPrev()); if (le.LexemText.ToLower() == "distinct") { SelectExpresion.Distinct = true; le = Collection.GotoNextMust(); } else if (le.LexemText.ToLower() == "all") { le = Collection.GotoNextMust(); } var idx = Collection.IndexLexem; ColumnClauseParser colsParser = new ColumnClauseParser(); colsParser.Parse(Collection); if (colsParser.Columns.Count == 0) Collection.Error("Columnn not found", Collection.Get(idx)); Results.Add(SelectExpresion); SelectExpresion.Columns.Replace(colsParser.Columns); var lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() != "from") return; lex = Collection.GotoNext(); FromParser fc = new FromParser(); fc.Parse(Collection); SelectExpresion.Tables.Replace(fc.Tables); lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "where") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Where clause not found", Collection.GetPrev()); idx = Collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(Collection); tonode.Parse(); if (tonode.Results.Count != 1) Collection.Error("не верное число параметров", Collection.Get(idx)); SelectExpresion.WhereExpr = tonode.Single(); } lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "having") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Having clause not found", Collection.GetPrev()); idx = Collection.IndexLexem; ExpressionParser tonode = new ExpressionParser(Collection); tonode.Parse(); if (tonode.Results.Count != 1) Collection.Error("не верное число параметров", Collection.Get(idx)); SelectExpresion.Having = tonode.Single(); } lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "group") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Group by clause error", Collection.GetPrev()); if (lex.LexemText.ToLower() != "by") Collection.Error("Group by clause error", Collection.GetPrev()); lex = Collection.GotoNext(); OrderByParser gb = new OrderByParser(); gb.Parse(Collection, false); SelectExpresion.GroupBys.Replace(gb.Columns); if (SelectExpresion.GroupBys.Count == 0) Collection.Error("\"Group by\" columns not found", Collection.Get(idx)); lex = Collection.CurrentLexem(); } lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "order") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Order by clause error", Collection.GetPrev()); if (lex.LexemText.ToLower() != "by") Collection.ErrorWaitKeyWord("BY", Collection.GetPrev()); lex = Collection.GotoNext(); OrderByParser gb = new OrderByParser(); gb.Parse(Collection, true); SelectExpresion.OrderBys.Replace(gb.Columns.Select(a => (OrderByClause)a).ToList()); if (SelectExpresion.OrderBys.Count == 0) Collection.Error("\"Order by\" columns not found", Collection.Get(idx)); lex = Collection.CurrentLexem(); } lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "limit") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Limit clause not found", Collection.GetPrev()); ExpressionParser tonode = new ExpressionParser(Collection); tonode.Parse(); SelectExpresion.LimitRecords = tonode.Single().GetIntResultOut(null); } lex = Collection.CurrentLexem(); if (lex == null) return; if (lex.LexemText.ToLower() == "offset") { lex = Collection.GotoNext(); if (lex == null) Collection.Error("Offset clause not found", Collection.GetPrev()); ExpressionParser tonode = new ExpressionParser(Collection); tonode.Parse(); SelectExpresion.SkipRecords = tonode.Single().GetIntResultOut(null); } while (true) { lex = Collection.CurrentLexem(); if (lex == null) return; string s = lex.LexemText.ToLower(); if (s == "union" || s == "intersect" || s == "except") { lex = Collection.GotoNextMust(); ExtSelectClause extS = new ExtSelectClause(); extS.Select = new SelectExpresion(); if (s == "union" && lex.LexemText.ToLower() == "all") { extS.Operation = SelectOperation.UnionAll; lex = Collection.GotoNextMust(); } else if (s == "union") extS.Operation = SelectOperation.Union; if (s == "intersect") extS.Operation = SelectOperation.Intersect; if (s == "except") extS.Operation = SelectOperation.Except; if (lex.LexemText.ToLower() != "select") Collection.Error("\"SELECT\" clouse is not found", lex); SelectParser sp = new SelectParser(Collection); sp.SelectExpresion = extS.Select; sp.Parse(); SelectExpresion.ExtSelects.Add(extS); } else break; } }