public SqlSelectQuery <T> Take(int rows)
{
var clause = new SqlRowFetchNextClause(rows);
Clauses.Add(clause);
return(this);
}
/// <summary>
/// Add a component clause to the query.
/// </summary>
/// <param name="component"></param>
/// <param name="clause"></param>
/// <returns></returns>
public Q Add(string component, AbstractClause clause)
{
clause.Component = component;
Clauses.Add(clause);
return((Q)this);
}
private void BuildQuery(string filterName, FilterClauseEnum clause, FilterConditionEnum condition, string filterValue)
{
FilterName = filterName;
Clause = clause;
Condition = condition;
FilterValue = filterValue;
foreach (FilterClauseEnum val in Enum.GetValues(typeof(FilterClauseEnum)))
{
var isSelected = val == clause;
Clauses.Add(new FilterEnumContainer {
Name = val.ToString(), Value = (int)val, Selected = isSelected
});
}
foreach (FilterConditionEnum val in Enum.GetValues(typeof(FilterConditionEnum)))
{
var isSelected = val == condition;
Conditions.Add(
new FilterEnumContainer {
Name = val.ToString(), Value = (int)val, Selected = isSelected
});
}
}
public SqlSelectQuery <T> Skip(int rows)
{
var clause = new SqlRowOffsetClause(rows);
Clauses.Add(clause);
return(this);
}
protected TSpecification Clause(Clause <TEntity> clause)
{
Clauses.Add(new ClauseData(CurrentOperator, clause));
CurrentOperator = Operator.And;
return(this as TSpecification);
}
/// <summary>
/// Create a new selector from DOM elements.
/// </summary>
///
/// <param name="elements">
/// A sequence of elements.
/// </param>
public Selector(IEnumerable <IDomObject> elements)
{
SelectorClause sel = new SelectorClause();
sel.SelectorType = SelectorType.Elements;
sel.SelectElements = elements;
Clauses.Add(sel);
}
protected TSpecification Clause(Expression <Func <TEntity, bool> > clauseData)
{
Clauses.Add(new ClauseData(CurrentOperator,
new DirectClause <TEntity>(clauseData)));
CurrentOperator = Operator.And;
return(this as TSpecification);
}
public ConfigurableSwitchSortClauseBuilder <TRequest, TEntity, TValue> ThenBy(string entityProperty)
{
var clauseBuilder = ConfigurableSwitchSortClauseBuilder <TRequest, TEntity, TValue>
.From(this, entityProperty);
Clauses.Add(clauseBuilder);
return(clauseBuilder);
}
private void AddClause(Clause clause)
{
learnedClauses.Add(clause);
Clauses.Add(clause);
foreach (var literal in clause)
{
ClauseReferences[literal.index].Add(clause);
}
}
/// <summary>
/// SELECT column_name(s)
/// FROM table_name
/// ORDER BY column_name[ASC|DESC]
/// </summary>
/// <param name="customization"></param>
/// <returns></returns>
public OrderByClause OrderBy(Action <Target, Context> customization)
{
var clause = new OrderByClause(this);
Clauses.Add(clause);
clause.Target.Customize(customization);
return(clause);
}
/// <summary>
/// Ends the current active clause, and creates a new one.
/// </summary>
public void CreateNewClause()
{
// Create new Group
if (CurrentClause.Expressions.Count > 0)
{
CurrentClause = new WhereClause <SelectWhereStatement>();
Clauses.Add(CurrentClause);
}
}
/// <summary>
/// Create a new selector from a single element.
/// </summary>
///
/// <param name="element">
/// The element to test.
/// </param>
public Selector(IDomObject element)
{
SelectorClause sel = new SelectorClause();
sel.SelectorType = SelectorType.Elements;
sel.SelectElements = new List <IDomObject>();
((List <IDomObject>)sel.SelectElements).Add(element);
Clauses.Add(sel);
}
public void AddValues(object values)
{
var properties = values.GetType().GetProperties();
Clauses.AddRange(new RawSqlClause("("), new ListSqlClause(properties.Select(p => new RawSqlClause(p.Name))), new RawSqlClause(")"));
Clauses.Add(new RawSqlClause("VALUES"));
Clauses.AddRange(new RawSqlClause("("), new ListSqlClause(properties.Select(p => new ParameterSqlClause(p.GetValue(values)))), new RawSqlClause(")"));
}
public ConfigurableSwitchSortClauseBuilder <TRequest, TEntity, TValue> ThenBy <TProp>(
Expression <Func <TEntity, TProp> > entityProperty)
{
var clauseBuilder = ConfigurableSwitchSortClauseBuilder <TRequest, TEntity, TValue>
.From(this, entityProperty);
Clauses.Add(clauseBuilder);
return(clauseBuilder);
}
public SqlSelectQuery <T> Where(Expression <Func <T, bool> > predicate)
{
if (predicate == null)
{
return(this);
}
var clause = new SqlWhereClause(predicate);
Clauses.Add(clause);
return(this);
}
public SqlSelectQuery <T> OrderBy(Expression <Func <T, object> > columns)
{
if (columns == null)
{
return(this);
}
var clause = new SqlOrderByClause(columns);
Clauses.Add(clause);
return(this);
}
public void Init(string tell)
/* This is the agents set up. It sets up:
* - the list of all symbols
* - all the clauses for the knowledge base
* - the facts about the world */
{
string[] sentances = tell.Split(';');
for (int i = 0; i < sentances.Length - 1; i++)
{
if (!sentances[i].Contains("=>")) // Checks to see if its a fact. eg b;
{
if (!Agenda.Contains(sentances[i])) // If the symbol is not already in the Symbols list
{
Agenda.Add(sentances[i]); // Adds this symbol to the symbols list
}
if (!Facts.Contains(sentances[i])) // Checks if Facts already contains the symbol
{
Facts.Add(sentances[i]); // Adds the symbol to the list of symbols that are true
}
}
else
{
// If it gets here; the current string is a Clause
Clauses.Add(sentances[i]);
string[] splitImp = sentances[i].Split("=>"); // Splits clause into pre-implication and post-implecation
if (!splitImp[0].Contains("&")) // if pre-implecation does not have &
{
for (int j = 0; j < splitImp.Length; j++) // loop through clause
{
if (!Agenda.Contains(splitImp[j])) // if agenda doesnt contain the symbol
{
Agenda.Add(splitImp[j]); // add symbols
}
}
}
else
{ // Pre-imp contains &
string[] splitLogic = splitImp[0].Split("&"); // split by logical separators
for (int j = 0; j < splitLogic.Length; j++) // loop through strings split
{
if (!Agenda.Contains(splitLogic[j]))
{
Agenda.Add(splitLogic[j]); // add symbols to symbols base
}
if (!Agenda.Contains(splitImp[1]))
{
Agenda.Add(splitImp[1]);
}
}
}
}
}
}
public SqlSelectQuery <T> Having(Expression <Func <T, object> > predicate)
{
if (predicate == null)
{
return(this);
}
var clause = new SqlHavingClause(predicate);
Clauses.Add(clause);
return(this);
}
/// <summary>
/// Adds the clause is active between dates.
/// </summary>
/// <param name="logicOperator">The logic operator.</param>
/// <param name="startColumn">The start column.</param>
/// <param name="endColumn">The end column.</param>
/// <param name="date">The date.</param>
public void AddClauseIsActiveBetweenDates(LogicOperator logicOperator, string startColumn, string endColumn, DateTime date)
{
var whereClause = new WhereClause(logicOperator, startColumn, Comparison.Equals, null);
whereClause.AddClause(Enums.LogicOperator.Or, startColumn, Comparison.LessOrEquals, date.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture));
Clauses.Add(whereClause);
whereClause = new WhereClause(logicOperator, endColumn, Comparison.Equals, null);
whereClause.AddClause(Enums.LogicOperator.Or, endColumn, Comparison.GreaterOrEquals, date.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture));
Clauses.Add(whereClause);
}
/// <summary>
/// Adds a clause to this selector.
/// </summary>
///
/// <param name="clause">
/// The clause to insert.
/// </param>
public void Add(SelectorClause clause)
{
// TODO: We'd like to prevent duplicate clauses, but in order to do so, they need to be combined into
// complete selectors (e.g. sets bounded by CombinatorType.Root). That really should be the definition of a
// selector, e.g. each part separated by a comma
//if (clause.CombinatorType == CombinatorType.Root && Clauses.Contains(clause))
//{
// return;
//}
Clauses.Add(clause);
}
public SqlSelectQuery <T> OrderBy(string columns)
{
if (columns == null)
{
return(this);
}
var exp = Expression.Constant(columns);
var clause = new SqlOrderByClause(exp);
Clauses.Add(clause);
return(this);
}
public SqlSelectQuery <T> Select(string columns, string from)
{
//_selectClauseTable = from;
if (string.IsNullOrWhiteSpace(columns))
{
columns = "*";
}
var exp = Expression.Constant(columns);
Clauses.Add(new SqlSelectClause <T>(exp, from));
return(this);
}
public SqlSelectQuery <T> Where(string predicate)
{
if (predicate == null)
{
return(this);
}
var exp = Expression.Constant(predicate);
var clause = new SqlWhereClause(exp as Expression);
Clauses.Add(clause);
return(this);
}
/// <summary>
/// Adds a `Clause` to this query.
/// Unless the clause contains the fields to be matched all fields will be matched.
/// In addition, a default boost of 1 is applied to the clause.
/// </summary>
/// <param name="clause">The clause to add to this query.</param>
/// <returns>The query.</returns>
public Query AddClause(Clause clause)
{
if (!clause.Fields.Any())
{
Clauses.Add(clause.WithFields(AllFields));
}
else
{
Clauses.Add(clause);
}
return(this);
}
public void CopyFromAll(QueryBuilderClause from, CMSDataContext Db)
{
foreach (var c in Clauses)
{
DeleteClause(c, Db);
}
CopyFrom(from);
foreach (var c in from.Clauses)
{
Clauses.Add(c.Clone(Db));
}
}
public CalculatedImmediateTmsOperand(List <object> sourceClauses, bool shiftLeft)
{
Clauses = sourceClauses.ToList();
if (shiftLeft)
{
Clauses.Add(Z80AssemblyParsing.Operands.MathOperator.TIMES);
Clauses.Add((ushort)0x100);
}
var sb = new StringBuilder();
Clauses.ForEach(clause => sb.Append(GetString(clause)));
DisplayValue = sb.ToString();
}
private void Initialize(string sqlText)
{
string curClause = string.Empty;
int curClauseIndex = 0;
for (int i = 0; i < sqlText.Length;)
{
//Find new Sql clause
int maxLenToSearch = sqlText.Length - i >= 10 ? 10 : sqlText.Length - i;
string keyword = StartsWithString(sqlText.Substring(i, maxLenToSearch), keywords, StringComparison.OrdinalIgnoreCase);
bool isWordStart = i > 0 ? sqlText[i - 1] == ' ' || (i > 1 && sqlText.Substring(i - 2, 2) == "\r\n") : true;
//Process Sql clause
if (keyword != null && curClause != keyword && isWordStart)
{
string inputText = sqlText.Substring(curClauseIndex, i - curClauseIndex);
if (!string.IsNullOrEmpty(curClause))
{
if (curClause == "DECLARE")
{
var declareParts = inputText.Substring(0, inputText.IndexOf(";")).Trim().Split(" ");
int sizeStartIndex = declareParts[1].IndexOf("(");
string dbTypeString = sizeStartIndex != -1 ? declareParts[1].Substring(0, sizeStartIndex) : declareParts[1];
SqlDbType dbType = (SqlDbType)Enum.Parse(typeof(SqlDbType), dbTypeString, true);
int size = sizeStartIndex != -1 ?
Convert.ToInt32(declareParts[1].Substring(sizeStartIndex).Replace(")", "")) : 0;
string value = declareParts[3][0] == '\'' ? declareParts[3].Substring(1, declareParts[3].Length - 2) : declareParts[3];
Parameters.Add(new SqlParameter(declareParts[0], dbType, size)
{
Value = value
});
}
else
{
Clauses.Add(SqlClause.Parse(curClause, inputText));
}
}
curClause = keyword;
curClauseIndex = i + curClause.Length;
i = i + curClause.Length;
}
else
{
i++;
}
}
if (!string.IsNullOrEmpty(curClause))
{
Clauses.Add(SqlClause.Parse(curClause, sqlText.Substring(curClauseIndex)));
}
}
private void SetStatement(SqlStatement value)
{
if (!Clauses.Any())
{
Clauses.Add(value);
}
if (Clauses[0] is SqlStatement)
{
Clauses[0] = value;
}
else
{
Clauses.Insert(0, value);
}
}
// method which sets up initial values for forward chaining
// takes in string representing KB and seperates symbols and
// clauses, calculates count etc ...
public void Init(string tell)
{
string[] sentances = tell.Split(';');
for (int i = 0; i < sentances.Length; i++)
{
if (!sentances[i].Contains("=>"))
{
Agenda.Add(sentances[i]);
}
else
{
// add sentances
Clauses.Add(sentances[i]);
Count.Add(sentances[i].Split('&').Length);
}
}
}
public override void BuildKB(string tell)
{
// Split tell into list of strings
List <string> sentences = tell.Split(';').ToList();
for (int i = 0; i < sentences.Count; i++)
{
//Look for Inference
if (sentences[i].Contains("=>"))
{
//If true, add to clause and count the conjuctions (A&B or Z)
Clauses.Add(sentences[i].ToLower());
Count.Add(sentences[i].Split('&').Length);
}
else if (!sentences[i].Trim().Equals("")) //If false and not empty, add to agenda
{
Agenda.Add(sentences[i].ToLower());
SingleStatement.Add(sentences[i].ToLower());
}
}
//add every symbol into the agenda including the deuplicated
//the deuplication will be remove in the next step
for (int i = 0; i < Clauses.Count; i++)
{
string statement = Clauses[i];
string aftermise = Regex.Split(statement, "=>")[1];
AllSymbolBeenIndicated.Add(aftermise);
//Console.WriteLine(aftermise);
statement = statement.Replace("=>", " ").Replace("&", " ");
string[] temp = statement.Split(' ');
for (int j = 0; j < temp.Length; j++)
{
if (!Agenda.Contains(temp[j])) //Check for Duplicates
{
Agenda.Add(temp[j]);
}
}
}
BuildTheModels();
}
