public IConditionGroup Add(IField field, RelationalOperators relationalOperator, object value, object ignoreValue = null)
{
var enumerableValue = value as IEnumerable;
if ((relationalOperator & RelationalOperators.Between) == RelationalOperators.Between)
{
var bv = value as IBetweenValue;
if (bv != null)
{
return(AddBetweenCondition(field, relationalOperator, bv, ignoreValue));
}
if (enumerableValue == null)
{
throw new ArrayTypeMismatchException("RelationalOperators.Between requires 2 values");
}
return(AddBetweenCondition(field, relationalOperator, enumerableValue, ignoreValue));
}
if ((relationalOperator & RelationalOperators.In) == RelationalOperators.In)
{
return(AddInCondition(field, relationalOperator, value, ignoreValue));
}
if (enumerableValue != null && !(value is string))
{
return(AddEnumerableValueCondition(field, relationalOperator, enumerableValue, ignoreValue));
}
/*if (!(value is IValue))
* {
* var enumerableValue = value as IEnumerable;
*
* if ((relationalOperator & RelationalOperators.Between) == RelationalOperators.Between)
* {
* if (enumerableValue == null)
* throw new ArrayTypeMismatchException("RelationalOperators.Between requires 2 values");
* return AddBetweenCondition(field, relationalOperator, enumerableValue, ignoreValue);
* }
*
* if ((relationalOperator & RelationalOperators.In) == RelationalOperators.In)
* {
* return AddInCondition(field, relationalOperator, value, ignoreValue);
* }
*
* if (enumerableValue != null && !(value is string))
* {
* return AddEnumerableValueCondition(field, relationalOperator, enumerableValue, ignoreValue);
* }
* }
* */
if (!ContainsIgnoreValue(value, ignoreValue))
{
EmbeddedStatements.Add(new FieldCondition(field, relationalOperator, GetDataTypeCheckedValue(value, field.DataType)));
}
return(this);
}
public Condition(string lhs, RelationalOperators relationalOperator, string rhs)
{
LOp = null;
Lhs = lhs;
Op = Condition.relationalOperators[relationalOperator];
Rhs = rhs;
}
private IConditionGroup AddBetweenCondition(IField field, RelationalOperators relationalOperator, IEnumerable values, object ignoreValue)
{
var i = -1;
var betweenValues = new object[2];
foreach (var value in values)
{
i++;
betweenValues[i] = value;
if (i == 1)
{
break;
}
}
if (i < 1)
{
throw new ArrayTypeMismatchException("RelationalOperators.Between requires 2 values");
}
if (ContainsIgnoreValue(betweenValues[0], ignoreValue) && ContainsIgnoreValue(betweenValues[1], ignoreValue))
{
return(this);
}
Add(new FieldCondition(field, relationalOperator, CreateBetweenValue(field.DataType, betweenValues[0], betweenValues[1])));
return(this);
}
private ScalarType AnalyzeExpression(HashSet <Symbol> followers)
{
var resultType = ScalarType.Unknown;
if (!Belongs(Starters.Expression))
{
InsertError(1004);
SkipTo(Starters.Expression, followers);
}
if (!Belongs(Starters.Expression))
{
return(resultType);
}
switch (CurrentSymbol)
{
case Symbol.Plus:
case Symbol.Minus:
case Symbol.Identifier:
case Symbol.IntegerConstant:
case Symbol.FloatConstant:
case Symbol.CharConstant:
case Symbol.StringConstant:
case Symbol.True:
case Symbol.False:
case Symbol.LeftRoundBracket:
case Symbol.Not:
resultType = AnalyzeSimpleExpression(Union(RelationalOperators, followers));
break;
default:
IoManager.InsertError(CurrentToken.CharacterNumber, 1004);
break;
}
if (RelationalOperators.Contains(CurrentSymbol))
{
var operation = AnalyzeRelationalOperators(Followers.RelationalOperators);
var secondType = AnalyzeSimpleExpression(Union(Followers.SimpleExpression, followers));
if (resultType != ScalarType.Boolean || secondType != ScalarType.Boolean)
{
InsertError(144);
resultType = ScalarType.Unknown;
}
else
{
resultType = ScalarType.Boolean;
}
}
if (!Belongs(followers))
{
InsertError(1010);
SkipTo(followers);
}
return(resultType);
}
public ISqlGenerator RightJoin(object leftSource, object rightSource,
object left01, object right01, RelationalOperators relationalOperator01 = RelationalOperators.Equal,
object left02 = null, object right02 = null, RelationalOperators relationalOperator02 = RelationalOperators.Equal)
{
return(Join(JoinOperator.Right, leftSource, rightSource,
left01, right01, relationalOperator01,
left02, right02, relationalOperator02));
}
private static bool ContainsCodePartsWithRelationalOperator(string checkedLine)
{
return(CodePartsWithRelationalOperator.Any(codePart =>
{
var index = checkedLine.IndexOf(codePart, StringComparison.InvariantCulture);
return index >= 0 && RelationalOperators.Any(op => checkedLine.IndexOf(op, index, StringComparison.InvariantCulture) >= 0);
}));
}
public void GenerateSqlString_DbNullValue(FieldDataType dataType, RelationalOperators relationalOperator)
{
_csb.Add("Field1", dataType, relationalOperator, System.DBNull.Value);
_csb.Add("Field2", dataType, relationalOperator, System.DBNull.Value);
var actual = _csb.ToString();
Assert.AreEqual(string.Empty, actual);
}
public JoinColumnMap(JoinColumn leftColumn, JoinColumn rightColumn,
RelationalOperators relationalOperator = RelationalOperators.Equal,
LogicalOperators logicalOperator = LogicalOperators.And)
{
LeftColumn = leftColumn ?? throw new ArgumentNullException(nameof(leftColumn));
RightColumn = rightColumn ?? throw new ArgumentNullException(nameof(rightColumn));
RelationalOperator = relationalOperator;
LogicalOperator = logicalOperator;
}
public IConditionGroup BeginGroup(IField field, RelationalOperators relationalOperator, object value,
LogicalOperator concatOperator = LogicalOperator.And)
{
var group = new ConditionGroup(concatOperator);
Add(group);
group.Add(field, relationalOperator, value);
return(group);
}
private IConditionGroup AddBetweenCondition(IField field, RelationalOperators relationalOperator, IBetweenValue values, object ignoreValue)
{
if (ContainsIgnoreValue(values.FirstValue, ignoreValue) && ContainsIgnoreValue(values.SecondValue, ignoreValue))
{
return(this);
}
Add(new FieldCondition(field, relationalOperator, values));
return(this);
}
public void GenerateSqlString_ConcatDbNullValue(FieldDataType dataType, RelationalOperators relationalOperator)
{
_csb.Add("Field1", FieldDataType.Text, RelationalOperators.Between, new object[] { System.DBNull.Value, "xyz" });
_csb.Add("Field2", FieldDataType.Numeric, RelationalOperators.Between, new object[] { 133.45, System.DBNull.Value });
_csb.Add("Field3", dataType, relationalOperator, System.DBNull.Value);
var actual = _csb.ToString();
Assert.AreEqual("Field1 <= 'xyz' And Field2 >= 133.45", actual);
}
public void GenerateSqlStringFieldAndValue_Date(object fieldName, RelationalOperators relationalOperator, string value, string expected)
{
System.DateTime date = System.DateTime.Parse(value);
_csb.Add(fieldName, FieldDataType.DateTime, relationalOperator, date);
var actual = _csb.ToString();
Assert.AreEqual(expected, actual);
}
protected virtual string CreateInConditionString(IField field, RelationalOperators op, IValue[] values)
{
var valueStrings = new string[values.Length];
for (var i = 0; i < values.Length; i++)
{
valueStrings[i] = ValueConverter.ConvertValueToString(values[i]);
}
return(string.Concat(ConditionStringItemPrefix, NameConverter.GenerateFieldString(field), OperatorString(op), "(", string.Join(",", valueStrings), ")", ConditionStringItemPostfix));
}
public void AddJoinColumn(
IEntityName leftTable,
IItemName leftColumnName,
IItemName rightColumnName,
RelationalOperators relationalOperator = RelationalOperators.Equal,
LogicalOperators logicalOperator = LogicalOperators.And)
{
var leftColumn = new JoinColumn(leftTable, leftColumnName);
AddJoinColumn(leftColumn, GetJoinColumn(rightColumnName), relationalOperator, logicalOperator);
}
private IConditionGroup AddEnumerableValueCondition(IField field, RelationalOperators relationalOperator, IEnumerable values, object ignoreValue = null)
{
var conditionGroup = new ConditionGroup(LogicalOperator.Or);
foreach (var value in values)
{
conditionGroup.Add(field, relationalOperator, value, ignoreValue);
}
Add(conditionGroup);
return(this);
}
protected virtual string CreateConditionString(IField field, RelationalOperators op, object value)
{
if ((op & RelationalOperators.In) == RelationalOperators.In)
{
return(CreateInConditionString(field, op, value));
}
if ((value is IBetweenValue) && (op & RelationalOperators.Between) == RelationalOperators.Between)
{
return(CreateBetweenConditionString(field, op, (IBetweenValue)value));
}
var valueArray = value as IValueArray;
if (valueArray != null)
{
return(CreateValueArrayConditionString(field, op, valueArray));
}
if (value is IEnumerable && !(value is string))
{
return(CreateEnumerableConditionString(field, op, value as IEnumerable));
}
var fieldName = NameConverter.GenerateFieldString(field);
var f = value as IField;
if (f != null)
{
return(CreateFieldConditionString(fieldName, op, f));
}
var v = value as IValue;
if (v != null)
{
return(CreateFieldConditionString(fieldName, op, v));
}
var s = value as string;
if (s != null)
{
return(CreateStringConditionString(fieldName, op, s));
}
if (value is DateTime)
{
return(CreateDateTimeConditionString(fieldName, op, (DateTime)value));
}
double number;
return(Double.TryParse(value.ToString(), out number) ? CreateNumericConditionString(fieldName, op, value) : string.Concat(ConditionStringItemPrefix, NameConverter.GenerateFieldString(field), OperatorString(op), value.ToString(), ConditionStringItemPostfix));
}
private IConditionGroup AddInCondition(IField field, RelationalOperators relationalOperator, IValueArray values, object ignoreValue)
{
var inValues = values.Values.Where(v => !ContainsIgnoreValue(v, ignoreValue)).ToList();
if (inValues.Count == 0)
{
return(this);
}
Add(new FieldCondition(field, relationalOperator, new ValueArray(inValues.ToArray())));
return(this);
}
protected virtual string AppendWildcard(string s, RelationalOperators wildCards)
{
if ((wildCards & RelationalOperators.AddWildcardPrefix) == RelationalOperators.AddWildcardPrefix)
{
s = string.Concat(WildcardString, s);
}
if ((wildCards & RelationalOperators.AddWildcardSuffix) == RelationalOperators.AddWildcardSuffix)
{
s = string.Concat(s, WildcardString);
}
return(s);
}
public void GenerateSqlStringFieldAndValue_Date_Between(object fieldName, RelationalOperators relationalOperator, string value1, string value2, string expected)
{
System.DateTime date1 = System.DateTime.Parse(value1);
System.DateTime date2 = System.DateTime.Parse(value2);
var dates = new System.DateTime[] { date1, date2 };
_csb.Add(fieldName, FieldDataType.DateTime, relationalOperator, dates);
var actual = _csb.ToString();
Assert.AreEqual(expected, actual);
}
public IConditionGroup Add(object field, FieldDataType dataType, RelationalOperators relationalOperator,
object value, object ignoreValue = null)
{
var fld = FieldGenerator.GetFieldFromObject(field);
if (fld.DataType != dataType && dataType != FieldDataType._Unspecified)
{
fld.DataType = dataType;
}
Add(fld, (Common.Sql.RelationalOperators)relationalOperator, value, ignoreValue);
return(this);
}
private ISqlGenerator Join(JoinOperator joinOperator, object leftSource, object rightSource,
object left01, object right01, RelationalOperators relationalOperator01,
object left02 = null, object right02 = null, RelationalOperators relationalOperator02 = RelationalOperators.Equal)
{
var conditionGenerator = new ConditionGenerator();
var leftSourceRef = leftSource is ISource ? (ISource)leftSource : new NamedSource((string)leftSource);
var rightSourceRef = rightSource is ISource ? (ISource)rightSource : new NamedSource((string)rightSource);
AddCondition(conditionGenerator, leftSourceRef, rightSourceRef, left01, right01, relationalOperator01);
AddCondition(conditionGenerator, leftSourceRef, rightSourceRef, left02, right02, relationalOperator02);
Join(GetSourceFromObject(rightSource), conditionGenerator, joinOperator);
return(this);
}
protected virtual string CreateInConditionString(IField field, RelationalOperators op, object value)
{
var valueArray = value as IValueArray;
if (valueArray != null)
{
return(CreateInConditionString(field, op, valueArray));
}
var v = value as IValue;
if (v != null)
{
return(CreateInConditionString(field, op, v));
}
throw new NotSupportedException();
}
protected virtual string CreateFieldConditionString(string fieldName, RelationalOperators op, INullValue value)
{
var cond = string.Empty;
if ((op & RelationalOperators.Equal) == RelationalOperators.Equal)
{
cond = string.Concat(fieldName, " Is Null");
op = op ^ RelationalOperators.Equal;
if (op == 0)
{
return(string.Concat(ConditionStringItemPrefix, cond, ConditionStringItemPostfix));
}
}
var cond2 = string.Concat(fieldName, OperatorString(op), ValueConverter.ConvertValueToString(value));
return(string.IsNullOrEmpty(cond2) ? cond : string.Concat("(", cond, " Or ", cond2, ")"));
}
public static string ToSqlString(this RelationalOperators relationalOperator)
{
var result = string.Empty;
switch (relationalOperator)
{
case RelationalOperators.Equal:
result = "=";
break;
case RelationalOperators.NotEqual:
result = "!=";
break;
case RelationalOperators.GreaterThan:
result = ">";
break;
case RelationalOperators.GreaterThanOrEqual:
result = ">=";
break;
case RelationalOperators.LessThan:
result = "<";
break;
case RelationalOperators.LessThanOrEqual:
result = "<=";
break;
case RelationalOperators.Like:
result = "like";
break;
case RelationalOperators.NotLike:
result = "not like";
break;
//case RelationalOperators.IsNull:
//case RelationalOperators.IsNotNull:
// throw new NotSupportedException($"{nameof(relationalOperator)} value of {relationalOperator.ToString()} can't be converted to String.");
}
return(result);
}
private static RelationalOperators RevertRelationalOperators(RelationalOperators op)
{
RelationalOperators newOp = 0;
if ((op & RelationalOperators.GreaterThan) == RelationalOperators.GreaterThan)
{
newOp |= RelationalOperators.LessThan;
op -= RelationalOperators.GreaterThan;
}
if ((op & RelationalOperators.LessThan) == RelationalOperators.LessThan)
{
newOp |= RelationalOperators.GreaterThan;
op -= RelationalOperators.LessThan;
}
newOp |= op;
return(newOp);
}
protected virtual string CreateFieldConditionString(string fieldName, RelationalOperators op, IValue value)
{
RelationalOperators valueOp = 0;
if ((op & RelationalOperators.AddWildcardPrefix) == RelationalOperators.AddWildcardPrefix)
{
op = op ^ RelationalOperators.AddWildcardPrefix;
valueOp = valueOp | RelationalOperators.AddWildcardPrefix;
}
if ((op & RelationalOperators.AddWildcardSuffix) == RelationalOperators.AddWildcardSuffix)
{
op = op ^ RelationalOperators.AddWildcardSuffix;
valueOp = valueOp | RelationalOperators.AddWildcardSuffix;
}
var nullValue = value as INullValue;
return(nullValue != null?CreateFieldConditionString(fieldName, op, nullValue) : string.Concat(ConditionStringItemPrefix, fieldName, OperatorString(op), ((valueOp != 0) && (value is ITextValue)) ? ValueConverter.ConvertValueToString((ITextValue)value, valueOp) : ValueConverter.ConvertValueToString(value), ConditionStringItemPostfix));
}
public static string GetRelationalOperators(RelationalOperators opt)
{
switch (opt)
{
case RelationalOperators.And:
{
return("AND");
}
case RelationalOperators.OR:
{
return("OR");
}
default:
{
return("AND");
}
}
}
protected virtual string OperatorString(RelationalOperators op)
{
switch (op)
{
case RelationalOperators.Like:
return(" Like ");
case RelationalOperators.Between:
return(" Between ");
case RelationalOperators.In:
return(" In ");
}
var opString = string.Empty;
if ((op & RelationalOperators.LessThan) == RelationalOperators.LessThan)
{
opString += "<";
op -= RelationalOperators.LessThan;
}
if ((op & RelationalOperators.GreaterThan) == RelationalOperators.GreaterThan)
{
opString += ">";
op -= RelationalOperators.GreaterThan;
}
if ((op & RelationalOperators.Equal) == RelationalOperators.Equal)
{
opString += "=";
op -= RelationalOperators.Equal;
}
if (op != 0)
{
throw new NotSupportedRelationalOperatorException(string.Concat(string.IsNullOrEmpty(opString) ? string.Empty : string.Concat("'", opString, "'", " and "), op, " is not supported."), op);
}
return(string.Format(" {0} ", opString));
}
private IConditionGroup AddInCondition(IField field, RelationalOperators relationalOperator, object value, object ignoreValue)
{
var valueArray = value as IValueArray;
if (valueArray != null)
{
return(AddInCondition(field, relationalOperator, valueArray, ignoreValue));
}
var enumerable = value as IEnumerable;
if (enumerable == null)
{
var v = TryCreateDataTypeConformValue(value, field.DataType);
if (v == null)
{
throw new InvalidCastException();
}
var values = new ValueArray(new[] { v });
return(AddInCondition(field, relationalOperator, values, ignoreValue));
}
var valueList = new List <IValue>();
foreach (var iv in from object v in enumerable select TryCreateDataTypeConformValue(v, field.DataType))
{
if (iv == null)
{
throw new InvalidCastException();
}
valueList.Add(iv);
}
return(AddInCondition(field, relationalOperator, new ValueArray(valueList.ToArray()), ignoreValue));
}
// ReSharper disable UnusedMethodReturnValue.Global
public IConditionGroup Add(IField field, RelationalOperators relationalOperator, object value, object ignoreValue = null)
// ReSharper restore UnusedMethodReturnValue.Global
{
Add(field, (Common.Sql.RelationalOperators)((int)relationalOperator), value, ignoreValue);
return(this);
}
