public static void ProcessQuery(DataViewModelBase sender, DataServiceQuery query, AsyncCallback callback) { if (!objectRepository.Value.Keys.Contains(query.ToString())) { query.BeginExecute(callback, null); } else { sender.OnCompleteSource(objectRepository.Value[query.ToString()]); } }
public string GenerateQueryUri <T>(string entitySet, IDictionary <string, object> entityParams, IDictionary <string, object> filters) where T : class { UriOperationParameter[] myParams = null; DataServiceQuery <T> query = null; if (!this.isConnected) { return(null); } if (string.IsNullOrEmpty(entitySet)) { return(null); } if (entityParams == null) { query = this.container.CreateQuery <T>(entitySet); } else { int count = entityParams.Count; if (count > 0) { myParams = new UriOperationParameter[count]; int i = 0; foreach (string paramKey in entityParams.Keys) { // check for null value here myParams[i++] = new UriOperationParameter(paramKey, entityParams[paramKey]); } query = this.container.CreateFunctionQuery <T>("", entitySet, false, myParams); } } if (query == null) { return(null); } if (filters != null) { foreach (string filter in filters.Keys) { object filterValue = filters[filter]; if (filterValue != null) { // Immutability here ? query = query.AddQueryOption(filter, filterValue); } } } return(query.ToString()); }
/// <summary> /// Verify the passed query tree. /// </summary> /// <param name="expression">The query tree which will be verified</param> public virtual void Verify(QueryExpression expression) { ExceptionUtilities.CheckAllRequiredDependencies(this); ExceptionUtilities.Assert(this.IsAsync, "this verifier can only run async"); this.ThrowSkippedExceptionIfQueryExpressionNotSupported(expression); var resolvedQuery = this.LinqQueryResolver.Resolve(expression); var dataServiceContext = this.DataServiceContextCreator.CreateContext(this.DataServiceContextScope, this.workspace.ContextType, this.workspace.ServiceUri); if (this.IsExecuteURI) { // TODO: update this verifier to call ExecuteUriAndCompare if ExecuteURI test parameter is set to true } else { ClientQueryGenerator queryGenerator = new ClientQueryGenerator(new CSharpGenericTypeBuilder()); DataServiceContext clientContext = dataServiceContext.Product as DataServiceContext; CoreLinq.Expression queryLinqExpression = queryGenerator.Generate(resolvedQuery, clientContext); IQueryProvider queryProvider = clientContext.CreateQuery <int>("Set").Provider as IQueryProvider; DataServiceQuery dataServiceQuery = queryProvider.CreateQuery(queryLinqExpression) as DataServiceQuery; this.ResultComparer.EnqueueNextQuery(resolvedQuery); AsyncExecutionContext.EnqueueAsynchronousAction((queryContinuation) => { this.Log.WriteLine(LogLevel.Info, dataServiceQuery.ToString()); QueryValue baselineValue = this.GetBaselineValue(resolvedQuery); DataServiceProtocolVersion maxProtocolVersion = this.workspace.ConceptualModel.GetMaxProtocolVersion(); #if WINDOWS_PHONE DataServiceProtocolVersion maxClientProtocolVersion = DataServiceProtocolVersion.V4; #else DataServiceProtocolVersion maxClientProtocolVersion = ((DSC.DataServiceProtocolVersion)dataServiceContext.MaxProtocolVersion.Product).ToTestEnum(); #endif // Calculate version errors ExpectedClientErrorBaseline clientError = this.LinqToAstoriaErrorCalculator.CalculateExpectedClientVersionError(resolvedQuery, true, maxClientProtocolVersion, maxProtocolVersion); if (clientError != null) { this.Log.WriteLine(LogLevel.Info, "Expected client exception: " + clientError.ExpectedExceptionType.ToString()); } Type queryType = dataServiceQuery.ElementType; MethodInfo genericExecuteMethod = this.ResultComparer.GetType().GetMethod("ExecuteAndCompare").MakeGenericMethod(queryType); genericExecuteMethod.Invoke(this.ResultComparer, new object[] { queryContinuation, this.IsAsync, dataServiceQuery, baselineValue, clientContext, clientError }); }); } }
public override string ToString() { return(_query.ToString()); }
public void NamedStreams_NestedQuery_2() { // projecting out collection of collection properties - both narrow type and anonymous type { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); context.EnableAtom = true; context.Format.UseAtom(); DataServiceQuery <EntityWithNamedStreams1> q = (DataServiceQuery <EntityWithNamedStreams1>) from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new EntityWithNamedStreams1 { ID = s.ID, Stream1 = s.Stream1, Collection = (from c in s.Collection select new EntityWithNamedStreams2() { ID = c.ID, ColStream = c.ColStream, Collection1 = (from c1 in c.Collection1 select new EntityWithNamedStreams1() { ID = c1.ID, RefStream1 = c1.RefStream1 }).ToList() }).ToList() }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Collection($select=ID),Collection($select=ColStream),Collection($expand=Collection1($select=ID)),Collection($expand=Collection1($select=RefStream1))&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); var response = (QueryOperationResponse <EntityWithNamedStreams1>)q.Execute(); DataServiceQueryContinuation <EntityWithNamedStreams2> continuation = null; foreach (var o in response) { Assert.IsNotNull(o.Stream1.EditLink, "Stream1 should not be null"); Assert.AreEqual(o.Stream1.EditLink, context.GetReadStreamUri(o, "Stream1"), "the stream url for Stream1 must be populated correctly"); foreach (var c in o.Collection) { Assert.IsNotNull(c.ColStream.EditLink, "ColStream should not be null"); Assert.AreEqual(c.ColStream.EditLink, context.GetReadStreamUri(c, "ColStream"), "the url for the nested collection entity should match - Level 0"); foreach (var c1 in c.Collection1) { Assert.IsNotNull(c1.RefStream1.EditLink, "RefStream1 should not be null"); Assert.AreEqual(c1.RefStream1.EditLink, context.GetReadStreamUri(c1, "RefStream1"), "the url for the nested collection entity should match - Level 1"); } } // Make sure you get the continuation token for the collection and try and get the next page continuation = response.GetContinuation(o.Collection); } Assert.AreEqual(context.Entities.Count, 3, "there should be 3 entities tracked by the context"); Assert.AreEqual(context.Entities[0].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet1(1)", "top level entity must be tracked"); Assert.AreEqual(context.Entities[1].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')", "top level entity must be tracked"); Assert.AreEqual(context.Entities[2].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet2(3)", "the nested entity must be tracked"); Assert.IsNotNull(continuation, "since SDP is turned on, we should get the continuation token"); // Get the next page and make sure we get the right entity and the link is populated. foreach (var entity in context.Execute(continuation)) { Assert.IsNotNull(entity.ColStream.EditLink, "ColStream should not be null"); Assert.AreEqual(entity.ColStream.EditLink, context.GetReadStreamUri(entity, "ColStream"), "the url for the nested collection entity should match - Level 1"); foreach (var c1 in entity.Collection1) { Assert.IsNotNull(c1.RefStream1.EditLink, "RefStream1 should not be null"); Assert.AreEqual(c1.RefStream1.EditLink, context.GetReadStreamUri(c1, "RefStream1"), "the url for the nested collection entity should match - Level 1"); } } Assert.AreEqual(context.Entities.Count, 4, "there should be 4 entities tracked by the context"); } { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); context.EnableAtom = true; context.Format.UseAtom(); var q = from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new { ID = s.ID, Stream1Url = s.Stream1, Collection = (from c in s.Collection select new { Name = c.Name, Stream1Url = c.ColStream, Collection1 = (from c1 in c.Collection1 select new { ID = c1.ID, Stream1Url = c1.RefStream1 }) }) }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Collection($select=Name),Collection($select=ColStream),Collection($expand=Collection1($select=ID)),Collection($expand=Collection1($select=RefStream1))&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); foreach (var o in q) { Assert.AreEqual(o.Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet1(1)/Stream1", "the stream url for Stream1 must be populated correctly"); Assert.AreEqual(o.Collection.First().Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')/ColStream", "the stream url of the collection stream must be populated correctly - index 0"); Assert.AreEqual(o.Collection.First().Collection1.Single().Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet2(3)/RefStream1", "the stream url of the collection stream must be populated correctly - index 0 - index 0"); } Assert.AreEqual(context.Entities.Count, 0, "there should be no entities tracked by the context"); } }
public void RefreshData() { ProxyServiceQuery.ClearData(_query.ToString()); GetData(); }
public string GenerateFunctionQueryUri <T>(string entitySet, string functionName, IDictionary <string, object> functionParams) where T : class { UriOperationParameter[] myParams = null; DataServiceQuery <T> query = null; if (!this.isConnected) { return(null); } if (string.IsNullOrEmpty(functionName)) { return(null); } // Are they manadatory? /*if (functionParams == null) * { * return null; * }*/ if (functionParams != null) { int count = functionParams.Count; if (count > 0) { myParams = new UriOperationParameter[count]; int i = 0; foreach (string paramKey in functionParams.Keys) { myParams[i++] = new UriOperationParameter(paramKey, functionParams[paramKey]); } } } //query = this.container.CreateFunctionQuery<T>(entitySet, "EIV.Demo.WebService.PaisAction", false, myParams); // First param cannot be null, but empty // Last param cannot be null // Java service (OLingo) requires '()' at the end of the function name if (myParams == null) { query = this.container.CreateFunctionQuery <T>(entitySet, functionName, false); } else { // I guess I need a two-step process //query = this.container.CreateFunctionQuery<T>(entitySet, functionName, false, myParams); query = this.container.CreateFunctionQuery <T>("", entitySet, false, myParams); } if (query == null) { return(null); } // Awful hack! string rstQuery = string.Empty; string preQuery = query.ToString(); if (myParams == null) { rstQuery = preQuery; } else { rstQuery = string.Format("{0}/{1}", preQuery, functionName); } return(rstQuery); }