Пример #1
0
        /// <summary>
        /// Converts <paramref name="filter"/> to <see cref="IWhereClause"/>.
        /// </summary>
        /// <param name="filter">The filter to convert</param>
        /// <returns>A <see cref="IWhereClause"/> equivalent of the given <paramref name="filter"/>.</returns>
        public static IWhereClause ToWhere(this IFilter filter)
        {
            IWhereClause clause = null;

            switch (filter)
            {
            case Filter f:
            {
                ClauseOperator clauseOperator;
                object         value = f.Value;

                switch (f.Operator)
                {
                case FilterOperator.EqualTo:
                    clauseOperator = ClauseOperator.EqualTo;
                    break;

                case FilterOperator.NotEqualTo:
                    clauseOperator = ClauseOperator.NotEqualTo;
                    break;

                case FilterOperator.IsNull:
                    clauseOperator = ClauseOperator.IsNull;
                    break;

                case FilterOperator.IsNotNull:
                    clauseOperator = ClauseOperator.IsNotNull;
                    break;

                case FilterOperator.LessThan:
                    clauseOperator = ClauseOperator.LessThan;
                    break;

                case FilterOperator.LessThanOrEqualTo:
                    clauseOperator = ClauseOperator.LessThanOrEqualTo;
                    break;

                case FilterOperator.GreaterThan:
                    clauseOperator = ClauseOperator.GreaterThan;
                    break;

                case FilterOperator.GreaterThanOrEqual:
                    clauseOperator = ClauseOperator.GreaterThanOrEqualTo;
                    break;

                case FilterOperator.StartsWith:
                case FilterOperator.EndsWith:
                case FilterOperator.Contains:
                    clauseOperator = ClauseOperator.Like;
                    if (f.Operator == FilterOperator.StartsWith)
                    {
                        value = $"{value}%";
                    }
                    else if (f.Operator == FilterOperator.EndsWith)
                    {
                        value = $"%{value}";
                    }
                    else
                    {
                        value = $"%{value}%";
                    }
                    break;

                case FilterOperator.NotStartsWith:
                case FilterOperator.NotEndsWith:
                case FilterOperator.NotContains:
                    clauseOperator = ClauseOperator.NotLike;
                    if (f.Operator == FilterOperator.NotStartsWith)
                    {
                        value = $"{value}%";
                    }
                    else if (f.Operator == FilterOperator.NotEndsWith)
                    {
                        value = $"%{value}";
                    }
                    else
                    {
                        value = $"%{value}%";
                    }
                    break;

                default:
                    throw new NotSupportedException($"Unsupported {f.Operator} operator");
                }

                clause = new WhereClause(f.Field.Field(), clauseOperator, value switch
                    {
                        bool b => b.Literal(),
                        DateTime date => date.Literal(),
                        string s => s.Literal(),
                        null => null,
                        long l => l.Literal(),
                        float floatValue => floatValue.Literal(),
                        decimal decimalValue => decimalValue.Literal(),
                        double doubleValue => doubleValue.Literal(),
                        int intValue => intValue.Literal(),
#if NET6_0_OR_GREATER
                        DateOnly date => date.Literal(),
                        TimeOnly time => time.Literal(),
#endif
                        _ => throw new NotSupportedException($"Unexpected '{value?.GetType().Name}' type when building WhereClause")
                    }
                                         );
                break;
            }
Пример #2
0
 /// <summary>
 /// Builds a new <see cref="WhereClause"/> instance with a <see cref="DateOnly"/> constraint.
 /// </summary>
 /// <param name="column"><see cref="IColumn"/> where to apply the clause onto</param>
 /// <param name="operator"><see cref="ClauseOperator"/> to apply</param>
 /// <param name="constraint">constraint to apply to <paramref name="column"/>.</param>
 /// <exception cref="ArgumentNullException">if <paramref name="column"/> is <c>null</c>.</exception>
 public WhereClause(IColumn column, ClauseOperator @operator, DateOnly?constraint) : this(column, @operator, constraint?.Literal())
 {
 }