/// <summary>
/// Gets the String representation of the Aggregate
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder output = new StringBuilder();
output.Append("GROUP_CONCAT(");
if (this._distinct)
{
output.Append("DISTINCT ");
}
if (this._expr is ConcatFunction)
{
ConcatFunction concatFunc = (ConcatFunction)this._expr;
for (int i = 0; i < concatFunc.Arguments.Count(); i++)
{
output.Append(concatFunc.Arguments.Skip(i).First().ToString());
if (i < concatFunc.Arguments.Count() - 1)
{
output.Append(", ");
}
}
}
else
{
output.Append(this._expr.ToString());
}
if (this._customSeparator)
{
output.Append(" ; SEPARATOR = ");
output.Append(this._sep.ToString());
}
output.Append(")");
return(output.ToString());
}
protected override string RenderConcatColumn(ConcatFunction concatColumn, bool renderAlias)
{
if (concatColumn == null)
{
throw new ArgumentNullException(nameof(concatColumn));
}
StringBuilder sbConcat = new StringBuilder();
sbConcat = concatColumn.Columns
.Aggregate(sbConcat, (current, column) => current.Append($"{(current.Length > 0 ? ", " : string.Empty)}{RenderColumn(column, renderAlias: false)}"));
sbConcat.Insert(0, "CONCAT(").Append(")");
return(renderAlias && !string.IsNullOrWhiteSpace(concatColumn.Alias)
? RenderColumnnameWithAlias(sbConcat.ToString(), EscapeName(concatColumn.Alias))
: sbConcat.ToString());
}
private IDataReader GetRelatedTableReader(string table_name)
{
var metadata = (TMappingInfo)MappingFactory.GetMapping(typeof(TMappingInfo));
var item = metadata.Associations.Where(x => x.Name == table_name).FirstOrDefault();
if (item == null)
{
return(null);
}
var omapping = MappingFactory.GetMapping(item.OtherMappingType);
var qry = (new SelectStatement())
.Column(omapping.Columns.Where(x => x.Name == item.OtherKeys[0]).Single().ColumnName)
.From(omapping.TableName);
var lblCount = item.OtherLabels.Count;
if (lblCount == 0)
{
return(null);
}
else
{
if (lblCount == 1)
{
qry.Column(omapping.Columns.Where(x => x.Name == item.OtherLabels[0]).Single().ColumnName);
}
else
{
var lblConcat = new ConcatFunction(" | ");
foreach (var lbl in item.OtherLabels)
{
lblConcat.Append(new SqlColumnName(omapping.Columns.Where(x => x.Name == lbl).Single().ColumnName));
}
qry.Column(lblConcat);
}
}
return(qry.ExecuteReader());
}
/// <summary>
/// Tries to create an XPath Function expression if the function Uri correseponds to a supported XPath Function.
/// </summary>
/// <param name="u">Function Uri.</param>
/// <param name="args">Function Arguments.</param>
/// <param name="scalarArgs">Scalar Arguments.</param>
/// <param name="expr">Generated Expression.</param>
/// <returns>Whether an expression was successfully generated.</returns>
public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <String, ISparqlExpression> scalarArgs, out ISparqlExpression expr)
{
// If any Scalar Arguments are present then can't possibly be an XPath Function
if (scalarArgs.Count > 0)
{
expr = null;
return(false);
}
String func = u.AbsoluteUri;
if (func.StartsWith(XPathFunctionsNamespace))
{
func = func.Substring(XPathFunctionsNamespace.Length);
ISparqlExpression xpathFunc = null;
switch (func)
{
case Absolute:
if (args.Count == 1)
{
xpathFunc = new AbsFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath abs() function");
}
break;
case AdjustDateTimeToTimezone:
throw new NotSupportedException("XPath adjust-dateTime-to-timezone() function is not supported");
case Boolean:
if (args.Count == 1)
{
xpathFunc = new BooleanFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath boolean() function");
}
throw new NotSupportedException("XPath boolean() function is not supported");
case Ceiling:
if (args.Count == 1)
{
xpathFunc = new CeilingFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ceiling() function");
}
break;
case Compare:
if (args.Count == 2)
{
xpathFunc = new CompareFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath compare() function");
}
break;
case Concat:
if (args.Count == 2)
{
xpathFunc = new ConcatFunction(args.First(), args.Last());
}
else if (args.Count > 2)
{
xpathFunc = new ConcatFunction(args);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath concat() function");
}
break;
case Contains:
if (args.Count == 2)
{
xpathFunc = new ContainsFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath contains() function");
}
break;
case DayFromDateTime:
if (args.Count == 1)
{
xpathFunc = new DayFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath day-from-dateTime() function");
}
break;
case EncodeForURI:
if (args.Count == 1)
{
xpathFunc = new EncodeForUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath encode-for-uri() function");
}
break;
case EndsWith:
if (args.Count == 2)
{
xpathFunc = new EndsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ends-with() function");
}
break;
case EscapeHtmlURI:
if (args.Count == 1)
{
xpathFunc = new EscapeHtmlUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath escape-html-uri() function");
}
break;
case False:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, false));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath false() function");
}
break;
case Floor:
if (args.Count == 1)
{
xpathFunc = new FloorFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath floor() function");
}
break;
case HoursFromDateTime:
if (args.Count == 1)
{
xpathFunc = new HoursFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath hours-from-dateTime() function");
}
break;
case LowerCase:
if (args.Count == 1)
{
xpathFunc = new LowerCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath lower-case() function");
}
break;
case Matches:
if (args.Count == 2)
{
xpathFunc = new Functions.Sparql.Boolean.RegexFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new Functions.Sparql.Boolean.RegexFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath matches() function");
}
break;
case MinutesFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MinutesFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath minutes-from-dateTime() function");
}
break;
case MonthFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MonthFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath month-from-dateTime() function");
}
break;
case NormalizeSpace:
if (args.Count == 1)
{
xpathFunc = new NormalizeSpaceFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
case NormalizeUnicode:
if (args.Count == 1)
{
xpathFunc = new NormalizeUnicodeFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new NormalizeUnicodeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
case Not:
if (args.Count == 1)
{
xpathFunc = new NotExpression(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath not() function");
}
break;
case Replace:
if (args.Count == 3)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args.Last());
}
else if (args.Count == 4)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args[2], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath replace() function");
}
break;
case Round:
if (args.Count == 1)
{
xpathFunc = new RoundFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round() function");
}
break;
case RoundHalfToEven:
if (args.Count == 1)
{
xpathFunc = new RoundHalfToEvenFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new RoundHalfToEvenFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round-half-to-even() function");
}
break;
case SecondsFromDateTime:
if (args.Count == 1)
{
xpathFunc = new SecondsFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath seconds-from-dateTime() function");
}
break;
case StartsWith:
if (args.Count == 2)
{
xpathFunc = new StartsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath starts-with() function");
}
break;
case StringJoin:
if (args.Count == 1)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First()));
}
else if (args.Count == 2)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First(), args.Last()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-join() function");
}
break;
case StringLength:
if (args.Count == 1)
{
xpathFunc = new StringLengthFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-length() function");
}
break;
case Substring:
if (args.Count == 2)
{
xpathFunc = new SubstringFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new SubstringFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring() function");
}
break;
case SubstringAfter:
if (args.Count == 2)
{
xpathFunc = new SubstringAfterFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-after() function");
}
break;
case SubstringBefore:
if (args.Count == 2)
{
xpathFunc = new SubstringBeforeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-before() function");
}
break;
case TimezoneFromDateTime:
if (args.Count == 1)
{
xpathFunc = new TimezoneFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath timezone-from-dateTime() function");
}
break;
case Translate:
throw new NotSupportedException("XPath translate() function is not supported");
case True:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath true() function");
}
break;
case UpperCase:
if (args.Count == 1)
{
xpathFunc = new UpperCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath upper-case() function");
}
break;
case YearFromDateTime:
if (args.Count == 1)
{
xpathFunc = new YearFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath year-from-dateTime() function");
}
break;
}
if (xpathFunc != null)
{
expr = xpathFunc;
return(true);
}
}
expr = null;
return(false);
}
/// <summary>
/// Tries to create a SPARQL Function expression if the function Uri correseponds to a supported SPARQL Function.
/// </summary>
/// <param name="u">Function Uri.</param>
/// <param name="args">Function Arguments.</param>
/// <param name="scalarArguments">Scalar Arguments.</param>
/// <param name="expr">Generated Expression.</param>
/// <returns>Whether an expression was successfully generated.</returns>
public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <string, ISparqlExpression> scalarArguments, out ISparqlExpression expr)
{
String func = u.ToString();
if (func.StartsWith(SparqlFunctionsNamespace))
{
func = func.Substring(SparqlFunctionsNamespace.Length);
func = func.ToUpper();
// If any Scalar Arguments are present then can't be a SPARQL Function UNLESS it is
// a GROUP_CONCAT function and it has the SEPARATOR argument
if (scalarArguments.Count > 0)
{
if (func.Equals(SparqlSpecsHelper.SparqlKeywordGroupConcat) && scalarArguments.Count == 1 && scalarArguments.ContainsKey(SparqlSpecsHelper.SparqlKeywordSeparator))
{
// OK
}
else
{
expr = null;
return(false);
}
}
// Q: Will there be special URIs for the DISTINCT modified forms of aggregates?
ISparqlExpression sparqlFunc = null;
switch (func)
{
case SparqlSpecsHelper.SparqlKeywordAbs:
if (args.Count == 1)
{
sparqlFunc = new AbsFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ABS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordAvg:
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new AverageAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL AVG() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordBound:
if (args.Count == 1)
{
if (args[0] is VariableTerm)
{
sparqlFunc = new BoundFunction((VariableTerm)args[0]);
}
else
{
throw new RdfParseException("The SPARQL BOUND() function only operates over Variables");
}
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL BOUND() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordCeil:
if (args.Count == 1)
{
sparqlFunc = new CeilFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL CEIL() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordCoalesce:
if (args.Count >= 1)
{
sparqlFunc = new CoalesceFunction(args);
}
else
{
throw new RdfParseException("The SPARQL COALESCE() function requires at least 1 argument");
}
break;
case SparqlSpecsHelper.SparqlKeywordConcat:
if (args.Count >= 1)
{
sparqlFunc = new ConcatFunction(args);
}
else
{
throw new RdfParseException("The SPARQL CONCAT() function requires at least 1 argument");
}
break;
case SparqlSpecsHelper.SparqlKeywordContains:
if (args.Count == 2)
{
sparqlFunc = new ContainsFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL CONTAINS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordCount:
// Q: What will the URIs be for the special forms of COUNT?
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new CountAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL COUNT() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordDataType:
if (args.Count == 1)
{
sparqlFunc = new DataTypeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL DATATYPE() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordDay:
if (args.Count == 1)
{
sparqlFunc = new DayFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL DAY() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordEncodeForUri:
if (args.Count == 1)
{
sparqlFunc = new EncodeForUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ENCODE_FOR_URI() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordFloor:
if (args.Count == 1)
{
sparqlFunc = new FloorFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL FLOOR() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordGroupConcat:
if (args.Count == 1)
{
if (scalarArguments.ContainsKey(SparqlSpecsHelper.SparqlKeywordSeparator))
{
sparqlFunc = new AggregateTerm(new GroupConcatAggregate(args.First(), scalarArguments[SparqlSpecsHelper.SparqlKeywordSeparator]));
}
else
{
sparqlFunc = new AggregateTerm(new GroupConcatAggregate(args.First()));
}
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL GROUP_CONCAT() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordHours:
if (args.Count == 1)
{
sparqlFunc = new HoursFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL HOURS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIf:
if (args.Count == 3)
{
sparqlFunc = new IfElseFunction(args[0], args[1], args[2]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL IF() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIri:
if (args.Count == 1)
{
sparqlFunc = new IriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL IRI() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIsBlank:
if (args.Count == 1)
{
sparqlFunc = new IsBlankFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ISBLANK() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIsIri:
if (args.Count == 1)
{
sparqlFunc = new IsIriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ISIRI() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIsLiteral:
if (args.Count == 1)
{
sparqlFunc = new IsLiteralFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ISLITERAL() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIsNumeric:
if (args.Count == 1)
{
sparqlFunc = new IsNumericFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ISNUMERIC() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordIsUri:
if (args.Count == 1)
{
sparqlFunc = new IsUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ISURI() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordLang:
if (args.Count == 1)
{
sparqlFunc = new LangFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL LANG() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordLangMatches:
if (args.Count == 2)
{
sparqlFunc = new LangMatchesFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL LANGMATCHES() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordLCase:
if (args.Count == 1)
{
sparqlFunc = new LCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL LCASE() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordMax:
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new MaxAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL MAX() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordMD5:
if (args.Count == 1)
{
sparqlFunc = new MD5HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL MD5() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordMin:
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new MinAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL MIN() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordMinutes:
if (args.Count == 1)
{
sparqlFunc = new MinutesFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL MINUTES() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordMonth:
if (args.Count == 1)
{
sparqlFunc = new MonthFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL MONTH() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordNow:
if (args.Count == 0)
{
sparqlFunc = new NowFunction();
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ABS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordRegex:
if (args.Count == 2)
{
sparqlFunc = new RegexFunction(args[0], args[1]);
}
else if (args.Count == 3)
{
sparqlFunc = new RegexFunction(args[0], args[1], args[2]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL REGEX() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordRound:
if (args.Count == 1)
{
sparqlFunc = new RoundFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL ROUND() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSameTerm:
if (args.Count == 2)
{
sparqlFunc = new SameTermFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SAMETERM() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSample:
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new SampleAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL AVG() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordSeconds:
if (args.Count == 1)
{
sparqlFunc = new SecondsFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SECONDS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSha1:
if (args.Count == 1)
{
sparqlFunc = new Sha1HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SHA1() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSha256:
if (args.Count == 1)
{
sparqlFunc = new Sha256HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SHA256() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSha384:
if (args.Count == 1)
{
sparqlFunc = new Sha384HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SHA384() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSha512:
if (args.Count == 1)
{
sparqlFunc = new Sha512HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SHA512() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStr:
if (args.Count == 1)
{
sparqlFunc = new StrFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STR() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStrDt:
if (args.Count == 2)
{
sparqlFunc = new StrDtFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STRDT() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStrEnds:
if (args.Count == 2)
{
sparqlFunc = new StrEndsFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STRENDS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStrLang:
if (args.Count == 2)
{
sparqlFunc = new StrLangFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STRLANG() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStrLen:
if (args.Count == 1)
{
sparqlFunc = new StrLenFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STRKEN() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordStrStarts:
if (args.Count == 2)
{
sparqlFunc = new StrStartsFunction(args[0], args[1]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL STRSTARTS() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSubStr:
if (args.Count == 2)
{
sparqlFunc = new SubStrFunction(args[0], args[1]);
}
else if (args.Count == 3)
{
sparqlFunc = new SubStrFunction(args[0], args[1], args[2]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SUBSTR() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordSum:
if (args.Count == 1)
{
sparqlFunc = new AggregateTerm(new SumAggregate(args.First()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL SUM() aggregate");
}
break;
case SparqlSpecsHelper.SparqlKeywordTimezone:
if (args.Count == 1)
{
sparqlFunc = new TimezoneFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL TIMEZONE() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordTz:
if (args.Count == 1)
{
sparqlFunc = new TZFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL TZ() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordUCase:
if (args.Count == 1)
{
sparqlFunc = new UCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL UCASE() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordUri:
if (args.Count == 1)
{
sparqlFunc = new IriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL URI() function");
}
break;
case SparqlSpecsHelper.SparqlKeywordYear:
if (args.Count == 1)
{
sparqlFunc = new YearFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the SPARQL YEAR() function");
}
break;
}
if (sparqlFunc != null)
{
expr = sparqlFunc;
return(true);
}
}
expr = null;
return(false);
}
public void TestConcatRhsNotEmptyLhsNull()
{
var function = new ConcatFunction();
Assert.That(function.Evaluate(null, "rhs"), Is.EqualTo("rhs"));
}
public void TestConcatLhsNotEmptyRhsNull()
{
var function = new ConcatFunction();
Assert.That(function.Evaluate("lhs", null), Is.EqualTo("lhs"));
}
public void TestConcatBothNull()
{
var function = new ConcatFunction();
Assert.That(function.Evaluate(null, null), Is.EqualTo(""));
}
public void TestConcatBothEmpty()
{
var function = new ConcatFunction();
Assert.That(function.Evaluate("", ""), Is.EqualTo(""));
}
public void TesSomethingToConcat()
{
var function = new ConcatFunction();
Assert.That(function.Evaluate("lhs", "rhs"), Is.EqualTo("lhsrhs"));
}
private void AddDataTable(string table_name, string table_alias, IMapping mapping)
{
if (this.Tables.Contains(table_alias))
{
return;
}
var table = new DataTable(table_alias);
var keys = new List <DataColumn>();
this.Tables.Add(table);
var columns = table.Columns;
var select = (new SelectStatement()).From(table_name, "t0");
table.ExtendedProperties["Storage"] = table_name;
foreach (var item in mapping.Columns)
{
if (IgnoreMemoFields && item.IsMemo)
{
continue;
}
var pinfo = (PropertyInfo)item.Property;
DataColumn column;
if (pinfo.PropertyType.IsGenericType && pinfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
column = columns.Add(item.Name, pinfo.PropertyType.GetGenericArguments()[0]);
}
else if (pinfo.PropertyType.IsEnum)
{
column = columns.Add(item.Name, typeof(string));
}
else
{
column = columns.Add(item.Name, pinfo.PropertyType);
}
select.Column(new SqlColumnName("t0", item.ColumnName), item.Name);
if (item.IsDbGenerated)
{
column.AutoIncrement = true;
column.AutoIncrementSeed = 1;
column.AutoIncrementStep = 1;
column.Unique = true;
}
if (item.IsPrimaryKey)
{
column.ExtendedProperties["PrimaryKey"] = true;
keys.Add(column);
}
column.AllowDBNull = item.IsNullable;
//if (item.IsNullable && item.DefaultValue != null)
// column.DefaultValue = item.DefaultValue;
if (!item.IsDbGenerated)
{
if (item.DefaultFunctionValue == null)
{
column.DefaultValue = item.DefaultValue;
}
else
{
column.DefaultValue = item.DefaultFunctionValue();
}
}
column.ExtendedProperties["Storage"] = item.ColumnName;
if (item.IsMemo)
{
column.ExtendedProperties["Memo"] = true;
}
}
table.ExtendedProperties["SelectStatement"] = select;
if (keys.Count > 0)
{
table.PrimaryKey = keys.ToArray();
}
/* Procedimiento para añadir las columnas descriptivas de las columnas foreanas */
var items = mapping.Associations.Where(x => x.GetType().Name == "MakeReferenceToMapping`2" || x.GetType().Name == "HasOneMapping`2");
if (items.Count() == 0)
{
return;
}
//Debes poner las otras columnas con el nombre fisico alias el nombre de la propiedad
int t = 1;
string tp = "t" + t;
foreach (var item in items)
{
var omapping = MappingFactory.GetMapping(item.OtherMappingType);
// extra columns for criteria support
for (var x = 0; x < omapping.Columns.Count; x++)
{
var col = omapping.Columns[x];
select.Column(new SqlColumnName(tp, col.ColumnName), item.Name + "." + col.Name);
}
/* build joins */
//for (var k = 0; k < item.ThisKeys.Count; k++ )
//{
var keyName = item.ThisKeys[0];
var otherKeyName = item.OtherKeys[0];
var tcol = mapping.Columns.Where(x => x.Name == keyName).Single();
var ocol = omapping.Columns.Where(x => x.Name == otherKeyName).Single();
if (tcol.IsNullable || item.GetType().Name == "HasOneMapping`2")
{
select.LeftJoin(omapping.TableName, tp, Condition.IsEqual(new SqlColumnName("t0", tcol.ColumnName), new SqlColumnName(tp, ocol.ColumnName)));
}
else
{
select.InnerJoin(omapping.TableName, tp, Condition.IsEqual(new SqlColumnName("t0", tcol.ColumnName), new SqlColumnName(tp, ocol.ColumnName)));
}
//}
/* build foreign row name */
var lblCount = item.OtherLabels.Count;
if (lblCount > 0)
{
var lbl0 = item.OtherLabels[0];
//var colName = omapping.Columns.Where(x => x.Name == lbl0).Single().ColumnName;
ISqlExpression lblExpr;
if (lblCount == 1)
{
lblExpr = new SqlColumnName(item.Name + "." + item.OtherLabels[0]);
}
else
{
var lblConcat = new ConcatFunction(" | ");
foreach (var lbl in item.OtherLabels)
{
lblConcat.Append(new SqlColumnName(item.Name, lbl));
}
lblExpr = lblConcat;
}
var column = columns.Add(item.Name, typeof(string));
column.ExtendedProperties["SelectExpression"] = lblExpr;
column.ExtendedProperties["NonStorable"] = true;
}
// Include OtherColumns in DataTable
foreach (string ocn in item.OtherColumns)
{
var column = columns.Add(omapping.EntityName + "." + ocn, typeof(string));
column.ExtendedProperties["NonStorable"] = true;
}
t++;
tp = "t" + t;
}
}
private ISparqlExpression TryParseAggregateExpression(Queue<IToken> tokens)
{
if (this._syntax == SparqlQuerySyntax.Sparql_1_0) throw new RdfParseException("Aggregates are not permitted in SPARQL 1.0");
IToken agg = tokens.Dequeue();
ISparqlExpression aggExpr = null;
bool distinct = false, all = false;
bool scalarArgs = false;
//Expect a Left Bracket next
IToken next = tokens.Dequeue();
if (next.TokenType != Token.LEFTBRACKET)
{
throw Error("Unexpected Token '" + next.GetType().ToString() + "', expected a Left Bracket after an Aggregate Keyword", next);
}
//Then a possible DISTINCT/ALL
next = tokens.Peek();
if (next.TokenType == Token.DISTINCT)
{
distinct = true;
tokens.Dequeue();
}
next = tokens.Peek();
if (next.TokenType == Token.ALL || next.TokenType == Token.MULTIPLY)
{
all = true;
tokens.Dequeue();
}
next = tokens.Peek();
//If we've seen an ALL then we need the closing bracket
if (all && next.TokenType != Token.RIGHTBRACKET)
{
throw Error("Unexpected Token '" + next.GetType().ToString() + "', expected a Right Bracket after the * specifier in an aggregate to terminate the aggregate", next);
}
else if (all && agg.TokenType != Token.COUNT)
{
throw new RdfQueryException("Cannot use the * specifier in aggregates other than COUNT");
}
else if (!all)
{
//If it's not an all then we expect some expression(s)
//Gather the Tokens and parse the Expression
Queue<IToken> subtokens = new Queue<IToken>();
int openBrackets = 1;
List<ISparqlExpression> expressions = new List<ISparqlExpression>();
while (openBrackets > 0)
{
subtokens = new Queue<IToken>();
next = tokens.Dequeue();
do
{
if (next.TokenType == Token.LEFTBRACKET)
{
openBrackets++;
}
else if (next.TokenType == Token.RIGHTBRACKET)
{
openBrackets--;
}
else if (next.TokenType == Token.COMMA)
{
//If we see a comma when we only have 1 bracket open then it is separating argument expressions
if (openBrackets == 1)
{
break;
}
}
else if (next.TokenType == Token.SEMICOLON)
{
//If we see a semicolon when we only have 1 bracket open then this indicates we have scalar arguments in-use
if (openBrackets == 1)
{
scalarArgs = true;
break;
}
}
if (openBrackets > 0)
{
subtokens.Enqueue(next);
next = tokens.Dequeue();
}
} while (openBrackets > 0);
//Parse this expression and add to the list of expressions we're concatenating
expressions.Add(this.Parse(subtokens));
//Once we've hit the ; for the scalar arguments then we can stop looking for expressions
if (scalarArgs) break;
//If we've hit a , then openBrackets will still be one and we'll go around again looking for another expression
//Otherwise we've reached the end of the aggregate and there was no ; for scalar arguments
}
if (expressions.Count == 0) throw new RdfParseException("Aggregate must have at least one argument expression unless they are a COUNT(*)");
if (agg.TokenType == Token.GROUPCONCAT)
{
aggExpr = new ConcatFunction(expressions);
}
else
{
if (expressions.Count > 1) throw new RdfParseException("The " + agg.Value + " aggregate does not support more than one argument expression");
aggExpr = expressions.First();
}
}
else
{
tokens.Dequeue();
}
//If the aggregate uses scalar arguments then we'll parse them here
Dictionary<String, ISparqlExpression> scalarArguments = new Dictionary<string, ISparqlExpression>();
if (scalarArgs)
{
scalarArguments = this.TryParseScalarArguments(agg, tokens);
}
//Now we need to generate the actual expression
switch (agg.TokenType)
{
case Token.AVG:
//AVG Aggregate
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new AverageAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new AverageAggregate(aggExpr, distinct));
}
case Token.COUNT:
//COUNT Aggregate
if (all)
{
if (distinct)
{
return new AggregateTerm(new CountAllDistinctAggregate());
}
else
{
return new AggregateTerm(new CountAllAggregate());
}
}
else if (aggExpr is VariableTerm)
{
if (distinct)
{
return new AggregateTerm(new CountDistinctAggregate((VariableTerm)aggExpr));
}
else
{
return new AggregateTerm(new CountAggregate((VariableTerm)aggExpr));
}
}
else
{
if (distinct)
{
return new AggregateTerm(new CountDistinctAggregate(aggExpr));
}
else
{
return new AggregateTerm(new CountAggregate(aggExpr));
}
}
case Token.GROUPCONCAT:
if (scalarArgs)
{
if (!scalarArguments.ContainsKey(SparqlSpecsHelper.SparqlKeywordSeparator)) throw new RdfParseException("The GROUP_CONCAT aggregate has Scalar Arguments but does not have the expected SEPARATOR argument");
return new AggregateTerm(new GroupConcatAggregate(aggExpr, scalarArguments[SparqlSpecsHelper.SparqlKeywordSeparator], distinct));
}
else
{
return new AggregateTerm(new GroupConcatAggregate(aggExpr, distinct));
}
case Token.MAX:
//MAX Aggregate
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new MaxAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new MaxAggregate(aggExpr, distinct));
}
case Token.MEDIAN:
//MEDIAN Aggregate
if (this._syntax != SparqlQuerySyntax.Extended) throw new RdfParseException("The MEDIAN aggregate is only supported when the Syntax is set to Extended.");
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new MedianAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new MedianAggregate(aggExpr, distinct));
}
case Token.MIN:
//MIN Aggregate
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new MinAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new MinAggregate(aggExpr, distinct));
}
case Token.MODE:
//MODE Aggregate
if (this._syntax != SparqlQuerySyntax.Extended) throw new RdfParseException("The MODE aggregate is only supported when the Syntax is set to Extended.");
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new ModeAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new ModeAggregate(aggExpr, distinct));
}
case Token.NMAX:
//NMAX Aggregate
if (this._syntax != SparqlQuerySyntax.Extended) throw new RdfParseException("The NMAX (Numeric Maximum) aggregate is only supported when the Syntax is set to Extended. To achieve an equivalent result in SPARQL 1.0/1.1 apply a FILTER to your query so the aggregated variable is only literals of the desired numeric type");
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new NumericMaxAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new NumericMaxAggregate(aggExpr, distinct));
}
case Token.NMIN:
//NMIN Aggregate
if (this._syntax != SparqlQuerySyntax.Extended) throw new RdfParseException("The NMIN (Numeric Minimum) aggregate is only supported when the Syntax is set to Extended. To achieve an equivalent result in SPARQL 1.0/1.1 apply a FILTER to your query so the aggregated variable is only literals of the desired numeric type");
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new NumericMinAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new NumericMinAggregate(aggExpr, distinct));
}
case Token.SAMPLE:
//SAMPLE Aggregate
if (distinct) throw new RdfParseException("DISTINCT modifier is not valid for the SAMPLE aggregate");
return new AggregateTerm(new SampleAggregate(aggExpr));
case Token.SUM:
//SUM Aggregate
if (aggExpr is VariableTerm)
{
return new AggregateTerm(new SumAggregate((VariableTerm)aggExpr, distinct));
}
else
{
return new AggregateTerm(new SumAggregate(aggExpr, distinct));
}
default:
//Should have already handled this but have to have it to keep the compiler happy
throw Error("Cannot parse an Aggregate since '" + agg.GetType().ToString() + "' is not an Aggregate Keyword Token", agg);
}
}
/// <summary>
/// Tries to create an XPath Function expression if the function Uri correseponds to a supported XPath Function
/// </summary>
/// <param name="u">Function Uri</param>
/// <param name="args">Function Arguments</param>
/// <param name="scalarArgs">Scalar Arguments</param>
/// <param name="expr">Generated Expression</param>
/// <returns>Whether an expression was successfully generated</returns>
public bool TryCreateExpression(Uri u, List<ISparqlExpression> args, Dictionary<String,ISparqlExpression> scalarArgs, out ISparqlExpression expr)
{
//If any Scalar Arguments are present then can't possibly be an XPath Function
if (scalarArgs.Count > 0)
{
expr = null;
return false;
}
String func = u.ToString();
if (func.StartsWith(XPathFunctionFactory.XPathFunctionsNamespace))
{
func = func.Substring(XPathFunctionFactory.XPathFunctionsNamespace.Length);
ISparqlExpression xpathFunc = null;
switch (func)
{
case XPathFunctionFactory.Absolute:
if (args.Count == 1)
{
xpathFunc = new AbsFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath abs() function");
}
break;
case XPathFunctionFactory.AdjustDateTimeToTimezone:
throw new NotSupportedException("XPath adjust-dateTime-to-timezone() function is not supported");
case XPathFunctionFactory.Boolean:
if (args.Count == 1)
{
xpathFunc = new BooleanFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath boolean() function");
}
throw new NotSupportedException("XPath boolean() function is not supported");
case XPathFunctionFactory.Ceiling:
if (args.Count == 1)
{
xpathFunc = new CeilingFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ceiling() function");
}
break;
case XPathFunctionFactory.Compare:
if (args.Count == 2)
{
xpathFunc = new CompareFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath compare() function");
}
break;
case XPathFunctionFactory.Concat:
if (args.Count == 2)
{
xpathFunc = new ConcatFunction(args.First(), args.Last());
}
else if (args.Count > 2)
{
xpathFunc = new ConcatFunction(args);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath concat() function");
}
break;
case XPathFunctionFactory.Contains:
if (args.Count == 2)
{
xpathFunc = new ContainsFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath contains() function");
}
break;
case XPathFunctionFactory.DayFromDateTime:
if (args.Count == 1)
{
xpathFunc = new DayFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath day-from-dateTime() function");
}
break;
case XPathFunctionFactory.EncodeForURI:
if (args.Count == 1)
{
xpathFunc = new EncodeForUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath encode-for-uri() function");
}
break;
case XPathFunctionFactory.EndsWith:
if (args.Count == 2)
{
xpathFunc = new EndsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ends-with() function");
}
break;
#if !NO_WEB
case XPathFunctionFactory.EscapeHtmlURI:
if (args.Count == 1)
{
xpathFunc = new EscapeHtmlUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath escape-html-uri() function");
}
break;
#endif
case XPathFunctionFactory.False:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, false));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath false() function");
}
break;
case XPathFunctionFactory.Floor:
if (args.Count == 1)
{
xpathFunc = new FloorFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath floor() function");
}
break;
case XPathFunctionFactory.HoursFromDateTime:
if (args.Count == 1)
{
xpathFunc = new HoursFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath hours-from-dateTime() function");
}
break;
case XPathFunctionFactory.LowerCase:
if (args.Count == 1)
{
xpathFunc = new LowerCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath lower-case() function");
}
break;
case XPathFunctionFactory.Matches:
if (args.Count == 2)
{
xpathFunc = new VDS.RDF.Query.Expressions.Functions.Sparql.Boolean.RegexFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new VDS.RDF.Query.Expressions.Functions.Sparql.Boolean.RegexFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath matches() function");
}
break;
case XPathFunctionFactory.MinutesFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MinutesFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath minutes-from-dateTime() function");
}
break;
case XPathFunctionFactory.MonthFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MonthFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath month-from-dateTime() function");
}
break;
case XPathFunctionFactory.NormalizeSpace:
if (args.Count == 1)
{
xpathFunc = new NormalizeSpaceFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
#if !NO_NORM
case XPathFunctionFactory.NormalizeUnicode:
if (args.Count == 1)
{
xpathFunc = new NormalizeUnicodeFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new NormalizeUnicodeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
#endif
case XPathFunctionFactory.Not:
if (args.Count == 1)
{
xpathFunc = new NotExpression(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath not() function");
}
break;
case XPathFunctionFactory.Replace:
if (args.Count == 3)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args.Last());
}
else if (args.Count == 4)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args[2], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath replace() function");
}
break;
case XPathFunctionFactory.Round:
if (args.Count == 1)
{
xpathFunc = new RoundFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round() function");
}
break;
#if !SILVERLIGHT
case XPathFunctionFactory.RoundHalfToEven:
if (args.Count == 1)
{
xpathFunc = new RoundHalfToEvenFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new RoundHalfToEvenFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round-half-to-even() function");
}
break;
#endif
case XPathFunctionFactory.SecondsFromDateTime:
if (args.Count == 1)
{
xpathFunc = new SecondsFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath seconds-from-dateTime() function");
}
break;
case XPathFunctionFactory.StartsWith:
if (args.Count == 2)
{
xpathFunc = new StartsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath starts-with() function");
}
break;
case XPathFunctionFactory.StringJoin:
if (args.Count == 1)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First()));
}
else if (args.Count == 2)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First(), args.Last()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-join() function");
}
break;
case XPathFunctionFactory.StringLength:
if (args.Count == 1)
{
xpathFunc = new StringLengthFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-length() function");
}
break;
case XPathFunctionFactory.Substring:
if (args.Count == 2)
{
xpathFunc = new SubstringFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new SubstringFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring() function");
}
break;
case XPathFunctionFactory.SubstringAfter:
if (args.Count == 2)
{
xpathFunc = new SubstringAfterFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-after() function");
}
break;
case XPathFunctionFactory.SubstringBefore:
if (args.Count == 2)
{
xpathFunc = new SubstringBeforeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-before() function");
}
break;
case XPathFunctionFactory.TimezoneFromDateTime:
if (args.Count == 1)
{
xpathFunc = new TimezoneFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath timezone-from-dateTime() function");
}
break;
case XPathFunctionFactory.Translate:
throw new NotSupportedException("XPath translate() function is not supported");
case XPathFunctionFactory.True:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath true() function");
}
break;
case XPathFunctionFactory.UpperCase:
if (args.Count == 1)
{
xpathFunc = new UpperCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath upper-case() function");
}
break;
case XPathFunctionFactory.YearFromDateTime:
if (args.Count == 1)
{
xpathFunc = new YearFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath year-from-dateTime() function");
}
break;
}
if (xpathFunc != null)
{
expr = xpathFunc;
return true;
}
}
expr = null;
return false;
}
public object Evaluate(ConcatFunction funcExp, object data, IEnumerable <object> parameters = null)
{
var paramValues = _GetParameterValues(funcExp, data, parameters);
return((object)paramValues.Aggregate((x, y) => (string)x + y));
}
public string ToSQL(ConcatFunction funcExp)
{
return(_FunctionToSQL(funcExp, "CONCAT"));
}
