/// <summary>
/// Initializes a new instance of <see cref="WhereExpression"/> filtering the specified source.
/// </summary>
/// <param name="source">The source expression to select from.</param>
public WhereExpression(ASourceExpression source, APredicateExpression predicate)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
Source = source;
Predicate = predicate;
Fields = new FieldExpressions(this, source.Fields);
Expressions = new[] { source };
}
/// <summary>
/// Initializes a new instance of <see cref="TableExpression"/>, selecting the specified fields from the specified table.
/// </summary>
/// <param name="table">The name of the table in the database to query.</param>
/// <param name="alias">The alias name the <see cref="TableExpression"/> should expose for other queries.</param>
public TableExpression(string table, string alias, IEnumerable <string> fields)
{
if (string.IsNullOrWhiteSpace(table))
{
throw new ArgumentException("Cannot be whitespace.", nameof(table));
}
if (string.IsNullOrWhiteSpace(alias))
{
throw new ArgumentException("Cannot be whitespace.", nameof(alias));
}
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
Table = table;
Alias = alias;
Fields = new FieldExpressions(this, alias, fields);
Expressions = new ASourceExpression[0];
}
/// <summary>
/// Initializes a new instance of <see cref="JoinExpression"/> with the specified sources.
/// </summary>
/// <param name="outer">The outer source expression to aggregate.</param>
/// <param name="inner">The inner source expression to aggregate.</param>
/// <param name="predicate">The optional predicate to condition the join on.</param>
/// <param name="fields">The fields to select from the sources. If null, all fields are selected.</param>
/// <param name="joinType">The type of join to perform.</param>
public JoinExpression(ASourceExpression outer, ASourceExpression inner, APredicateExpression predicate = null, IEnumerable <FieldExpression> fields = null, JoinType joinType = JoinType.Inner)
{
if (outer == null)
{
throw new ArgumentNullException(nameof(outer));
}
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
Outer = outer;
Inner = inner;
Predicate = predicate ?? new BooleanExpression(true);
JoinType = joinType;
fields = fields ?? outer.Fields.Concat(inner.Fields);
Fields = new FieldExpressions(this, fields);
Expressions = new[] { outer, inner };
}
/// <summary>
/// Initializes a new instance of <see cref="SelectExpression"/> selecting the specified fields from the source.
/// </summary>
/// <param name="source">The source expression to select from.</param>
/// <param name="fields">The fields to select from the source.</param>
/// <param name="take">The number of fields to take from the source. Values less than zero indicate all rows.</param>
/// <param name="skip">The number of fields to ignore on the source before reading rows.</param>
/// <param name="orderings">The optional sorting of the selected rows.</param>
/// <exception cref="ArgumentNullException">fields is null.</exception>
/// <exception cref="ArgumentException">fields contains no elements or orderings contains duplicate field orderings.</exception>
/// <exception cref="KeyNotFoundException">An ordering key could not be found in fields.</exception>
public SelectExpression(ASourceExpression source, IEnumerable <FieldExpression> fields, int take = -1, int skip = 0, IEnumerable <Ordering> orderings = null)
{
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
if (!fields.Any())
{
throw new ArgumentException("There must be at least one field specified in a select query.", nameof(fields));
}
Source = source;
Fields = new FieldExpressions(this, fields);
Expressions = new[] { source };
Take = take;
Skip = skip;
Orderings = orderings?
.Select(x =>
{
if (x == null)
{
throw new ArgumentException("None of the ordering can be null.", nameof(orderings));
}
int count = orderings.Count(y => y.Field == x.Field);
if (count != 1)
{
throw new ArgumentException($"One ordering per field is allowed but '[{x.Field.TableName}].[{x.Field.FieldName}]' has {count}.", nameof(orderings));
}
if (!Fields.Any(y => y.SourceExpression == x.Field))
{
throw new KeyNotFoundException($"The ordering field '[{x.Field.TableName}].[{x.Field.FieldName}]' could not be found in the fields parameter.");
}
return(x);
})
.ToArray();
}
private IEnumerable <FieldExpression> DecodeJoinSelector(Expression expression, FieldExpressions outer, FieldExpressions inner)
{
// Get the associated lambda
LambdaExpression lambda = StripQuotes(expression) as LambdaExpression;
// Decode paramter body
ParameterExpression parameter = lambda.Body as ParameterExpression;
if (parameter != null)
{
if (parameter == lambda.Parameters[0])
{
return(outer);
}
else if (parameter == lambda.Parameters[1])
{
return(inner);
}
throw new InvalidOperationException($"The Join result selector does not recognise the specified '{parameter}' parameter. When using a paramter it must be one of the result selector paramter list.");
}
// Decode binary selector (It should always evaluate to all fields)
BinaryExpression binary = lambda.Body as BinaryExpression;
if (binary != null)
{
// Check the correct operator is being used
if (binary.NodeType != ExpressionType.Or)
{
throw new NotSupportedException("The only supported binary operator of an Sql Join call is Or: '|'.");
}
// Check the binary expressions are the paramters specified in the expression
if (binary.Left != lambda.Parameters[0] && binary.Left != lambda.Parameters[1])
{
throw new NotSupportedException("The left of the '|' operator in a Join result selector must be a parameter of the selector expression.");
}
if (binary.Right != lambda.Parameters[0] && binary.Right != lambda.Parameters[1])
{
throw new NotSupportedException("The right of the '|' operator in a Join result selector must be a parameter of the selector expression.");
}
// Resolve select all
if ((binary.Left == lambda.Parameters[0] && binary.Right == lambda.Parameters[1]) ||
(binary.Left == lambda.Parameters[1] && binary.Right == lambda.Parameters[0]))
{
return(null);
}
throw new InvalidOperationException("The Join result selector should not select the same parameter more than once. e.g. '(o, i) => i | i' should be replaced with '(o, i) => i'.");
}
throw new NotSupportedException($"The Join result selctor does not know how to translate '{expression}' to SQL. The supported expressions are: '(o, i) => o', '(o, i) => i', '(o, i) => o | i' and '(o, i) => i | o'.");
}
private static ILookup <string, CommandField> GetFieldMap(this DbDataReader reader, FieldExpressions fields)
{
return(fields
.Select(x => new CommandField(x.TableName, x.FieldName, reader.GetOrdinal(fields.GetKey(x))))
.ToLookup(x => x.Table));
}