/// <summary> /// Casts a <see cref="QueryScalarValue"/> to a <see cref="QueryScalarType"/>. The cast will return the value type cast to the new type. /// </summary> /// <param name="type">The type for the cast operation.</param> /// <returns><see cref="QueryScalarValue"/> which is cast to the appropriate type</returns> public override QueryValue Cast(QueryType type) { bool wasNullBefore = this.IsNull; var typeToCastTo = type as QueryScalarType; var clrType = ((IQueryClrType)typeToCastTo).ClrType; QueryScalarValue result = null; if ((clrType.GetGenericArguments().Length == 1 && clrType.GetGenericArguments()[0].IsEnum()) || clrType.IsEnum()) { result = typeToCastTo.CreateValue(this.Value); } else { result = this.EvaluationStrategy.Cast(this, typeToCastTo); } // if the value wasn't null before, but is null now after the cast if (result.IsNull && !wasNullBefore) { return(type.CreateErrorValue(new QueryError("Invalid Cast : Cannot perform Cast to the specified type"))); } result = result.MaterializeValueIfEnum(typeToCastTo); return(result); }
/// <summary> /// Determines if two QueryKeyStructural values are equal or not /// </summary> /// <param name="obj">Object to compare to</param> /// <returns>true if keys are equal false if not</returns> public override bool Equals(object obj) { var otherKeyValue = obj as QueryKeyStructuralValue; if (otherKeyValue != null) { if (this.Type.IsAssignableFrom(otherKeyValue.Type)) { bool match = true; foreach (QueryProperty keyProperty in this.keyProperties) { QueryScalarValue currentKeySubPartValue = this.GetScalarValue(keyProperty.Name); QueryScalarValue otherKeySubPartValue = otherKeyValue.GetScalarValue(keyProperty.Name); if (!currentKeySubPartValue.Type.EvaluationStrategy.AreEqual(currentKeySubPartValue, otherKeySubPartValue)) { match = false; break; } } if (match) { return(true); } } } return(false); }
/// <summary> /// Subtracts the specified value from this value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryScalarValue Subtract(QueryScalarValue otherValue) { var evaluationResult = this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.Subtract); // Enums do not exist as a concept at the store level, so whenever we evaluate something on the store side, we have to // simulate the materialization of the result value to an enum. var materializedResult = evaluationResult.MaterializeValueIfEnum(this.Type); return(materializedResult); }
private QueryScalarValue EvaluateBinaryOperation(QueryScalarValue otherValue, QueryBinaryOperation operation) { ExceptionUtilities.CheckArgumentNotNull(otherValue, "otherValue"); var result = this.EvaluationStrategy.Evaluate(operation, this, otherValue); var error = QueryError.Combine(this.EvaluationError, otherValue.EvaluationError); if (error != null) { result.EvaluationError = error; } return(result); }
private bool ScalarValuesAreEqual(QueryScalarValue firstValueScalar, QueryScalarValue secondValueScalar) { if (!this.ScalarTypesAreEqualComparable(firstValueScalar.Type, secondValueScalar.Type)) { return(false); } if (firstValueScalar.IsNull) { return(secondValueScalar.IsNull); } if (secondValueScalar.IsNull) { return(false); } return((bool)firstValueScalar.EqualTo(secondValueScalar).Value); }
/// <summary> /// Applies the Take operation on the given collection. /// </summary> /// <param name="takeCount">How many elements to take.</param> /// <returns>Collection with the applied Take operation.</returns> public QueryCollectionValue Take(QueryScalarValue takeCount) { ExceptionUtilities.CheckArgumentNotNull(takeCount, "takeCount"); QueryError currentError = QueryError.Combine(this.EvaluationError, takeCount.EvaluationError); if (currentError != null) { return((QueryCollectionValue)this.Type.CreateErrorValue(currentError)); } IEnumerable <QueryValue> result = null; if (!this.IsNull) { result = this.Elements.Take((int)takeCount.Value).ToList(); } return(new QueryCollectionValue(this.Type, this.Type.EvaluationStrategy, QueryError.GetErrorFromValues(result), result, this.IsSorted)); }
/// <summary> /// Applies the Skip operation on the given collection. /// </summary> /// <param name="skipCount">How many elements to skip.</param> /// <returns>Collection with the applied Skip operation.</returns> public QueryCollectionValue Skip(QueryScalarValue skipCount) { ExceptionUtilities.CheckArgumentNotNull(skipCount, "skipCount"); QueryError currentError = QueryError.Combine(this.EvaluationError, skipCount.EvaluationError); if (currentError != null) { return((QueryCollectionValue)this.Type.CreateErrorValue(currentError)); } IEnumerable <QueryValue> result = null; if (!this.IsNull) { // perhaps this must be changed - moved to EvaluationStrategy result = this.Elements.Skip((int)skipCount.Value); } return(new QueryCollectionValue(this.Type, this.Type.EvaluationStrategy, QueryError.GetErrorFromValues(result), result, this.IsSorted)); }
/// <summary> /// Transforms a value from one scalar type to another. /// </summary> /// <param name="valueToTransform">The value to transform.</param> /// <param name="targetType">The target type of the value.</param> /// <returns>The value transformed to the target type.</returns> public static QueryScalarValue MaterializeValueIfEnum(this QueryScalarValue valueToTransform, QueryScalarType targetType) { ExceptionUtilities.CheckArgumentNotNull(targetType, "targetType"); var clrType = ((IQueryClrType)targetType).ClrType; Type clrEnumType; object enumValue = null; if (TryExtractEnumType(clrType, out clrEnumType)) { if (valueToTransform.Value != null) { enumValue = Enum.ToObject(clrEnumType, valueToTransform.Value); } return(targetType.CreateValue(enumValue)); } else { return(valueToTransform); } }
/// <summary> /// Builds a table of sorted orderby primitive values, where the rows by the size of result set, the columns by the number of orderby key selectors. /// </summary> /// <param name="ordering">query ordering of order by key selectors</param> /// <param name="elements">Elements used to get the table values.</param> /// <returns>the table of sorted orderby/thenby scalar values. </returns> private static QueryScalarValue[][] BuildSortedSelectorsTable(QueryOrdering ordering, IEnumerable <object> elements) { int orderingSelectorsCount = ordering.Selectors.Count(); int selectorRowCount = elements.Count(); var orderingSelectorsTable = new QueryScalarValue[selectorRowCount][]; for (int i = 0; i < selectorRowCount; i++) { orderingSelectorsTable[i] = new QueryScalarValue[orderingSelectorsCount]; } for (int row = 0; row < selectorRowCount; row++) { var currentRow = elements.ElementAt(row); for (int col = 0; col < orderingSelectorsCount; col++) { var selector = ordering.Selectors.ElementAt(col); orderingSelectorsTable[row][col] = selector(currentRow); } } return(orderingSelectorsTable); }
/// <summary> /// Gets the result of bitwise AND operation on this value and specified value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryValue BitwiseAnd(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.BitwiseAnd)); }
/// <summary> /// Do the specified BinaryOperation for the two values and returns the result. /// </summary> /// <param name="operation">The binary operation to perform.</param> /// <param name="firstValue">The first value.</param> /// <param name="secondValue">The second value.</param> /// <returns>Result of the operation.</returns> public QueryScalarValue Evaluate(QueryBinaryOperation operation, QueryScalarValue firstValue, QueryScalarValue secondValue) { throw new TaupoNotSupportedException("Attempt to use evaluation strategy from " + typeof(QueryUnresolvedType).Name + ". Please resolve expression first."); }
/// <summary> /// Compares the primitive value to another value and returns their relative ordering. /// </summary> /// <param name="value">First value.</param> /// <param name="otherValue">Second value.</param> /// <returns> /// Integer which is less than zero if this value is less than the other value, 0 if they are equal, /// greater than zero if this value is greater than the other value /// </returns> public int Compare(QueryScalarValue value, QueryScalarValue otherValue) { throw new TaupoNotSupportedException("Attempt to use evaluation strategy from " + typeof(QueryUnresolvedType).Name + ". Please resolve expression first."); }
/// <summary> /// Gets a <see cref="QueryScalarValue"/> value representing the result of boolean conjunction (AND) of two values. /// </summary> /// <param name="otherValue">The second boolean value.</param> /// <returns> /// Instance of <see cref="QueryScalarValue"/> which represents the result of boolean operation. /// </returns> public QueryScalarValue AndAlso(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.LogicalAnd)); }
/// <summary> /// Gets a <see cref="QueryScalarValue"/> value indicating whether first value is greater than or equal to the second one. /// </summary> /// <param name="otherValue">The second value.</param> /// <returns> /// Instance of <see cref="QueryScalarValue"/> which represents the result of comparison. /// </returns> public QueryScalarValue GreaterThanOrEqual(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.GreaterThanOrEqualTo)); }
/// <summary> /// Gets a <see cref="QueryScalarValue"/> value indicating whether two values are not equal. /// </summary> /// <param name="otherValue">The query scalar value.</param> /// <returns> /// Instance of <see cref="QueryScalarValue"/> which represents the result of comparison. /// </returns> public QueryScalarValue NotEqualTo(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.NotEqualTo)); }
/// <summary> /// Gets a <see cref="QueryScalarValue"/> value indicating whether first value is less than the second one. /// </summary> /// <param name="otherValue">The second value.</param> /// <returns> /// Instance of <see cref="QueryScalarValue"/> which represents the result of comparison. /// </returns> public QueryScalarValue LessThan(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.LessThan)); }
/// <summary> /// Compares the primitive value to another value and returns their relative ordering. /// </summary> /// <param name="otherValue">The other scalar value.</param> /// <returns> /// Integer which is less than zero if this value is less than the other value, 0 if they are equal, /// greater than zero if this value is greater than the other value /// </returns> private int CompareTo(QueryScalarValue otherValue) { ExceptionUtilities.CheckArgumentNotNull(otherValue, "otherValue"); return(this.EvaluationStrategy.Compare(this, otherValue)); }
/// <summary> /// Gets a <see cref="QueryScalarValue"/> value representing the result of boolean alternative (OR) of two values. /// </summary> /// <param name="otherValue">The second boolean value.</param> /// <returns> /// Instance of <see cref="QueryScalarValue"/> which represents the result of boolean operation. /// </returns> public QueryScalarValue OrElse(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.LogicalOr)); }
/// <summary> /// Divides the value by the the specified other value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryScalarValue Divide(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.Divide)); }
/// <summary> /// Gets the result of exclusive OR (XOR) operation on this value and specified value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryValue ExclusiveOr(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.BitwiseExclusiveOr)); }
/// <summary> /// Casts a <see cref="QueryScalarValue"/> to a <see cref="QueryScalarType"/>. The cast will return the value type cast to the new type. /// </summary> /// <param name="source">The source for the cast operation.</param> /// <param name="type">The type for the cast operation.</param> /// <returns><see cref="QueryScalarValue"/> which is cast to the appropriate type</returns> public QueryScalarValue Cast(QueryScalarValue source, QueryScalarType type) { throw new TaupoNotSupportedException("Attempt to use evaluation strategy from " + typeof(QueryUnresolvedType).Name + ". Please resolve expression first."); }
/// <summary> /// Gets the result of modulo operation of the value by the the specified other value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryScalarValue Modulo(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.Modulo)); }
/// <summary> /// Multiplies the value by the the specified other value. /// </summary> /// <param name="otherValue">The other value.</param> /// <returns>Result of the arithmetic operation.</returns> public QueryScalarValue Multiply(QueryScalarValue otherValue) { return(this.EvaluateBinaryOperation(otherValue, QueryBinaryOperation.Multiply)); }