internal static ReadOnlyCollection <DbExpressionBinding> ValidateCrossJoin(
IEnumerable <DbExpressionBinding> inputs,
out TypeUsage resultType)
{
List <DbExpressionBinding> expressionBindingList = new List <DbExpressionBinding>();
List <KeyValuePair <string, TypeUsage> > columns = new List <KeyValuePair <string, TypeUsage> >();
Dictionary <string, int> dictionary = new Dictionary <string, int>();
IEnumerator <DbExpressionBinding> enumerator = inputs.GetEnumerator();
int index = 0;
while (enumerator.MoveNext())
{
DbExpressionBinding current = enumerator.Current;
string paramName = StringUtil.FormatIndex(nameof(inputs), index);
if (current == null)
{
throw new ArgumentNullException(paramName);
}
int num = -1;
if (dictionary.TryGetValue(current.VariableName, out num))
{
throw new ArgumentException(Strings.Cqt_CrossJoin_DuplicateVariableNames((object)num, (object)index, (object)current.VariableName));
}
expressionBindingList.Add(current);
dictionary.Add(current.VariableName, index);
columns.Add(new KeyValuePair <string, TypeUsage>(current.VariableName, current.VariableType));
++index;
}
if (expressionBindingList.Count < 2)
{
throw new ArgumentException(Strings.Cqt_CrossJoin_AtLeastTwoInputs, nameof(inputs));
}
resultType = ArgumentValidation.CreateCollectionOfRowResultType(columns);
return(new ReadOnlyCollection <DbExpressionBinding>((IList <DbExpressionBinding>)expressionBindingList));
}
internal static TypeUsage ValidateGroupBy(
IEnumerable <KeyValuePair <string, DbExpression> > keys,
IEnumerable <KeyValuePair <string, DbAggregate> > aggregates,
out DbExpressionList validKeys,
out ReadOnlyCollection <DbAggregate> validAggregates)
{
List <KeyValuePair <string, TypeUsage> > columns = new List <KeyValuePair <string, TypeUsage> >();
HashSet <string> keyNames = new HashSet <string>();
EnumerableValidator <KeyValuePair <string, DbExpression>, DbExpression, DbExpressionList> validator1 = ArgumentValidation.CreateValidator <KeyValuePair <string, DbExpression>, DbExpression, DbExpressionList>(keys, nameof(keys), (Func <KeyValuePair <string, DbExpression>, int, DbExpression>)((keyInfo, index) =>
{
ArgumentValidation.CheckNamed <DbExpression>(keyInfo, nameof(keys), index);
if (!TypeHelpers.IsValidGroupKeyType(keyInfo.Value.ResultType))
{
throw new ArgumentException(Strings.Cqt_GroupBy_KeyNotEqualityComparable((object)keyInfo.Key));
}
keyNames.Add(keyInfo.Key);
columns.Add(new KeyValuePair <string, TypeUsage>(keyInfo.Key, keyInfo.Value.ResultType));
return(keyInfo.Value);
}), (Func <List <DbExpression>, DbExpressionList>)(expList => new DbExpressionList((IList <DbExpression>)expList)));
validator1.AllowEmpty = true;
validator1.GetName = (Func <KeyValuePair <string, DbExpression>, int, string>)((keyInfo, idx) => keyInfo.Key);
validKeys = validator1.Validate();
bool hasGroupAggregate = false;
EnumerableValidator <KeyValuePair <string, DbAggregate>, DbAggregate, ReadOnlyCollection <DbAggregate> > validator2 = ArgumentValidation.CreateValidator <KeyValuePair <string, DbAggregate>, DbAggregate, ReadOnlyCollection <DbAggregate> >(aggregates, nameof(aggregates), (Func <KeyValuePair <string, DbAggregate>, int, DbAggregate>)((aggInfo, idx) =>
{
ArgumentValidation.CheckNamed <DbAggregate>(aggInfo, nameof(aggregates), idx);
if (keyNames.Contains(aggInfo.Key))
{
throw new ArgumentException(Strings.Cqt_GroupBy_AggregateColumnExistsAsGroupColumn((object)aggInfo.Key));
}
if (aggInfo.Value is DbGroupAggregate)
{
if (hasGroupAggregate)
{
throw new ArgumentException(Strings.Cqt_GroupBy_MoreThanOneGroupAggregate);
}
hasGroupAggregate = true;
}
columns.Add(new KeyValuePair <string, TypeUsage>(aggInfo.Key, aggInfo.Value.ResultType));
return(aggInfo.Value);
}), (Func <List <DbAggregate>, ReadOnlyCollection <DbAggregate> >)(aggList => ArgumentValidation.NewReadOnlyCollection <DbAggregate>((IList <DbAggregate>)aggList)));
validator2.AllowEmpty = true;
validator2.GetName = (Func <KeyValuePair <string, DbAggregate>, int, string>)((aggInfo, idx) => aggInfo.Key);
validAggregates = validator2.Validate();
if (validKeys.Count == 0 && validAggregates.Count == 0)
{
throw new ArgumentException(Strings.Cqt_GroupBy_AtLeastOneKeyOrAggregate);
}
return(ArgumentValidation.CreateCollectionOfRowResultType(columns));
}
internal static TypeUsage ValidateApply(
DbExpressionBinding input,
DbExpressionBinding apply)
{
if (input.VariableName.Equals(apply.VariableName, StringComparison.Ordinal))
{
throw new ArgumentException(Strings.Cqt_Apply_DuplicateVariableNames);
}
return(ArgumentValidation.CreateCollectionOfRowResultType(new List <KeyValuePair <string, TypeUsage> >()
{
new KeyValuePair <string, TypeUsage>(input.VariableName, input.VariableType),
new KeyValuePair <string, TypeUsage>(apply.VariableName, apply.VariableType)
}));
}
internal static TypeUsage ValidateJoin(
DbExpressionBinding left,
DbExpressionBinding right,
DbExpression joinCondition)
{
if (left.VariableName.Equals(right.VariableName, StringComparison.Ordinal))
{
throw new ArgumentException(Strings.Cqt_Join_DuplicateVariableNames);
}
ArgumentValidation.RequireCompatibleType(joinCondition, PrimitiveTypeKind.Boolean, nameof(joinCondition));
return(ArgumentValidation.CreateCollectionOfRowResultType(new List <KeyValuePair <string, TypeUsage> >(2)
{
new KeyValuePair <string, TypeUsage>(left.VariableName, left.VariableType),
new KeyValuePair <string, TypeUsage>(right.VariableName, right.VariableType)
}));
}