public void stepOuterFor(Clause i) {
System.Console.Write(" " + outerCnt);
if (outerCnt % 50 == 0) {
System.Console.WriteLine("");
}
outerCnt++;
}
public void testImmutable()
{
Clause c = new Clause();
Assert.IsFalse(c.isImmutable());
c.addNegativeLiteral(new Predicate("Pred1", new List<Term>()));
c.addPositiveLiteral(new Predicate("Pred2", new List<Term>()));
c.setImmutable();
Assert.IsTrue(c.isImmutable());
//try {
c.addNegativeLiteral(new Predicate("Pred3", new List<Term>()));
Assert.Fail("Should have thrown an IllegalStateException");
//} catch (IllegalStateException ise) {
// // Ok, Expected
//}
// try {
c.addPositiveLiteral(new Predicate("Pred3", new List<Term>()));
Assert.Fail("Should have thrown an IllegalStateException");
//} catch (IllegalStateException ise) {
// Ok, Expected
//}
}
public void testIsEmpty()
{
Clause c1 = new Clause();
Assert.IsTrue(c1.isEmpty());
c1.addNegativeLiteral(new Predicate("Pred1", new List<Term>()));
Assert.IsFalse(c1.isEmpty());
Clause c2 = new Clause();
Assert.IsTrue(c2.isEmpty());
c2.addPositiveLiteral(new Predicate("Pred1", new List<Term>()));
Assert.IsFalse(c2.isEmpty());
Clause c3 = new Clause();
Assert.IsTrue(c3.isEmpty());
c3.addNegativeLiteral(new Predicate("Pred1", new List<Term>()));
c3.addPositiveLiteral(new Predicate("Pred1", new List<Term>()));
// Should be empty as they resolved with each other
Assert.IsFalse(c3.isEmpty());
c3.addNegativeLiteral(new Predicate("Pred1", new List<Term>()));
c3.addPositiveLiteral(new Predicate("Pred2", new List<Term>()));
Assert.IsFalse(c3.isEmpty());
}
public ProofStepClauseDemodulation(Clause demodulated, Clause origClause,
TermEquality assertion)
{
this.demodulated = demodulated;
this.origClause = origClause;
this.assertion = assertion;
this.predecessors.Add(origClause.getProofStep());
}
public static int standardizeApart(Clause c, int saIdx) {
List<Variable> variables = new List<Variable>();
foreach (Literal l in c.getLiterals()) {
collectAllVariables(l.getAtomicSentence(), variables);
}
return standardizeApart(variables, c, saIdx);
}
public ProofStepBwChGoal(Clause toProve, Literal currentGoal,
Dictionary<Variable, Term> bindings)
{
this.toProve = toProve;
this.currentGoal = currentGoal;
foreach (Variable key in bindings.Keys)
{
this.bindings.Add(key, bindings[key]);
}
}
public ProofStepClauseParamodulation(Clause paramodulated,
Clause topClause, Clause equalityClause, TermEquality assertion)
{
this.paramodulated = paramodulated;
this.topClause = topClause;
this.equalityClause = equalityClause;
this.assertion = assertion;
this.predecessors.Add(topClause.getProofStep());
this.predecessors.Add(equalityClause.getProofStep());
}
public ProofStepFoChAssertFact(Clause implication, Literal fact,
Dictionary<Variable, Term> bindings, ProofStep predecessor)
{
this.implication = implication;
this.fact = fact;
this.bindings = bindings;
if (null != predecessor)
{
predecessors.Add(predecessor);
}
}
public List<Variable> collectAllVariables(Clause aClause)
{
List<Variable> variables = new List<Variable>();
foreach (Literal l in aClause.getLiterals())
{
l.getAtomicSentence().accept(this, variables);
}
return variables;
}
public ProofStepClauseBinaryResolvent(Clause resolvent, Clause parent1,
Clause parent2, Dictionary<Variable, Term> subst,
Dictionary<Variable, Term> renameSubst)
{
this.resolvent = resolvent;
this.parent1 = parent1;
this.parent2 = parent2;
this.subst = subst;
this.renameSubst = renameSubst;
this.predecessors.Add(parent1.getProofStep());
this.predecessors.Add(parent2.getProofStep());
}
public Criteria(string parameter, Clause clause)
: this(parameter, clause, null)
{
switch (clause)
{
case Clause.IsNull:
case Clause.IsNotNull:
break;
default:
throw new ArgumentException(string.Format("Only {0} and {1} are allowed", Clause.IsNull, Clause.IsNotNull));
}
}
public CriteriaItem(LogicalOperator logicalOperator, string parameter, Clause clause, object value)
: base(logicalOperator)
{
Clause newClause = clause;
if (value == null)
{
if (clause == Clause.Eq)
{
newClause = Clause.IsNull;
}
}
this.clause = newClause;
this.parameter = parameter;
this.value = value;
}
//
// START-ClauseSimplifier
public Clause simplify(Clause c) {
Clause simplified = c;
// Apply each of the rewrite rules to
// the clause
foreach (TermEquality te in rewrites) {
Clause dc = simplified;
// Keep applying the rewrite as many times as it
// can be applied before moving on to the next one.
while (null != (dc = demodulation.apply(te, dc))) {
simplified = dc;
}
}
return simplified;
}
public Clause standardizeApart(Clause clause,
StandardizeApartIndexical standardizeApartIndexical)
{
List<Variable> toRename = variableCollector.collectAllVariables(clause);
Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>();
foreach (Variable var in toRename)
{
Variable v = null;
do
{
v = new Variable(standardizeApartIndexical.getPrefix()
+ standardizeApartIndexical.getNextIndex());
// Ensure the new variable name is not already
// accidentally used in the sentence
} while (toRename.Contains(v));
if (renameSubstitution.ContainsKey(var))
{
renameSubstitution[var] = v;
}
else
{
renameSubstitution.Add(var, v);
}
}
if (renameSubstitution.Count > 0)
{
List<Literal> literals = new List<Literal>();
foreach (Literal l in clause.getLiterals())
{
literals.Add(substVisitor.subst(renameSubstitution, l));
}
Clause renamed = new Clause(literals);
renamed.setProofStep(new ProofStepRenaming(renamed, clause
.getProofStep()));
return renamed;
}
return clause;
}
public Clause apply(TermEquality assertion, Clause clExpression)
{
Clause altClExpression = null;
foreach (Literal l1 in clExpression.getLiterals())
{
AtomicSentence altExpression = apply(assertion, l1
.getAtomicSentence());
if (null != altExpression)
{
// I have an alternative, create a new clause
// with the alternative and return
List<Literal> newLits = new List<Literal>();
foreach (Literal l2 in clExpression.getLiterals())
{
if (l1.Equals(l2))
{
newLits.Add(l1.newInstance(altExpression));
}
else
{
newLits.Add(l2);
}
}
// Only apply demodulation at most once on
// each call.
altClExpression = new Clause(newLits);
altClExpression.setProofStep(new ProofStepClauseDemodulation(
altClExpression, clExpression, assertion));
if (clExpression.isImmutable())
{
altClExpression.setImmutable();
}
if (!clExpression.isStandardizedApartCheckRequired())
{
altClExpression.setStandardizedApartCheckNotRequired();
}
break;
}
}
return altClExpression;
}
public void stepResolved(Clause iFactor, Clause jFactor,
Set<Clause> resolvents) {
noPairsResolved++;
Clause egLargestClause = null;
for (Clause c : resolvents) {
if (c.getNumberLiterals() > maxClauseSizeSeen) {
egLargestClause = c;
maxClauseSizeSeen = c.getNumberLiterals();
}
}
if (null != egLargestClause) {
System.Console.WriteLine("");
System.Console.WriteLine("E.g. largest clause so far="
+ maxClauseSizeSeen + ", " + egLargestClause);
System.Console.WriteLine("i=" + iFactor);
System.Console.WriteLine("j=" + jFactor);
}
}
public void testSimpleExample()
{
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addPredicate("P");
domain.addPredicate("Q");
domain.addPredicate("R");
domain.addFunction("F");
FOLParser parser = new FOLParser(domain);
List<Literal> lits = new List<Literal>();
AtomicSentence a1 = (AtomicSentence)parser.parse("P(F(x,B),x)");
AtomicSentence a2 = (AtomicSentence)parser.parse("Q(x)");
lits.Add(new Literal(a1));
lits.Add(new Literal(a2));
Clause c1 = new Clause(lits);
lits.Clear();
a1 = (AtomicSentence)parser.parse("F(A,y) = y");
a2 = (AtomicSentence)parser.parse("R(y)");
lits.Add(new Literal(a1));
lits.Add(new Literal(a2));
Clause c2 = new Clause(lits);
List<Clause> paras = paramodulation.apply(c1, c2);
Assert.AreEqual(2, paras.Count);
foreach (Clause c in paras)
{
Assert.AreEqual("[P(B,A), Q(A), R(B)]", c.ToString());
Assert.AreEqual("[P(F(A,F(x,B)),x), Q(x), R(F(x,B))]", c
.ToString());
}
}
internal OperationResult ContainsAnyOperationDelegate(Clause clause, object?state1, object?state2, IEnumerable <ClauseCapture>?captures)
{
var typeHolder = state1 ?? state2;
if (typeHolder?.GetType().IsDefined(typeof(FlagsAttribute), false) is true)
{
bool ParseContainsAnyEnum(Enum state)
{
foreach (var datum in clause.Data ?? new List <string>())
{
#if !NETSTANDARD2_0
if (Enum.TryParse(typeHolder.GetType(), datum, out var result))
{
if (result is Enum eresult)
{
if (state.HasFlag(eresult))
{
return(true);
}
}
}
else
{
return(false);
}
#else
try
{
var result = Enum.Parse(typeHolder.GetType(), datum);
if (state.HasFlag(result as Enum))
{
return(true);
}
}
catch (Exception)
{
return(false);
}
#endif
}
return(false);
}
if (state1 is Enum enum1)
{
var res = ParseContainsAnyEnum(enum1);
if ((res && !clause.Invert) || (clause.Invert && !res))
{
return(new OperationResult(true, !clause.Capture ? null : new TypedClauseCapture <Enum>(clause, enum1, state1, null)));
}
}
if (state2 is Enum enum2)
{
var res = ParseContainsAnyEnum(enum2);
if ((res && !clause.Invert) || (clause.Invert && !res))
{
return(new OperationResult(true, !clause.Capture ? null : new TypedClauseCapture <Enum>(clause, enum2, null, state2)));
}
}
return(new OperationResult(false, null));
}
(var stateOneList, var stateOneDict) = Analyzer?.ObjectToValues(state1) ?? (new List <string>(), new List <KeyValuePair <string, string> >());
(var stateTwoList, var stateTwoDict) = Analyzer?.ObjectToValues(state2) ?? (new List <string>(), new List <KeyValuePair <string, string> >());
if (clause.DictData is List <KeyValuePair <string, string> > ContainsData && ContainsData.Any())
{
if (stateOneDict.Any())
{
var captured = new List <KeyValuePair <string, string> >();
foreach (var entry in stateOneDict)
{
var res = ContainsData.Contains(entry);
if ((res && !clause.Invert) || (clause.Invert && !res))
{
captured.Add(entry);
}
}
if (captured.Any())
{
var returnVal = clause.Capture ?
new TypedClauseCapture <List <KeyValuePair <string, string> > >(clause, captured, state1, null) :
null;
return(new OperationResult(true, returnVal));
}
}
if (stateTwoDict.Any())
{
var captured = new List <KeyValuePair <string, string> >();
foreach (var entry in stateTwoDict)
{
var res = ContainsData.Contains(entry);
if ((res && !clause.Invert) || (clause.Invert && !res))
{
captured.Add(entry);
}
}
if (captured.Any())
{
var returnVal = clause.Capture ?
new TypedClauseCapture <List <KeyValuePair <string, string> > >(clause, captured, null, state2) :
null;
return(new OperationResult(true, returnVal));
}
}
return(new OperationResult(false, null));
}
if (clause.Data is List <string> ClauseData && ClauseData.Any())
{
(bool Applies, List <string>?Matches) ClauseAppliesToList(List <string> stateList)
{
var results = new List <string>();
if (typeHolder is string)
{
foreach (var datum in stateList)
{
if (clause.Data.Any(x => (clause.Invert && !datum.Contains(x)) || (!clause.Invert && datum.Contains(x))))
{
results.Add(datum);
}
}
return(results.Any(), clause.Capture ? results : null);
}
else
{
foreach (var datum in stateList)
{
if (clause.Data.Any(x => (clause.Invert && !datum.Equals(x)) || (!clause.Invert && datum.Equals(x))))
{
results.Add(datum);
}
}
return(results.Any(), clause.Capture ? results : null);
}
}
var result = ClauseAppliesToList(stateOneList);
if (result.Applies)
{
if (result.Matches?.Any() is true)
{
return(typeHolder switch
{
string _ => new OperationResult(true, new TypedClauseCapture <string>(clause, result.Matches.First(), state1, null)),
_ => new OperationResult(true, new TypedClauseCapture <List <string> >(clause, result.Matches, state1, null)),
});
public static IAliasedDataOrder DeleteQuery(string tableName, Clause whereCondition) => DeleteQuery(tableName, whereCondition, new string[0]);
protected SelectItem(IDatabaseAccessor accessor, TableItem[] tables, bool distinct, Clause clause) : base(accessor, clause)
{
if (tables == null || tables.Count(t => t != null) <= 0)
{
throw new ArgumentNullException("table");
}
_tables = new List <TableItem>(tables);
Distinct = distinct;
}
public bool isCheckForUnitRefutation(Clause clause)
{
if (isLookingForAnswerLiteral())
{
if (2 == clause.getNumberLiterals())
{
foreach (Literal t in clause.getLiterals())
{
if (t.getAtomicSentence().getSymbolicName().Equals(
answerLiteral.getAtomicSentence()
.getSymbolicName()))
{
return true;
}
}
}
}
else
{
return clause.isUnitClause();
}
return false;
}
public static Clause <T> Receive <TSrc, T>(this Clause <TSrc> before, TopBase top, T selected)
{
throw new InvalitContextException(nameof(Receive));
}
//--//
public Atom(Clause clause, Truth.State truth)
{
m_clause = clause;
m_truth = truth;
}
public static Clause <Non> With <T>(this Clause <T> before) => throw new InvalitContextException(nameof(With));
public static Clause <T> WaitForTimeout <T>(this Clause <T> before, SqlExpression expression, object timeout) => throw new InvalitContextException(nameof(WaitForTimeout));
public static Clause <Non> OnConcat <T>(this Clause <T> before, string path) => throw new InvalitContextException(nameof(OnConcat));
public static Clause <T> LifeTime_Assign <T>(this Clause <T> before, object time) => throw new InvalitContextException(nameof(LifeTime_Assign));
public static Clause <T> ToService <T>(this Clause <T> before, string path) => throw new InvalitContextException(nameof(ToService));
public Clause standardizeApart(Clause aClause)
{
return(_standardizeApart.standardizeApart(aClause, variableIndexical));
}
private void AddClause()
{
ClauseDisplay clauseDisplay = clauseSpawner.spawnClause();
activeClause = new Clause(clauseGenerator.getRandomClause(), clauseDisplay, this);
}
public Node ParseInputSyntax(Node rootNode, string expression)
{
expression = expression.ToUpper();
var freqs = expression
.Where(c => Char.IsLetter(c))
.GroupBy(c => c)
.ToDictionary(g => g.Key, g => g.Count());
int firstSBrac = expression.IndexOf('(');
int firstEBrac = ScanMatchingBrace(expression, firstSBrac);
if (firstEBrac - firstSBrac == expression.Length)
return ParseInputSyntax(rootNode, expression.Substring(firstSBrac+1, firstEBrac - firstSBrac-2));
// base case, raw expression
if (firstEBrac == -1 || firstSBrac == -1)
{
int isIndex = expression.IndexOf("IS");
int notIndex = expression.IndexOf("NOT");
string left = expression.Substring(0, isIndex - 1);
string right = expression.Substring(isIndex + 3 + (notIndex > 0 ? 4 : 0));
Variable inputVar = new Variable(left);
// Condition cond = new Condition(right);
Condition cond = GetInputConditionFromFis(inputVar, right);
// IF there is a not
var clause = new Clause(inputVar, cond);
if(notIndex > 0)
{
Node node = new Node(new NotFunction(), clause, null);
return node;
}
return clause;
}
string leftParse = expression.Substring(firstSBrac + 1, firstEBrac - 2);
Node leftOperand = new Node();
rootNode.LeftOperand = ParseInputSyntax(leftOperand, leftParse);
expression = expression.Substring(firstEBrac).TrimStart();
string function = expression.Substring(0, expression.IndexOf(' '));
IFunction func = null;
switch (function.ToLower().Trim())
{
case "and":
func = new AndFunction();
break;
case "or":
func = new OrFunction();
break;
default:
break;
}
rootNode.Function = func;
expression = expression.Substring(expression.IndexOf(' ') + 1);
int lastSBrac = expression.IndexOf('(');
int lastEBrac = ScanMatchingBrace(expression, firstSBrac);
string rightParse = expression.Substring(lastSBrac + 1, lastEBrac - 2);
Node rightOperand = new Node();
rootNode.RightOperand = ParseInputSyntax(rightOperand, rightParse);
return rootNode;
}
public Criteria(string parameter, Clause clause, object value)
: this()
{
var criteriaItem = new CriteriaItem(LogicalOperator.None, parameter, clause, value);
_criteriaList.Add(criteriaItem);
}
public string GetComments(Clause clauseModel)
{
string abc = null;
return(abc);
}
public Criteria Or(string parameter, Clause clause, object value)
{
var criteriaItem = new CriteriaItem(LogicalOperator.Or, parameter, clause, value);
_criteriaList.Add(criteriaItem);
return this;
}
public static Clause <T> MoveConversationTo <T>(this Clause <T> before, object conversation_handle, object conversation_group_id) => throw new InvalitContextException(nameof(MoveConversationTo));
public ProofStepClauseFactor(Clause factor, Clause factorOf)
{
this.factor = factor;
this.factorOf = factorOf;
this.predecessors.Add(factorOf.getProofStep());
}
public string Edit(Clause clauseModel)
{
string abc = null;
return(abc);
}
public string Approve(Clause clauseModel)
{
string abc = null;
return(abc);
}
protected InsertItem(IDatabaseAccessor accessor, string table, Clause clause, params string[] columns) : base(accessor, table, null, clause, columns)
{
}
public void addProofStep(
List<List<ProofStepBwChGoal>> currentLevelProofSteps,
Clause toProve, Literal currentGoal,
Dictionary<Variable, Term> bindings)
{
if (currentLevelProofSteps.Count > 0)
{
ProofStepBwChGoal predecessor = new ProofStepBwChGoal(toProve,
currentGoal, bindings);
foreach (List<ProofStepBwChGoal> steps in currentLevelProofSteps)
{
if (steps.Count > 0)
{
steps[0].setPredecessor(predecessor);
}
steps.Insert(0, predecessor);
}
}
}
public void testFindSubsumedClauses()
{
// Taken from AIMA2e pg 679
FOLDomain domain = new FOLDomain();
domain.addPredicate("patrons");
domain.addPredicate("hungry");
domain.addPredicate("type");
domain.addPredicate("fri_sat");
domain.addPredicate("will_wait");
domain.addConstant("Some");
domain.addConstant("Full");
domain.addConstant("French");
domain.addConstant("Thai");
domain.addConstant("Burger");
FOLParser parser = new FOLParser(domain);
string c1 = "patrons(v,Some)";
string c2 = "patrons(v,Full) AND (hungry(v) AND type(v,French))";
string c3 = "patrons(v,Full) AND (hungry(v) AND (type(v,Thai) AND fri_sat(v)))";
string c4 = "patrons(v,Full) AND (hungry(v) AND type(v,Burger))";
string sh = "FORALL v (will_wait(v) <=> (" + c1 + " OR (" + c2
+ " OR (" + c3 + " OR (" + c4 + ")))))";
Sentence s = parser.parse(sh);
CNFConverter cnfConv = new CNFConverter(parser);
CNF cnf = cnfConv.convertToCNF(s);
// Contains 9 duplicates
Assert.AreEqual(40, cnf.getNumberOfClauses());
ISet <Clause> clauses = CollectionFactory.CreateSet <Clause>(cnf.getConjunctionOfClauses());
// duplicates removed
Assert.AreEqual(31, clauses.Size());
clauses.RemoveAll(SubsumptionElimination.findSubsumedClauses(clauses));
// subsumed clauses removed
Assert.AreEqual(8, clauses.Size());
// Ensure only the 8 correct/expected clauses remain
Clause cl1 = cnfConv
.convertToCNF(
parser.parse("(NOT(will_wait(v)) OR (patrons(v,Full) OR patrons(v,Some)))"))
.getConjunctionOfClauses().Get(0);
Clause cl2 = cnfConv
.convertToCNF(
parser.parse("(NOT(will_wait(v)) OR (hungry(v) OR patrons(v,Some)))"))
.getConjunctionOfClauses().Get(0);
Clause cl3 = cnfConv
.convertToCNF(
parser.parse("(NOT(will_wait(v)) OR (patrons(v,Some) OR (type(v,Burger) OR (type(v,French) OR type(v,Thai)))))"))
.getConjunctionOfClauses().Get(0);
Clause cl4 = cnfConv
.convertToCNF(
parser.parse("(NOT(will_wait(v)) OR (fri_sat(v) OR (patrons(v,Some) OR (type(v,Burger) OR type(v,French)))))"))
.getConjunctionOfClauses().Get(0);
Clause cl5 = cnfConv
.convertToCNF(
parser.parse("(NOT(patrons(v,Some)) OR will_wait(v))"))
.getConjunctionOfClauses().Get(0);
Clause cl6 = cnfConv
.convertToCNF(
parser.parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,French)) OR will_wait(v))))"))
.getConjunctionOfClauses().Get(0);
Clause cl7 = cnfConv
.convertToCNF(
parser.parse("(NOT(fri_sat(v)) OR (NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Thai)) OR will_wait(v)))))"))
.getConjunctionOfClauses().Get(0);
Clause cl8 = cnfConv
.convertToCNF(
parser.parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Burger)) OR will_wait(v))))"))
.getConjunctionOfClauses().Get(0);
Assert.IsTrue(clauses.Contains(cl1));
Assert.IsTrue(clauses.Contains(cl2));
Assert.IsTrue(clauses.Contains(cl3));
Assert.IsTrue(clauses.Contains(cl4));
Assert.IsTrue(clauses.Contains(cl5));
Assert.IsTrue(clauses.Contains(cl6));
Assert.IsTrue(clauses.Contains(cl7));
Assert.IsTrue(clauses.Contains(cl8));
}
public string Delete(Clause clauseModel)
{
string abc = null;
return(abc);
}
public bool isAnswer(Clause aClause)
{
bool isAns = false;
if (answerClause.isEmpty())
{
if (aClause.isEmpty())
{
proofs.Add(new ProofFinal(aClause.getProofStep(),
new Dictionary<Variable, Term>()));
complete = true;
isAns = true;
}
}
else
{
if (aClause.isEmpty())
{
// This should not happen
// as added an answer literal to sos, which
// implies the database (i.e. premises) are
// unsatisfiable to begin with.
throw new ApplicationException(
"Generated an empty clause while looking for an answer, implies original KB or usable is unsatisfiable");
}
if (aClause.isUnitClause()
&& aClause.isDefiniteClause()
&& aClause.getPositiveLiterals()[0]
.getAtomicSentence().getSymbolicName().Equals(
answerLiteral.getAtomicSentence()
.getSymbolicName()))
{
Dictionary<Variable, Term> answerBindings = new Dictionary<Variable, Term>();
List<FOLNode> answerTerms = aClause.getPositiveLiterals()[
0].getAtomicSentence().getArgs();
int idx = 0;
foreach (Variable v in answerLiteralVariables)
{
answerBindings.Add(v,(Term)answerTerms[idx]);
idx++;
}
bool addNewAnswer = true;
foreach (Proof.Proof p in proofs)
{
if (p.getAnswerBindings().Equals(answerBindings))
{
addNewAnswer = false;
break;
}
}
if (addNewAnswer)
{
proofs.Add(new ProofFinal(aClause.getProofStep(),
answerBindings));
}
isAns = true;
}
}
if (DateTime.UtcNow.Ticks > finishTime)
{
complete = true;
// Indicate that I have run out of query time
timedOut = true;
}
return isAns;
}
public static Clause <T> Cleanup <T>(this Clause <T> before) => throw new InvalitContextException(nameof(Cleanup));
public static ISimpleDataOrder RecordCopyQuery(string tableName, string primaryKeyFieldName, Clause tempTableClause, Tuple <string, string>[] fieldParameterNameTupleCollection, string[] fieldsToCopy)
{
string uniqueAppendage = SafeGuid();
string sourceAlias = "source";
string query = $"MERGE {tableName}\r\nUSING ("
+ $"\r\nSELECT{string.Join(",", fieldsToCopy.Concat(new[] { primaryKeyFieldName }).Distinct().Select(field => $" \ r \ n {
field
} "))}\r\nFROM {tableName}";
SimpleDataOrder firstDataOrder =
tempTableClause
.Build();
if (string.IsNullOrEmpty(firstDataOrder.Query) == false)
{
query += "\r\nWHERE" + firstDataOrder.Query;
}
query += $"\r\n) AS {sourceAlias}\r\nON (1 = 0)\r\nWHEN NOT MATCHED THEN";
IEnumerable <Tuple <string, string> > insertValues = fieldsToCopy.Select(field => Tuple.Create(field, $"{sourceAlias}.{field}")).Concat(fieldParameterNameTupleCollection);
query += $"\r\nINSERT ({string.Join(",", insertValues.Select(tuple => $"\r\n {tuple.Item1}"))}\r\n)\r\nVALUES (\r\n";
query += string.Join(",", insertValues.Select(tuple => $"\r\n {tuple.Item2}"));
query += $"\r\n)\r\nOUTPUT {sourceAlias}.{primaryKeyFieldName} AS OldId, INSERTED.{primaryKeyFieldName} AS NewId;";
return(new SimpleDataOrder(query, firstDataOrder.Parameters));
}
public static Clause <T> GetConversationGroup <T>(this Clause <T> before, object conversation_group_id) => throw new InvalitContextException(nameof(GetConversationGroup));
protected internal override Node TransformClause(Clause clause)
{
return Dispatch(clause);
}
public static Clause <T> WaitFor <T>(this Clause <T> before, SqlExpression expression) => throw new InvalitContextException(nameof(WaitFor));
public static Clause <T> Encryption_Assign <T>(this Clause <T> before, OnOff onOff) => throw new InvalitContextException(nameof(Encryption_Assign));
public string Search(Clause clauseModel)
{
string abc = null;
return(abc);
}
public Criteria(LogicalOperator logicalOperator, string parameter, Clause clause, object value)
: this(parameter, clause, value)
{
LogicalOperator = logicalOperator;
}
public static Clause <Non> Related_Conversation_Group_Assign <T>(this Clause <T> before, object related_conversation_group_id) => throw new InvalitContextException(nameof(Related_Conversation_Group_Assign));
public Criteria Or(string parameter, Clause clause)
{
return Or(parameter, clause, null);
}
public static Clause <T> EndConversation <T>(this Clause <T> before, object conversation_handle) => throw new InvalitContextException(nameof(EndConversation));
protected internal override void TraverseClause(Clause clause)
{
Dispatch(clause);
}
public static Clause <T> Error_Assign <T>(this Clause <T> before, object error) => throw new InvalitContextException(nameof(Error_Assign));
protected internal virtual void TraverseClause(Clause clause) { TraverseBlock(clause); }
public static Clause <T> BeginConversationTimer <T>(this Clause <T> before, object conversation_handle) => throw new InvalitContextException(nameof(BeginConversationTimer));
private void AssertClause(Clause clause, string expectedOutput)
{
using (var writer = new IndentedTextWriter(new StringWriter(), " "))
{
using (var tsql = new TSqlCodeProvider())
{
tsql.GenerateCodeFromStatement(clause, writer, new CodeGeneratorOptions());
var output = writer.InnerWriter.ToString();
Assert.IsTrue(output.ToString() == expectedOutput);
}
}
}
public static Clause <T> Description_Assign <T>(this Clause <T> before, object description) => throw new InvalitContextException(nameof(Description_Assign));
