private IEnumerable <SparqlResult> RunTriple(ObjectVariants subject, ObjectVariants objct) { return(this.predicatePath.CreateTriple(subject, objct, this.q).Aggregate(Enumerable.Repeat(new SparqlResult(this.q), 1), (enumerable, triple) => triple.Run(enumerable))); }
public override IEnumerable <ISparqlGraphPattern> CreateTriple(ObjectVariants subject, ObjectVariants @object, RdfQuery11Translator q) { var subjectNode = IsInverse ? @object : subject; var objectNode = IsInverse ? subject : @object; yield return(new SparqlPathManyTriple(subjectNode, path, objectNode, q)); }
public TripleOVStruct(ObjectVariants s, ObjectVariants p, ObjectVariants o) { Subject = s; Predicate = p; Object = o; }
public IEnumerable <TripleOVStruct> GetTriplesWithPredicate(ObjectVariants p) { return(Graph.GetTriplesWithObject(p)); }
public SparqlIriExpression(ObjectVariants sparqlUriNode) { Const = sparqlUriNode; }
public SparqlResult Add(ObjectVariants newObj, VariableNode variable) { this.rowArray[variable.Index] = newObj; return(this); }
public bool Contains(ObjectVariants subject, ObjectVariants predicate, ObjectVariants obj) { return(Graph.Contains(subject, predicate, obj)); }
private IEnumerable <SparqlResult> SetVariablesValues(SparqlResult variableBinding, StoreCallCase @case) { switch (@case) { case StoreCallCase.spo: return(this.spo(this.Subject, this.Predicate, this.Object, variableBinding)); case StoreCallCase.spO: return(this.store.GetTriplesWithSubjectPredicate(this.Subject, this.Predicate).Select(o => variableBinding.Add(o, this.oVariableNode))); case StoreCallCase.sPo: return(this.store.GetTriplesWithSubjectObject(this.Subject, this.Object).Select(p => variableBinding.Add(p, this.pVariableNode))); case StoreCallCase.sPO: return(this.store.GetTriplesWithSubject(this.Subject).Select(t => this.SetValues(variableBinding, t))); case StoreCallCase.Spo: return(this.store.GetTriplesWithPredicateObject(this.Predicate, this.Object).Select(s => variableBinding.Add(s, this.sVariableNode))); case StoreCallCase.SpO: return(this.store.GetTriplesWithPredicate(this.Predicate).Select(t => this.SetValues(variableBinding, t))); case StoreCallCase.SPo: return(this.store.GetTriplesWithObject(this.Object).Select(t => this.SetValues(variableBinding, t))); case StoreCallCase.SPO: return(this.store.GetTriples((s, p, o) => variableBinding.Add(s, this.sVariableNode, p, this.pVariableNode, o, this.oVariableNode))); case StoreCallCase.gspo: return(this.spoGraphs(variableBinding)); case StoreCallCase.gspO: return(this.graphs.SelectMany(graph => this.store.NamedGraphs .GetObject(this.Subject, this.Predicate, graph) .Select(o => variableBinding.Add(o, this.oVariableNode)))); case StoreCallCase.gsPo: return(this.graphs.SelectMany(graph => this.store.NamedGraphs .GetPredicate(this.Subject, this.Object, graph) .Select(p => variableBinding.Add(p, this.pVariableNode)))); case StoreCallCase.gsPO: return(this.graphs.SelectMany(g => this.store .NamedGraphs .GetTriplesWithSubjectFromGraph(this.Subject, g) .Select(quad => this.SetValues(variableBinding, quad)))); case StoreCallCase.gSpo: return(this.graphs.SelectMany(graph => this.store.NamedGraphs .GetSubject(this.Predicate, this.Object, graph) .Select(s => variableBinding.Add(s, this.sVariableNode)))); case StoreCallCase.gSpO: return(this.graphs.SelectMany(g => this.store .NamedGraphs .GetTriplesWithPredicateFromGraph(this.Predicate, g) .Select(quad => this.SetValues(variableBinding, quad)))); case StoreCallCase.gSPo: return(this.graphs.SelectMany(g => this.store .NamedGraphs .GetTriplesWithObjectFromGraph(this.Object, g) .Select(quad => this.SetValues(variableBinding, quad)))); case StoreCallCase.gSPO: return(this.graphs.SelectMany(g => this.store.NamedGraphs.GetTriplesFromGraph(g, (s, p, o) => variableBinding.Add(s, this.sVariableNode, p, this.pVariableNode, o, this.oVariableNode)))); case StoreCallCase.Gspo: return((this.variableDataSet.Any() ? this.variableDataSet.Where(g => this.store.NamedGraphs.Contains(this.Subject, this.Predicate, this.Object, g)) : this.store.NamedGraphs.GetGraph(this.Subject, this.Predicate, this.Object)) .Select(g => variableBinding.Add(g, this.variableDataSet.Variable))); case StoreCallCase.GspO: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store .NamedGraphs .GetObject(this.Subject, this.Predicate, g) .Select(o => variableBinding.Add(o, this.oVariableNode, g, this.variableDataSet.Variable)))); } else { return(this.store .NamedGraphs .GetTriplesWithSubjectPredicate(this.Subject, this.Predicate) .Select(quad => this.SetValues(variableBinding, quad))); } // if graphVariable is null, ctor check this. case StoreCallCase.GsPo: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store.NamedGraphs.GetPredicate(this.Subject, this.Object, g) .Select(p => variableBinding.Add(p, this.pVariableNode, g, this.variableDataSet.Variable)))); } else { return(this.store .NamedGraphs .GetTriplesWithSubjectObject(this.Subject, this.Object) .Select(quad => this.SetValues(variableBinding, quad))); } case StoreCallCase.GsPO: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store .NamedGraphs .GetTriplesWithSubjectFromGraph(this.Subject, g) .Select(quad => this.SetValues(variableBinding, quad)))); } else { return(this.store .NamedGraphs .GetTriplesWithSubject(this.Subject) .Select(quad => this.SetValues(variableBinding, quad))); } case StoreCallCase.GSpo: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store .NamedGraphs .GetSubject(this.Predicate, this.Object, g) .Select(s => variableBinding.Add(s, this.sVariableNode, g, this.variableDataSet.Variable)))); } else { return(this.store .NamedGraphs .GetTriplesWithPredicateObject(this.Predicate, this.Object) .Select(quad => this.SetValues(variableBinding, quad))); } case StoreCallCase.GSpO: ObjectVariants predicate = this.Predicate; if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany( g => this.store.NamedGraphs.GetTriplesWithPredicateFromGraph(predicate, g) .Select(quad => this.SetValues(variableBinding, quad)))); } else { return(this.store.NamedGraphs.GetTriplesWithPredicate(predicate) .Select(quad => this.SetValues(variableBinding, quad))); } case StoreCallCase.GSPo: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store .NamedGraphs .GetTriplesWithObjectFromGraph(this.Object, g)) .Select(quad => this.SetValues(variableBinding, quad))); } return(this.store .NamedGraphs .GetTriplesWithObject(this.Object) .Select(quad => this.SetValues(variableBinding, quad))); case StoreCallCase.GSPO: if (this.variableDataSet.Any()) { return(this.variableDataSet.SelectMany(g => this.store .NamedGraphs .GetTriplesFromGraph(g, (s, p, o) => variableBinding.Add(s, this.sVariableNode, p, this.pVariableNode, o, this.oVariableNode, g, this.variableDataSet.Variable)))); } return(this.store .NamedGraphs .GetAll((s, p, o, g) => variableBinding.Add(s, this.sVariableNode, p, this.pVariableNode, o, this.oVariableNode, g, this.variableDataSet.Variable))); default: throw new ArgumentOutOfRangeException("case"); } }
public IEnumerable <ObjectVariants> GetSubjects(ObjectVariants pred, ObjectVariants obj) { return(Graph.GetSubjects(pred, obj)); }
public void Add(ObjectVariants s, ObjectVariants p, ObjectVariants o) { throw new NotImplementedException(); }
public IEnumerable <ObjectVariants> GetTriplesWithSubjectObject(ObjectVariants subj, ObjectVariants obj) { return(Graph.GetTriplesWithSubjectObject(subj, obj)); }
public IEnumerable <ObjectVariants> GetTriplesWithSubjectPredicate(ObjectVariants subj, ObjectVariants pred) { ObjectVariants[] objects; var key = new KeyValuePair <int, int>(((OV_iriint)subj).code, ((OV_iriint)pred).code); if (spCache.TryGetValue(key, out objects)) { return(objects); } objects = Graph.GetTriplesWithSubjectPredicate(subj, pred).ToArray(); spCache.Add(key, objects); return(objects); }
public IEnumerable <TripleOVStruct> GetTriplesWithSubject(ObjectVariants s) { return(Graph.GetTriplesWithSubject(s)); }
public SparqlLiteralExpression(ObjectVariants sparqlLiteralNode) { Const = sparqlLiteralNode; //SetExprType(sparqlLiteralNode.Variant); }
public void Delete(ObjectVariants subject, ObjectVariants predicate, ObjectVariants obj) { throw new NotImplementedException(); }
public SparqlGraphGraph(ObjectVariants sparqlNode) { // TODO: Complete member initialization Name = sparqlNode; }
public void SetWith(ObjectVariants iri) { with = iri; }
private IEnumerable <SparqlResult> spo(ObjectVariants subjectNode, ObjectVariants predicateNode, ObjectVariants objNode, SparqlResult variablesBindings) { if (this.store.Contains(subjectNode, predicateNode, objNode)) { yield return(variablesBindings); } }
protected virtual ObjectVariants ApplyTyped(ObjectVariants left, ObjectVariants right) { if (left.Variant == ObjectVariantEnum.Typed && right.Variant == ObjectVariantEnum.Typed) { // double dl,dr; int il, ir; long ll, lr; if (int.TryParse((string)left.Content, out il) && int.TryParse((string)right.Content, out ir)) { return(new OV_typed(this.@operator(il, ir).ToString(), ((OV_typed)left).turi)); } if (long.TryParse((string)left.Content, out ll) && long.TryParse((string)left.Content, out lr)) { return(new OV_typed(this.@operator(ll, lr).ToString(), ((OV_typed)left).turi)); } else { return (new OV_typed(this.@operator(Convert.ToDouble(left.Content), Convert.ToDouble(right.Content)).ToString(), ((OV_typed)left).turi)); } } else if (left.Variant == ObjectVariantEnum.Typed || right.Variant == ObjectVariantEnum.Typed) { OV_typed t; ObjectVariants second; if ((left as OV_typed) != null) { t = left as OV_typed; second = right; } else { t = right as OV_typed; second = left; } // double d; int i; long l; if (int.TryParse((string)t.Content, out i) && second.Content is int) { return (new OV_typed( this.@operator(Convert.ToInt32(left.Content), Convert.ToInt32(right.Content)).ToString(), t.turi)); } if (long.TryParse((string)t.Content, out l) && second.Content is long) { return (new OV_typed( this.@operator(Convert.ToInt64(left.Content), Convert.ToInt64(right.Content)).ToString(), t.turi)); } else { return (new OV_typed( this.@operator(Convert.ToDouble(left.Content), Convert.ToDouble(right.Content)).ToString(), t.turi)); } } else { if (left is INumLiteral && right is INumLiteral) { if (left.Variant == ObjectVariantEnum.Double || right.Variant == ObjectVariantEnum.Double) { return (new OV_double( this.@operator(Convert.ToDouble(left.Content), Convert.ToDouble(right.Content)))); } else if (left.Variant == ObjectVariantEnum.Decimal || right.Variant == ObjectVariantEnum.Decimal) { return (new OV_decimal( this.@operator(Convert.ToDecimal(left.Content), Convert.ToDecimal(right.Content)))); } else if (left.Variant == ObjectVariantEnum.Float || right.Variant == ObjectVariantEnum.Float) { return (new OV_float( this.@operator(Convert.ToSingle(left.Content), Convert.ToSingle(right.Content)))); } else if (left.Variant == ObjectVariantEnum.Int || right.Variant == ObjectVariantEnum.Int) { return(new OV_integer(this.@operator(left.Content, right.Content))); } // todo } } throw new NotImplementedException(); }
public void Add(VariableNode variable, ObjectVariants value) { this.rowArray[variable.Index] = value; }
public SparqlPathManyTriple(ObjectVariants subject, SparqlPathTranslator pred, ObjectVariants @object, RdfQuery11Translator q) { this.predicatePath = pred; this.Subject = subject; this.Object = @object; this.q = q; this.sVariableNode = this.Subject as VariableNode; this.oVariableNode = this.Object as VariableNode; }
public SparqlBoolLiteralExpression(ObjectVariants sparqlLiteralNode) { this.Const = sparqlLiteralNode; }
public IEnumerable <SparqlResult> Run(IEnumerable <SparqlResult> variableBindings) { var bindings = variableBindings; Queue <ObjectVariants> newSubjects = new Queue <ObjectVariants>(); ObjectVariants[] fromVariable = null; ObjectVariants o = null; ObjectVariants s = null; switch (NullablePairExt.Get(this.sVariableNode, this.oVariableNode)) { case NP.bothNull: return(this.TestSOConnection(this.Subject, this.Object) ? bindings : Enumerable.Empty <SparqlResult>()); case NP.leftNull: newSubjects.Enqueue(this.Subject); return(bindings.SelectMany(binding => { o = binding[this.oVariableNode]; if (o != null) { return this.TestSOConnection(this.Subject, o) ? Enumerable.Repeat(binding, 1) : Enumerable.Empty <SparqlResult>(); } else { if (fromVariable == null) { fromVariable = this.GetAllSConnections(this.Subject).ToArray(); } return fromVariable.Select(node => binding.Add(node, this.oVariableNode)); } })); case NP.rigthNull: return(bindings.SelectMany(binding => { s = binding[this.sVariableNode]; if (s != null) { return this.TestSOConnection(s, this.Object) ? Enumerable.Repeat(binding, 1) : Enumerable.Empty <SparqlResult>(); } else { if (fromVariable == null) { fromVariable = this.GetAllOConnections(this.Object).ToArray(); } return fromVariable.Select(node => binding.Add(node, this.sVariableNode)); } })); case NP.bothNotNull: return(bindings.SelectMany(binding => { s = binding[this.sVariableNode]; o = binding[this.oVariableNode]; switch (NullablePairExt.Get(s, o)) { case NP.bothNotNull: if ((this.useCache && this.TestSOConnectionFromCache(s, o)) || this.TestSOConnection(s, o)) { return Enumerable.Repeat(binding, 1); } else { return Enumerable.Empty <SparqlResult>(); } case NP.rigthNull: return this.GetAllSConnections(s).Select(node => binding.Add(node, this.oVariableNode)); break; case NP.leftNull: return this.GetAllOConnections(o).Select(node => binding.Add(node, this.sVariableNode)); break; case NP.bothNull: this.useCache = true; this.bothVariablesChache = this.predicatePath.CreateTriple(this.sVariableNode, this.oVariableNode, this.q) .Aggregate(Enumerable.Repeat(new SparqlResult(this.q), 1), (enumerable, triple) => triple.Run(enumerable)) .Select( r => new KeyValuePair <ObjectVariants, ObjectVariants>(r[this.sVariableNode], r[this.oVariableNode])) .ToArray(); return this.bothVariablesCacheBySubject.Keys.SelectMany(this.GetAllSConnections, (sbj, node) => binding.Add(sbj, this.sVariableNode, node, this.oVariableNode)); default: throw new ArgumentOutOfRangeException(); } })); default: throw new ArgumentOutOfRangeException(); } }
public SparqlNumLiteralExpression(ObjectVariants sparqlLiteralNode) { //SetExprType(ExpressionTypeEnum.numeric); Const = sparqlLiteralNode; //TypedOperator = result => sparqlLiteralNode; }
public SparqlVariableBinding(VariableNode variable, ObjectVariants node) { // TODO: Complete member initialization this.Variable = variable; this.value = node; }