public SparqlExpressionAsVariable(VariableNode variableNode, SparqlExpression sparqlExpression, RdfQuery11Translator q)
{
// TODO: Complete member initialization
this.variableNode = variableNode;
this.sparqlExpression = sparqlExpression;
this.q = q;
}
public SparqlOrderCondition(SparqlFunctionCall sparqlFunctionCall, RdfQuery11Translator q)
{
this.q = q;
// TODO: Complete member initialization
getNode = sparqlFunctionCall.Operator;
AggregateLevel = sparqlFunctionCall.AggregateLevel;
}
private static ObjectVariants Xml2Node(XNamespace xn, XElement b, RdfQuery11Translator q)
{
if (b.Name == xn + "uri")
{
return(new OV_iri(q.prolog.GetFromString(b.Value)));
}
else if (b.Name == xn + "bnode")
{
return(q.CreateBlankNode(b.Value));
}
else if (b.Name == xn + "literal")
{
var lang = b.Attribute(xn + "lang");
var type = b.Attribute(xn + "type");
if (lang != null)
{
return(new OV_langstring(b.Value, lang.Value));
}
else if (type != null)
{
return(q.Store.NodeGenerator.CreateLiteralNode(b.Value, q.prolog.GetFromString(type.Value)));
}
else
{
return(new OV_string(b.Value));
}
}
throw new ArgumentOutOfRangeException();
}
internal void Create(ObjectVariants iri, string graphPattern, string prolog, RdfQuery11Translator q)
{
this.q = q;
this.prolog = prolog;
this.sparqlGraphPattern = graphPattern;
this.uri = (ObjectVariants)iri;
}
public SparqlOrderCondition(VariableNode variableNode, RdfQuery11Translator q)
{
this.q = q;
// TODO: Complete member initialization
getNode = result => result[variableNode] ?? new SparqlUnDefinedNode();
AggregateLevel = SparqlExpression.VariableDependenceGroupLevel.SimpleVariable;
}
public SparqlOrderCondition(SparqlExpression sparqlExpression, RdfQuery11Translator q)
{
this.q = q;
// TODO: Complete member initialization
getNode = sparqlExpression.Operator;
AggregateLevel = sparqlExpression.AggregateLevel;
}
public SparqlMayBeOneTriple(IEnumerable <ISparqlGraphPattern> triples, ObjectVariants s, ObjectVariants o, RdfQuery11Translator q)
{
oNode = o;
this.q = q;
this.triples = triples;
this.sNode = s;
}
public SparqlPathManyTriple(ObjectVariants subject, SparqlPathTranslator pred, ObjectVariants @object, RdfQuery11Translator q)
{
this.predicatePath = pred;
Subject = subject;
Object = @object;
this.q = q;
sVariableNode = Subject as VariableNode;
oVariableNode = Object as VariableNode;
}
public SparqlEncodeForUri(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
//SetExprType(ObjectVariantEnum.Str);
// value.SetExprType(ExpressionTypeEnum.stringOrWithLang);
if (value.Const != null)
{
Const = new OV_string(HttpUtility.UrlEncode((string)value.Const.Content));
}
else
{
Operator = result => HttpUtility.UrlEncode((string)value.Operator(result).Content);
TypedOperator = result => new OV_string(Operator(result));
}
}
public SparqlUri(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
if (value.Const != null)
{
Const = new OV_iri(q.prolog.GetFromString((string)value.Const.Content));
}
else
{
Operator = result => new OV_iri(q.prolog.GetFromString((string)value.Operator(result).Content));
//SetExprType(ObjectVariantEnum.Iri);
TypedOperator =
result => new OV_iri(q.prolog.GetFromString((string)value.TypedOperator(result).Content));
}
}
public SparqlTriple(ObjectVariants subj, ObjectVariants pred, ObjectVariants obj, RdfQuery11Translator q)
{
this.q = q;
Subject = subj;
Predicate = pred;
Object = obj;
//if(!(subj is ObjectVariants)) throw new ArgumentException();
graphs = q.ActiveGraphs;
//this.Graph = graph;
sVariableNode = subj as VariableNode;
pVariableNode = pred as VariableNode;
oVariableNode = obj as VariableNode;
variableDataSet = (q.ActiveGraphs as VariableDataSet);
isDefaultGraph = variableDataSet == null && graphs.Count == 0;
}
public static IEnumerable <SparqlResult> FromXml(XElement load, RdfQuery11Translator q)
{
XNamespace xn = "http://www.w3.org/2005/sparql-results#";
return(load
.Element(xn + "results")
.Elements()
.Select(xResult => new SparqlResult(q).Add(xResult.Elements()
.Select(xb =>
{
var variable = q.GetVariable(xb.Attribute(xn + "name").Value);
var node = xb.Elements().FirstOrDefault();
return new KeyValuePair <VariableNode, ObjectVariants>(variable, Xml2Node(xn, node, q));
}))));
}
internal IEnumerable <SparqlGroupOfResults> Having4CollectionGroups(
IEnumerable <SparqlGroupOfResults> resultsGroups, RdfQuery11Translator q)
{
return(this.Aggregate(resultsGroups, (result, testExpr) =>
{
switch (testExpr.AggregateLevel)
{
case SparqlExpression.VariableDependenceGroupLevel.Const:
if ((bool)testExpr.Const.Content)
{
return result;
}
else
{
return Enumerable.Empty <SparqlGroupOfResults>();
}
case SparqlExpression.VariableDependenceGroupLevel.UndependableFunc:
if ((bool)testExpr.Operator(null))
{
return result;
}
else
{
return Enumerable.Empty <SparqlGroupOfResults>();
}
case SparqlExpression.VariableDependenceGroupLevel.SimpleVariable:
case SparqlExpression.VariableDependenceGroupLevel.Group:
return result.Where(testExpr.Test);
case SparqlExpression.VariableDependenceGroupLevel.GroupOfGroups:
var group = new SparqlGroupOfResults(q)
{
Group = result.Select(sparqlResult => sparqlResult.Clone()).ToArray()
};
return testExpr.Test(group) ? group.Group.Cast <SparqlGroupOfResults>() : Enumerable.Empty <SparqlGroupOfResults>();
default:
throw new ArgumentOutOfRangeException();
}
return resultsGroups;
}));
}
public SparqlOrderCondition(SparqlExpression sparqlExpression, string dir, RdfQuery11Translator q)
{
this.q = q;
// TODO: Complete member initialization
switch (dir.ToLower())
{
case "desc":
direction = SparqlOrderDirection.Desc;
break;
case "asc":
default:
direction = SparqlOrderDirection.Asc;
break;
}
getNode = sparqlExpression.Operator;
AggregateLevel = sparqlExpression.AggregateLevel;
}
public SparqlBnode(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
//IsDistinct = value.IsDistinct;
//value.SetExprType(ObjectVariantEnum.Str);
//SetExprType(ObjectVariantEnum.Iri);
var litConst = value.Const;
if (litConst != null)
{
Operator =
TypedOperator = result => q.Store.NodeGenerator.CreateBlankNode(value.Const.Content + result.Id);
}
else
{
Operator =
TypedOperator = result => q.Store.NodeGenerator.CreateBlankNode(value.Operator(result) + result.Id);
//OvConstruction = o => q.Store.NodeGenerator.CreateBlankNode((string) o);
}
}
public override IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q)
{
var subjectNode = IsInverse ? @object : subject;
var objectNode = IsInverse ? subject : @object;
var sparqlPathManyTriple = new SparqlPathManyTriple(subjectNode, path, objectNode, q);
yield return(new SparqlMayBeOneTriple(Enumerable.Repeat(sparqlPathManyTriple, 1), subjectNode, objectNode, q));
}
public SparqlSubSelect(ISparqlGraphPattern sparqlWhere, SparqlSolutionModifier sparqlSolutionModifier, ISparqlGraphPattern sparqlValueDataBlock, RdfQuery11Translator q)
: base(q)
{
// TODO: Complete member initialization
this.sparqlWhere = sparqlWhere;
this.sparqlSolutionModifier = sparqlSolutionModifier;
this.valueDataBlock = sparqlValueDataBlock;
// this.sparqlValueDataBlock = sparqlValueDataBlock;
}
public SparqlUpdateModify(RdfQuery11Translator q)
{
this.q = q;
}
public override IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q)
{
var subjectNode = this.IsInverse ? @object : subject;
var objectNode = this.IsInverse ? subject : @object;
var directed = this.alt.Where(translator => !translator.IsInverse).ToList();
var anyDirected = directed.Any();
if (anyDirected)
{
var variableNode = q.CreateBlankNode();
yield return(new SparqlTriple((ObjectVariants)subjectNode, variableNode, (ObjectVariants)objectNode, q));
foreach (var pathTranslator in directed)
{
yield return
(new SparqlFilter(new SparqlNotEqualsExpression(new SparqlVarExpression(variableNode),
new SparqlIriExpression(pathTranslator.predicate), q.Store.NodeGenerator)));
}
}
// TODO drop subject object variables
var inversed = this.alt.Where(translator => translator.IsInverse).ToList();
var anyInversed = inversed.Any();
if (anyInversed)
{
var variableNode = q.CreateBlankNode();
yield return(new SparqlTriple((ObjectVariants)objectNode, variableNode, (ObjectVariants)subjectNode, q));
foreach (var pathTranslator in inversed)
{
yield return
(new SparqlFilter(new SparqlNotEqualsExpression(new SparqlVarExpression(variableNode),
new SparqlIriExpression(pathTranslator.predicate), q.Store.NodeGenerator)));
}
}
}
public SparqlDescribeQuery(RdfQuery11Translator q) : base(q)
{
}
internal void Add(SparqlSolutionModifierHaving sparqlSolutionModifierHaving, RdfQuery11Translator q)
{
this.sparqlSolutionModifierHaving = sparqlSolutionModifierHaving;
this.q = q;
}
internal IEnumerable <SparqlResult> Having(IEnumerable <SparqlResult> resultsGroups, RdfQuery11Translator q)
{
// IEnumerable<SparqlResult> resultsGroups = enumerable as SparqlResult[] ?? enumerable.ToArray();
//if (!resultsGroups.Any()) return resultsGroups; //todo
return(this.Aggregate(resultsGroups, (result, testExpr) =>
{
switch (testExpr.AggregateLevel)
{
case SparqlExpression.VariableDependenceGroupLevel.Const:
return (bool)testExpr.Const.Content ? result : Enumerable.Empty <SparqlResult>();
case SparqlExpression.VariableDependenceGroupLevel.UndependableFunc:
return testExpr.Test(null) ? result : Enumerable.Empty <SparqlResult>();
case SparqlExpression.VariableDependenceGroupLevel.SimpleVariable:
return result.Where(testExpr.Test);
case SparqlExpression.VariableDependenceGroupLevel.Group:
var sparqlGroupOfResults = new SparqlGroupOfResults(q)
{
Group = result.Select(sparqlResult => sparqlResult.Clone()).ToArray()
};
return testExpr.Test(sparqlGroupOfResults) ? sparqlGroupOfResults.Group : Enumerable.Empty <SparqlResult>();
case SparqlExpression.VariableDependenceGroupLevel.GroupOfGroups:
default:
throw new Exception("requested grouping");
}
}));
}
public override IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q)
{
var subjectNode = IsInverse ? @object : subject;
var objectNode = IsInverse ? subject : @object;
return(alt.SelectMany(path => path.CreateTriple(subjectNode, objectNode, q)));
}
internal IEnumerable <SparqlResult> Having(IEnumerable <SparqlResult> resultsGroups, RdfQuery11Translator q)
{
// IEnumerable<SparqlResult> resultsGroups = enumerable as SparqlResult[] ?? enumerable.ToArray();
//if (!resultsGroups.Any()) return resultsGroups; //todo
foreach (var testExpr in this)
{
switch (testExpr.AggregateLevel)
{
case SparqlExpression.VariableDependenceGroupLevel.Const:
if ((bool)testExpr.Const.Content)
{
continue;
}
else
{
return(Enumerable.Empty <SparqlResult>());
}
case SparqlExpression.VariableDependenceGroupLevel.UndependableFunc:
if (testExpr.Test(null))
{
continue;
}
else
{
return(Enumerable.Empty <SparqlResult>());
}
case SparqlExpression.VariableDependenceGroupLevel.SimpleVariable:
//if (resultsGroups.Any(testExpr.Test)) continue;
//else return Enumerable.Empty<SparqlResult>();//todo
resultsGroups = resultsGroups.Where(testExpr.Test);
break;
case SparqlExpression.VariableDependenceGroupLevel.Group:
if (testExpr.Test(new SparqlGroupOfResults(q)
{
Group = resultsGroups
}))
{
continue;
}
else
{
return(Enumerable.Empty <SparqlResult>());
}
case SparqlExpression.VariableDependenceGroupLevel.GroupOfGroups:
throw new Exception("requested grouping");
}
}
return(resultsGroups);
}
internal IEnumerable <SparqlGroupOfResults> Having4CollectionGroups(IEnumerable <SparqlGroupOfResults> resultsGroups, RdfQuery11Translator q)
{
foreach (var testExpr in this)
{
switch (testExpr.AggregateLevel)
{
case SparqlExpression.VariableDependenceGroupLevel.Const:
if ((bool)testExpr.Const.Content)
{
continue;
}
else
{
return(Enumerable.Empty <SparqlGroupOfResults>());
}
case SparqlExpression.VariableDependenceGroupLevel.UndependableFunc:
if ((bool)testExpr.Operator(null))
{
continue;
}
else
{
return(Enumerable.Empty <SparqlGroupOfResults>());
}
case SparqlExpression.VariableDependenceGroupLevel.SimpleVariable:
case SparqlExpression.VariableDependenceGroupLevel.Group:
SparqlExpression expr = testExpr;
resultsGroups = resultsGroups.Where(result => expr.Operator(result));
continue;
case SparqlExpression.VariableDependenceGroupLevel.GroupOfGroups:
if (testExpr.Test(new SparqlGroupOfResults(q)
{
Group = resultsGroups
}))
{
continue;
}
break;
}
}
return(resultsGroups);
}
public override IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q)
{
VariableNode t = q.CreateBlankNode();
var subjectNode = IsInverse ? @object : subject;
var objectNode = IsInverse ? subject : @object;
return(seq.First().CreateTriple((ObjectVariants)subjectNode, t, q)
.Concat(seq.Skip(1).Take(seq.Count - 2).SelectMany(path => path.CreateTriple(t, t = q.CreateBlankNode(), q)))
.Concat(seq.Last().CreateTriple(t, objectNode, q)));
}
public SparqlUpdateQuery(RdfQuery11Translator q) : base(q)
{
ResultSet.ResultType = ResultType.Update;
}
public virtual IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q)
{
var subjectNode = IsInverse ? @object : subject;
var objectNode = IsInverse ? subject : @object;
yield return(new SparqlTriple((ObjectVariants)subjectNode, predicate, (ObjectVariants)objectNode, q));
}
internal void CreateTriple(ObjectVariants subj, ObjectVariants predicate, ObjectVariants obj, RdfQuery11Translator q)
{
var pathTranslator = predicate as SparqlPathTranslator;
if (pathTranslator != null)
{
this.AddRange(pathTranslator.CreateTriple(subj, obj, q));
}
else
{
this.Add(new SparqlTriple(subj, predicate, obj, q));
}
}
public SparqlSelect(RdfQuery11Translator q)
{
this.q = q;
}
