public Clause(string f, ClauseType <T> t, T v)
{
field = f;
type = t;
value = v;
}
internal ClauseType GetDefaultOperationCore(IBoundProperty property, ClauseType operation)
{
GetDefaultOperationEventArgs args = new GetDefaultOperationEventArgs(property, operation);
RaiseGetDefaultOperation(args);
return(args.ClauseType);
}
private void ClearSqlText(ClauseType clauseType)
{
if (this.dicSqlText.TryGetValue(clauseType, out List <string> listText))
{
this.dicSqlText.Remove(clauseType);
}
}
internal void SetFieldUsable <T>(Expression <T> predicate, ClauseType type)
{
try
{
var result = _translateQuery.Translate(predicate, type);
string commandText = TranslateToNativeColumn(result.CommandText);
TableSchema tableSchema = TableSchemaResolver.GetTableSchema(typeof(TTable));
var fieldIndex = tableSchema.FieldsSchema.FindIndex(x => x.ToString() == commandText);
if (fieldIndex != -1)
{
var field = tableSchema.FieldsSchema[fieldIndex];
if (field.IsPrimaryKey || field.IsUpdCount)
{
this._fieldsUsable[fieldIndex] = true;
}
else
{
this._fieldsUsable[fieldIndex] = type == ClauseType.Take;
}
}
}
catch (Exception e)
{
this._dbError.Code = ErrorCode.InvalidOperation;
this._dbError.Text = e.Message;
}
}
public HavingClause(ClauseType type, Column column, Is op, object value, Conditional condition)
{
_type = type;
_column = column;
_operator = op;
_value = value;
_condition = condition;
_query = null;
}
public WhereClause(ClauseType type, Column column, Is op, object value, Conditional condition, bool not)
{
_type = type;
_column = column;
_operator = op;
_value = value;
_condition = condition;
_not = not;
_nestedQuery = null;
}
public void Initialize(ClauseType _gameMode)
{
SetMode(_gameMode);
Signals.ResetWordComposingMenu.AddListener(() =>
{
if (MainMenuUIControl.Mode == MenuMode.Play)
{
resetAction();
}
});
}
internal void AddClause(Clause clause, ClauseType clause_type)
{
if (clause_type == ClauseType.Case)
{
case_clauses.Add(clause);
}
else if (clause_type == ClauseType.CaseAfterDefault)
{
sec_case_clauses.Add(clause);
}
}
public WhereClause(ClauseType type, Column column, Conditional condition)
{
_type = type;
_column = column;
_condition = condition;
_operator = Is.EqualTo;
_value = null;
_not = false;
_nestedQuery = null;
}
private static Clause GetClause(string q, string clauseAlias, ClauseType clauseType)
{
string[] operands = Regex.Split(q, clauseAlias, RegexOptions.IgnoreCase);
var criteria = new Clause
{
Value = operands[1],
ClauseType = clauseType
};
return(criteria);
}
/// <summary>
/// Clauses the specified clause.
/// </summary>
/// <param name="clause">The clause.</param>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
/// <exception cref="Exception">
/// WHERE clause already provided once
/// or
/// WHERE or HAVING clause not provided
/// or
/// HAVING clause already provided once
/// or
/// Invalid clause
/// </exception>
public QueryBuilder Clause(ClauseType clause, string key, object value)
{
string clausesTemp = string.Empty;
switch (clause)
{
case ClauseType.Where:
if (this.whereClauseProvided && !this.havingClauseProvided)
{
throw new Exception("WHERE clause already provided once");
}
this.whereClauses += $" WHERE {key} = @{key} ";
this.whereClauseProvided = true;
break;
case ClauseType.And:
if (!this.whereClauseProvided || !this.havingClauseProvided)
{
throw new Exception("WHERE or HAVING clause not provided");
}
this.whereClauses += $" AND {key} = @{key} ";
break;
case ClauseType.Or:
if (!this.whereClauseProvided || !this.havingClauseProvided)
{
throw new Exception("WHERE or HAVING clause not provided");
}
this.whereClauses += $" OR {key} = @{key} ";
break;
case ClauseType.Having:
if (!this.havingClauseProvided)
{
throw new Exception("HAVING clause already provided once");
}
this.whereClauses += $" HAVING {key} = @{key} ";
break;
default:
throw new Exception("Invalid clause");
}
if (this.Parameters == null)
{
this.Parameters = new Dictionary <string, object>();
}
this.Parameters.Add($"@{key}", value);
return(this);
}
public static Clause New(ClauseType type, string sqlPart = null, string name = null, string aliace = null,
string condition = null, string direction = null, string extra = null)
{
return(new Clause
{
ClauseType = type,
SqlPart = sqlPart,
Name = name,
Aliace = aliace,
Condition = condition,
Direction = direction,
Extra = extra
});
}
private static string BuildSql <T>(ClauseType clauseType, Expression <Func <T, bool> > expression)
{
Type type = GetType(typeof(T));
var columns = GetColumnsCache(type).Keys.ToList();
var where = new StringBuilder();
expression.Body.WalkThrough((name, oper, _) =>
{
where.AppendIf(name != null, $"{name} {oper} @{name}");
where.AppendIf(name is null, $" {oper} ");
});
return(BuildSql(clauseType, GetTypeName(type), columns.ToClause(), where.ToString()));
}
private static bool IsValidLookupClause(ClauseType operation)
{
switch (operation)
{
case ClauseType.Equals:
case ClauseType.IsNotNull:
case ClauseType.IsNull:
case ClauseType.DoesNotEqual:
return(true);
default:
return(false);
}
}
private static string BuildSql <T>(ClauseType clauseType, IDictionary <string, object> parameters)
{
Type type = GetType(typeof(T));
var keys = GetKeysCache(type).Keys.ToList();
var columns = GetColumnsCache(type).Keys.ToList();
if (clauseType == ClauseType.Update)
{
columns.Reduce(keys);
return(BuildSql(clauseType, GetTypeName(type), columns.ToSetClause(), keys.ToWhereClause()));
}
return(BuildSql(clauseType, GetTypeName(type), columns.ToClause(), parameters.ToWhereClause()));
}
public static Clause New(ClauseType type, string sqlPart = null, string name = null, string aliace = null,
string condition = null, string direction = null, string extra = null)
{
return new Clause
{
ClauseType = type,
SqlPart = sqlPart,
Name = name,
Aliace = aliace,
Condition = condition,
Direction = direction,
Extra = extra
};
}
private void AppenSqlText(ClauseType clauseType, string sqlText)
{
if (this.dicSqlText.TryGetValue(clauseType, out List <string> listText))
{
listText.Add(sqlText);
}
else
{
listText = new List <string>()
{
sqlText
};
this.dicSqlText.Add(clauseType, listText);
}
}
internal TranslateResult Translate <T>(Expression <T> expression, ClauseType clauseType)
{
this.clauseBuilder = new ClauseBuilder();
this.parameterBuilder = new ParameterBuilder();
this.clauseType = clauseType;
this.Visit(expression);
return(new TranslateResult
{
CommandText = clauseBuilder.GetExpressionText(),
Parameters = clauseBuilder.GetExpressionParameters(),
});
}
protected QueryBuilder AddDatabaseWhere(ClauseType type, Column column, Is op, object value, Conditional condition)
{
WhereClause where = new WhereClause()
{
Type = type,
Column = column,
Operator = op,
Value = value,
Condition = condition
};
_wheres.Add(where);
AddBinding(BindingType.Where, value);
return(this);
}
private static Clause GetClause(string q, string clauseAlias, ClauseType clauseType)
{
string res = Regex.Replace(
q,
Regex.Escape(clauseAlias),
"",
RegexOptions.IgnoreCase
);
var criteria = new Clause
{
Value = res,
ClauseType = clauseType
};
return(criteria);
}
public bool IsClauseAllowed(ClauseType clauseType)
{
var isClauseAllowed = true;
var isAllowed = AllowedClauses?.HasFlag(clauseType);
var isDisallowed = DisAllowedClauses?.HasFlag(clauseType);
if (isAllowed.HasValue && !isAllowed.Value)
{
isClauseAllowed = false;
}
if (isDisallowed.HasValue && isDisallowed.Value)
{
isClauseAllowed = false;
}
return(isClauseAllowed);
}
public static bool IsClauseAllowed(this AutoQueryableProfile profile, ClauseType clauseType)
{
bool isClauseAllowed = true;
bool?isAllowed = profile?.AllowedClauses?.HasFlag(clauseType);
bool?isDisallowed = profile?.DisAllowedClauses?.HasFlag(clauseType);
if (isAllowed.HasValue && !isAllowed.Value)
{
isClauseAllowed = false;
}
if (isDisallowed.HasValue && isDisallowed.Value)
{
isClauseAllowed = false;
}
return(isClauseAllowed);
}
private void TestNullDeviceId(ClauseType filterType)
{
var devicesWithNullDeviceId = GetListWithOneSpecialDeviceIdValue(null);
var filters = new List <Clause>
{
new Clause
{
ColumnName = "DeviceID",
ClauseType = filterType,
ClauseValue = "x"
}
};
var filtered = FilterHelper.FilterDeviceList(devicesWithNullDeviceId, filters);
Assert.Equal(0, filtered.Count());
}
private static bool IsValidDefaultClause(ClauseType operation)
{
switch (operation)
{
case ClauseType.Equals:
case ClauseType.IsNotNull:
case ClauseType.IsNull:
case ClauseType.DoesNotEqual:
case ClauseType.Less:
case ClauseType.LessOrEqual:
case ClauseType.Greater:
case ClauseType.GreaterOrEqual:
return(true);
default:
return(false);
}
}
//=========================================================================================
/// <summary>Возвращает список вариантов для автоподстановки.</summary>
public override CompletionVariantList GetVariants()
{
ClauseType clauseType = this.GetClauseType();
if (clauseType == ClauseType.Unknown)
{
return(null);
}
var components = this.GetIdComponents();
int iComponentsCount = components == null ? 0 : components.Count;
switch (clauseType)
{
case ClauseType.From:
switch (iComponentsCount)
{
case 0:
return(this.Get_Variants_For_Sources_1());
case 1:
return(this.Get_Variants_For_Sources_2(components[0]));
}
break;
case ClauseType.Select:
var sources = this.GetSources();
switch (iComponentsCount)
{
case 0:
return(this.Get_Variants_For_Items_1(sources));
case 1:
return(this.Get_Variants_For_Items_2(components[0], sources));
case 2:
return(this.Get_Variants_For_Items_3(components[1], components[0], sources));
}
break;
}
return(null);
}
public ClauseCompiler(
Rule rule,
int clauseNumber,
int clauseCount,
ImmutableDictionary <Sig, int> procedures,
ImmutableDictionary <string, int> symbols
)
{
_rule = rule;
_choiceType = (clauseCount, clauseNumber) switch
{
(1, _) => ClauseType.NoChoice,
(_, 0) => ClauseType.FirstClause,
(var x, var y)when y == x - 1 => ClauseType.LastClause,
_ => ClauseType.NextClause
};
_procedures = procedures;
_symbols = symbols;
}
private static bool IsValidDateClause(ClauseType operation)
{
switch (operation)
{
case ClauseType.Between:
case ClauseType.NotBetween:
case ClauseType.Like:
case ClauseType.NotLike:
case ClauseType.AnyOf:
case ClauseType.NoneOf:
case ClauseType.IsLaterThisMonth:
case ClauseType.IsLaterThisWeek:
case ClauseType.IsLaterThisYear:
case ClauseType.IsTomorrow:
case ClauseType.IsNextWeek:
case ClauseType.IsBeyondThisYear:
return(false);
default:
return(true);
}
}
public static Clause New(ClauseType type, string select = null
, string rowRumberOrderBy = null //, string selectCounts = null
, string selectColumn = null, string fromJoin = null
, string seletTable = null //, string jointable = null, string aliace = null
, string condition = null, DynamicParameters conditionParms = null
, string order = null, string extra = null
, string insert = null, string addcolumn = null, DynamicParameters insertParms = null
, string update = null, string editcolumn = null, DynamicParameters updateParms = null
, string delete = null, string sqlclause = null, DynamicParameters sqlClauseParms = null)
{
return(new Clause
{
ClauseType = type,
Select = select,
//SelectCounts = selectCounts,
SeletTable = seletTable, // 无用
RowRumberOrderBy = rowRumberOrderBy,
SelectColumn = selectColumn,
FromJoin = fromJoin,
//JoinTable = jointable,
//Aliace = aliace,
Condition = condition,
ConditionParms = conditionParms,
Order = order,
Extra = extra,
//添加 ------------
Insert = insert,
AddColumn = addcolumn,
InsertParms = insertParms,
//修改 ------------
Update = update,
EditColumn = editcolumn,
UpdateParms = updateParms,
Delete = delete,
// 任意位置sql
SqlClause = sqlclause,
SqlClauseParms = sqlClauseParms
});
}
public void SetMode(ClauseType _gameMode)
{
switch (_gameMode)
{
case ClauseType.OneWord:
resetAction = ConfigurateForOneWord;
break;
case ClauseType.TwoWord:
resetAction = ConfigurateForTwoWord;
break;
case ClauseType.ThreeWord:
resetAction = ConfigurateForTreeWord;
break;
default:
break;
}
resetAction();
}
private void TestNullDeviceProperties(ClauseType filterType)
{
var device = DeviceCreatorHelper.BuildDeviceStructure(Guid.NewGuid().ToString(), true, null);
device.DeviceProperties = null;
var list = new List <DeviceModel> {
device
};
var filters = new List <Clause>
{
new Clause
{
ColumnName = "DeviceID",
ClauseType = filterType,
ClauseValue = "x"
}
};
var filtered = FilterHelper.FilterDeviceList(list.AsQueryable(), filters);
Assert.Equal(0, filtered.Count());
}
private static bool IsValidStringClause(ClauseType operation)
{
switch (operation)
{
case ClauseType.Equals:
case ClauseType.DoesNotEqual:
case ClauseType.Greater:
case ClauseType.GreaterOrEqual:
case ClauseType.Less:
case ClauseType.LessOrEqual:
case ClauseType.Contains:
case ClauseType.DoesNotContain:
case ClauseType.BeginsWith:
case ClauseType.EndsWith:
case ClauseType.Like:
case ClauseType.NotLike:
case ClauseType.IsNotNull:
case ClauseType.IsNull:
return(true);
default:
return(false);
}
}
internal void AddClause (Clause clause, ClauseType clause_type)
{
if (clause_type == ClauseType.Case)
case_clauses.Add (clause);
else if (clause_type == ClauseType.CaseAfterDefault)
sec_case_clauses.Add (clause);
}
public override string GetMenuStringByType(ClauseType type) {
return Enum.IsDefined(typeof(ClauseType), type) ? base.GetMenuStringByType(type) :
ClauseTypeEnumHelper.GetMenuStringByClauseType((int)type);
}
/// <summary>
/// Converts data into parameters and adds to the dictionary collection
/// </summary>
/// <param name="Data"></param>
private void ConvertDataToParams(string[] Data, ClauseType operation, ClauseNode ClauseNode)
{
for (int i = 0; i < Data.Length; i++)
{
string s = Data[i];
string paramName = string.Format("@PM{0}", _params.Count + 1);
// Strip the single quotes when adding parameters.
if (s.StartsWith("'") || s.EndsWith("'"))
_params.Add(paramName, s.Substring(1, s.Length - 2));
else
_params.Add(paramName, s);
object value = ((DevExpress.Data.Filtering.OperandValue)ClauseNode.AdditionalOperands[0]).Value;
_paramDataTypes.Add(paramName, value);
if (HelpDBExt.GetDbType(value) == System.Data.DbType.String)
{
switch (operation)
{
case ClauseType.BeginsWith:
_params[paramName] = string.Format("{0}%", _params[paramName]);
_paramDataTypes[paramName] = string.Format("{0}%", _paramDataTypes[paramName].ToString());
break;
case ClauseType.EndsWith:
_params[paramName] = string.Format("%{0}", _params[paramName]);
_paramDataTypes[paramName] = string.Format("%{0}", _paramDataTypes[paramName].ToString());
break;
case ClauseType.Contains:
_params[paramName] = string.Format("%{0}%", _params[paramName]);
_paramDataTypes[paramName] = string.Format("%{0}%", _paramDataTypes[paramName].ToString());
break;
case ClauseType.DoesNotContain:
_params[paramName] = string.Format("%{0}%", _params[paramName]);
_paramDataTypes[paramName] = string.Format("%{0}%", _paramDataTypes[paramName].ToString());
break;
case ClauseType.Like:
break;
case ClauseType.NotLike:
break;
}
}
Data[i] = paramName;
}
}
