protected override void InitStartingTokensForRule(Dictionary <string, NonTerminal <IN> > nonTerminals, Rule <IN> rule)
{
if (rule.PossibleLeadingTokens == null || rule.PossibleLeadingTokens.Count == 0)
{
rule.PossibleLeadingTokens = new List <IN>();
if (rule.Clauses.Count > 0)
{
IClause <IN> first = rule.Clauses[0];
if (first is TerminalClause <IN> )
{
TerminalClause <IN> term = first as TerminalClause <IN>;
InitStartingTokensWithTerminal(rule, term);
}
else if (first is NonTerminalClause <IN> )
{
NonTerminalClause <IN> nonterm = first as NonTerminalClause <IN>;
InitStartingTokensWithNonTerminal(rule, nonterm, nonTerminals);
}
else if (first is ZeroOrMoreClause <IN> )
{
ZeroOrMoreClause <IN> many = first as ZeroOrMoreClause <IN>;
InitStartingTokensWithZeroOrMore(rule, many, nonTerminals);
}
else if (first is OneOrMoreClause <IN> )
{
OneOrMoreClause <IN> many = first as OneOrMoreClause <IN>;
InitStartingTokensWithOneOrMore(rule, many, nonTerminals);
}
}
}
}
public async Task GetTransaction()
{
using var httpClient = new HttpClient { BaseAddress = _vechainClient.ServerUri };
var raw = await httpClient.GetByteArrayAsync("/transactions/0x9b97b53100c7fc27eb17cf38486fdbaa2eb7c8befa41ed0b033ad11fc9c6673e");
var o = JsonSerializer.Deserialize <dynamic>(raw);
Assert.Equal(749, o["clauses"].Count);
var transaction = await _vechainClient.GetTransaction("0x9b97b53100c7fc27eb17cf38486fdbaa2eb7c8befa41ed0b033ad11fc9c6673e");
Assert.Equal(749, transaction.clauses.Count);
for (var i = 0; i < 749; ++i)
{
var oClause = o["clauses"][i];
IClause clause = transaction.clauses[i];
Assert.Equal(oClause["to"], clause.to);
Assert.Equal(oClause["data"], clause.data);
Assert.Equal(
((string)oClause["value"]).HexToByteArray().ToHexCompact(),
clause.value.ToBigInteger().ToByteArrayUnsigned().ToHexCompact()
);
}
Assert.Equal("0x00183e68e864ee05", "0x" + transaction.blockRef.ToHex().PadLeft(16, '0'));
}
public Task <IEnumerable <IClause> > CandidatesForLiteral(ILiteral literal)
{
if (literal == null)
{
throw new ArgumentNullException("literal");
}
// Index by unification key
FillClauseCache();
// Result is all clauses if there is no unification key
if (literal.UnificationKey == null)
{
return(Task.FromResult(Clauses));
}
// Result is the clauses for this value's unification key
IClause[] result;
if (!_unificationCandidates.TryGetValue(literal.UnificationKey, out result))
{
result = new IClause[0];
}
return(Task.FromResult <IEnumerable <IClause> >(result));
}
public SelectClause ColumnAs(IClause expression, IClause alias)
{
_delegate.AppendSeparated(expression)
.AppendText(" as ")
.Append(alias);
return(this);
}
public SimpleSingleClauseSolver(IClause clause, ISolver subclauseSolver)
{
if (clause == null)
{
throw new ArgumentNullException("clause");
}
if (subclauseSolver == null)
{
throw new ArgumentNullException("subclauseSolver");
}
_clause = clause;
_subclauseSolver = subclauseSolver;
// Compile each part of the clause to its subclauses
_clauseAssignments = new[] { clause.Implies }.Concat(clause.If)
.Select(predicate =>
{
var assignments = PredicateAssignmentList.FromPredicate(predicate);
return(new AssignmentData
{
PredicateName = predicate.UnificationKey,
NumArguments = assignments.CountArguments(),
Assignments = assignments.Assignments.ToArray()
});
})
.ToList();
}
public ChoiceClause(IClause <T> clause)
{
Choices = new List <IClause <T> >()
{
clause
};
}
public virtual string GetSql (IClause clause)
{
if (clause == null)
throw new ArgumentNullException ("clause");
Type type = clause.GetType ();
if (type == typeof (FromSelectClause))
return GetClauseSql (clause as FromSelectClause);
else if (type == typeof (FromTableClause))
return GetClauseSql (clause as FromTableClause);
else if (type == typeof (WhereClause))
return GetClauseSql (clause as WhereClause);
else if (type == typeof (HavingClause))
return GetClauseSql (clause as HavingClause);
else if (type == typeof (JoinClause))
return GetClauseSql (clause as JoinClause);
else if (type == typeof (OrderByClause))
return GetClauseSql (clause as OrderByClause);
else if (type == typeof (GroupByClause))
return GetClauseSql (clause as GroupByClause);
else if (type == typeof (UnionClause))
return GetClauseSql (clause as UnionClause);
else
throw new NotImplementedException (type.FullName);
}
protected virtual void InitStartingTokensForRule(Dictionary <string, NonTerminal <IN> > nonTerminals, Rule <IN> rule)
{
if (rule.PossibleLeadingTokens == null || rule.PossibleLeadingTokens.Count == 0)
{
rule.PossibleLeadingTokens = new List <IN>();
if (rule.Clauses.Count > 0)
{
IClause <IN> first = rule.Clauses[0];
if (first is TerminalClause <IN> )
{
TerminalClause <IN> term = first as TerminalClause <IN>;
rule.PossibleLeadingTokens.Add(term.ExpectedToken);
rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.Distinct <IN>().ToList <IN>();
}
else
{
NonTerminalClause <IN> nonterm = first as NonTerminalClause <IN>;
InitStartingTokensForNonTerminal(nonTerminals, nonterm.NonTerminalName);
if (nonTerminals.ContainsKey(nonterm.NonTerminalName))
{
NonTerminal <IN> firstNonTerminal = nonTerminals[nonterm.NonTerminalName];
firstNonTerminal.Rules.ForEach(r =>
{
rule.PossibleLeadingTokens.AddRange(r.PossibleLeadingTokens);
});
rule.PossibleLeadingTokens = rule.PossibleLeadingTokens.Distinct <IN>().ToList <IN>();
}
}
}
}
}
public IDataReader Read(IClause clause)
{
var command = this.CreateCommand(clause);
Console.WriteLine(clause.Text);
return(command.ExecuteReader());
}
private void AppendIfNotEmpty(string prefix, IClause append, MutableClause appendTo)
{
if (append != null && !append.IsEmpty)
{
appendTo.AppendText(prefix).Append(append).Line();
}
}
public static List <string> GetLeftClausesName(IClause <IN> clause)
{
if (clause is NonTerminalClause <IN> nonTerminal)
{
return(Lst(nonTerminal.NonTerminalName));
}
if (clause is ManyClause <IN> many)
{
return(GetLeftClausesName(many.Clause));
}
if (clause is OptionClause <IN> option)
{
return(GetLeftClausesName(option.Clause));
}
if (clause is ChoiceClause <IN> choice && choice.IsNonTerminalChoice)
{
return(choice.Choices.SelectMany(x => GetLeftClausesName(x)).ToList());
}
if (clause is GroupClause <IN> group)
{
return(GetLeftClausesName(group.Clauses.First()));
}
return(new List <string>());
}
public override IEnumerable <KeyValuePair <object[], long> > ExecuteQuery(IClause sqlAggregateClause)
{
var command = BuildCommand(sqlAggregateClause);
// ReSharper disable once RedundantTypeArgumentsOfMethod // Need for wince.Proj
return(ExecuteCommandReader(command));
}
public override int ExecuteScalar(IClause sqlClause)
{
var command = BuildCommand(sqlClause);
var count = ExecuteScalar(command);
return(Convert.ToInt32(count));
}
public GroupClause(IClause <T> clause)
{
Clauses = new List <IClause <T> >()
{
clause
};
}
public IAggragableQuery <TIEntity> Where(Expression <Func <TIEntity, bool> > predicate)
{
var filterBuilder = new FilterBuilder <TIEntity>(_datastore.Entities, new FilterFactory(_datastore), predicate);
_where = filterBuilder.Build();
return(this);
}
public ListKnowledgeBase(IClause newClause, IKnowledgeBase next)
{
if (newClause == null) throw new ArgumentNullException("newClause");
if (next == null) throw new ArgumentNullException("next");
_clause = newClause;
_next = CreateKnowledgeList(next);
}
private Rule <IN> BuildNonTerminal(Tuple <string, string> ntAndRule)
{
var rule = new Rule <IN>();
var clauses = new List <IClause <IN> >();
var ruleString = ntAndRule.Item2;
var clausesString = ruleString.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var item in clausesString)
{
IClause <IN> clause = null;
var isTerminal = false;
var token = default(IN);
try
{
var tIn = typeof(IN);
var b = Enum.TryParse(item, out token);
if (b)
{
isTerminal = true;
;
}
//token = (IN)Enum.Parse(tIn , item);
//isTerminal = true;
}
catch (ArgumentException)
{
isTerminal = false;
}
if (isTerminal)
{
clause = new TerminalClause <IN>(token);
}
else if (item == "[d]")
{
if (clauses.Last() is TerminalClause <IN> discardedTerminal)
{
discardedTerminal.Discarded = true;
}
}
else
{
clause = new NonTerminalClause <IN>(item);
}
if (clause != null)
{
clauses.Add(clause);
}
}
rule.Clauses = clauses;
//rule.Key = ntAndRule.Item1 + "_" + ntAndRule.Item2.Replace(" ", "_");
return(rule);
}
public NotSpecification(IClause <TEntity> originalSpecification)
{
if (originalSpecification == null)
{
throw new ArgumentNullException(nameof(originalSpecification));
}
_originalCriteria = originalSpecification.SatisfiedBy();
}
internal QuerySet(EntityInfoCollection entities, Type entityInvolve)
{
_where = new Where();
_orderBy = new OrderBy();
_groupBy = new GroupBy();
Entities = entities;
EntityInvolve = new Dictionary <string, IEntityInfo>();
Entity = AddInvolveEntity(entityInvolve);
JoinList = new List <IJoin>();
}
public object Clauses(IClause <IN> clause, ClauseSequence <IN> clauses)
{
ClauseSequence <IN> list = new ClauseSequence <IN>(clause);
if (clauses != null)
{
list.AddRange(clauses);
}
return(list);
}
public GrammarNode <IN> Clauses(IClause <IN> clause, ClauseSequence <IN> clauses)
{
var list = new ClauseSequence <IN>(clause);
if (clauses != null)
{
list.AddRange(clauses);
}
return(list);
}
private void AddNegatedClause(IClause clause)
{
var headNode = clause.Head != null ? (_graph.GetNode(clause.Head.Value) ?? _graph.AddNode(clause.Head.Negated ? (ILogicNode) new ClauseNode(clause.Head.Value) : new LiteralNode(clause.Head.Value)).GetNode(clause.Head.Value)): null;
if (clause.Body.Count < 1)
{
return;
}
if (headNode != null)
{
if (clause.Body.Count == 1)
{
var literal = clause.Body.First();
if (headNode.Id != literal.Value)
{
var negatedLiteral = _graph.GetNode(literal.Value) ?? _graph.AddNode(literal.Negated ? (ILogicNode) new ClauseNode(literal.Value) : new LiteralNode(literal.Value)).GetNode(literal.Value);
if (_graph.GetEdge(headNode, negatedLiteral) == null)
{
_graph.AddEdge(new DirectedEdge <ILogicNode> (headNode, negatedLiteral));
}
}
}
else
{
var literals = clause.Body.Where(literal => headNode.Id != literal.Value).ToList();
if (literals.Count > 0)
{
var disjointLiteralKey = DisjointLiteralKey(literals);
var disjointLiteral = _graph.GetNode(disjointLiteralKey) ?? _graph.AddNode(new LiteralNode(disjointLiteralKey)).GetNode(disjointLiteralKey);
if (_graph.GetEdge(headNode, disjointLiteral) == null)
{
_graph.AddEdge(new DirectedEdge <ILogicNode> (headNode, disjointLiteral));
}
foreach (var literalNode in literals.Select(literal => _graph.GetNode(literal.Value) ?? _graph.AddNode(literal.Negated ? (ILogicNode) new ClauseNode(literal.Value) : new LiteralNode(literal.Value)).GetNode(literal.Value)).Where(literalNode => _graph.GetEdge(disjointLiteral, literalNode) == null))
{
_graph.AddEdge(new DirectedEdge <ILogicNode> (disjointLiteral, literalNode));
}
}
}
}
else
{
var jointLiteralKey = ClauseKey(clause.Body);
var jointLiteral = _graph.GetNode(jointLiteralKey) ?? _graph.AddNode(new ClauseNode(jointLiteralKey)).GetNode(jointLiteralKey);
foreach (var literalNode in clause.Body.Select(literal => _graph.GetNode(literal.Value) ?? _graph.AddNode(new ClauseNode(literal.Value)).GetNode(literal.Value)).Where(literalNode => _graph.GetEdge(jointLiteral, literalNode) == null))
{
_graph.AddEdge(new DirectedEdge <ILogicNode>(jointLiteral, literalNode));
}
}
}
public Updatable(IDataStore datastore)
{
_datastore = datastore;
_where = new Where();
_setFieldList = new SetFieldList <TIEntity>();
_entityName = datastore.Entities.GetNameForType(typeof(TIEntity));
if (string.IsNullOrEmpty(_entityName))
{
throw new NotSupportedException($"Entity type must be added in datastore. Type:{typeof(TIEntity)}.");
}
}
private PredicateClause AppendPredicate(string condition, IClause predicate)
{
if (!IsEmpty)
{
_delegate.AppendText($" {condition} ");
}
_delegate
.AppendText("(")
.Append(predicate)
.AppendText(")");
return(this);
}
public SyntaxParseResult <IN> ParseOneOrMore(IList <Token <IN> > tokens, OneOrMoreClause <IN> clause, int position)
{
SyntaxParseResult <IN> result = new SyntaxParseResult <IN>();
ManySyntaxNode <IN> manyNode = new ManySyntaxNode <IN>("");
int currentPosition = position;
IClause <IN> innerClause = clause.Clause;
bool isError;
SyntaxParseResult <IN> lastInnerResult = null;
SyntaxParseResult <IN> firstInnerResult = null;
if (innerClause is TerminalClause <IN> )
{
manyNode.IsManyTokens = true;
firstInnerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition);
}
else if (innerClause is NonTerminalClause <IN> )
{
manyNode.IsManyValues = true;
firstInnerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition);
}
else
{
throw new NotImplementedException("unable to apply repeater to " + innerClause.GetType().Name);
}
if (firstInnerResult != null && !firstInnerResult.IsError)
{
manyNode.Add(firstInnerResult.Root);
lastInnerResult = firstInnerResult;
currentPosition = firstInnerResult.EndingPosition;
ZeroOrMoreClause <IN> more = new ZeroOrMoreClause <IN>(innerClause);
SyntaxParseResult <IN> nextResult = ParseZeroOrMore(tokens, more, currentPosition);
if (nextResult != null && !nextResult.IsError)
{
currentPosition = nextResult.EndingPosition;
ManySyntaxNode <IN> moreChildren = (ManySyntaxNode <IN>)nextResult.Root;
manyNode.Children.AddRange(moreChildren.Children);
}
isError = false;
}
else
{
isError = true;
}
result.EndingPosition = currentPosition;
result.IsError = isError;
result.Root = manyNode;
result.IsEnded = lastInnerResult != null && lastInnerResult.IsEnded;
return(result);
}
public static IDbCommand CreateCommand(this IDbConnection connection, IClause clause)
{
var command = connection.CreateCommand();
command.CommandText = clause.Text;
foreach (var parameter in clause.Parameters)
{
var param = command.CreateParameter(parameter);
command.Parameters.Add(param);
}
return(command);
}
public MutableClause Append(IClause clause)
{
if (clause == null)
{
return(this);
}
var text = clause.Text;
_textBuilder.Append(text);
_parameters.AddRange(clause.Parameters);
return(this);
}
public ListKnowledgeBase(IClause newClause, IKnowledgeBase next)
{
if (newClause == null)
{
throw new ArgumentNullException("newClause");
}
if (next == null)
{
throw new ArgumentNullException("next");
}
_clause = newClause;
_next = CreateKnowledgeList(next);
}
public void Transform(IClause whereClause)
{
whereClause.TransformExpressions(Visit);
var values = _values.Pop();
foreach (var memberExpression in values.MemberExpressions)
{
// If outer join can never produce true, we can safely inner join.
if (!values.GetValues(memberExpression).Contains(true))
{
_joiner.MakeInnerIfJoined(memberExpression);
}
}
}
private IDbCommand BuildCommand(IClause sqlClause)
{
var @params = new List <IDataParameter>();
var sql = sqlClause.ToStatement(@params);
var command = SqlFactory.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = sql;
foreach (var param in @params)
{
command.Parameters.Add(param);
}
return(command);
}
public virtual string GetSql(IClause clause)
{
if (clause == null)
{
throw new ArgumentNullException("clause");
}
Type type = clause.GetType();
if (type == typeof(FromSelectClause))
{
return(GetClauseSql(clause as FromSelectClause));
}
else if (type == typeof(FromTableClause))
{
return(GetClauseSql(clause as FromTableClause));
}
else if (type == typeof(WhereClause))
{
return(GetClauseSql(clause as WhereClause));
}
else if (type == typeof(HavingClause))
{
return(GetClauseSql(clause as HavingClause));
}
else if (type == typeof(JoinClause))
{
return(GetClauseSql(clause as JoinClause));
}
else if (type == typeof(OrderByClause))
{
return(GetClauseSql(clause as OrderByClause));
}
else if (type == typeof(GroupByClause))
{
return(GetClauseSql(clause as GroupByClause));
}
else if (type == typeof(UnionClause))
{
return(GetClauseSql(clause as UnionClause));
}
else
{
throw new NotImplementedException(type.FullName);
}
}
/// <summary>
/// Adds a positive literal to a negative Horn clause
/// </summary>
public static IClause Then(this IClause negativeHornClause, ILiteral then)
{
if (negativeHornClause == null)
{
throw new ArgumentNullException("negativeHornClause");
}
if (negativeHornClause.Implies != null)
{
throw new ArgumentException("Clause already has an implication", "negativeHornClause");
}
if (then == null)
{
throw new ArgumentNullException("then");
}
return(new PositiveClause(negativeHornClause, then));
}
public SimpleSingleClauseSolver(IClause clause, ISolver subclauseSolver)
{
if (clause == null) throw new ArgumentNullException("clause");
if (subclauseSolver == null) throw new ArgumentNullException("subclauseSolver");
_clause = clause;
_subclauseSolver = subclauseSolver;
// Compile each part of the clause to its subclauses
_clauseAssignments = new[] { clause.Implies }.Concat(clause.If)
.Select(predicate =>
{
var assignments = PredicateAssignmentList.FromPredicate(predicate);
return new AssignmentData
{
PredicateName = predicate.UnificationKey,
NumArguments = assignments.CountArguments(),
Assignments = assignments.Assignments.ToArray()
};
})
.ToList();
}
public Task<IEnumerable<IClause>> CandidatesForLiteral(ILiteral literal)
{
if (literal == null) throw new ArgumentNullException("literal");
// Index by unification key
FillClauseCache();
// Result is all clauses if there is no unification key
if (literal.UnificationKey == null)
{
return Task.FromResult(Clauses);
}
// Result is the clauses for this value's unification key
IClause[] result;
if (!_unificationCandidates.TryGetValue(literal.UnificationKey, out result))
{
result = new IClause[0];
}
return Task.FromResult<IEnumerable<IClause>>(result);
}
public void AddClause (IClause clause)
{
ArgumentUtility.CheckNotNull ("clause", clause);
var clauseAsMainFromClause = clause as MainFromClause;
if (clauseAsMainFromClause != null)
{
if (MainFromClause != null)
throw new InvalidOperationException ("Builder already has a MainFromClause.");
MainFromClause = clauseAsMainFromClause;
return;
}
var clauseAsSelectClause = clause as SelectClause;
if (clauseAsSelectClause != null)
{
if (SelectClause != null)
throw new InvalidOperationException ("Builder already has a SelectClause.");
SelectClause = clauseAsSelectClause;
return;
}
var clauseAsBodyClause = clause as IBodyClause;
if (clauseAsBodyClause != null)
{
_bodyClauses.Add (clauseAsBodyClause);
return;
}
var message = string.Format (
"Cannot add clause of type '{0}' to a query model. Only instances of IBodyClause, MainFromClause, or ISelectGroupClause are supported.",
clause.GetType());
throw new ArgumentException (message, "clause");
}
/// <summary>
/// Generates a new knowledge base with an additional assertion
/// </summary>
public static IKnowledgeBase Assert(this IKnowledgeBase oldKnowledge, IClause assertion)
{
return new ListKnowledgeBase(assertion, oldKnowledge);
}
private ListKnowledgeBase(IClause ourClause, ListKnowledgeBase next)
{
_clause = ourClause;
_next = next;
}
public SelectClause CreateSelectClause (IClause previousClause, ClauseGenerationContext clauseGenerationContext)
{
throw new NotImplementedException();
}
