Deveel.Data.Linq.DeveelDbFormatter Class Reference

Inheritance diagram for Deveel.Data.Linq.DeveelDbFormatter:

Public Member Functions
	DeveelDbFormatter (DeveelDbLanguage language)

Static Public Member Functions
static new string	Format (Expression expression)
static string	Format (Expression expression, DeveelDbLanguage language)

Protected Member Functions
override Expression	VisitSelect (SelectExpression @select)
override string	GetOperator (BinaryExpression b)
override Expression	VisitMethodCall (MethodCallExpression m)
override Expression	VisitMemberAccess (MemberExpression m)

Detailed Description

Definition at line 8 of file DeveelDbFormatter.cs.

Constructor & Destructor Documentation

Deveel.Data.Linq.DeveelDbFormatter.DeveelDbFormatter ( DeveelDbLanguage  language )

inline

Definition at line 9 of file DeveelDbFormatter.cs.

            : base(language) {
        }

Member Function Documentation

static new string Deveel.Data.Linq.DeveelDbFormatter.Format ( Expression  expression )

inlinestatic

Definition at line 13 of file DeveelDbFormatter.cs.

                                                               {
            return Format(expression, new DeveelDbLanguage());
        }

static string Deveel.Data.Linq.DeveelDbFormatter.Format ( Expression  expression, DeveelDbLanguage  language  )

inlinestatic

Definition at line 17 of file DeveelDbFormatter.cs.

                                                                                      {
            var formatter = new DeveelDbFormatter(language);
            formatter.Visit(expression);
            return formatter.ToString();
        }

override string Deveel.Data.Linq.DeveelDbFormatter.GetOperator ( BinaryExpression  b )

inlineprotected

Definition at line 97 of file DeveelDbFormatter.cs.

                                                                  {
            if (b.NodeType == ExpressionType.Add && b.Type == typeof (string))
                return "||";

            return base.GetOperator(b);
        }

override Expression Deveel.Data.Linq.DeveelDbFormatter.VisitMemberAccess ( MemberExpression  m )

inlineprotected

Definition at line 157 of file DeveelDbFormatter.cs.

                                                                            {
            var declaringType = m.Member.DeclaringType;
            if (declaringType == typeof (string)) {
                switch (m.Member.Name) {
                    case "Length": {
                        Write("LENGTH(");
                        Visit(m.Expression);
                        Write(")");
                        return m;
                    }
                }
            } else if (declaringType == typeof (DateTime) ||
                       declaringType == typeof (DateTimeOffset)) {
                switch (m.Member.Name) {
                    case "Day": {
                        Write("DAY(");
                        Visit(m.Expression);
                        Write(")");
                        return m;
                    }
                    case "Year": {
                        Write("YEAR(");
                        Visit(m.Expression);
                        Write(")");
                        return m;
                    }
                    // TODO: Continue with date function
                }
            } else if (declaringType == typeof (TimeSpan)) {
                
            }

            return base.VisitMemberAccess(m);
        }

override Expression Deveel.Data.Linq.DeveelDbFormatter.VisitMethodCall ( MethodCallExpression  m )

inlineprotected

Definition at line 104 of file DeveelDbFormatter.cs.

                                                                              {
            var declaringType = m.Method.DeclaringType;

            if (declaringType == typeof (string)) {
                switch (m.Method.Name) {
                    case "StartsWith": {
                        Visit(m.Object);
                        Write(" LIKE '");
                        Visit(m.Arguments[0]);
                        Write("%'");
                        return m;
                    }
                    case "EndsWith": {
                        Visit(m.Object);
                        Write(" LIKE '%");
                        Visit(m.Arguments[0]);
                        Write("'");
                        return m;
                    }
                    case "Contains": {
                        Visit(m.Object);
                        Write(" LIKE '%");
                        Visit(m.Arguments[0]);
                        Write("%'");
                        return m;
                    }
                    case "Concat": {
                        IList<Expression> args = m.Arguments;
                        if (args.Count == 1 && args[0].NodeType == ExpressionType.NewArrayInit) {
                            args = ((NewArrayExpression) args[0]).Expressions;
                        }
                        for (int i = 0, n = args.Count; i < n; i++) {
                            if (i > 0)
                                Write(" || ");

                            Visit(args[i]);
                        }

                        return m;
                    }
                    case "IsNullOrEmpty": {
                        Visit(m.Arguments[0]);
                        Write(" IS NULL OR ");
                        Visit(m.Arguments[0]);
                        Write(" = ''");
                        return m;
                    }
                }
            }

            return base.VisitMethodCall(m);
        }

override Expression Deveel.Data.Linq.DeveelDbFormatter.VisitSelect ( SelectExpression @  select )

inlineprotected

Definition at line 23 of file DeveelDbFormatter.cs.

                                                                            {
            AddAliases(select.From);

            Write("SELECT ");

            if (select.IsDistinct)
                Write("DISTINCT ");

            WriteColumns(select.Columns);

            if (select.From != null) {
                WriteLine(Indentation.Same);
                Write("FROM ");
                VisitSource(select.From);
            }

            if (select.Where != null && 
                (select.GroupBy == null || select.GroupBy.Count ==0)) {
                WriteLine(Indentation.Same);
                Write("WHERE ");
                VisitPredicate(select.Where);
            }

            if (select.GroupBy != null && select.GroupBy.Count > 0) {
                WriteLine(Indentation.Same);
                Write("GROUP BY ");

                for (int i = 0, n = select.GroupBy.Count; i < n; i++) {
                    if (i > 0) {
                        Write(", ");
                    }

                    VisitValue(select.GroupBy[i]);
                }

                if (select.Where != null) {
                    WriteLine(Indentation.Same);
                    Write("HAVING ");
                    VisitPredicate(select.Where);
                }
            }
            if (select.OrderBy != null && select.OrderBy.Count > 0) {
                WriteLine(Indentation.Same);
                Write("ORDER BY ");

                for (int i = 0, n = select.OrderBy.Count; i < n; i++) {
                    OrderExpression exp = select.OrderBy[i];
                    if (i > 0) {
                        Write(", ");
                    }

                    VisitValue(exp.Expression);

                    if (exp.OrderType != OrderType.Ascending)
                        Write(" DESC");
                }
            }

            if (select.Take != null) {
                WriteLine(Indentation.Same);
                Write("LIMIT ");
                if (select.Skip == null) {
                    Write("0");
                } else {
                    Write(select.Skip);
                }

                Write(", ");
                Visit(select.Take);
            }

            return select;
        }

---

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

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb-linq/Deveel.Data.Linq/DeveelDbFormatter.cs