/// <summary>
///
/// </summary>
/// <param name="c1"></param>
/// <param name="c2"></param>
/// <param name="op"></param>
/// <returns></returns>
private static esComparison HandleOperator(esComparison c1, esComparison c2, esConjunction op)
{
List <esComparison> exp = null;
if (c1.data.WhereExpression == null)
{
c1.data.WhereExpression = new List <esComparison>();
exp = c1.data.WhereExpression;
exp.Add(new esComparison(esParenthesis.Open));
exp.Add(c1);
}
else
{
exp = c1.data.WhereExpression;
exp.Insert(0, new esComparison(esParenthesis.Open));
}
esConjunction conj = op;
if (c2.not)
{
switch (op)
{
case esConjunction.And:
conj = esConjunction.AndNot;
break;
case esConjunction.Or:
conj = esConjunction.OrNot;
break;
}
}
exp.Add(new esComparison(conj));
if (c2.data.WhereExpression == null)
{
exp.Add(c2);
}
else
{
exp.AddRange(c2.data.WhereExpression);
}
exp.Add(new esComparison(esParenthesis.Close));
return(c1);
}
/// <summary>
/// Used to describe the "where" conditions of the join itself
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
public esDynamicQuery On(params object[] items)
{
if (this.data.WhereItems == null)
{
this.data.WhereItems = new List <esComparison>();
}
foreach (object item in items)
{
esComparison wi = item as esComparison;
if (wi != null)
{
if (wi.data.WhereExpression != null)
{
foreach (esComparison exp in wi.data.WhereExpression)
{
esDynamicQuery q = exp.Value as esDynamicQuery;
if (q != null)
{
IDynamicQueryInternal iQ = q as IDynamicQueryInternal;
iQ.HookupProviderMetadata(q);
}
}
this.data.WhereItems.AddRange(wi.data.WhereExpression);
}
else
{
this.data.WhereItems.Add(wi);
}
esDynamicQuery query = wi.Value as esDynamicQuery;
if (query != null)
{
IDynamicQueryInternal iQ = query as IDynamicQueryInternal;
iQ.HookupProviderMetadata(query);
}
}
else
{
throw new Exception("Unsupported Join Syntax");
}
}
return(this.parentQuery);
}
public esCase When(esComparison comparison)
{
this.WhenItem = new esExpressionOrComparison();
this.WhenItem.Comparisons = new List <esComparison>();
if (comparison != null)
{
if (comparison.data.WhereExpression != null)
{
foreach (esComparison exp in comparison.data.WhereExpression)
{
esDynamicQuerySerializable q = exp.Value as esDynamicQuerySerializable;
if (q != null)
{
IDynamicQuerySerializableInternal iQ = q as IDynamicQuerySerializableInternal;
iQ.HookupProviderMetadata(q);
}
}
this.WhenItem.Comparisons.AddRange(comparison.data.WhereExpression);
}
else
{
this.WhenItem.Comparisons.Add(comparison);
}
esDynamicQuerySerializable query = comparison.Value as esDynamicQuerySerializable;
if (query != null)
{
IDynamicQuerySerializableInternal iQ = query as IDynamicQuerySerializableInternal;
iQ.HookupProviderMetadata(query);
}
}
return(this);
}
protected static string ApplyWhereSubOperations(StandardProviderParameters std, esDynamicQuerySerializable query, esComparison.esComparisonData comparisonData)
{
string sql = string.Empty;
if (comparisonData.HasExpression)
{
sql += GetMathmaticalExpressionColumn(std, query, comparisonData.Expression);
if (comparisonData.SubOperators != null && comparisonData.SubOperators.Count > 0)
{
sql = BuildSubOperationsSql(std, sql, comparisonData.SubOperators);
}
return sql;
}
string delimitedColumnName = GetColumnName(comparisonData.Column);
if (comparisonData.SubOperators != null)
{
sql = BuildSubOperationsSql(std, delimitedColumnName, comparisonData.SubOperators);
}
else
{
sql = delimitedColumnName;
}
return sql;
}
protected static string ApplyWhereSubOperations(esComparison.esComparisonData comparisonData)
{
string sql = string.Empty;
if (comparisonData.HasExpression)
{
sql += GetMathmaticalExpressionColumn(comparisonData.Expression);
if (comparisonData.SubOperators != null && comparisonData.SubOperators.Count > 0)
{
sql = BuildSubOperationsSql(sql, comparisonData.SubOperators);
}
return sql;
}
string delimitedColumnName = GetColumnName(comparisonData.Column);
if (comparisonData.SubOperators != null)
{
sql = BuildSubOperationsSql(delimitedColumnName, comparisonData.SubOperators);
}
else
{
sql = delimitedColumnName;
}
return sql;
}
public esCase When(esComparison comparison)
{
this.WhenItem = new esExpressionOrComparison();
this.WhenItem.Comparisons = new List<esComparison>();
if (comparison != null)
{
if (comparison.data.WhereExpression != null)
{
foreach (esComparison exp in comparison.data.WhereExpression)
{
esDynamicQuerySerializable q = exp.Value as esDynamicQuerySerializable;
if (q != null)
{
IDynamicQuerySerializableInternal iQ = q as IDynamicQuerySerializableInternal;
iQ.HookupProviderMetadata(q);
}
}
this.WhenItem.Comparisons.AddRange(comparison.data.WhereExpression);
}
else
{
this.WhenItem.Comparisons.Add(comparison);
}
esDynamicQuerySerializable query = comparison.Value as esDynamicQuerySerializable;
if (query != null)
{
IDynamicQuerySerializableInternal iQ = query as IDynamicQuerySerializableInternal;
iQ.HookupProviderMetadata(query);
}
}
return this;
}
protected static string ApplyWhereSubOperations(StandardProviderParameters std, esDynamicQuerySerializable query, esComparison.esComparisonData comparisonData)
{
string sql = string.Empty;
string delimitedColumnName = GetColumnName(comparisonData.Column);
if (comparisonData.SubOperators != null)
{
sql = BuildSubOperationsSql(std, delimitedColumnName, comparisonData.SubOperators);
}
else
{
sql = delimitedColumnName;
}
return sql;
}
/// <summary>
/// Greater Than or Equal >= (to use in Where clauses).
/// </summary>
/// <example>
/// The operators provide an alternative, natural syntax for DynamicQueries.
/// <code>
/// emps.Query.Where(emps.Query.BirthDate >= "2000-01-01");
/// </code>
/// </example>
/// <param name="item">Passed in via DynamicQuery</param>
/// <param name="value">Passed in via DynamicQuery</param>
/// <returns>The esComparison returned to DynamicQuery</returns>
public static esComparison operator >=(esQueryItem item, esQueryItem value)
{
esComparison wi = new esComparison(item.query);
wi.Operand = esComparisonOperand.GreaterThanOrEqual;
wi.data.Column = item.Column;
wi.data.ComparisonColumn = value.Column;
wi.SubOperators = item.SubOperators;
return wi;
}
private static esComparison GreaterThanOrEqual(esQueryItem queryItem, object literal, esSystemType literalType, bool itemFirst)
{
esComparison wi = new esComparison(queryItem.query);
wi.Operand = esComparisonOperand.GreaterThanOrEqual;
wi.data.Column = queryItem.Column;
wi.data.Value = literal;
wi.data.Expression = queryItem.Expression;
wi.data.ItemFirst = itemFirst;
wi.SubOperators = queryItem.SubOperators;
return wi;
}
/// <summary>
/// Comparison ensuring that this column is NOT IN a list of values.
/// See <see cref="esComparisonOperand"/> Enumeration.
/// </summary>
/// <example>
/// <code>
/// Where(LastName.NotIn("Doe", "Smith", "Johnson"))
/// </code>
/// </example>
/// <param name="value">The list of values for comparison.</param>
/// <returns>The esComparison returned to DynamicQuery.</returns>
public esComparison NotIn(params object[] value)
{
List<object> values = new List<object>();
#region Convert object[] into a List<object>
object[] oValues = (object[])value;
foreach (object o in oValues)
{
string str = o as string;
if (str != null)
{
// String supports IEnumerable and we don't want to break
// up each individual character
values.Add(o);
}
else
{
IEnumerable enumer = o as IEnumerable;
if (enumer != null)
{
foreach (object oo in enumer)
{
values.Add(oo);
}
}
else
{
values.Add(o);
}
}
}
#endregion
esComparison comparison = new esComparison(this.query);
comparison.Operand = esComparisonOperand.NotIn;
comparison.data.Column = this.Column;
comparison.SubOperators = this.SubOperators;
comparison.Values = values;
return comparison;
}
/// <summary>
/// Comparison ensuring that this column is NOT IN a list of values.
/// </summary>
/// <param name="value">The Query to provide the matching values for the NOT IN comparison</param>
/// <returns></returns>
public esComparison NotIn(esDynamicQuerySerializable subQuery)
{
esComparison comparison = new esComparison(this.query);
comparison.Operand = esComparisonOperand.NotIn;
comparison.data.Column = this.Column;
comparison.SubOperators = this.SubOperators;
comparison.Value = subQuery;
this.query.AddQueryToList(subQuery);
return comparison;
}
/// <summary>
/// Comparison ensuring that this column is BETWEEN two values.
/// See <see cref="esComparisonOperand"/> Enumeration.
/// </summary>
/// <example>
/// <code>
/// Where(BirthDate.Between("2000-01-01", "2000-12-31"))
/// </code>
/// </example>
/// <param name="start">The starting value for comparison.</param>
/// <param name="end">The ending value for comparison.</param>
/// <returns>The esComparison returned to DynamicQuery.</returns>
public esComparison Between(object start, object end)
{
esComparison comparison = new esComparison(this.query);
comparison.Operand = esComparisonOperand.Between;
comparison.SubOperators = this.SubOperators;
comparison.data.Column = this.Column;
esQueryItem qi = start as esQueryItem;
if (Object.Equals(qi, null))
{
comparison.BetweenBegin = start;
}
else
{
comparison.data.ComparisonColumn = qi.Column;
}
qi = end as esQueryItem;
if (Object.Equals(qi, null))
{
comparison.BetweenEnd = end;
}
else
{
comparison.data.ComparisonColumn2 = qi.Column;
}
comparison.SubOperators = this.SubOperators;
return comparison;
}
/// <summary>
/// Comparison ensuring that the value passed in is NOT LIKE this column.
/// This overload takes a single escape character.
/// See <see cref="esComparisonOperand"/> Enumeration.
/// </summary>
/// <example>
/// The optional escape character is used if the search phrase
/// contains one of the LIKE wildcards. For example,
/// the following will exclude columns with "30%" anywhere in them.
/// <code>
/// Where(Discount.NotLike("%30!//", '!'))
/// </code>
/// </example>
/// <param name="value">The value for comparison.</param>
/// <param name="escapeCharacter">The single escape character.</param>
/// <returns>The esComparison returned to DynamicQuery.</returns>
public esComparison NotLike(object value, char escapeCharacter)
{
esComparison comparison = new esComparison(this.query);
comparison.data.Column = this.Column;
comparison.data.LikeEscape = escapeCharacter;
comparison.Operand = esComparisonOperand.NotLike;
comparison.SubOperators = this.SubOperators;
esQueryItem qi = value as esQueryItem;
if (Object.Equals(qi, null))
{
comparison.data.Value = value;
}
else
{
comparison.data.ComparisonColumn = qi.Column;
}
return comparison;
}
private esComparison CreateComparisonParameter(esComparisonOperand operand)
{
esComparison comparison = new esComparison(this.query);
comparison.Operand = operand;
if (this.HasExpression)
{
comparison.data.Expression = this.Expression;
}
comparison.data.Column = this.Column;
comparison.SubOperators = this.SubOperators;
return comparison;
}
private esComparison CreateComparisonParameter(esComparisonOperand operand, object value)
{
esComparison comparison = null;
esQueryItem qi = value as esQueryItem;
if (Object.Equals(qi, null))
{
comparison = new esComparison(this.query);
comparison.Operand = operand;
if (this.HasExpression)
{
comparison.data.Expression = this.Expression;
}
comparison.data.Column = this.Column;
comparison.data.Value = value;
comparison.SubOperators = this.SubOperators;
}
else
{
comparison = new esComparison(this.query);
comparison.Operand = operand;
comparison.data.Column = this.Column;
comparison.data.ComparisonColumn = qi.Column;
comparison.SubOperators = qi.SubOperators;
}
return comparison;
}
/// <summary>
///
/// </summary>
/// <param name="c1"></param>
/// <param name="c2"></param>
/// <param name="op"></param>
/// <returns></returns>
private static esComparison HandleOperator(esComparison c1, esComparison c2, esConjunction op)
{
List<esComparison> exp = null;
if (c1.data.WhereExpression == null)
{
c1.data.WhereExpression = new List<esComparison>();
exp = c1.data.WhereExpression;
exp.Add(new esComparison(esParenthesis.Open));
exp.Add(c1);
}
else
{
exp = c1.data.WhereExpression;
exp.Insert(0, new esComparison(esParenthesis.Open));
}
esConjunction conj = op;
if (c2.not)
{
switch (op)
{
case esConjunction.And:
conj = esConjunction.AndNot;
break;
case esConjunction.Or:
conj = esConjunction.OrNot;
break;
}
}
exp.Add(new esComparison(conj));
if (c2.data.WhereExpression == null)
{
exp.Add(c2);
}
else
{
exp.AddRange(c2.data.WhereExpression);
}
exp.Add(new esComparison(esParenthesis.Close));
return c1;
}
