/// <summary> /// Gets the Numeric Value of the function as evaluated in the given Context for the given Binding ID /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = this._expr.Evaluate(context, bindingID); if (a == null) { throw new RdfQueryException("Cannot calculate an arithmetic expression on a null"); } int p = 0; if (this._precision != null) { IValuedNode precision = this._precision.Evaluate(context, bindingID); if (precision == null) { throw new RdfQueryException("Cannot use a null precision for rounding"); } try { p = Convert.ToInt32(precision.AsInteger()); } catch { throw new RdfQueryException("Unable to cast precision to an integer"); } } switch (a.NumericType) { case SparqlNumericType.Integer: //Rounding an Integer has no effect return(a); case SparqlNumericType.Decimal: return(new DecimalNode(null, Math.Round(a.AsDecimal(), p, MidpointRounding.AwayFromZero))); case SparqlNumericType.Float: try { return(new FloatNode(null, Convert.ToSingle(Math.Round(a.AsDouble(), p, MidpointRounding.AwayFromZero)))); } catch (RdfQueryException) { throw; } catch (Exception ex) { throw new RdfQueryException("Unable to cast the float value of a round to a float", ex); } case SparqlNumericType.Double: return(new DoubleNode(null, Math.Round(a.AsDouble(), p, MidpointRounding.AwayFromZero))); default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } }
/// <summary> /// Gets the Numeric Value of the function as evaluated in the given Context for the given Binding ID /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = this._expr.Evaluate(context, bindingID); if (a == null) { throw new RdfQueryException("Cannot calculate an arithmetic expression on a null"); } switch (a.NumericType) { #if !SILVERLIGHT case SparqlNumericType.Integer: try { return(new LongNode(null, Convert.ToInt64(Math.Floor(a.AsDecimal())))); } catch (RdfQueryException) { throw; } catch (Exception ex) { throw new RdfQueryException("Unable to cast floor value of integer to an integer", ex); } case SparqlNumericType.Decimal: return(new DecimalNode(null, Math.Floor(a.AsDecimal()))); #else case SparqlNumericType.Integer: case SparqlNumericType.Decimal: #endif case SparqlNumericType.Float: try { return(new FloatNode(null, Convert.ToSingle(Math.Floor(a.AsDouble())))); } catch (RdfQueryException) { throw; } catch (Exception ex) { throw new RdfQueryException("Unable to cast floor value of float to a float", ex); } case SparqlNumericType.Double: return(new DoubleNode(null, Math.Floor(a.AsDouble()))); default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } }
/// <summary> /// Gets the Numeric Value of the function as evaluated in the given Context for the given Binding ID /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = this._expr.Evaluate(context, bindingID); if (a == null) { throw new RdfQueryException("Cannot calculate an arithmetic expression on a null"); } switch (a.NumericType) { case SparqlNumericType.Integer: //Rounding an Integer has no effect return(a); case SparqlNumericType.Decimal: #if !SILVERLIGHT return(new DecimalNode(null, Math.Round(a.AsDecimal(), MidpointRounding.AwayFromZero))); #else return(new DecimalNode(null, Math.Round(a.AsDecimal()))); #endif case SparqlNumericType.Float: try { #if !SILVERLIGHT return(new FloatNode(null, Convert.ToSingle(Math.Round(a.AsDouble(), MidpointRounding.AwayFromZero), CultureInfo.InvariantCulture))); #else return(new FloatNode(null, Convert.ToSingle(Math.Round(a.AsDouble()), CultureInfo.InvariantCulture))); #endif } catch (RdfQueryException) { throw; } catch (Exception ex) { throw new RdfQueryException("Unable to cast the float value of a round to a float", ex); } case SparqlNumericType.Double: #if !SILVERLIGHT return(new DoubleNode(null, Math.Round(a.AsDouble(), MidpointRounding.AwayFromZero))); #else return(new DoubleNode(null, Math.Round(a.AsDouble()))); #endif default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode min = _leftExpr.Evaluate(context, bindingID); if (min == null) { throw new RdfQueryException("Cannot randomize with a null minimum"); } IValuedNode max = _rightExpr.Evaluate(context, bindingID); if (max == null) { throw new RdfQueryException("Cannot randomize with a null maximum"); } if (min.NumericType == SparqlNumericType.NaN || max.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot randomize when one/both arguments are non-numeric"); } double x = min.AsDouble(); double y = max.AsDouble(); if (x > y) { throw new RdfQueryException("Cannot generate a random number in the given range since the minumum is greater than the maximum"); } double range = y - x; double rnd = _rnd.NextDouble() * range; rnd += x; return(new DoubleNode(null, rnd)); }
/// <summary> /// Internal helper for calculating 2D Cartesian Distance. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> private IValuedNode CartesianDistance2D(SparqlEvaluationContext context, int bindingID) { IValuedNode x1 = _x1.Evaluate(context, bindingID); if (x1 == null) { throw new RdfQueryException("Cannot calculate cartesian distance when a argument is null"); } IValuedNode y1 = _y1.Evaluate(context, bindingID); if (y1 == null) { throw new RdfQueryException("Cannot calculate cartesian distance when a argument is null"); } IValuedNode x2 = _x2.Evaluate(context, bindingID); if (x2 == null) { throw new RdfQueryException("Cannot calculate cartesian distance when a argument is null"); } IValuedNode y2 = _y2.Evaluate(context, bindingID); if (y2 == null) { throw new RdfQueryException("Cannot calculate cartesian distance when a argument is null"); } double dX = x2.AsDouble() - x1.AsDouble(); double dY = y2.AsDouble() - y1.AsDouble(); return(new DoubleNode(null, Math.Sqrt(Math.Pow(dX, 2) + Math.Pow(dY, 2)))); }
/// <summary> /// Compares two Nodes for Numeric Ordering /// </summary> /// <param name="x">Node</param> /// <param name="y">Node</param> /// <param name="type">Numeric Type</param> /// <returns></returns> protected virtual int NumericCompare(IValuedNode x, IValuedNode y, SparqlNumericType type) { if (x == null || y == null) { throw new RdfQueryException("Cannot evaluate numeric ordering when one or both arguments are Null"); } if (type == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot evaluate numeric ordering when the Numeric Type is NaN"); } switch (type) { case SparqlNumericType.Decimal: return(x.AsDecimal().CompareTo(y.AsDecimal())); case SparqlNumericType.Double: return(x.AsDouble().CompareTo(y.AsDouble())); case SparqlNumericType.Float: return(x.AsFloat().CompareTo(y.AsFloat())); case SparqlNumericType.Integer: return(x.AsInteger().CompareTo(y.AsInteger())); default: throw new RdfQueryException("Cannot evaluate numeric equality since of the arguments is not numeric"); } }
/// <summary> /// Evaluates the expression /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode temp = _expr.Evaluate(context, bindingID); if (temp == null) { throw new RdfQueryException("Cannot square a null"); } switch (temp.NumericType) { case SparqlNumericType.Integer: long l = temp.AsInteger(); return(new LongNode(null, l * l * l)); case SparqlNumericType.Decimal: decimal d = temp.AsDecimal(); return(new DecimalNode(null, d * d * d)); case SparqlNumericType.Float: float f = temp.AsFloat(); return(new FloatNode(null, f * f * f)); case SparqlNumericType.Double: double dbl = temp.AsDouble(); return(new DoubleNode(null, Math.Pow(dbl, 3))); case SparqlNumericType.NaN: default: throw new RdfQueryException("Cannot square a non-numeric argument"); } }
/// <summary> /// Gets the numeric value of the function in the given Evaluation Context for the given Binding ID /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = _leftExpr.Evaluate(context, bindingID); IValuedNode b = _rightExpr.Evaluate(context, bindingID); SparqlNumericType type = (SparqlNumericType)Math.Max((int)a.NumericType, (int)b.NumericType); switch (type) { case SparqlNumericType.Integer: return(new LongNode(null, Math.Max(a.AsInteger(), b.AsInteger()))); case SparqlNumericType.Decimal: return(new DecimalNode(null, Math.Max(a.AsDecimal(), b.AsDecimal()))); case SparqlNumericType.Float: return(new FloatNode(null, Math.Max(a.AsFloat(), b.AsFloat()))); case SparqlNumericType.Double: return(new DoubleNode(null, Math.Max(a.AsDouble(), b.AsDouble()))); default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } }
/// <summary> /// Evaluates the expression /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode temp = this._expr.Evaluate(context, bindingID); if (temp == null) throw new RdfQueryException("Cannot evaluate reciprocal of a null"); double d = temp.AsDouble(); if (d == 0) throw new RdfQueryException("Cannot evaluate reciprocal of zero"); return new DoubleNode(null, 1d / d); }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode temp = _expr.Evaluate(context, bindingID); if (temp == null) { throw new RdfQueryException("Cannot apply a numeric function to a null"); } if (temp.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot apply a numeric function to a non-numeric argument"); } return(new DoubleNode(null, Math.PI * (temp.AsDouble() / 180d))); }
public void ShouldSuccesfullyEvaluateDoubleCastRegardlessOfCulture() { foreach (var ci in TestedCultureInfos) { TestTools.ExecuteWithChangedCulture(ci, () => { // given var cast = new DoubleCast(new ConstantTerm(3.4d.ToLiteral(_graph))); // when IValuedNode valuedNode = cast.Evaluate(new SparqlEvaluationContext(new SparqlQuery(), new InMemoryDataset()), 0); // then Assert.AreEqual(3.4d, valuedNode.AsDouble()); }); } }
/// <summary> /// Calculates the Numeric Value of this Expression as evaluated for a given Binding /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = this._leftExpr.Evaluate(context, bindingID); IValuedNode b = this._rightExpr.Evaluate(context, bindingID); if (a == null || b == null) { throw new RdfQueryException("Cannot apply division when one/both arguments are null"); } SparqlNumericType type = (SparqlNumericType)Math.Max((int)a.NumericType, (int)b.NumericType); try { switch (type) { case SparqlNumericType.Integer: case SparqlNumericType.Decimal: //For Division Integers are treated as decimals decimal d = a.AsDecimal() / b.AsDecimal(); if (Decimal.Floor(d).Equals(d) && d >= Int64.MinValue && d <= Int64.MaxValue) { return(new LongNode(null, Convert.ToInt64(d))); } return(new DecimalNode(null, d)); case SparqlNumericType.Float: return(new FloatNode(null, a.AsFloat() / b.AsFloat())); case SparqlNumericType.Double: return(new DoubleNode(null, a.AsDouble() / b.AsDouble())); default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } } catch (DivideByZeroException) { throw new RdfQueryException("Cannot evaluate a Division Expression where the divisor is Zero"); } }
private static object GetPrimitiveValue(IValuedNode valuedNode, IEdmPrimitiveType targetType, bool asNullable) { // TODO: Some sort of cast to nullable when necessary switch (targetType.PrimitiveKind) { case EdmPrimitiveTypeKind.Boolean: return(valuedNode.AsBoolean()); case EdmPrimitiveTypeKind.Byte: return((byte)valuedNode.AsInteger()); case EdmPrimitiveTypeKind.DateTime: return(valuedNode.AsDateTime()); case EdmPrimitiveTypeKind.Decimal: return(valuedNode.AsDecimal()); case EdmPrimitiveTypeKind.Double: return(valuedNode.AsDouble()); case EdmPrimitiveTypeKind.Int16: return((Int16)valuedNode.AsInteger()); case EdmPrimitiveTypeKind.Int32: return((Int32)valuedNode.AsInteger()); case EdmPrimitiveTypeKind.Int64: return(valuedNode.AsInteger()); case EdmPrimitiveTypeKind.String: return(valuedNode.AsString()); case EdmPrimitiveTypeKind.DateTimeOffset: return(valuedNode.AsDateTime()); default: throw new NotSupportedException( String.Format("Support for primitive type {0} has not been implemented yet", targetType.PrimitiveKind)); } }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode arg = _leftExpr.Evaluate(context, bindingID); if (arg == null) { throw new RdfQueryException("Cannot raise a null to a power"); } IValuedNode pow = _rightExpr.Evaluate(context, bindingID); if (pow == null) { throw new RdfQueryException("Cannot raise to a null power"); } if (arg.NumericType == SparqlNumericType.NaN || pow.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot raise to a power when one/both arguments are non-numeric"); } return(new DoubleNode(null, Math.Pow(arg.AsDouble(), pow.AsDouble()))); }
/// <summary> /// Evaluates the expression /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode temp = this._expr.Evaluate(context, bindingID); if (temp == null) { throw new RdfQueryException("Cannot square root a null"); } switch (temp.NumericType) { case SparqlNumericType.Integer: case SparqlNumericType.Decimal: case SparqlNumericType.Float: case SparqlNumericType.Double: return(new DoubleNode(null, Math.Log(temp.AsDouble(), Math.E))); case SparqlNumericType.NaN: default: throw new RdfQueryException("Cannot square a non-numeric argument"); } }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode x = _leftExpr.Evaluate(context, bindingID); if (x == null) { throw new RdfQueryException("Cannot calculate distance of a null"); } IValuedNode y = _rightExpr.Evaluate(context, bindingID); if (y == null) { throw new RdfQueryException("Cannot calculate distance of a null"); } if (x.NumericType == SparqlNumericType.NaN || y.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot calculate distance when one/both arguments are non-numeric"); } return(new DoubleNode(null, Math.Sqrt(Math.Pow(x.AsDouble(), 2) + Math.Pow(y.AsDouble(), 2)))); }
/// <summary> /// Evaluates the expression. /// </summary> /// <param name="context">Evaluation Context.</param> /// <param name="bindingID">Binding ID.</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode arg = _leftExpr.Evaluate(context, bindingID); if (arg == null) { throw new RdfQueryException("Cannot log a null"); } IValuedNode logBase = _rightExpr.Evaluate(context, bindingID); if (logBase == null) { throw new RdfQueryException("Cannot log to a null base"); } if (arg.NumericType == SparqlNumericType.NaN || logBase.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot log when one/both arguments are non-numeric"); } return(new DoubleNode(null, Math.Log(arg.AsDouble(), logBase.AsDouble()))); }
/// <summary> /// Evaluates the expression /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode arg = this._leftExpr.Evaluate(context, bindingID); if (arg == null) { throw new RdfQueryException("Cannot root a null"); } IValuedNode root = this._rightExpr.Evaluate(context, bindingID); if (root == null) { throw new RdfQueryException("Cannot root to a null root"); } if (arg.NumericType == SparqlNumericType.NaN || root.NumericType == SparqlNumericType.NaN) { throw new RdfQueryException("Cannot root when one/both arguments are non-numeric"); } return(new DoubleNode(null, Math.Pow(arg.AsDouble(), (1d / root.AsDouble())))); }
/// <summary> /// Calculates the Numeric Value of this Expression as evaluated for a given Binding /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode a = this._expr.Evaluate(context, bindingID); if (a == null) { throw new RdfQueryException("Cannot apply unary minus to a null"); } switch (a.NumericType) { case SparqlNumericType.Integer: return(new LongNode(null, -1 * a.AsInteger())); case SparqlNumericType.Decimal: decimal decvalue = a.AsDecimal(); if (decvalue == Decimal.Zero) { return(new DecimalNode(null, Decimal.Zero)); } else { return(new DecimalNode(null, -1 * decvalue)); } case SparqlNumericType.Float: float fltvalue = a.AsFloat(); if (Single.IsNaN(fltvalue)) { return(new FloatNode(null, Single.NaN)); } else if (Single.IsPositiveInfinity(fltvalue)) { return(new FloatNode(null, Single.NegativeInfinity)); } else if (Single.IsNegativeInfinity(fltvalue)) { return(new FloatNode(null, Single.PositiveInfinity)); } else { return(new FloatNode(null, -1.0f * fltvalue)); } case SparqlNumericType.Double: double dblvalue = a.AsDouble(); if (Double.IsNaN(dblvalue)) { return(new DoubleNode(null, Double.NaN)); } else if (Double.IsPositiveInfinity(dblvalue)) { return(new DoubleNode(null, Double.NegativeInfinity)); } else if (Double.IsNegativeInfinity(dblvalue)) { return(new DoubleNode(null, Double.PositiveInfinity)); } else { return(new DoubleNode(null, -1.0 * dblvalue)); } default: throw new RdfQueryException("Cannot evalute an Arithmetic Expression when the Numeric Type of the expression cannot be determined"); } }
/// <summary> /// Casts the value of the inner Expression to a Double /// </summary> /// <param name="context">Evaluation Context</param> /// <param name="bindingID">Binding ID</param> /// <returns></returns> public override IValuedNode Evaluate(SparqlEvaluationContext context, int bindingID) { IValuedNode n = _expr.Evaluate(context, bindingID);//.CoerceToDouble(); if (n == null) { throw new RdfQueryException("Cannot cast a Null to a xsd:double"); } // New method should be much faster // if (n is DoubleNode) return n; // return new DoubleNode(null, n.AsDouble()); switch (n.NodeType) { case NodeType.Blank: case NodeType.GraphLiteral: case NodeType.Uri: throw new RdfQueryException("Cannot cast a Blank/URI/Graph Literal Node to a xsd:double"); case NodeType.Literal: if (n is DoubleNode) { return(n); } if (n is FloatNode) { return(new DoubleNode(n.Graph, n.AsDouble())); } // See if the value can be cast ILiteralNode lit = (ILiteralNode)n; if (lit.DataType != null) { string dt = lit.DataType.ToString(); if (dt.Equals(XmlSpecsHelper.XmlSchemaDataTypeDouble) || dt.Equals(XmlSpecsHelper.XmlSchemaDataTypeFloat)) { double d; if (Double.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out d)) { // Parsed OK return(new DoubleNode(lit.Graph, d)); } else { throw new RdfQueryException("Invalid lexical form for xsd:double"); } } else if (dt.Equals(XmlSpecsHelper.XmlSchemaDataTypeDateTime)) { // DateTime cast forbidden throw new RdfQueryException("Cannot cast a xsd:dateTime to a xsd:double"); } else { double d; if (Double.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out d)) { // Parsed OK return(new DoubleNode(lit.Graph, d)); } else { throw new RdfQueryException("Cannot cast the value '" + lit.Value + "' to a xsd:double"); } } } else { double d; if (Double.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out d)) { // Parsed OK return(new DoubleNode(lit.Graph, d)); } else { throw new RdfQueryException("Cannot cast the value '" + lit.Value + "' to a xsd:double"); } } default: throw new RdfQueryException("Cannot cast an Unknown Node to a xsd:double"); } }
private static object GetPrimitiveValue(IValuedNode valuedNode, IEdmPrimitiveType targetType, bool asNullable) { // TODO: Some sort of cast to nullable when necessary switch (targetType.PrimitiveKind) { case EdmPrimitiveTypeKind.Boolean: return valuedNode.AsBoolean(); case EdmPrimitiveTypeKind.Byte: return (byte) valuedNode.AsInteger(); case EdmPrimitiveTypeKind.DateTime: return valuedNode.AsDateTime(); case EdmPrimitiveTypeKind.Decimal: return valuedNode.AsDecimal(); case EdmPrimitiveTypeKind.Double: return valuedNode.AsDouble(); case EdmPrimitiveTypeKind.Int16: return (Int16) valuedNode.AsInteger(); case EdmPrimitiveTypeKind.Int32: return (Int32) valuedNode.AsInteger(); case EdmPrimitiveTypeKind.Int64: return valuedNode.AsInteger(); case EdmPrimitiveTypeKind.String: return valuedNode.AsString(); case EdmPrimitiveTypeKind.DateTimeOffset: return valuedNode.AsDateTime(); default: throw new NotSupportedException( String.Format("Support for primitive type {0} has not been implemented yet", targetType.PrimitiveKind)); } }
/// <summary> /// Constructs a Full Text Match property function /// </summary> /// <param name="info">Property Function information</param> public FullTextMatchPropertyFunction(PropertyFunctionInfo info) { if (info == null) { throw new ArgumentNullException("info"); } if (!EqualityHelper.AreUrisEqual(info.FunctionUri, this.FunctionUri)) { throw new ArgumentException("Property Function information is not valid for this function"); } //Get basic arguments this._matchVar = info.SubjectArgs[0]; if (this._matchVar.VariableName != null) { this._vars.Add(this._matchVar.VariableName); } if (info.SubjectArgs.Count == 2) { this._scoreVar = info.SubjectArgs[1]; if (this._scoreVar.VariableName != null) { this._vars.Add(this._scoreVar.VariableName); } } //Check extended arguments this._searchVar = info.ObjectArgs[0]; if (this._searchVar.VariableName != null) { this._vars.Add(this._searchVar.VariableName); } switch (info.ObjectArgs.Count) { case 1: break; case 2: PatternItem arg = info.ObjectArgs[1]; if (arg.VariableName != null) { throw new RdfQueryException("Cannot use a variable as the limit/score threshold for full text queries, must use a numeric constant"); } IValuedNode n = ((NodeMatchPattern)arg).Node.AsValuedNode(); switch (n.NumericType) { case SparqlNumericType.Integer: this._limit = (int)n.AsInteger(); break; case SparqlNumericType.Decimal: case SparqlNumericType.Double: case SparqlNumericType.Float: this._threshold = n.AsDouble(); break; default: throw new RdfQueryException("Cannot use a non-numeric constant as the limit/score threshold for full text queries, must use a numeric constant"); } break; case 3: default: PatternItem arg1 = info.ObjectArgs[1]; PatternItem arg2 = info.ObjectArgs[2]; if (arg1.VariableName != null || arg2.VariableName != null) { throw new RdfQueryException("Cannot use a variable as the limit/score threshold for full text queries, must use a numeric constant"); } IValuedNode n1 = ((NodeMatchPattern)arg1).Node.AsValuedNode(); switch (n1.NumericType) { case SparqlNumericType.NaN: throw new RdfQueryException("Cannot use a non-numeric constant as the score threshold for full text queries, must use a numeric constant"); default: this._threshold = n1.AsDouble(); break; } IValuedNode n2 = ((NodeMatchPattern)arg2).Node.AsValuedNode(); switch (n2.NumericType) { case SparqlNumericType.NaN: throw new RdfQueryException("Cannot use a non-numeric constant as the limit for full text queries, must use a numeric constant"); default: this._limit = (int)n2.AsInteger(); break; } break; } }