public string GetPageLink(IJsonApiContext context, int pageOffset, int pageSize) { var filterQueryComposer = new QueryComposer(); var filters = filterQueryComposer.Compose(context); return($"{context.BasePath}/{context.RequestEntity.EntityName}?page[size]={pageSize}&page[number]={pageOffset}{filters}"); }
public SimpleDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) { this.Info = info; this.Composer = composer; this.Provider = provider; this.Handler = handler; }
public Query ComposeQuery(string keywords, string[] fields) { var queryString = QueryComposer.Provide(keywords); var parser = new MultiFieldQueryParser(fields, Factory.GetAnalyser()); return(parser.Parse(queryString)); }
internal ModelOperator(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) { this.Info = info; this.Composer = composer; this.Provider = provider; this._saver = SaverFactory.CreateSaver(info, composer, provider, handler); this._deleter = DeleterFactory.CreateDeleter(info, composer, provider, handler); this.Fixer = AutoSchemeFixer.CreateInstance(this.Provider, this.Info); }
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { if (actionExecutedContext == null) { throw Error.ArgumentNull("actionExecutedContext"); } Contract.Assert(actionExecutedContext.Request != null); HttpRequestMessage request = actionExecutedContext.Request; HttpResponseMessage response = actionExecutedContext.Response; IQueryable query; if (response != null && response.TryGetContentValue(out query)) { IQueryable deserializedQuery = null; if (request != null && request.RequestUri != null && !String.IsNullOrWhiteSpace(request.RequestUri.Query)) { Uri requestUri = request.RequestUri; try { ServiceQuery serviceQuery = ODataQueryDeserializer.GetServiceQuery(requestUri); if (serviceQuery.QueryParts.Count > 0) { IQueryable baseQuery = Array.CreateInstance(query.ElementType, 0).AsQueryable(); // T[] deserializedQuery = ODataQueryDeserializer.Deserialize(baseQuery, serviceQuery.QueryParts); if (_queryValidator != null) { _queryValidator.Validate(deserializedQuery); } } } catch (ParseException e) { actionExecutedContext.Response = request.CreateResponse( HttpStatusCode.BadRequest, Error.Format(SRResources.UriQueryStringInvalid, e.Message)); return; } } if (deserializedQuery != null) { query = QueryComposer.Compose(query, deserializedQuery); } query = ApplyResultLimit(actionExecutedContext, query); ((ObjectContent)response.Content).Value = query; } }
public void SplitPartiallySupportedQuery() { IQueryable <string> queryRoot = new[] { "query", "root" }.AsQueryable(); IQueryable <string> query = queryRoot.Where(s => true).Take(5).OrderBy(s => s).ThenBy(s => s); IQueryable supportedQuery; IQueryable unsupportedQuery; supportedQuery = QueryComposer.Split(query, out unsupportedQuery); MethodCallExpression mce = supportedQuery.Expression as MethodCallExpression; Assert.IsNotNull(mce, "The first supported expression should be a method call."); Assert.AreEqual("Take", mce.Method.Name, "The first supported expression should be a Take call."); Assert.AreEqual(2, mce.Arguments.Count, "The first supported expression should have 2 arguments."); MethodCallExpression mce2 = mce.Arguments[0] as MethodCallExpression; Assert.IsNotNull(mce2, "The second supported expression should be a method call."); Assert.AreEqual("Where", mce2.Method.Name, "The second supported expression should be a Where call."); Assert.AreEqual(2, mce2.Arguments.Count, "The second supported expression should have 2 arguments."); ConstantExpression ce = mce2.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first argument in the second supported expression should be constant."); mce = unsupportedQuery.Expression as MethodCallExpression; Assert.IsNotNull(mce, "The first unsupported expression should be a method call."); Assert.AreEqual("ThenBy", mce.Method.Name, "The first unsupported expression should be a ThenBy call."); Assert.AreEqual(2, mce.Arguments.Count, "The first unsupported expression should have 2 arguments."); mce2 = mce.Arguments[0] as MethodCallExpression; Assert.IsNotNull(mce2, "The second unsupported expression should be a method call."); Assert.AreEqual("OrderBy", mce2.Method.Name, "The second unsupported expression should be an OrderBy call."); Assert.AreEqual(2, mce2.Arguments.Count, "The second unsupported expression should have 2 arguments."); ce = mce2.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first argument in the second unsupported expression should be constant."); }
public void TestQueryBuilder() { ISelectQuery selectQuery = new SelectQuery { SelectFrom = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition("*") }) }; List <IWhereQuery> whereQueries = new List <IWhereQuery> { new WhereQuery() { ColumnsDefinition = new[] { new ColumnDefinition(0, "tA.ColumnA", "Sahil", CompareOperatorEnum.Equals) } }, new WhereQuery() { ColumnsDefinition = new[] { new ColumnDefinition(0, "ColumnA", "Sahil", CompareOperatorEnum.Equals), new ColumnDefinition(1, "ColumnB", "9901", CompareOperatorEnum.NotEquals) }, ConditionOperator = ConditionOperatorEnum.And } }; List <IJoinQuery> joinQueries = new List <IJoinQuery>() { new JoinQuery() { JoinOperator = JoinOperatorEnum.InnerJoin, TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition("ColumnB") }), TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition("ColumnA") }) }, new JoinQuery() { JoinOperator = JoinOperatorEnum.InnerJoin, TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition(0, "ColumnB2"), new ColumnDefinition(1, "ColumnB3") }), TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition(0, "ColumnA2"), new ColumnDefinition(1, "ColumnA3") }) }, //TODO: Test Case is Failing - columns already added in join condition, shouldn't get added again new JoinQuery() { JoinOperator = JoinOperatorEnum.InnerJoin, TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition(0, "ColumnB") }), TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition(0, "ColumnA") }) } }; ISqlQuery sqlQuery = new SqlQuery(selectQuery, joinQueries.ToArray(), whereQueries.ToArray()); var queryString = QueryComposer.GenerateQuerySql(sqlQuery); }
public static SimpleDeleter CreateDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) { if (info.HasRelation) { return(new RelationModelDeleter(info, composer, provider, handler)); } if (info.HasOnePrimaryKey && info.KeyMembers[0].UnsavedValue != null) { return(new KeyModelDeleter(info, composer, provider, handler)); } return(new SimpleDeleter(info, composer, provider, handler)); }
public void NoFilter_Compose_EmptyStringReturned() { // arrange var querySet = new QuerySet(); _jsonApiContext .Setup(m => m.QuerySet) .Returns(querySet); var queryComposer = new QueryComposer(); // act var filterString = queryComposer.Compose(_jsonApiContext.Object); // assert Assert.Equal("", filterString); }
public List <object> SearchTwitter(QueryInfo queryInfo, bool filterAll) { string searchText = QueryComposer.ComposeQuery(queryInfo); Dictionary <string, string> parameters = new Dictionary <string, string>() { { "q", searchText }, { "result_type", queryInfo.ResultType }, { "lang", queryInfo.LanguageCode }, { "count", queryInfo.SearchCount.ToString() } }; string jsonResult = SearchTweet(parameters); List <Status> lstSearches = Deserializer.DeserializeJSON <List <Status> >("statuses", jsonResult); if (filterAll) { if (lstSearches != null && lstSearches.Count > 0) { int takeCount = 0; int totalFound = lstSearches.Count; int half = queryInfo.SearchCount / 2; if (totalFound > half) { takeCount = half + 1; // TAKE 1 MORE THAN HALF } else if (totalFound <= half) { takeCount = half; // TAKE ALL } else { takeCount = 0; // TAKE NONE } lstSearches = lstSearches.OrderBy(x => x.retweet_count) .Take(takeCount).ToList(); } } return(new List <object>(lstSearches.Cast <object>())); }
private ModelContext(Type t) { Info = ObjectInfoFactory.Instance.GetInstance(t); Provider = DataProviderFactory.Instance.GetInstance(Info.ContextName); Composer = GetQueryComposer(); if (LoadHandler) { Handler = CreateDbObjectHandler(); } if (ConfigReader.Config.Database.Cache.Enabled && Info.HasOnePrimaryKey && Info.Cacheable) { Operator = new CachedModelOperator(Info, Composer, Provider, Handler); } else { Operator = new ModelOperator(Info, Composer, Provider, Handler); } }
public void Can_ComposeEqual_FilterStringForUrl() { // arrange var filter = new FilterQuery("attribute", "value", "eq"); var querySet = new QuerySet(); List <FilterQuery> filters = new List <FilterQuery>(); filters.Add(filter); querySet.Filters = filters; _jsonApiContext .Setup(m => m.QuerySet) .Returns(querySet); var queryComposer = new QueryComposer(); // act var filterString = queryComposer.Compose(_jsonApiContext.Object); // assert Assert.Equal("&filter[attribute]=eq:value", filterString); }
public static SimpleObjectSaver CreateSaver(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) { if (info.HasSystemKey && info.KeyMembers[0].UnsavedValue == null) { throw new DataException("System key must have UnsavedValue."); } if (info.HandleType.IsSubclassOf(typeof(DbObjectSmartUpdate))) { if (info.HasRelation) { return(new RelationModelSaver(info, composer, provider, handler)); } return(new DbModelSaver(info, composer, provider, handler)); } if (info.HasSystemKey) { return(new DbObjectSaver(info, composer, provider, handler)); } return(new SimpleObjectSaver(info, composer, provider, handler)); }
public void Rebase() { IQueryable <string> queryRoot = new[] { "query", "root" }.AsQueryable(); IQueryable <string> query = queryRoot.Where(s => true); MethodCallExpression mce = query.Expression as MethodCallExpression; Assert.IsNotNull(mce, "Expression should be a method call."); Assert.AreEqual("Where", mce.Method.Name, "Expression should be a Where call."); Assert.AreEqual(2, mce.Arguments.Count, "Expression should have 2 arguments."); ConstantExpression ce = mce.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first expression argument should be constant."); Assert.AreEqual(queryRoot, ce.Value, "The first expression argument should be the query root."); IQueryable <string> newQueryRoot = new[] { "new", "query", "root" }.AsQueryable(); IQueryable rebasedQuery = QueryComposer.Compose(newQueryRoot, query); mce = rebasedQuery.Expression as MethodCallExpression; Assert.IsNotNull(mce, "Rebased expression should be a method call."); Assert.AreEqual("Where", mce.Method.Name, "Rebased expression should be a Where call."); Assert.AreEqual(2, mce.Arguments.Count, "Rebased expression should have 2 arguments."); ce = mce.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first rebased expression argument should be constant."); Assert.AreEqual(newQueryRoot, ce.Value, "The first rebased expression argument should be the new query root."); }
internal Reclaimer(QueryComposer composer) { this.composer = composer; this.passer = new Passer(this); }
public DbModelSaver(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) : base(info, composer, provider, handler) { }
public RelationModelDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) : base(info, composer, provider, handler) { }
internal Reclaimer( QueryComposer composer ) { this.composer = composer; this.passer = new Passer(this); }
internal CachedModelOperator(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler) : base(info, composer, provider, handler) { }