Exemple #1
0
        private SqlNode ParseSelectItemAlias()
        {
            SqlNode node = new SqlNode(SqlNodeType.SelectItemAlias);

            switch (this._token.Type)
            {
            case SqlTokenType.AS:
            {
                node.Nodes.Add(ParseAS());
                node.Nodes.Add(ParseIDENTIFIER());
                return(node);
            }

            case SqlTokenType.IDENTIFIER:
            {
                node.Nodes.Add(ParseIDENTIFIER());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #2
0
        private SqlNode ParseLogicalOperator()
        {
            SqlNode node = new SqlNode(SqlNodeType.LogicalOperator);

            switch (this._token.Type)
            {
            case SqlTokenType.AND:
            {
                node.Nodes.Add(ParseAND());
                return(node);
            }

            case SqlTokenType.OR:
            {
                node.Nodes.Add(ParseOR());
                return(node);
            }

            case SqlTokenType.NOT:
            {
                node.Nodes.Add(ParseNOT());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #3
0
        private SqlNode ParseJoinList()
        {
            SqlNode node = new SqlNode(SqlNodeType.JoinList);

            switch (this._token.Type)
            {
            case SqlTokenType.INNER:
            {
                node.Nodes.Add(ParseINNER());
                node.Nodes.Add(ParseJOIN());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseTableTail());
                node.Nodes.Add(ParseON());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseComparisonOperator());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseJoinList());
                return(node);
            }

            case SqlTokenType.LEFT:
            {
                node.Nodes.Add(ParseLEFT());
                node.Nodes.Add(ParseOUTER());
                node.Nodes.Add(ParseJOIN());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseTableTail());
                node.Nodes.Add(ParseON());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseComparisonOperator());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseJoinList());
                return(node);
            }

            case SqlTokenType.RIGHT:
            {
                node.Nodes.Add(ParseRIGHT());
                node.Nodes.Add(ParseOUTER());
                node.Nodes.Add(ParseJOIN());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseTableTail());
                node.Nodes.Add(ParseON());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseComparisonOperator());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseJoinList());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #4
0
 protected override object EvaluateSelectUnionStatementTail(SqlNode node)
 {
     if (node.Nodes[1].Nodes.Count == 0)
     {
         return(this.Evaluate(node.Nodes[0]));
     }
     else
     {
         return(new UnionStatement(this.Evaluate(node.Nodes[0]), this.Evaluate(node.Nodes[1].Nodes[1])));
     }
 }
Exemple #5
0
        private SqlNode ParseComparisonOperator()
        {
            SqlNode node = new SqlNode(SqlNodeType.ComparisonOperator);

            switch (this._token.Type)
            {
            case SqlTokenType.EQUALS:
            {
                node.Nodes.Add(ParseEQUALS());
                return(node);
            }

            case SqlTokenType.GREATER_THAN:
            {
                node.Nodes.Add(ParseGREATER_THAN());
                return(node);
            }

            case SqlTokenType.GREATER_THAN_OR_EQUAL:
            {
                node.Nodes.Add(ParseGREATER_THAN_OR_EQUAL());
                return(node);
            }

            case SqlTokenType.LESS_THAN:
            {
                node.Nodes.Add(ParseLESS_THAN());
                return(node);
            }

            case SqlTokenType.LESS_THAN_OR_EQUAL:
            {
                node.Nodes.Add(ParseLESS_THAN_OR_EQUAL());
                return(node);
            }

            case SqlTokenType.NOT_EQUALS:
            {
                node.Nodes.Add(ParseNOT_EQUALS());
                return(node);
            }

            case SqlTokenType.LIKE:
            {
                node.Nodes.Add(ParseLIKE());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #6
0
 private SqlNode ParseLESS_THAN_OR_EQUAL()
 {
     if (this._token.Type == SqlTokenType.LESS_THAN_OR_EQUAL)
     {
         SqlNode node = new SqlNode(SqlNodeType.LESS_THAN_OR_EQUAL, this._token.Value);
         this._token = this._tokenizer.Tokenize(this._reader);
         return(node);
     }
     else
     {
         throw new System.Exception("Syntax error.");
     }
 }
Exemple #7
0
 private SqlNode ParseCOMMA()
 {
     if (this._token.Type == SqlTokenType.COMMA)
     {
         SqlNode node = new SqlNode(SqlNodeType.COMMA, this._token.Value);
         this._token = this._tokenizer.Tokenize(this._reader);
         return(node);
     }
     else
     {
         throw new System.Exception("Syntax error.");
     }
 }
Exemple #8
0
        protected override object EvaluateCOMMAIDENTIFIERGroupByTail(SqlNode node)
        {
            List <Identifier> columns = new List <Identifier>();

            columns.Add((Identifier)this.Evaluate(node.Nodes[1]));
            if (node.Nodes[2].Nodes.Count > 0)
            {
                foreach (Identifier column in (List <Identifier>) this.Evaluate(node.Nodes[2]))
                {
                    columns.Add(column);
                }
            }
            return(columns);
        }
Exemple #9
0
        protected override object EvaluateCOMMAVALUEFunctionParameterListTail(SqlNode node)
        {
            List <object> functionParameters = new List <object>();

            functionParameters.Add(this.Evaluate(node.Nodes[1]));
            if (node.Nodes[2].Nodes.Count > 0)
            {
                foreach (object functionParameter in (List <object>) this.Evaluate(node.Nodes[2]))
                {
                    functionParameters.Add(functionParameter);
                }
            }
            return(functionParameters);
        }
Exemple #10
0
        protected override object EvaluateCOMMASelectItemSelectListTail(SqlNode node)
        {
            List <object> columns = new List <object>();

            columns.Add(this.Evaluate(node.Nodes[1]));
            if (node.Nodes[2].Nodes.Count > 0)
            {
                foreach (object column in (List <object>) this.Evaluate(node.Nodes[2]))
                {
                    columns.Add(column);
                }
            }
            return(columns);
        }
Exemple #11
0
        protected override object EvaluateCOMMAIDENTIFIERColumnListTail(SqlNode node)
        {
            Identifier column = (Identifier)Evaluate(node.Nodes[1]);

            if (node.Nodes[2].Nodes.Count == 0)
            {
                return(new Identifier[] { column });
            }
            else
            {
                Identifier[] columns = (Identifier[])Evaluate(node.Nodes[2]);
                return(cons(column, columns));
            }
        }
Exemple #12
0
        protected override object EvaluateCOMMAVALUEValueListTail(SqlNode node)
        {
            object value = Evaluate(node.Nodes[1]);

            if (node.Nodes[2].Nodes.Count == 0)
            {
                return(new object[] { value });
            }
            else
            {
                object[] values = (object[])Evaluate(node.Nodes[2]);
                return(cons(value, values));
            }
        }
Exemple #13
0
        protected override object EvaluateIDENTIFIERPredicateIdentifierTail(SqlNode node)
        {
            Predicate predicate = new Predicate((string)this.Evaluate(node.Nodes[1].Nodes[0]), this.Evaluate(node.Nodes[0]), this.Evaluate(node.Nodes[1].Nodes[1]));

            if (node.Nodes[1].Nodes[0].Value == "BETWEEN")
            {
                predicate = new Predicate("AND", predicate, this.Evaluate(node.Nodes[1].Nodes[3]));
            }
            else if (node.Nodes[1].Nodes[2].Nodes.Count > 0)
            {
                string    op         = (string)this.Evaluate(node.Nodes[1].Nodes[2].Nodes[0]);
                Predicate predicate2 = (Predicate)this.Evaluate(node.Nodes[1].Nodes[2].Nodes[1]);
                predicate = new Predicate(op, predicate, predicate2);
            }
            return(predicate);
        }
Exemple #14
0
        protected override object EvaluateCOMMAIDENTIFIERAscDescOrderByTail(SqlNode node)
        {
            List <Sort> sorts  = new List <Sort>();
            Identifier  column = (Identifier)this.Evaluate(node.Nodes[1]);
            bool        asc    = (node.Nodes[2].Nodes.Count == 0) ? true : (bool)this.Evaluate(node.Nodes[2]);

            sorts.Add(new Sort(column, asc));
            if (node.Nodes[3].Nodes.Count > 0)
            {
                foreach (Sort sort in (List <Sort>) this.Evaluate(node.Nodes[3]))
                {
                    sorts.Add(sort);
                }
            }
            return(sorts);
        }
Exemple #15
0
        private SqlNode ParseStatementTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.StatementTail);

            switch (this._token.Type)
            {
            case SqlTokenType.SEMICOLON:
            {
                node.Nodes.Add(ParseSEMICOLON());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #16
0
        protected override object EvaluateIDENTIFIERSelectItemTailSelectItemAlias(SqlNode node)
        {
            object column = this.Evaluate(node.Nodes[0]);

            if (node.Nodes[1].Nodes.Count == 3 && node.Nodes[1].Nodes[0].Type == SqlNodeType.LEFT_PAREN && node.Nodes[1].Nodes[2].Type == SqlNodeType.RIGHT_PAREN)
            {
                column = new Function((Identifier)column, (List <object>) this.Evaluate(node.Nodes[1].Nodes[1]));
            }
            if (node.Nodes[2].Nodes.Count == 1)
            {
                column = new Alias(column, (Identifier)this.Evaluate(node.Nodes[2].Nodes[0]));
            }
            else if (node.Nodes[2].Nodes.Count == 2)
            {
                column = new Alias(column, (Identifier)this.Evaluate(node.Nodes[2].Nodes[1]));
            }
            return(column);
        }
Exemple #17
0
        private SqlNode ParseTableTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.TableTail);

            switch (this._token.Type)
            {
            case SqlTokenType.IDENTIFIER:
            {
                node.Nodes.Add(ParseIDENTIFIER());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #18
0
        private SqlNode ParseSelectList()
        {
            SqlNode node = new SqlNode(SqlNodeType.SelectList);

            switch (this._token.Type)
            {
            case SqlTokenType.IDENTIFIER:
            {
                node.Nodes.Add(ParseSelectItem());
                node.Nodes.Add(ParseSelectListTail());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #19
0
        private SqlNode ParsePredicate()
        {
            SqlNode node = new SqlNode(SqlNodeType.Predicate);

            switch (this._token.Type)
            {
            case SqlTokenType.IDENTIFIER:
            {
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParsePredicateIdentifierTail());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #20
0
        private SqlNode ParseFrom()
        {
            SqlNode node = new SqlNode(SqlNodeType.From);

            switch (this._token.Type)
            {
            case SqlTokenType.FROM:
            {
                node.Nodes.Add(ParseFROM());
                node.Nodes.Add(ParseTableList());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #21
0
        protected override object EvaluateCOMMAIDENTIFIERTableTailTableListTail(SqlNode node)
        {
            List <object> tables = new List <object>();
            object        table  = this.Evaluate(node.Nodes[1]);

            if (node.Nodes[2].Nodes.Count > 0)
            {
                table = new Alias(table, (Identifier)this.Evaluate(node.Nodes[2]));
            }
            tables.Add(table);
            if (node.Nodes[3].Nodes.Count > 0)
            {
                foreach (object table2 in (List <object>) this.Evaluate(node.Nodes[3]))
                {
                    tables.Add(table2);
                }
            }
            return(tables);
        }
Exemple #22
0
        private SqlNode ParseWhereClause()
        {
            SqlNode node = new SqlNode(SqlNodeType.WhereClause);

            switch (this._token.Type)
            {
            case SqlTokenType.WHERE:
            {
                node.Nodes.Add(ParseWHERE());
                node.Nodes.Add(ParsePredicate());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #23
0
        private SqlNode ParseUnion()
        {
            SqlNode node = new SqlNode(SqlNodeType.Union);

            switch (this._token.Type)
            {
            case SqlTokenType.UNION:
            {
                node.Nodes.Add(ParseUNION());
                node.Nodes.Add(ParseSelect());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #24
0
        private SqlNode ParseVALUE()
        {
            SqlNode node = new SqlNode(SqlNodeType.VALUE);

            switch (this._token.Type)
            {
            case SqlTokenType.INTEGER:
            {
                node.Nodes.Add(ParseINTEGER());
                return(node);
            }

            case SqlTokenType.FLOAT:
            {
                node.Nodes.Add(ParseFLOAT());
                return(node);
            }

            case SqlTokenType.IDENTIFIER:
            {
                node.Nodes.Add(ParseIDENTIFIER());
                return(node);
            }

            case SqlTokenType.QUOTED_STRING:
            {
                node.Nodes.Add(ParseQUOTED_STRING());
                return(node);
            }

            case SqlTokenType.DATE:
            {
                node.Nodes.Add(ParseDATE());
                return(node);
            }

            default:
            {
                throw new System.Exception("Syntax error.");
            }
            }
        }
Exemple #25
0
        private SqlNode ParseValueListTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.ValueListTail);

            switch (this._token.Type)
            {
            case SqlTokenType.COMMA:
            {
                node.Nodes.Add(ParseCOMMA());
                node.Nodes.Add(ParseVALUE());
                node.Nodes.Add(ParseValueListTail());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #26
0
        private SqlNode ParseSelectItemTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.SelectItemTail);

            switch (this._token.Type)
            {
            case SqlTokenType.LEFT_PAREN:
            {
                node.Nodes.Add(ParseLEFT_PAREN());
                node.Nodes.Add(ParseFunctionParameterList());
                node.Nodes.Add(ParseRIGHT_PAREN());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #27
0
        private SqlNode ParseColumnListTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.ColumnListTail);

            switch (this._token.Type)
            {
            case SqlTokenType.COMMA:
            {
                node.Nodes.Add(ParseCOMMA());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseColumnListTail());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #28
0
        private SqlNode ParsePredicateTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.PredicateTail);

            switch (this._token.Type)
            {
            case SqlTokenType.AND:
            case SqlTokenType.NOT:
            case SqlTokenType.OR:
            {
                node.Nodes.Add(ParseLogicalOperator());
                node.Nodes.Add(ParsePredicate());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #29
0
        private SqlNode ParseGroupByClause()
        {
            SqlNode node = new SqlNode(SqlNodeType.GroupByClause);

            switch (this._token.Type)
            {
            case SqlTokenType.GROUP:
            {
                node.Nodes.Add(ParseGROUP());
                node.Nodes.Add(ParseBY());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseGroupByTail());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }
Exemple #30
0
        private SqlNode ParseSetListTail()
        {
            SqlNode node = new SqlNode(SqlNodeType.SetListTail);

            switch (this._token.Type)
            {
            case SqlTokenType.COMMA:
            {
                node.Nodes.Add(ParseCOMMA());
                node.Nodes.Add(ParseIDENTIFIER());
                node.Nodes.Add(ParseComparisonOperator());
                node.Nodes.Add(ParseVALUE());
                node.Nodes.Add(ParseSetListTail());
                return(node);
            }

            default:
            {
                return(node);
            }
            }
        }