예제 #1
0
        static void Main(string[] args)
        {
            var optionsBuilder = new DbContextOptionsBuilder <AdventureWorksContext>();

            optionsBuilder.UseSqlServer(Settings.Adventure);
            AdventureWorksContext context = new AdventureWorksContext(optionsBuilder.Options);

            new IntroAnimation().Play();

            History history = new History(context);

            history.Presenter();

            LanguageSupport language = new LanguageSupport(context);

            language.Presenter();

            QueryOperators queryOperators = new QueryOperators();

            queryOperators.Presenter();

            DeferredExecution deferred = new DeferredExecution(context);

            deferred.Presenter();

            Performance perf = new Performance(context);

            perf.PerformancePresenter();

            Console.ReadLine();
        }
예제 #2
0
        /// <summary>
        /// Converts a QueryOperator to a string
        /// </summary>
        public static string ToQuery(this QueryOperators qe)
        {
            switch (qe)
            {
            case QueryOperators.Equals:
                return("=");

            case QueryOperators.NotEqualTo:
                return("<>");

            case QueryOperators.GreaterThan:
                return(">");

            case QueryOperators.GreaterThanOrEqualTo:
                return(">=");

            case QueryOperators.LessThan:
                return("<");

            case QueryOperators.LessThanOrEqualTo:
                return("<=");

            case QueryOperators.Like:
                return("LIKE");

            case QueryOperators.NotLike:
                return("NOT LIKE");

            case QueryOperators.IsNot:
                return("IS NOT");

            case QueryOperators.Is:
                return("IS");

            case QueryOperators.In:
                return("IN");

            case QueryOperators.NotIn:
                return("NOT IN");

            default:
                return(string.Empty);
            }
        }
        public static String GetQueryOperatorSymbol(this QueryOperators value)
        {
            String queryOperatorSymbol = String.Empty;

            switch (value)
            {
            case QueryOperators.Equals:
                queryOperatorSymbol = "=";
                break;

            case QueryOperators.NotEquals:
                queryOperatorSymbol = "!=";
                break;

            case QueryOperators.GreaterThan:
                queryOperatorSymbol = ">";
                break;

            case QueryOperators.LessThan:
                queryOperatorSymbol = "<";
                break;

            case QueryOperators.GreaterThanOrEqual:
                queryOperatorSymbol = ">=";
                break;

            case QueryOperators.LessThanOrEqual:
                queryOperatorSymbol = "<=";
                break;

            case QueryOperators.Contains:
                queryOperatorSymbol = "LIKE";
                break;
            }

            return(queryOperatorSymbol);
        }
        public static Query ToQuery(this DataSourceRequest request)
        {
            Query query = new Query();

            #region Paging
            query.UsePaging   = true;
            query.PageSize    = request.PageSize;
            query.CurrentPage = request.Page - 1;
            #endregion

            #region Sort
            query.SortPropertyName = request.Sorts[0].Member;
            query.SortDescending   = request.Sorts[0].SortDirection == System.ComponentModel.ListSortDirection.Descending;
            #endregion

            #region Filters
            if (request.Filters.Count > 0)
            {
                QueryFilterGroup qfg = new QueryFilterGroup()
                {
                    IsAndFilter = true
                };
                foreach (IFilterDescriptor iFilterDescriptor in request.Filters)
                {
                    if (iFilterDescriptor is FilterDescriptor)
                    {
                        FilterDescriptor filterDescriptor = iFilterDescriptor as FilterDescriptor;
                        QueryOperators   queryOperator    = QueryOperators.None;

                        switch (filterDescriptor.Operator)
                        {
                        case FilterOperator.IsLessThan:
                            queryOperator = QueryOperators.LessThan;
                            break;

                        case FilterOperator.IsLessThanOrEqualTo:
                            queryOperator = QueryOperators.LessThanOrEqual;
                            break;

                        case FilterOperator.IsEqualTo:
                            queryOperator = QueryOperators.Equals;
                            break;

                        case FilterOperator.IsNotEqualTo:
                            queryOperator = QueryOperators.NotEquals;
                            break;

                        case FilterOperator.IsGreaterThanOrEqualTo:
                            queryOperator = QueryOperators.GreaterThanOrEqual;
                            break;

                        case FilterOperator.IsGreaterThan:
                            queryOperator = QueryOperators.GreaterThan;
                            break;

                        case FilterOperator.StartsWith:
                            break;

                        case FilterOperator.EndsWith:
                            break;

                        case FilterOperator.Contains:
                            break;

                        case FilterOperator.IsContainedIn:
                            break;

                        case FilterOperator.DoesNotContain:
                            break;

                        case FilterOperator.IsNull:
                            break;

                        case FilterOperator.IsNotNull:
                            break;

                        case FilterOperator.IsEmpty:
                            break;

                        case FilterOperator.IsNotEmpty:
                            break;

                        case FilterOperator.IsNullOrEmpty:
                            break;

                        case FilterOperator.IsNotNullOrEmpty:
                            break;

                        default:
                            break;
                        }

                        String parameter = filterDescriptor.Value.ToString();
                        if (filterDescriptor.Value is String)
                        {
                            parameter = String.Format("\'{0}\'", filterDescriptor.Value);
                        }

                        //filterDescriptor.v

                        if (queryOperator != QueryOperators.None)
                        {
                            qfg.QuerySingleFilters.Add(new QuerySingleFilter()
                            {
                                IsAndFilter   = true,
                                PropertyName  = filterDescriptor.Member,
                                QueryOperator = queryOperator,
                                Parameter     = parameter
                            });
                        }
                    }
                }

                query.QueryFilterGroups.Add(qfg);
            }
            #endregion

            return(query);
        }
예제 #5
0
 /// <summary>
 /// Constrcutor with the most common parameters
 /// </summary>
 public WhereCondition(Expression <Func <T, object> > column, QueryOperators queryOperator, object value)
 {
     Column   = column;
     Value    = value;
     Operator = queryOperator;
 }
예제 #6
0
 /// <summary>
 /// Returns an object collection of the type T where
 /// the object's value(s) matches the supplied value(s)
 /// </summary>
 protected static List <TY> LoadReferencing <TY>(Expression <Func <TY, object> > column, QueryOperators queryOperator, object value) where TY : Dwarf <TY>, new()
 {
     return(LoadReferencing(new WhereCondition <TY> {
         Column = column, Operator = queryOperator, Value = value
     }));
 }