private static int GetOid(string seqType, string serverPrefix, Session generatorSession)
{
CriteriaOperator serverPrefixCriteria;
if (serverPrefix == null)
{
serverPrefixCriteria = new NullOperator("Prefix");
}
else
{
serverPrefixCriteria = new BinaryOperator("Prefix", serverPrefix);
}
OidGenerator generator = generatorSession.FindObject <OidGenerator>(
new GroupOperator(new BinaryOperator("Type", seqType), serverPrefixCriteria));
if (generator == null)
{
generator = new OidGenerator(generatorSession);
generator.Type = seqType;
generator.Prefix = serverPrefix;
}
generator.Oid++;
generator.Save();
return(generator.Oid);
}
public void ExtractNullOperator()
{
var nullOperator = new NullOperator("");
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(nullOperator);
Assert.AreEqual(nullOperator, binaryOperatorExtractor.NullOperators[0]);
}
public void ExtractNullOperator()
{
var nullOperator = new NullOperator("");
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(nullOperator);
Assert.AreEqual(nullOperator, binaryOperatorExtractor.NullOperators[0]);
}
/// <summary>
/// Processes a Null Operator
/// </summary>
/// <param name="nullOp">Null Operator</param>
/// <param name="context">SPARQL Evaluation Context</param>
/// <returns></returns>
public virtual BaseMultiset ProcessNullOperator(NullOperator nullOp, SparqlEvaluationContext context)
{
if (context == null)
{
context = this.GetContext();
}
return(nullOp.Evaluate(context));
}
public void Visit(NullOperator op)
{
var leftArgs = VisitChild(op.Left);
var rightArgs = VisitChild(op.Right);
_codeStack.Peek().Scope = leftArgs.Scope;
_codeStack.Peek().CodeExpression = new CodeMethodInvokeExpression(leftArgs.CodeExpression, "NullOperator", rightArgs.CodeExpression);
}
public void ExtractContainsNullOperator()
{
var nullOperator = new NullOperator();
var containsOperator = new ContainsOperator("", nullOperator);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(containsOperator);
Assert.AreEqual(nullOperator, binaryOperatorExtractor.NullOperators[0]);
}
public void ExtractContainsNullOperator()
{
var nullOperator = new NullOperator();
var containsOperator = new ContainsOperator("", nullOperator);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(containsOperator);
Assert.AreEqual(nullOperator, binaryOperatorExtractor.NullOperators[0]);
}
public void ExtractGroupedNullOperator()
{
var nullOperator1 = new NullOperator();
var nullOperator2 = new NullOperator();
var groupOperator = new GroupOperator(nullOperator1, nullOperator2);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(groupOperator);
Assert.AreEqual(nullOperator1, binaryOperatorExtractor.NullOperators[0]);
Assert.AreEqual(nullOperator2, binaryOperatorExtractor.NullOperators[1]);
}
public void ExtractGroupedNullOperator()
{
var nullOperator1 = new NullOperator();
var nullOperator2 = new NullOperator();
var groupOperator = new GroupOperator(nullOperator1, nullOperator2);
CriteriaOperatorExtractor binaryOperatorExtractor = GetBinaryOperatorExtractor(groupOperator);
Assert.AreEqual(nullOperator1, binaryOperatorExtractor.NullOperators[0]);
Assert.AreEqual(nullOperator2, binaryOperatorExtractor.NullOperators[1]);
}
internal static ICollection <MaterialWarehouseItem> GetItemsNeedingPutAway(Part part)
{
var op1 = new BinaryOperator("Part", part);
var op2 = new NullOperator("RackLocation");
var op3 = new BinaryOperator("Qty", 0, BinaryOperatorType.Greater);
var criteria = new GroupOperator(op1, op2, op3);
return(Repository
.GetList <MaterialWarehouseItem>(part.Session)
.ByCriteria(criteria));
}
private IXPObject GetTargetObject(string keyName, object keyValue)
{
CriteriaOperator criteria = new BinaryOperator(keyName, keyValue);
if (string.IsNullOrEmpty(Convert.ToString(keyValue)))
{
var keyType = objTypeInfo.Members.Where(m => m.Name == keyName).FirstOrDefault().MemberType;
if (keyType == typeof(Guid))
{
criteria = new NullOperator(keyName);
}
}
return((IXPObject)param.Session.FindObject(objTypeInfo.Type, criteria));
}
/// <summary>
/// Processes a Null Operator.
/// </summary>
/// <param name="nullOp">Null Operator.</param>
/// <param name="context">SPARQL Evaluation Context.</param>
/// <returns></returns>
public override BaseMultiset ProcessNullOperator(NullOperator nullOp, SparqlEvaluationContext context)
{
return(ExplainAndEvaluate <NullOperator>(nullOp, context, base.ProcessNullOperator));
}
public void Visit(NullOperator op, CommonTree tree)
{
SetLine(op, tree);
Parent(tree).Children.Add(op);
VisitChildren(tree);
}
/// <summary>
/// Optimises the algebra so that all Node terms are virtualised
/// </summary>
/// <param name="algebra">Algebra</param>
/// <returns></returns>
public ISparqlAlgebra Optimise(ISparqlAlgebra algebra)
{
if (algebra is IAbstractJoin)
{
return(((IAbstractJoin)algebra).Transform(this));
}
else if (algebra is IUnaryOperator)
{
return(((IUnaryOperator)algebra).Transform(this));
}
else if (algebra is IBgp)
{
IBgp current = (IBgp)algebra;
if (current.PatternCount == 0)
{
return(current);
}
else
{
ISparqlAlgebra result = new Bgp();
List <ITriplePattern> patterns = new List <ITriplePattern>();
List <ITriplePattern> ps = new List <ITriplePattern>(current.TriplePatterns.ToList());
TNodeID nullID = this._provider.NullID;
for (int i = 0; i < current.PatternCount; i++)
{
if (ps[i] is FilterPattern || ps[i] is BindPattern)
{
//First ensure that if we've found any other Triple Patterns up to this point
//we dump this into a BGP and join with the result so far
if (patterns.Count > 0)
{
result = Join.CreateJoin(result, new Bgp(patterns));
patterns.Clear();
}
if (ps[i] is FilterPattern)
{
result = new Filter(result, ((FilterPattern)ps[i]).Filter);
}
else
{
BindPattern bind = (BindPattern)ps[i];
result = new Extend(result, bind.AssignExpression, bind.VariableName);
}
}
else
{
//Convert Terms in the Pattern into Virtual Nodes
TriplePattern tp = (TriplePattern)ps[i];
PatternItem subj, pred, obj;
if (tp.Subject is NodeMatchPattern)
{
TNodeID id = this._provider.GetID(((NodeMatchPattern)tp.Subject).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
subj = new NodeMatchPattern(this.CreateVirtualNode(id, ((NodeMatchPattern)tp.Subject).Node));
}
}
else
{
subj = tp.Subject;
}
if (tp.Predicate is NodeMatchPattern)
{
TNodeID id = this._provider.GetID(((NodeMatchPattern)tp.Predicate).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
pred = new NodeMatchPattern(this.CreateVirtualNode(id, ((NodeMatchPattern)tp.Predicate).Node));
}
}
else
{
pred = tp.Predicate;
}
if (tp.Object is NodeMatchPattern)
{
TNodeID id = this._provider.GetID(((NodeMatchPattern)tp.Object).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
obj = new NodeMatchPattern(this.CreateVirtualNode(id, ((NodeMatchPattern)tp.Object).Node));
}
}
else
{
obj = tp.Object;
}
patterns.Add(new TriplePattern(subj, pred, obj));
}
}
if (result is NullOperator)
{
return(result);
}
else if (patterns.Count == current.PatternCount)
{
//If count of remaining patterns same as original pattern count there was no optimisation
//to do so return as is
return(current);
}
else if (patterns.Count > 0)
{
//If any patterns left at end join as a BGP with result so far
result = Join.CreateJoin(result, new Bgp(patterns));
return(result);
}
else
{
return(result);
}
}
}
else if (algebra is ITerminalOperator)
{
return(algebra);
}
else
{
return(algebra);
}
}
/// <summary>
/// Optimises the algebra so that all Node terms are virtualised.
/// </summary>
/// <param name="algebra">Algebra.</param>
/// <returns></returns>
public ISparqlAlgebra Optimise(ISparqlAlgebra algebra)
{
if (algebra is IAbstractJoin)
{
return(((IAbstractJoin)algebra).Transform(this));
}
else if (algebra is IUnaryOperator)
{
return(((IUnaryOperator)algebra).Transform(this));
}
else if (algebra is IBgp)
{
IBgp current = (IBgp)algebra;
if (current.PatternCount == 0)
{
return(current);
}
else
{
ISparqlAlgebra result = new Bgp();
List <ITriplePattern> patterns = new List <ITriplePattern>();
List <ITriplePattern> ps = new List <ITriplePattern>(current.TriplePatterns.ToList());
TNodeID nullID = _provider.NullID;
for (int i = 0; i < current.PatternCount; i++)
{
if (ps[i].PatternType == TriplePatternType.Filter || ps[i].PatternType == TriplePatternType.BindAssignment || ps[i].PatternType == TriplePatternType.LetAssignment)
{
// First ensure that if we've found any other Triple Patterns up to this point
// we dump this into a BGP and join with the result so far
if (patterns.Count > 0)
{
result = Join.CreateJoin(result, new Bgp(patterns));
patterns.Clear();
}
if (ps[i].PatternType == TriplePatternType.Filter)
{
result = new Filter(result, new UnaryExpressionFilter(Transform(((IFilterPattern)ps[i]).Filter.Expression)));
}
else
{
IAssignmentPattern bind = (IAssignmentPattern)ps[i];
result = new Extend(result, Transform(bind.AssignExpression), bind.VariableName);
}
}
else if (ps[i].PatternType == TriplePatternType.Match)
{
// Convert Terms in the Pattern into Virtual Nodes
IMatchTriplePattern tp = (IMatchTriplePattern)ps[i];
PatternItem subj, pred, obj;
if (tp.Subject is NodeMatchPattern)
{
TNodeID id = _provider.GetID(((NodeMatchPattern)tp.Subject).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
subj = new NodeMatchPattern(CreateVirtualNode(id, ((NodeMatchPattern)tp.Subject).Node));
}
}
else
{
subj = tp.Subject;
}
if (tp.Predicate is NodeMatchPattern)
{
TNodeID id = _provider.GetID(((NodeMatchPattern)tp.Predicate).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
pred = new NodeMatchPattern(CreateVirtualNode(id, ((NodeMatchPattern)tp.Predicate).Node));
}
}
else
{
pred = tp.Predicate;
}
if (tp.Object is NodeMatchPattern)
{
TNodeID id = _provider.GetID(((NodeMatchPattern)tp.Object).Node);
if (id == null || id.Equals(nullID))
{
result = new NullOperator(current.Variables);
break;
}
else
{
obj = new NodeMatchPattern(CreateVirtualNode(id, ((NodeMatchPattern)tp.Object).Node));
}
}
else
{
obj = tp.Object;
}
patterns.Add(new TriplePattern(subj, pred, obj));
}
else
{
// Can't optimize if other pattern types involved
return(current);
}
}
if (result is NullOperator)
{
return(result);
}
else if (patterns.Count > 0)
{
// If any patterns left at end join as a BGP with result so far
result = Join.CreateJoin(result, new Bgp(patterns));
return(result);
}
else
{
return(result);
}
}
}
else if (algebra is ITerminalOperator)
{
return(algebra);
}
else
{
return(algebra);
}
}
