/// <summary> /// Creates a copy of the provided value which includes all objects reachable through given span paths. /// </summary> /// <param name="valueToSpan">Value to apply span for.</param> /// <param name="expandedPaths">The expanded paths.</param> /// <param name="selectedPaths">The selected paths needed to match up with the expanded paths.</param> /// <returns> /// Copy of the value trimmed to given span paths. /// </returns> public QueryValue GenerateSpan(QueryValue valueToSpan, IEnumerable<string> expandedPaths, IEnumerable<string> selectedPaths) { ExceptionUtilities.CheckArgumentNotNull(valueToSpan, "valueToSpan"); ExceptionUtilities.CheckArgumentNotNull(expandedPaths, "expandedPaths"); ExceptionUtilities.CheckArgumentNotNull(selectedPaths, "selectedPaths"); var collection = valueToSpan as QueryCollectionValue; if (collection == null) { return valueToSpan; } // split each span path into a string array, which we can efficiently analyze later without // having to deal with string parsing all the time var identityMap = new Dictionary<QueryStructuralValue, QueryStructuralValue>(); var result = this.CloneCollectionValue(identityMap, collection); foreach (var spanPath in expandedPaths) { var splitPath = spanPath.Split('.'); foreach (var item in collection.Elements) { this.ExpandRelated(identityMap, item, splitPath, 0, expandedPaths, selectedPaths); } } return result; }
/// <summary> /// Sets the given values on the given structural value instance /// </summary> /// <param name="queryValue">The instance to set the values on</param> /// <param name="namedValues">The values to set</param> public void UpdateValues(QueryValue queryValue, IEnumerable<NamedValue> namedValues) { ExceptionUtilities.CheckArgumentNotNull(queryValue, "queryValue"); ExceptionUtilities.CheckArgumentNotNull(namedValues, "namedValues"); this.unusedNamedValuePaths = new List<string>(namedValues.Select(s => s.Name).ToArray()); var queryStructuralValue = queryValue as QueryStructuralValue; if (queryStructuralValue != null) { this.UpdateValues(queryStructuralValue, namedValues, null); } else { var queryCollectionValue = queryValue as QueryCollectionValue; ExceptionUtilities.CheckObjectNotNull(queryCollectionValue, "Can only update QueryValues of Collection or Structural type not '{0}'", queryValue.Type); this.UpdateValues(queryCollectionValue, namedValues); } var errorStringBuilder = new StringBuilder(); foreach (NamedValue unusedNamedValue in namedValues.Where(nv => this.unusedNamedValuePaths.Contains(nv.Name))) { errorStringBuilder.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}={1}", unusedNamedValue.Name, Convert.ToString(unusedNamedValue.Value, CultureInfo.InvariantCulture))); } if (errorStringBuilder.Length > 0) { throw new TaupoInfrastructureException("All properties have not been set:\r\n" + errorStringBuilder.ToString()); } }
/// <summary> /// Gets the expected query value for the action request /// </summary> /// <param name="initialExpectedResults">Initial expected values for an action</param> /// <param name="parameterValues">Parameter values for the action</param> /// <returns>A query Value that is the expected value</returns> public QueryValue GetExpectedQueryValue(QueryValue initialExpectedResults, params QueryValue[] parameterValues) { ExceptionUtilities.CheckArgumentNotNull(initialExpectedResults, "initialExpectedResults"); ExceptionUtilities.Assert(parameterValues.Length == 1, "There must be only one parameter that is passed in"); return parameterValues[0]; }
private bool WriteErrorIfNotNull(string propertyPath, QueryValue queryValue) { if (!queryValue.IsNull) { this.errors.Add(string.Format(CultureInfo.InvariantCulture, "Error: expected null value for propertyPath '{0}' instead recieved '{1}'", propertyPath, queryValue.ToString())); return true; } return false; }
internal void SetNavigateResult(AssociationType associationType, AssociationEnd toEnd, QueryValue result) { if (!this.navigateResultLookup.ContainsKey(associationType)) { this.navigateResultLookup.Add(associationType, new Dictionary<AssociationEnd, QueryValue>()); } Dictionary<AssociationEnd, QueryValue> lookupBasedOnEnd = this.navigateResultLookup[associationType]; lookupBasedOnEnd[toEnd] = result; }
/// <summary> /// Validates a payload with the given root element against the given expected value /// </summary> /// <param name="rootElement">The root element of the payload</param> /// <param name="expectedValue">The expected value</param> public void Validate(ODataPayloadElement rootElement, QueryValue expectedValue) { ExceptionUtilities.CheckArgumentNotNull(rootElement, "rootElement"); ExceptionUtilities.CheckArgumentNotNull(expectedValue, "expectedValue"); ExceptionUtilities.CheckAllRequiredDependencies(this); this.Assert.IsNull(expectedValue.EvaluationError, string.Format(CultureInfo.InvariantCulture, "Query evaluation error: {0}", expectedValue.EvaluationError)); var visitor = new PayloadDataValidatingVisitor(this); visitor.Validate(rootElement, expectedValue); }
private void ExpandRelated(Dictionary<QueryStructuralValue, QueryStructuralValue> identityMap, QueryValue item, string[] splitPath, int position, IEnumerable<string> expandedPath, IEnumerable<string> selectedPath) { QueryStructuralValue qsv = item as QueryStructuralValue; if (qsv == null) { return; } if (position >= splitPath.Length) { return; } var memberName = splitPath[position]; var member = qsv.Type.Properties.SingleOrDefault(c => c.Name == memberName); if (member == null) { return; } // do not expand if the selected paths don't contain the expand value if (selectedPath.Count() > 0 && !selectedPath.Contains(member.Name)) { return; } var clone = this.CloneStructuralValue(identityMap, qsv); if (member.PropertyType is QueryCollectionType) { var oldValue = qsv.GetCollectionValue(memberName); clone.SetValue(memberName, this.CloneCollectionValue(identityMap, oldValue)); if (!oldValue.IsNull) { foreach (var e in oldValue.Elements) { this.ExpandRelated(identityMap, e, splitPath, position + 1, expandedPath, selectedPath); } } } else if (member.PropertyType is QueryStructuralType) { var oldValue = qsv.GetStructuralValue(memberName); var newValue = this.CloneStructuralValue(identityMap, oldValue); clone.SetValue(memberName, newValue); this.ExpandRelated(identityMap, oldValue, splitPath, position + 1, expandedPath, selectedPath); } }
/// <summary> /// Validates the data in the response payload based on the expected query value /// </summary> /// <param name="requestUri">The request uri</param> /// <param name="response">The response</param> /// <param name="expected">The expected query value</param> /// <param name="maxProtocolVersion">The max protocol version of the service</param> public void ValidateResponsePayload(ODataUri requestUri, ODataResponse response, QueryValue expected, DataServiceProtocolVersion maxProtocolVersion) { ExceptionUtilities.CheckObjectNotNull(requestUri, "requestUri"); ExceptionUtilities.CheckObjectNotNull(response, "response"); ExceptionUtilities.CheckObjectNotNull(expected, "expected"); var expectedVersion = response.GetDataServiceVersion(); this.Validator.ExpectedProtocolVersion = expectedVersion; this.Validator.ExpectedPayloadOptions = ODataPayloadOptions.None; string contentType; if (response.Headers.TryGetValue(HttpHeaders.ContentType, out contentType)) { var strategy = this.FormatSelector.GetStrategy(contentType, requestUri); ExceptionUtilities.CheckObjectNotNull(strategy, "Could not get strategy for content type '{0}'", contentType); this.Validator.PrimitiveValueComparer = strategy.GetPrimitiveComparer(); this.Validator.ExpectedPayloadOptions = this.ProtocolImplementationDetails.GetExpectedPayloadOptions(contentType, expectedVersion, requestUri); } this.ValidateAndPrintInfoOnError(requestUri, response.RootElement, expected); }
/// <summary> /// Gets the expected query value for the action request /// </summary> /// <param name="initialExpectedResults">Initial expected values for an action</param> /// <param name="parameterValues">Parameter values for the action</param> /// <returns>A query Value that is the expected value</returns> public QueryValue GetExpectedQueryValue(QueryValue initialExpectedResults, params QueryValue[] parameterValues) { ExceptionUtilities.CheckArgumentNotNull(initialExpectedResults, "initialExpectedResults"); if (initialExpectedResults.IsNull || this.ReturnProperty == null) { return initialExpectedResults.Type.NullValue; } QueryStructuralValue initialStructuralValue = initialExpectedResults as QueryStructuralValue; QueryCollectionValue initialCollectionValue = initialExpectedResults as QueryCollectionValue; if (initialStructuralValue != null) { return initialStructuralValue.GetValue(this.ReturnProperty); } else { ExceptionUtilities.CheckArgumentNotNull(initialCollectionValue, "Unsupported initialExpectedResults type."); if (initialCollectionValue.Elements.Count > 0) { // Sort the results by the keys var queryEntityType = (QueryEntityType)initialCollectionValue.Type.ElementType; var sortedList = initialCollectionValue.Elements.Select(r => (QueryStructuralValue)r).ToList(); foreach (var key in queryEntityType.EntityType.AllKeyProperties) { sortedList = sortedList.OrderBy(r => r.GetScalarValue(key.Name).Value).ToList(); } var firstItemValue = (QueryStructuralValue)sortedList.First(); ExceptionUtilities.CheckArgumentNotNull(firstItemValue, "firstItemValue"); return firstItemValue.GetValue(this.ReturnProperty); } else { return initialCollectionValue.Type.ElementType.NullValue; } } }
/// <summary> /// Gets the expected query value for the action request /// </summary> /// <param name="initialExpectedResults">Initial expected values for an action</param> /// <param name="parameterValues">Parameter values for the action</param> /// <returns>A query Value that is the expected value</returns> public QueryValue GetExpectedQueryValue(QueryValue initialExpectedResults, params QueryValue[] parameterValues) { ExceptionUtilities.CheckArgumentNotNull(initialExpectedResults, "initialExpectedResults"); QueryStructuralValue initialStructuralValue = initialExpectedResults as QueryStructuralValue; ExceptionUtilities.CheckArgumentNotNull(initialStructuralValue, "initialStructuralValue"); QueryScalarValue initialScalarValue = initialStructuralValue.GetScalarValue(this.IntegerProperty); ExceptionUtilities.CheckArgumentNotNull(initialScalarValue, "initialScalarValue"); int intPropertyValue = (int)initialScalarValue.Value; ExceptionUtilities.CheckArgumentNotNull(intPropertyValue, "intPropertyValue"); if (intPropertyValue != int.MaxValue) { initialStructuralValue.SetPrimitiveValue(this.IntegerProperty, intPropertyValue + 1); } else { initialStructuralValue.SetPrimitiveValue(this.IntegerProperty, 0); } return initialStructuralValue; }
/// <summary> /// Adds entities that are materialized in the given QueryValue into list of currently visible entities. /// </summary> /// <param name="value">QueryValue representing result of a query.</param> /// <param name="spanPaths">Span paths for the query.</param> protected void UpdateVisibleEntitiesGraph(QueryValue value, string[] spanPaths) { this.UpdateVisibleEntitiesGraphForQueryValue(value, string.Empty, spanPaths); }
private string VerifyExpected(ODataRequest request, ODataResponse response, QueryValue expected, HttpStatusCode expectedStatusCode, string expectedETag) { if (expected.IsNull) { ExceptionUtilities.Assert(response.StatusCode == HttpStatusCode.NoContent, "Expected status code {0} actual {1}", HttpStatusCode.NoContent, response.StatusCode); } else { this.VerificationServices.ValidateResponsePayload(request.Uri, response, expected, this.maxProtocolVersion); ExceptionUtilities.Assert(response.StatusCode == expectedStatusCode, "Expected status code {0} actual {1}", expectedStatusCode, response.StatusCode); // Verify that there are no next links in a response payload to an action with SDP enabled var entitySetInstance = response.RootElement as EntitySetInstance; if (entitySetInstance != null) { this.Assert(entitySetInstance.NextLink == null, "Should be no next links in response", request, response); } expectedETag = this.CalculateExpectedETag(expected); } return expectedETag; }
// Math private QueryValue EvaluateMathMethod(string functionName, QueryType type, QueryValue[] arguments) { ValidateArguments(functionName, type, 1, arguments); return this.EvaluateMethod((QueryScalarType)type, typeof(Math), functionName, (QueryScalarValue)arguments[0]); }
// String private QueryValue EvaluateStringMethod(string functionName, QueryType type, QueryValue[] arguments) { ValidateArguments(functionName, type, null, arguments); return this.EvaluateMethod((QueryScalarType)type, typeof(string), functionName, arguments.Cast<QueryScalarValue>().ToArray()); }
/// <summary> /// Helper method for recursively validating elements and wrapping exceptions from the assertion handler. /// If validation fails, the exception type will be maintained, but it will be wrapped in an exception with the given message. /// </summary> /// <param name="element">The element to validate</param> /// <param name="value">The expected value</param> /// <param name="errorMessage">The error message template to wrap any exceptions in</param> /// <param name="args">The arguments to the error message template</param> private void RecurseWithMessage(ODataPayloadElement element, QueryValue value, string errorMessage, params object[] args) { using (this.parent.Assert.WithMessage(errorMessage, args)) { this.Recurse(element, value); } }
/// <summary> /// Validates a payload with the given root element against the given expected value /// </summary> /// <param name="rootElement">The root element of the payload</param> /// <param name="expected">The expected value</param> public void Validate(ODataPayloadElement rootElement, QueryValue expected) { ExceptionUtilities.CheckArgumentNotNull(rootElement, "rootElement"); ExceptionUtilities.CheckArgumentNotNull(expected, "expected"); this.expectedValueStack.Push(expected); this.payloadStack.Push(rootElement); rootElement.Accept(this); }
/// <summary> /// Validates the arguments. /// </summary> /// <param name="functionName">Name of the function.</param> /// <param name="type">The query type.</param> /// <param name="expectedCount">The expected argument count.</param> /// <param name="arguments">The arguments.</param> private static void ValidateArguments(string functionName, QueryType type, int? expectedCount, QueryValue[] arguments) { ExceptionUtilities.CheckArgumentNotNull(functionName, "functionName"); ExceptionUtilities.CheckArgumentNotNull(type, "type"); ExceptionUtilities.CheckArgumentNotNull(arguments, "arguments"); ExceptionUtilities.Assert(type is QueryScalarType, "Type for function '{0}' was not a scalar type", functionName); ExceptionUtilities.Assert(arguments.All(a => a is QueryScalarValue), "Arguments for function '{0}' were not all scalar", functionName); if (expectedCount.HasValue) { ExceptionUtilities.Assert(arguments.Length == expectedCount.Value, "Number of arguments for function '{0}' was wrong. Expected {1} but got {2}", functionName, expectedCount.Value, arguments.Length); } }
/// <summary> /// This function returns a multidimensional array containing a list of all defined variables, /// be them environment, server or user-defined variables, within the scope that get_defined_vars() is called. /// </summary> /// <param name="locals">The table of defined variables.</param> /// <returns></returns> public static PhpArray get_defined_vars(QueryValue <LocalVariables> locals) => locals.Value.Locals.DeepCopy();
/// <summary> /// Import variables into the current variables table from an array. /// </summary> /// <param name="ctx">Runtime context.</param> /// <param name="localsData">The table of defined variables.</param> /// <param name="vars">The <see cref="PhpArray"/> containing names of variables and values to be assigned to them.</param> /// <param name="type">The type of the extraction.</param> /// <param name="prefix">The prefix (can be a <B>null</B> reference) of variables names.</param> /// <returns>The number of variables actually affected by the extraction.</returns> /// <exception cref="PhpException"><paramref name="type"/> is invalid.</exception> /// <exception cref="PhpException"><paramref name="vars"/> is a <B>null</B> reference.</exception> /// <exception cref="InvalidCastException">Some key of <paramref name="localsData"/> is not type of <see cref="string"/>.</exception> public static int extract(Context ctx, QueryValue <LocalVariables> localsData, PhpArray vars, ExtractType type = ExtractType.Overwrite, string prefix = null) { if (vars == null) { //PhpException.ArgumentNull("vars"); //return 0; throw new ArgumentNullException(nameof(vars)); } if (vars.Count == 0) { return(0); } var locals = localsData.Value.Locals; // unfortunately, type contains flags are combined with enumeration: bool refs = (type & ExtractType.Refs) != 0; type &= ExtractType.NonFlags; // // // int extracted_count = 0; var enumerator = vars.GetFastEnumerator(); while (enumerator.MoveNext()) { var name = enumerator.CurrentKey.ToString(); if (string.IsNullOrEmpty(name) && type != ExtractType.PrefixInvalid) { continue; } switch (type) { case ExtractType.Overwrite: // anything is overwritten: break; case ExtractType.Skip: // skips existing name: if (locals.ContainsKey(name)) { continue; } break; case ExtractType.IfExists: // skips nonexistent name: if (!locals.ContainsKey(name)) { continue; } break; case ExtractType.PrefixAll: // prefix anything: name = string.Concat(prefix, "_", name); break; case ExtractType.PrefixInvalid: // prefixes invalid, others are overwritten: if (!PhpVariable.IsValidName(name)) { name = string.Concat(prefix, "_", name); } break; case ExtractType.PrefixSame: // prefixes existing, others are overwritten: if (locals.ContainsKey(name)) { name = string.Concat(prefix, "_", name); } break; case ExtractType.PrefixIfExists: // prefixes existing, others are skipped: if (locals.ContainsKey(name)) { name = string.Concat(prefix, "_", name); } else { continue; } break; default: throw new ArgumentException(nameof(type)); //PhpException.InvalidArgument("type", LibResources.GetString("arg_invalid_value")); //return 0; } // invalid names are skipped: if (PhpVariable.IsValidName(name)) { // write the value to locals: if (refs) { // makes a reference and writes it back (deep copy is not necessary, "no duplicate pointers" rule preserved): locals.SetItemAlias(new IntStringKey(name), enumerator.CurrentValueAliased); } else { // deep copy the value and write into locals locals.SetItemValue(new IntStringKey(name), enumerator.CurrentValue.GetValue().DeepCopy()); } extracted_count++; } } // return(extracted_count); }
// Token: 0x06000227 RID: 551 RVA: 0x0000D064 File Offset: 0x0000B264 public void queryDB(Dictionary <string, QueryValue> dicts) { if (this.qb == null || dicts == null || dicts.Count < 0) { return; } DataTable dataTable = new DataTable(); dataTable.Columns.Add("permanentUserId"); dataTable.Columns.Add("username"); dataTable.Columns.Add("identityId"); dataTable.Columns.Add("phoneNum"); dataTable.Columns.Add("address"); dataTable.Columns.Add("usertype"); dataTable.Columns.Add("priceType"); dataTable.Columns.Add("paytype"); dataTable.Columns.Add("pursuitTimes"); dataTable.Columns.Add("pursuitNum"); dataTable.Columns.Add("paynum"); dataTable.Columns.Add("time"); dataTable.Columns.Add("operator"); List <string> list = new List <string>(); string sqlStrForQueryUser = this.getSqlStrForQueryUser(dicts); DataTable dataTable2; if (sqlStrForQueryUser != "") { foreach (string key in dicts.Keys) { QueryValue queryValue = dicts[key]; this.db.AddParameter(key, queryValue.Value); } dataTable2 = this.db.ExecuteQuery("SELECT * FROM usersTable WHERE " + sqlStrForQueryUser + " ORDER BY createTime ASC"); if (dataTable2 != null && dataTable2.Rows != null && dataTable2.Rows.Count > 0) { foreach (object obj in dataTable2.Rows) { DataRow dataRow = (DataRow)obj; list.Add(dataRow["permanentUserId"].ToString()); } } } string text = ""; if (list.Count > 0) { for (int i = 0; i < list.Count; i++) { string text2 = list[i]; this.db.AddParameter("permanentUserId" + text2, text2); if (i != 0) { text += " OR "; } text = text + "permanentUserId=@permanentUserId" + text2; } } else if (list.Count == 0 && dicts.Count != 0 && sqlStrForQueryUser != "") { this.qb.initDGV(this.initDGV(dataTable)); return; } TimeSpan timeSpan = this.qb.getStartDT() - WMConstant.DT1970; TimeSpan timeSpan2 = this.qb.getEndDT() - WMConstant.DT1970; this.db.AddParameter("createTimeStart", string.Concat(timeSpan.TotalSeconds)); this.db.AddParameter("createTimeEnd", string.Concat(timeSpan2.TotalSeconds)); this.db.AddParameter("operateType", "3"); string sqlKeys = this.getQueryConditionEntitys()[7].SqlKeys; if (dicts.ContainsKey(sqlKeys)) { QueryValue queryValue2 = dicts[sqlKeys]; this.db.AddParameter(sqlKeys, queryValue2.Value); string text3 = text; text = string.Concat(new string[] { text3, (text == "") ? "" : (" " + queryValue2.AndOr + " "), sqlKeys, queryValue2.Oper, "@", sqlKeys }); } dataTable2 = this.db.ExecuteQuery("SELECT * FROM userCardLog WHERE " + ((text == "") ? "" : ("(" + text + ") AND ")) + "time>=@createTimeStart AND time<=@createTimeEnd AND operateType=@operateType ORDER BY operationId ASC"); if (dataTable2 != null && dataTable2.Rows != null && dataTable2.Rows.Count > 0) { foreach (object obj2 in dataTable2.Rows) { DataRow dataRow2 = (DataRow)obj2; this.db.AddParameter("permanentUserId", dataRow2["permanentUserId"].ToString()); DataRow dataRow3 = this.db.ExecuteRow("SELECT * FROM usersTable WHERE permanentUserId=@permanentUserId"); if (dataRow3 != null) { this.db.AddParameter("typeId", dataRow3["userTypeId"].ToString()); DataRow dataRow4 = this.db.ExecuteRow("SELECT * FROM userTypeTable WHERE typeId=@typeId"); this.db.AddParameter("priceConsistId", dataRow3["userPriceConsistId"].ToString()); DataRow dataRow5 = this.db.ExecuteRow("SELECT * FROM priceConsistTable WHERE priceConsistId=@priceConsistId"); this.db.AddParameter("userCardLogId", dataRow2["operationId"].ToString()); DataRow dataRow6 = this.db.ExecuteRow("SELECT * FROM payLogTable WHERE userCardLogId=@userCardLogId"); if (dataRow4 != null && dataRow5 != null && dataRow6 != null) { DataRow dataRow7 = dataTable.NewRow(); dataRow7["permanentUserId"] = dataRow3["permanentUserId"].ToString(); dataRow7["username"] = dataRow3["username"].ToString(); dataRow7["identityId"] = dataRow3["identityId"].ToString(); dataRow7["phoneNum"] = dataRow3["phoneNum"].ToString(); dataRow7["address"] = dataRow3["address"].ToString(); dataRow7["usertype"] = dataRow4["userType"].ToString(); dataRow7["priceType"] = dataRow5["priceConstistName"].ToString(); dataRow7["paytype"] = WMConstant.PayTypeList[(int)(checked ((IntPtr)(Convert.ToInt64(dataRow6["payType"]))))]; dataRow7["pursuitTimes"] = dataRow2["consumeTimes"].ToString(); dataRow7["pursuitNum"] = dataRow6["pursuitNum"].ToString(); dataRow7["paynum"] = dataRow6["totalPrice"].ToString(); dataRow7["time"] = WMConstant.DT1970.AddSeconds(ConvertUtils.ToDouble(dataRow2["time"].ToString())).ToString("yyyy-MM-dd HH:mm:ss"); dataRow7["operator"] = dataRow2["operator"].ToString(); dataTable.Rows.Add(dataRow7); dataTable.AcceptChanges(); } } } } this.qb.initDGV(this.initDGV(dataTable)); }
/// <summary> /// Verifies the descriptor after execute. /// </summary> /// <param name="continuation">The continuation.</param> /// <param name="dataContext">The data context.</param> /// <param name="entityPayloads">The list of entities</param> /// <param name="expectedValue">The expected value.</param> protected void VerifyDescriptorAfterExecute(IAsyncContinuation continuation, DataServiceContext dataContext, IEnumerable <object> entityPayloads, QueryValue expectedValue) { // If no streams were generated as part of the test initialization then this block of verification is needed if (this.SkipGenerateNamedStream) { continuation.Continue(); } else { object[] entities = entityPayloads.ToArray(); if (this.DataProviderSettings.UsePayloadDrivenVerification) { expectedValue = this.baselineQueryValue; } var expectedEntities = expectedValue as QueryCollectionValue; QueryStructuralValue element; if (expectedEntities == null) { continuation.Continue(); } else { AsyncHelpers.AsyncForEach( expectedEntities.Elements.ToList(), continuation, (qv, entityContinuation) => { // NOTE: The results could be a list of AnonTypes at which point these wouldn't be have descriptors so // no need to verify element = qv as QueryStructuralValue; var queryEntityType = element.Type as QueryEntityType; if (queryEntityType == null) { entityContinuation.Continue(); } else { var queryEntityValue = element as QueryEntityValue; QueryKeyStructuralValue key = queryEntityValue.Key(); // This handles the expand scenario (Orders(1)?$expand=Customer) where the entity in the list doesn't have a corresponding QueryStructuralValue object entity = entities.Where(upe => queryEntityType.ClrType.IsAssignableFrom(upe.GetType()) && queryEntityType.GetEntityInstanceKey(upe).Equals(key)).FirstOrDefault(); if (entity == null) { entityContinuation.Continue(); } else { EntityDescriptor ed = dataContext.GetEntityDescriptor(entity); var streamProperties = queryEntityType.Properties.Where(p => p.IsStream()).ToList(); // intentionally include the default stream int expectedStreamDescriptorCount = streamProperties.Count(p => p.Name != AstoriaQueryStreamType.DefaultStreamPropertyName); this.Assert.AreEqual(expectedStreamDescriptorCount, ed.StreamDescriptors.Count, "Entity descriptor had unexpected number of stream descriptors"); AsyncHelpers.AsyncForEach( streamProperties, entityContinuation, (streamProperty, streamDescriptorContinuation) => { if (streamProperty.Name == AstoriaQueryStreamType.DefaultStreamPropertyName) { this.VerifyDefaultStream(dataContext, element, ed, streamDescriptorContinuation); } else { this.VerifyNamedStreams(dataContext, element, streamProperty, ed, streamDescriptorContinuation); } }); } } }); } } }
public void ExecuteUriAndCompare <TResult>(IAsyncContinuation continuation, bool isAsync, IQueryable <TResult> query, string uriString, QueryValue expectedValue, DataServiceContext dataContext, ExpectedClientErrorBaseline clientExpectedError) { this.isAsynchronous = isAsync; this.ExecuteQueryAction( continuation, expectedValue, dataContext, clientExpectedError, delegate(List <object> entityPayloads, IAsyncContinuation continuation2) { AsyncHelpers.CatchErrors( continuation2, () => { this.Logger.WriteLine(LogLevel.Verbose, "Executing query, async:{0}, Uri:{1}:", isAsync, dataContext.BaseUri + "/" + uriString); Uri builtUri = new Uri(dataContext.BaseUri + "/" + uriString); EventHandler <SendingRequest2EventArgs> sendingRequest = delegate(object sender, SendingRequest2EventArgs args) { HttpRequestMessage request = ((HttpClientRequestMessage)args.RequestMessage).HttpRequestMessage; this.VerifyCommonExecuteHeaders(request.Headers); }; dataContext.SendingRequest2 += sendingRequest; dataContext.Execute( continuation2, isAsync, builtUri, delegate(IEnumerable <TResult> results) { this.Compare(expectedValue, () => results, dataContext); if (entityPayloads.Count > 0) { this.VerifyDescriptorAfterExecute(continuation2, dataContext, entityPayloads, expectedValue); } else { dataContext.SendingRequest2 -= sendingRequest; continuation2.Continue(); } }); }); }); }
/// <summary> /// Executes the given expression asynchronously and compares the result to a given expected value. /// </summary> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="continuation">The continuation.</param> /// <param name="isAsync">Determines if we execute async or not</param> /// <param name="query">Query to execute</param> /// <param name="expectedValue">The expected value.</param> /// <param name="dataContext">The data context.</param> /// <param name="clientExpectedError">Client Expected Error Information</param> public void ExecuteAndCompare <TResult>(IAsyncContinuation continuation, bool isAsync, IQueryable <TResult> query, QueryValue expectedValue, DataServiceContext dataContext, ExpectedClientErrorBaseline clientExpectedError) { this.isAsynchronous = isAsync; this.ExecuteQueryAction( continuation, expectedValue, dataContext, clientExpectedError, delegate(List <object> entityPayloads, IAsyncContinuation continuation2) { AsyncHelpers.CatchErrors( continuation2, () => { var dataServiceQuery = (DataServiceQuery <TResult>)query; this.Logger.WriteLine(LogLevel.Verbose, "Executing query async:{0}, Expression:{1}:", isAsync, dataServiceQuery.Expression); dataServiceQuery.Execute( continuation2, isAsync, delegate(IEnumerable <TResult> results) { this.Compare(expectedValue, () => results, dataContext); if (entityPayloads.Count > 0) { this.VerifyDescriptorAfterExecute(continuation2, dataContext, entityPayloads, expectedValue); } else { continuation2.Continue(); } }); }); }); }
/// <summary> /// Fixes up references added via Full span. /// </summary> /// <param name="value">QueryValue representing result of a query.</param> /// <param name="spanPaths">Span paths for the query.</param> protected void FixupReferencesBasedOnSpanPaths(QueryValue value, string[] spanPaths) { this.FixupReferencesBasedOnSpanPaths(value, null, null, string.Empty, spanPaths); }
/// <summary> /// Helper method for walking down a query value tree and invoking a callback on all structural values /// </summary> /// <param name="value">The value to visit</param> /// <param name="callback">The callback for structural values</param> /// <returns>The result of visiting the value</returns> private QueryValue VisitEntityValues(QueryValue value, Func<QueryStructuralValue, QueryStructuralValue> callback) { ExceptionUtilities.CheckArgumentNotNull(value, "value"); ExceptionUtilities.CheckArgumentNotNull(callback, "callback"); var collection = value as QueryCollectionValue; if (collection != null && collection.Type.ElementType is QueryEntityType) { return this.VisitEntityValues(collection, callback); } var structural = value as QueryStructuralValue; if (structural != null && structural.Type is QueryEntityType && !structural.IsNull) { return callback(structural); } return value; }
private QueryValue CloneValue(Dictionary<QueryStructuralValue, QueryStructuralValue> identityMap, QueryValue value) { // no need to clone scalar values if (value is QueryScalarValue) { return value; } if (value is AstoriaQueryStreamValue) { return value; } QueryStructuralValue qsv = value as QueryStructuralValue; if (qsv != null) { return this.CloneStructuralValue(identityMap, qsv); } QueryCollectionValue qcv = value as QueryCollectionValue; ExceptionUtilities.Assert(qcv != null, "Expected collection value."); return this.CloneCollectionValue(identityMap, qcv); }
public static bool IsDynamicPropertyValue(this QueryValue value) { ExceptionUtilities.CheckArgumentNotNull(value, "value"); return(value.Annotations.OfType <IsDynamicPropertyValueAnnotation>().Any()); }
private QueryValue EvaluateProperty(string functionName, QueryType type, QueryValue[] arguments) { ValidateArguments(functionName, type, 1, arguments); return this.EvaluateProperty((QueryScalarType)type, functionName, (QueryScalarValue)arguments[0]); }
/// <summary> /// Evaluates member property of a spatial instance. /// </summary> /// <param name="instance">The instance of query value object</param> /// <param name="resultType">The property result type.</param> /// <param name="memberPropertyName">The member property name to evaluate.</param> /// <returns> /// Query value which is the result of method evaluation. /// </returns> public override QueryValue EvaluateMemberProperty(QueryValue instance, QueryType resultType, string memberPropertyName) { if (this.IsSpatialType((IQueryClrType)instance.Type)) { var clrInstance = ((QueryScalarValue)instance).Value; if (clrInstance == null) { var nullValue = resultType.NullValue; nullValue.EvaluationError = new QueryError("Cannot access member property on a null instance"); return nullValue; } var clrType = clrInstance.GetType(); while (!clrType.IsPublic()) { clrType = clrType.GetBaseType(); } var property = clrType.GetProperty(memberPropertyName, true, false); ExceptionUtilities.CheckObjectNotNull(property, "Could not find property"); var propertyValue = property.GetValue(clrInstance, null); if (propertyValue == null) { return resultType.NullValue; } var collectionType = resultType as QueryCollectionType; if (collectionType != null) { var enumerable = propertyValue as IEnumerable; ExceptionUtilities.CheckObjectNotNull(enumerable, "Collection value must be ienumerable. Value was '{0}'", propertyValue); var elementType = (QueryScalarType)collectionType.ElementType; return collectionType.CreateCollectionWithValues(enumerable.Cast<object>().Select(o => (QueryValue)elementType.CreateValue(o))); } else { return ((QueryScalarType)resultType).CreateValue(propertyValue); } } return base.EvaluateMemberProperty(instance, resultType, memberPropertyName); }
/// <summary> /// Helper method for recursively validating elements and catching exceptions from the assertion handler /// </summary> /// <param name="element">The element to validate</param> /// <param name="value">The expected value</param> /// <returns>Null if not exception was caught, or the caught exception</returns> private TestFailedException RecurseAndCatch(ODataPayloadElement element, QueryValue value) { this.expectedValueStack.Push(value); this.payloadStack.Push(element); try { this.Recurse(element, value); return null; } catch (TestFailedException e) { return e; } finally { this.expectedValueStack.Pop(); this.payloadStack.Pop(); } }
static Bool RuntimeQueryValue(QueryValue input) => Undefined.IsDefined(input);
private void Recurse(ODataPayloadElement element, QueryValue value) { this.expectedValueStack.Push(value); this.payloadStack.Push(element); try { element.Accept(this); } finally { this.expectedValueStack.Pop(); this.payloadStack.Pop(); } }
/// <summary> /// Retrieves a value of a constant. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="callerCtx">type of caller class. Used to resolve reserved type names if used in <paramref name="name"/>.</param> /// <param name="name">The name of the constant.</param> /// <param name="this">Optional. Reference to <c>$this</c> object. Used to resolve <c>static::</c> type reference.</param> /// <returns>The value.</returns> public static PhpValue constant(Context ctx, [ImportCallerClass] RuntimeTypeHandle callerCtx, QueryValue <ThisVariable> @this, string name) { if (!TryGetConstant(ctx, callerCtx, @this.Value.This, name, out var value)) { PhpException.Throw(PhpError.Warning, Core.Resources.ErrResources.constant_not_found, name); } // return(value); }
private void VerifyTypeName(QueryValue value, string actualTypeName, string message) { var type = value.Type; string expectedTypeName = this.GetExpectedTypeName(type); bool expectTypeName = false; if (this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.IncludeTypeNames)) { expectTypeName = true; // if type names are omitted within multivalues, we need to figure out if we're within one if (this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.OmitTypeNamesWithinMultiValues)) { bool inMultiValue = false; if (this.payloadStack.Count > 2) { var elementType = this.payloadStack.ElementAt(2).ElementType; inMultiValue = elementType == ODataPayloadElementType.ComplexMultiValueProperty || elementType == ODataPayloadElementType.PrimitiveMultiValueProperty; } if (inMultiValue) { var multivalue = (ITypedValue)this.payloadStack.ElementAt(1); string multiValueElementName; if (ODataUtilities.TryGetMultiValueElementTypeName(multivalue.FullTypeName, out multiValueElementName)) { expectTypeName = expectedTypeName != multiValueElementName; } } } // if this is a primitive type, it may not have a type name var primitiveType = type as QueryScalarType; if (expectTypeName && primitiveType != null) { if (this.payloadStack.Count == 1) { // top-level raw $value payloads don't have a place to write the type name expectTypeName = false; } else if (this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.OmitTypeNamesForAllPrimitives)) { // no type name is expected for any un-structured primitive (JSON does not have a place for this, for instance) // TODO: have a knob for services which choose not to write the type for spatial expectTypeName = false; } else if (this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.OmitTypeNamesForStrings)) { // string is the default type and is not always specified var clrType = primitiveType as IQueryClrType; ExceptionUtilities.CheckObjectNotNull(clrType, "Primitive type did not have a clr type. Type was: {0}", primitiveType); expectTypeName = clrType.ClrType != typeof(string); } } if (type is QueryClrSpatialType) { expectTypeName |= this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.AlwaysIncludeTypeNamesForSpatialPrimitives); } } if (expectTypeName) { // special cases for null values var typedValue = this.payloadStack.Peek() as TypedValue; if (typedValue != null && typedValue.IsNull) { if (!this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.IncludeTypeNamesForNullValues)) { // if nulls are not typed, then do not expect it expectTypeName = false; } else if (this.payloadStack.Count < 3) { // Astoria-ODataLib-Integration: For null top-level properties, ODataLib does not write the type attribute expectTypeName = false; } else if (value.IsDynamicPropertyValue()) { // dynamic nulls do not have type information, but if this is a sub-property of a complex type, then it will have a type name var parentElement = this.payloadStack.ElementAt(2); if (parentElement.ElementType == ODataPayloadElementType.EntityInstance) { expectTypeName = false; } } } } if (expectTypeName) { this.parent.Assert.AreEqual(expectedTypeName, actualTypeName, message); } else { this.parent.Assert.IsNull(actualTypeName, "{0}. Unexpected type name '{1}' found.", message, actualTypeName); } }
private static QueryValue EnsureLastSegmentIsSingletonOrNull(QueryValue value) { QueryCollectionValue collection = value as QueryCollectionValue; if (collection != null) { if (collection.IsNull || collection.Elements.Count == 0) { value = collection.Type.ElementType.NullValue; } else { value = collection.Elements.Single(); } } return value; }
internal string CalculateExpectedETag(QueryValue expected) { if (!expected.IsNull) { QueryEntityType queryEntityType = expected.Type as QueryEntityType; if (queryEntityType != null) { return this.LiteralConverter.ConstructWeakETag(expected as QueryStructuralValue); } } return null; }
private QueryValue ApplySelectAndExpand(ODataUri uri, QueryValue value) { // Note: this is applied on all URIs, and it is left up to the FixupPropertiesForExpand helper method // to skip cases where it is not an entity type var expandedPaths = uri.ExpandSegments.Select(s => this.UriConverter.ConcatenateSegments(s)); value = this.VisitEntityValues(value, s => this.FixupPropertiesForExpand(s, expandedPaths)); var collection = value as QueryCollectionValue; // since we remove expand expression earlier, we need explictly examine it here and set correct IsSorted value for collections. if (collection != null) { var strategy = collection.Type.ElementType.EvaluationStrategy as ILinqToAstoriaQueryEvaluationStrategy; ExceptionUtilities.CheckObjectNotNull(strategy, "Cannot get astoria-specific evaluation strategy from collection value."); if (uri.ExpandSegments.Any() && !strategy.IsCollectionOrderPredictable) { value = QueryCollectionValue.Create(collection.Type.ElementType, collection.Elements, false); } } // if there are any select segments, then fixup the value if (uri.SelectSegments.Count > 0) { // post-process the result to omit properties that were not selected var selectedPaths = uri.SelectSegments.Select(s => this.UriConverter.ConcatenateSegments(s.Where(s2 => !(s2 is EntityTypeSegment)))); value = this.VisitEntityValues(value, s => this.FixupPropertiesForSelect(s, selectedPaths)); } return value; }
public static Bool IsDefined(QueryValue input) => (Bool)(input.ValueType != QueryValueType.None);
private void ValidateAndPrintInfoOnError(ODataUri requestUri, ODataPayloadElement rootElement, QueryValue expectedValue) { try { this.Validator.Validate(rootElement, expectedValue); } catch (DataComparisonException) { // Doing this because of unit test failures, will need to fix this later if (this.QueryDataSet != null) { this.Logger.WriteLine(LogLevel.Info, "Actual Payload Entity Graph:"); this.Logger.WriteLine(LogLevel.Info, this.ODataPayloadElementEntityGraphPrettyPrinter.PrettyPrint(rootElement)); this.Logger.WriteLine(LogLevel.Info, "Expected Query Entity Graph:"); this.Logger.WriteLine(LogLevel.Info, this.ODataQueryValueEntityGraphPrettyPrinter.PrettyPrint(expectedValue, 10)); this.Logger.WriteLine(LogLevel.Info, "Query DataSet Data"); foreach (var entitySet in requestUri.GetAllEntitySetsIncludingExpands()) { this.Logger.WriteLine(LogLevel.Info, entitySet.Name + " DataSet"); var results = this.QueryDataSet[entitySet.Name]; this.Logger.WriteLine(LogLevel.Info, this.ODataQueryValueEntityGraphPrettyPrinter.PrettyPrint(results, 1)); } } throw; } }
// Token: 0x06000281 RID: 641 RVA: 0x000149F4 File Offset: 0x00012BF4 public void queryDB(Dictionary <string, QueryValue> dicts) { double num = ConvertUtils.ToDouble(this.monthLimitTB.Text.Trim()); double num2 = ConvertUtils.ToDouble(this.avaliableLimitTB.Text.Trim()) * 10.0; if (num <= 0.0 && num2 <= 0.0) { WMMessageBox.Show(this, "查询条件需要大于0!"); return; } this.getSqlStr(dicts); new List <string>(); string sqlStrForQueryUser = this.getSqlStrForQueryUser(dicts); DataTable dataTable = new DataTable(); foreach (string key in dicts.Keys) { QueryValue queryValue = dicts[key]; this.db.AddParameter(key, queryValue.Value); } this.db.AddParameter("isActive", "1"); DataTable dataTable2 = this.db.ExecuteQuery("SELECT * FROM usersTable WHERE " + ((sqlStrForQueryUser != "") ? (sqlStrForQueryUser + " AND ") : "") + " isActive=@isActive ORDER BY createTime ASC"); if (dataTable2 != null && dataTable2.Rows != null && dataTable2.Rows.Count > 0) { DateTime dateTime = DateTime.Now; dateTime -= new TimeSpan((int)(num * 30.0), 0, 0, 0); TimeSpan timeSpan = dateTime - WMConstant.DT1970; dataTable.Columns.Add("userId"); dataTable.Columns.Add("username"); dataTable.Columns.Add("identityId"); dataTable.Columns.Add("phoneNum"); dataTable.Columns.Add("address"); dataTable.Columns.Add("lastPursuitDate"); dataTable.Columns.Add("lastPursuitNum"); dataTable.Columns.Add("avaliableNum"); foreach (object obj in dataTable2.Rows) { DataRow dataRow = (DataRow)obj; this.db.AddParameter("permanentUserId", dataRow["permanentUserId"].ToString()); this.db.AddParameter("operateType", "2"); this.db.AddParameter("lastReadInfo", "1"); DataTable dataTable3 = this.db.ExecuteQuery("SELECT * FROM userCardLog WHERE permanentUserId=@permanentUserId ORDER BY operationId DESC"); if (dataTable3 != null && dataTable3.Rows != null && dataTable3.Rows.Count > 0) { DataRow dataRow2 = dataTable3.Rows[0]; double num3 = ConvertUtils.ToDouble(dataRow2["totalNum"].ToString()); double num4 = ConvertUtils.ToDouble(dataRow["totalPursuitNum"].ToString()); if (num2 <= 0.0 || num2 > num4 - num3) { if (num > 0.0) { bool flag = false; foreach (object obj2 in dataTable3.Rows) { DataRow dataRow3 = (DataRow)obj2; if (Convert.ToInt64(dataRow3["operateType"]) < 2L) { if (num <= 0.0 || ConvertUtils.ToUInt64(dataRow3["time"].ToString()) <= timeSpan.TotalSeconds) { dataRow2 = dataRow3; flag = true; break; } break; } } if (!flag) { continue; } } DataRow dataRow4 = dataTable.NewRow(); dataRow4["userId"] = dataRow["userId"].ToString(); dataRow4["username"] = dataRow["username"].ToString(); dataRow4["identityId"] = dataRow["identityId"].ToString(); dataRow4["phoneNum"] = dataRow["phoneNum"].ToString(); dataRow4["address"] = dataRow["address"].ToString(); dataRow4["lastPursuitDate"] = WMConstant.DT1970.AddSeconds(ConvertUtils.ToDouble(dataRow2["time"].ToString())).ToString("yyyy-MM-dd HH:mm:ss"); dataRow4["lastPursuitNum"] = dataRow2["pursuitNum"].ToString(); dataRow4["avaliableNum"] = string.Concat(ConvertUtils.ToInt64(num4 - num3)); dataTable.Rows.Add(dataRow4); dataTable.AcceptChanges(); } } } } this.initDGV(dataTable); }
/// <summary> /// Determines whether a constant is defined. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="callerCtx">type of caller class. Used to resolve reserved type names if used in <paramref name="name"/>.</param> /// <param name="this">Optional. Reference to <c>$this</c> object. Used to resolve <c>static::</c> type reference.</param> /// <param name="name">The name of the constant. Might be a class constant.</param> /// <returns>Whether the constant is defined.</returns> public static bool defined(Context ctx, [ImportCallerClass] RuntimeTypeHandle callerCtx, QueryValue <ThisVariable> @this, string name) { return(TryGetConstant(ctx, callerCtx, @this.Value.This, name, out _)); }
/// <summary> /// Evaluates member method of a spatial instance. /// </summary> /// <param name="instance">The instance of query value object</param> /// <param name="resultType">The function result type.</param> /// <param name="methodName">The member method to evaluate.</param> /// <param name="arguments">Arguments for the function call.</param> /// <returns>Query value which is the result of function evaluation.</returns> public override QueryValue EvaluateMemberMethod(QueryValue instance, QueryType resultType, string methodName, params QueryValue[] arguments) { var value = base.EvaluateMemberMethod(instance, resultType, methodName, arguments); if (instance.IsDynamicPropertyValue() || arguments.Any(a => a.IsDynamicPropertyValue())) { value = value.AsDynamicPropertyValue(); } return value; }
/// <summary> /// 将字段名、字段值、查询方式拼接成SQL查询字符串 /// </summary> /// <returns>查询字符串</returns> public string toQueryString(string iIndex, out string returnStr) { returnStr = string.Empty; var QueryCondition = new StringBuilder(); switch (EQueryType) { case QueryType.BETWEEN: { var pars = QueryValue.Split(','); if (pars.Length == 2) { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" >= @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append("1"); QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" <= @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append("2"); } break; } case QueryType.等于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" = "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" = @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.等于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" <> "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" <> @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.大于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" > "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" > @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.大于等于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" >= "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" >= @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.小于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" < "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" < @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.小于等于: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); if (IsInnerQuery) { QueryCondition.Append(" <= "); QueryCondition.Append(QueryValue); } else { QueryCondition.Append(" <= @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); } break; } case QueryType.LIKE: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" LIKE @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); break; } case QueryType.左LIKE: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" LIKE @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); break; } case QueryType.右LIKE: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" LIKE @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); break; } case QueryType.包含: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.AppendFormat(@" IN (SELECT * FROM @{0}table)", QueryName + iIndex); returnStr = string.Format(@"DECLARE @{0}table TABLE(SID VARCHAR(100)); INSERT INTO @{0}table (SID) SELECT WI.{0}.value('@i','varchar(100)') as Ids FROM @{0}.nodes('/es/e') WI({0}); " , QueryName + iIndex); break; } case QueryType.包含: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.AppendFormat(@" NOT IN (SELECT * FROM @{0}table)", QueryName + iIndex); returnStr = string.Format(@"DECLARE @{0}table TABLE(SID VARCHAR(100)); INSERT INTO @{0}table (SID) SELECT WI.{0}.value('@i','varchar(100)') as Ids FROM @{0}.nodes('/es/e') WI({0}); " , QueryName + iIndex); break; } case QueryType.为空: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" IS NOT NULL "); break; } case QueryType.为空: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(QueryName); QueryCondition.Append(" IS NULL "); break; } case QueryType.升序: { QueryCondition.Append(" ORDER BY "); QueryCondition.Append(QueryName); QueryCondition.Append(" ASC "); break; } case QueryType.降序: { QueryCondition.Append(" ORDER BY "); QueryCondition.Append(QueryName); QueryCondition.Append(" DESC "); break; } case QueryType.组合排序: { QueryCondition.Append(" ORDER BY "); QueryCondition.Append(QueryValue); break; } case QueryType.左括号: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(" ( "); break; } case QueryType.右括号: { QueryCondition.Append(" ) "); break; } case QueryType.或: { QueryCondition.Append(" OR "); break; } case QueryType.异或与: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(" ( "); QueryCondition.Append(QueryName); QueryCondition.Append(" & @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append(" = @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append(" ) "); break; } case QueryType.非异或与: { QueryCondition.Append(QueryRelatedTypeString); QueryCondition.Append(" ( "); QueryCondition.Append(QueryName); QueryCondition.Append(" & @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append(" != @"); QueryCondition.Append(QueryName); QueryCondition.Append(iIndex); QueryCondition.Append(" ) "); break; } } return(QueryCondition.ToString()); }