public string Compile(IWhereFilter filter, SelectQuery selectQuery, IQueryParameterManager parameters)
        {
            var whereFilters = filter as WhereFilterCollection;

            if (!whereFilters.Any())
            {
                return("(1 = 1)");
            }

            var whereCompiler = new WhereFilterCompiler();

            var operatorString = whereFilters.GroupingOperator.ToSqlString();

            var  result = string.Empty;
            bool first  = true;

            foreach (var where in whereFilters)
            {
                result += string.Format("\n\t {0} {1} ",
                                        !first ? operatorString : null,
                                        whereCompiler.Compile(where, selectQuery, parameters)
                                        );

                first = false;
            }

            return(string.Format("({0} \n\t )", result));
        }
Ejemplo n.º 2
0
        public string Compile(IWhereFilter filter, SelectQuery query, IQueryParameterManager parameters)
        {
            var where = filter as ColumnColumnWhereFilter;

            return(string.Format("{0} {1} {2}.{3}",
                                 where.LeftColumn.FullName,
                                 where.Operator.ToSqlString(),
                                 where.RightColumn.TableAlias,
                                 where.RightColumn.Field.Name
                                 ));
        }
        public string Compile(IWhereFilter filter, SelectQuery query, IQueryParameterManager parameters)
        {
            var where = filter as ColumnInWhereFilter;

            var valueString = ValuesCsv(where, parameters);

            return(string.Format("{0} IN ({1})",
                                 where.LeftColumn.FullName,
                                 valueString
                                 ));
        }
Ejemplo n.º 4
0
        public string Compile(IWhereFilter filter, SelectQuery query, IQueryParameterManager parameters)
        {
            var where = filter as ColumnContainsWhereFilter;

            switch (where.ContainsMode)
            {
            case ContainsMode.AllWords:
            case ContainsMode.AllWordsWildcardRight:
            case ContainsMode.AnyWord:
            case ContainsMode.AnyWordWildcardRight:
                return(MultiWord(where, parameters));

            case ContainsMode.Default:
            case ContainsMode.WildcardRight:
                return(SingleWord(where, parameters));

            case ContainsMode.FreeText:
                return(FreeText(where, parameters));
            }

            throw new NotImplementedException();
        }
Ejemplo n.º 5
0
        public string Compile(IWhereFilter filter, SelectQuery query, IQueryParameterManager parameters)
        {
            var where = filter as ColumnValueWhereFilter;

            var valueString = parameters.Parameterize(where.RightValue.Value, where.RightValue.Type, where.ParameterAlias ?? where.LeftColumn.Field.Name);

            if (where.IsNullValue != null)
            {
                string isnullQuotes = where.RightValue.Type.IsStringType() ? "'" : null;

                return(string.Format("ISNULL({0},{1}) {2} {3}",
                                     where.LeftColumn.FullName,
                                     isnullQuotes + where.IsNullValue + isnullQuotes,
                                     where.Operator.ToSqlString(),
                                     valueString
                                     ));
            }

            return(string.Format("{0} {1} {2}",
                                 where.LeftColumn.FullName,
                                 where.Operator.ToSqlString(),
                                 valueString
                                 ));
        }
Ejemplo n.º 6
0
 public string Compile(IWhereFilter filter, SelectQuery query, IQueryParameterManager parameters)
 {
     var where = filter as SqlWhereFilter;
     return(where.Sql);
 }
Ejemplo n.º 7
0
 /// <summary>
 /// Add Not Equal to query
 /// </summary>
 /// <param name="whereFilter">Where Filter instance</param>
 /// <param name="value">Value to filter</param>
 /// <returns></returns>
 public static IComparisonOperators NotEqualTo(this IWhereFilter whereFilter, string value)
 => whereFilter.To <ComparisonOperators>().NotEqualTo(value);
Ejemplo n.º 8
0
 /// <summary>
 /// Add Less Than Or Equal to query
 /// </summary>
 /// <param name="whereFilter">Where Filter instance</param>
 /// <param name="value">Value to filter</param>
 /// <returns></returns>
 public static IComparisonOperators LessThanOrEqualTo(this IWhereFilter whereFilter, int value)
 => whereFilter.To <ComparisonOperators>().LessThanOrEqualTo(value);
Ejemplo n.º 9
0
 /// <summary>
 /// Add Greater Than to query
 /// </summary>
 /// <param name="whereFilter">Where Filter instance</param>
 /// <param name="value">Value to filter</param>
 /// <returns></returns>
 public static IComparisonOperators GreaterThan(this IWhereFilter whereFilter, int value)
 => whereFilter.To <ComparisonOperators>().GreaterThan(value);
Ejemplo n.º 10
0
 public SelectQueryBuilder <T> Where(IWhereFilter where)
 {
     _whereFilter.Add(where);
     return(this);
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Add Equal to query
 /// </summary>
 /// <param name="whereFilter">Where Filter instance</param>
 /// <param name="value">Value to filter</param>
 /// <returns></returns>
 public static IComparisonOperators EqualTo <T>(this IWhereFilter whereFilter, T value)
 => whereFilter is IComparisonOperators command?command.EqualTo <T>(value) : null;