Deveel.Data.Sql.Parser.ExpressionBuilder Class Reference

Static Public Member Functions
static SqlExpression	Build (IExpressionNode node)

Static Private Member Functions
static SqlExpression	VisitVariableRefExpression (SqlVariableRefExpressionNode node)
static SqlExpression	VisitTupleExpression (SqlExpressionTupleNode node)
static SqlExpression	VisitQueryExpression (SqlQueryExpressionNode node)
static CompositeFunction	GetCompositeFunction (string s)
static void	SetFromTableInClause (FromClause clause, IFromSourceNode source, JoinNode join)
static void	AddSourceToClause (FromClause clause, IFromSourceNode source)
static JoinType	GetJoinType (string typeName)
static void	SetFromClause (FromClause clause, FromClauseNode node)
static IEnumerable< SelectColumn >	GetSelectColumns (SqlQueryExpressionNode node)
static SqlExpression	VisitCaseExpression (SqlCaseExpressionNode expressionNode)
static SqlExpression	VisitConstantExpression (SqlConstantExpressionNode expressionNode)
static SqlExpression	VisitReferenceExpression (SqlReferenceExpressionNode node)
static SqlExpression	VisitFunctionCall (SqlFunctionCallExpressionNode node)
static SqlExpression	VisitBetweenExpression (SqlBetweenExpressionNode expressionNode)
static SqlExpression	VisitBinaryExpression (SqlBinaryExpressionNode expressionNode)
static SqlExpressionType	GetBinaryExpressionType (string op)
static SqlExpression	VisitUnaryExpression (SqlUnaryExpressionNode expressionNode)
static SqlExpressionType	GetUnaryExpressionType (string op)

Detailed Description

Definition at line 26 of file ExpressionBuilder.cs.

Member Function Documentation

static void Deveel.Data.Sql.Parser.ExpressionBuilder.AddSourceToClause ( FromClause  clause, IFromSourceNode  source  )

inlinestaticprivate

Definition at line 124 of file ExpressionBuilder.cs.

                                                                                         {
            string alias = null;
            if (source.Alias != null)
                alias = source.Alias.Text;

            if (source is FromTableSourceNode) {
                var tableSource = (FromTableSourceNode)source;
                clause.AddTable(alias, tableSource.TableName.Name);
            } else if (source is FromQuerySourceNode) {
                var querySource = (FromQuerySourceNode)source;
                var queryExpression = (SqlQueryExpression) Build(querySource.Query);
                clause.AddSubQuery(alias, queryExpression);
            }
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.Build ( IExpressionNode  node )

inlinestatic

Definition at line 27 of file ExpressionBuilder.cs.

                                                                {
            if (node is SqlVariableRefExpressionNode)
                return VisitVariableRefExpression((SqlVariableRefExpressionNode) node);
            if (node is SqlExpressionTupleNode)
                return VisitTupleExpression((SqlExpressionTupleNode) node);
            if (node is SqlQueryExpressionNode)
                return VisitQueryExpression((SqlQueryExpressionNode) node);
            if (node is SqlCaseExpressionNode)
                return VisitCaseExpression((SqlCaseExpressionNode) node);
            if (node is SqlConstantExpressionNode)
                return VisitConstantExpression((SqlConstantExpressionNode) node);
            if (node is SqlFunctionCallExpressionNode)
                return VisitFunctionCall((SqlFunctionCallExpressionNode) node);
            if (node is SqlReferenceExpressionNode)
                return VisitReferenceExpression((SqlReferenceExpressionNode) node);
            if (node is SqlBinaryExpressionNode)
                return VisitBinaryExpression((SqlBinaryExpressionNode) node);
            if (node is SqlUnaryExpressionNode)
                return VisitUnaryExpression((SqlUnaryExpressionNode) node);
            if (node is SqlBetweenExpressionNode)
                return VisitBetweenExpression((SqlBetweenExpressionNode) node);

            throw new NotSupportedException();
        }

static SqlExpressionType Deveel.Data.Sql.Parser.ExpressionBuilder.GetBinaryExpressionType ( string  op )

inlinestaticprivate

Definition at line 248 of file ExpressionBuilder.cs.

                                                                            {
            if (op == "+" ||
                op == "||")
                return SqlExpressionType.Add;
            if (op == "-")
                return SqlExpressionType.Subtract;
            if (op == "*")
                return SqlExpressionType.Multiply;
            if (op == "/")
                return SqlExpressionType.Divide;
            if (op == "%" ||
                String.Equals(op, "MOD", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.Modulo;
            if (op == "=")
                return SqlExpressionType.Equal;
            if (op == "<>")
                return SqlExpressionType.NotEqual;
            if (op == ">")
                return SqlExpressionType.GreaterThan;
            if (op == ">=")
                return SqlExpressionType.GreaterOrEqualThan;
            if (op == "<")
                return SqlExpressionType.SmallerThan;
            if (op == "<=")
                return SqlExpressionType.SmallerOrEqualThan;
            if (String.Equals(op, "LIKE", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.Like;
            if (String.Equals(op, "NOT LIKE", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.NotLike;

            if (String.Equals(op, "IS", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.Is;
            if (String.Equals(op, "IS NOT", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.IsNot;

            if (String.Equals(op, "AND", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.And;
            if (String.Equals(op, "OR", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.Or;

            if (String.Equals(op, "IN", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.AnyEqual;
            if (String.Equals(op, "NOT IN", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.AllNotEqual;

            throw new ArgumentException(String.Format("The operator {0} is not a binary one.", op));
        }

static CompositeFunction Deveel.Data.Sql.Parser.ExpressionBuilder.GetCompositeFunction ( string  s )

inlinestaticprivate

Definition at line 95 of file ExpressionBuilder.cs.

                                                                        {
            if (String.Equals(s, "UNION", StringComparison.OrdinalIgnoreCase))
                return CompositeFunction.Union;
            if (String.Equals(s, "EXCEPT", StringComparison.OrdinalIgnoreCase))
                return CompositeFunction.Except;
            if (String.Equals(s, "INTERSECT", StringComparison.OrdinalIgnoreCase))
                return CompositeFunction.Intersect;
            
            throw new InvalidOperationException(String.Format("Composite function {0} is invalid.", s));
        }

static JoinType Deveel.Data.Sql.Parser.ExpressionBuilder.GetJoinType ( string  typeName )

inlinestaticprivate

Definition at line 139 of file ExpressionBuilder.cs.

                                                             {
            if (String.Equals(typeName, "INNER", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "INNER JOIN", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, ",", StringComparison.OrdinalIgnoreCase))
                return JoinType.Inner;
            if (String.Equals(typeName, "LEFT OUTER", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "LFT OUTER JOIN", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "LEFT", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "LFT JOIN", StringComparison.OrdinalIgnoreCase))
                return JoinType.Left;
            if (String.Equals(typeName, "RIGHT OUTER", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "RIGHT OUTER JOIN", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "RIGHT", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(typeName, "RIGHT JOIN", StringComparison.OrdinalIgnoreCase))
                return JoinType.Right;

            return JoinType.None;
        }

static IEnumerable<SelectColumn> Deveel.Data.Sql.Parser.ExpressionBuilder.GetSelectColumns ( SqlQueryExpressionNode  node )

inlinestaticprivate

Definition at line 162 of file ExpressionBuilder.cs.

                                                                                               {
            if (node.IsAll) {
                return new[] {new SelectColumn(SqlExpression.Reference(new ObjectName("*")))};
            }

            var items = new List<SelectColumn>();
            foreach (var item in node.SelectItems) {
                SqlExpression exp;
                if (item.Name != null) {
                    exp = SqlExpression.Reference(ObjectName.Parse(item.Name.Name));
                } else if (item.Expression != null) {
                    exp = Build(item.Expression);
                } else {
                    throw new InvalidOperationException();
                }

                string alias = null;
                if (item.Alias != null)
                    alias = item.Alias.Text;

                items.Add(new SelectColumn(exp, alias));
            }

            return items.ToArray();
        }

static SqlExpressionType Deveel.Data.Sql.Parser.ExpressionBuilder.GetUnaryExpressionType ( string  op )

inlinestaticprivate

Definition at line 303 of file ExpressionBuilder.cs.

                                                                           {
            if (op == "+")
                return SqlExpressionType.UnaryPlus;
            if (op == "-")
                return SqlExpressionType.Negate;
            if (String.Equals(op, "NOT", StringComparison.OrdinalIgnoreCase))
                return SqlExpressionType.Not;

            throw new ArgumentException(String.Format("The operator {0} is not a unary one.", op));
        }

static void Deveel.Data.Sql.Parser.ExpressionBuilder.SetFromClause ( FromClause  clause, FromClauseNode  node  )

inlinestaticprivate

Definition at line 158 of file ExpressionBuilder.cs.

                                                                                  {
            SetFromTableInClause(clause, node.Source, node.Join);
        }

static void Deveel.Data.Sql.Parser.ExpressionBuilder.SetFromTableInClause ( FromClause  clause, IFromSourceNode  source, JoinNode  join  )

inlinestaticprivate

Definition at line 106 of file ExpressionBuilder.cs.

                                                                                                           {
            AddSourceToClause(clause, source);

            if (join != null) {
                var joinType = JoinType.Inner;
                if (!String.IsNullOrEmpty(join.JoinType))
                    joinType = GetJoinType(join.JoinType);

                SqlExpression onExpression = null;
                if (join.OnExpression != null)
                    onExpression = Build(join.OnExpression);

                clause.Join(joinType, onExpression);

                SetFromTableInClause(clause, join.Source, join.NextJoin);
            }
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitBetweenExpression ( SqlBetweenExpressionNode  expressionNode )

inlinestaticprivate

Definition at line 222 of file ExpressionBuilder.cs.

                                                                                                     {
            var testExp = Build(expressionNode.Expression);
            var minValue = Build(expressionNode.MinValue);
            var maxValue = Build(expressionNode.MaxValue);

            var smallerExp = SqlExpression.SmallerOrEqualThan(testExp, maxValue);
            var greaterExp = SqlExpression.GreaterOrEqualThan(testExp, minValue);

            SqlExpression exp = SqlExpression.And(smallerExp, greaterExp);

            if (expressionNode.Not)
                exp = SqlExpression.Not(exp);

            return exp;
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitBinaryExpression ( SqlBinaryExpressionNode  expressionNode )

inlinestaticprivate

Definition at line 238 of file ExpressionBuilder.cs.

                                                                                                   {
            var left = Build(expressionNode.Left);
            var right = Build(expressionNode.Right);
            var op = expressionNode.Operator;

            var expType = GetBinaryExpressionType(op);

            return SqlExpression.Binary(left, expType, right);
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitCaseExpression ( SqlCaseExpressionNode  expressionNode )

inlinestaticprivate

Definition at line 188 of file ExpressionBuilder.cs.

                                                                                               {
            throw new NotImplementedException();
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitConstantExpression ( SqlConstantExpressionNode  expressionNode )

inlinestaticprivate

Definition at line 192 of file ExpressionBuilder.cs.

                                                                                                       {
            var sqlValue = expressionNode.Value;
            DataObject obj;
            if (sqlValue is SqlString) {
                obj = DataObject.VarChar((SqlString) sqlValue);
            } else if (sqlValue is SqlBoolean) {
                obj = DataObject.Boolean((SqlBoolean) sqlValue);
            } else if (sqlValue is SqlNumber) {
                obj = DataObject.Number((SqlNumber) sqlValue);
            } else if (sqlValue is SqlNull) { 
                obj = DataObject.Null();
            } else {
                throw new NotSupportedException("Constant value not supported.");
            }

            return SqlExpression.Constant(obj);
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitFunctionCall ( SqlFunctionCallExpressionNode  node )

inlinestaticprivate

Definition at line 214 of file ExpressionBuilder.cs.

                                                                                           {
            var args = new List<SqlExpression>();
            if (node.Arguments != null)
                args.AddRange(node.Arguments.Select(Build));

            return SqlExpression.FunctionCall(node.FunctionName, args.ToArray());
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitQueryExpression ( SqlQueryExpressionNode  node )

inlinestaticprivate

Definition at line 60 of file ExpressionBuilder.cs.

                                                                                       {
            var selectColumns = GetSelectColumns(node);
            var exp = new SqlQueryExpression(selectColumns);

            if (node.FromClause != null) {
                SetFromClause(exp.FromClause, node.FromClause);
            }

            if (node.WhereExpression != null) {
                exp.WhereExpression = Build(node.WhereExpression);
            }

            if (node.GroupBy != null) {
                var groupBy = new List<SqlExpression>();
                if (node.GroupBy.GroupExpressions != null)
                    groupBy.AddRange(node.GroupBy.GroupExpressions.Select(Build));

                exp.GroupBy = groupBy.ToList();

                var having = node.GroupBy.HavingExpression;
                if (having != null)
                    exp.HavingExpression = Build(having);

            }

            if (node.Composite != null) {
                var compositeExp = Build(node.Composite.QueryExpression);
                exp.NextComposite = compositeExp as SqlQueryExpression;
                exp.IsCompositeAll = node.Composite.IsAll;
                exp.CompositeFunction = GetCompositeFunction(node.Composite.CompositeFunction);
            }

            return exp;
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitReferenceExpression ( SqlReferenceExpressionNode  node )

inlinestaticprivate

Definition at line 210 of file ExpressionBuilder.cs.

                                                                                               {
            return SqlExpression.Reference(ObjectName.Parse(node.Reference.Name));
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitTupleExpression ( SqlExpressionTupleNode  node )

inlinestaticprivate

Definition at line 56 of file ExpressionBuilder.cs.

                                                                                       {
            return SqlExpression.Tuple(node.Expressions.Select(Build).ToArray());
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitUnaryExpression ( SqlUnaryExpressionNode  expressionNode )

inlinestaticprivate

Definition at line 296 of file ExpressionBuilder.cs.

                                                                                                 {
            var expressionType = GetUnaryExpressionType(expressionNode.Operator);
            var operand = Build(expressionNode.Operand);

            return SqlExpression.Unary(expressionType, operand);
        }

static SqlExpression Deveel.Data.Sql.Parser.ExpressionBuilder.VisitVariableRefExpression ( SqlVariableRefExpressionNode  node )

inlinestaticprivate

Definition at line 52 of file ExpressionBuilder.cs.

                                                                                                   {
            return SqlExpression.VariableReference(node.Variable);
        }

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Parser/ExpressionBuilder.cs