private SqlJoinCollectionExpression(
SqlCollectionExpression left,
SqlCollectionExpression right)
{
this.Left = left;
this.Right = right;
}
/// <summary>
/// Create a FROM clause from a set of FROM parameter bindings.
/// </summary>
/// <returns>The created FROM clause.</returns>
private SqlFromClause CreateFrom()
{
SqlCollectionExpression input = null;
foreach (var paramDef in this.fromParameters.GetBindings())
{
var parameter = paramDef.Parameter;
var paramBinding = paramDef.ParameterDefinition;
var ident = new SqlIdentifier(parameter.Name);
SqlCollectionExpression collExpr;
if (!paramDef.IsInCollection)
{
var newInput = new SqlInputPathCollection(ident, null);
collExpr = new SqlAliasedCollectionExpression(newInput, null);
}
else
{
collExpr = new SqlArrayIteratorCollectionExpression(ident, paramBinding);
}
if (input != null)
{
input = new SqlJoinCollectionExpression(input, collExpr);
}
else
{
input = collExpr;
}
}
var fromClause = new SqlFromClause(input);
return(fromClause);
}
private SqlJoinCollectionExpression(
SqlCollectionExpression leftExpression,
SqlCollectionExpression rightExpression)
: base(SqlObjectKind.JoinCollectionExpression)
{
this.LeftExpression = leftExpression;
this.RightExpression = rightExpression;
}
public override SqlObject VisitFrom_clause([NotNull] sqlParser.From_clauseContext context)
{
Contract.Requires(context != null);
SqlCollectionExpression collectionExpression = (SqlCollectionExpression)this.Visit(context.collection_expression());
return(SqlFromClause.Create(collectionExpression));
}
public void SetUp()
{
var item1 = new SqlLiteralExpression(13);
var item2 = Expression.Constant(12);
_items = new Expression[] { item1, item2 };
_collectionExpression = new SqlCollectionExpression(typeof(List <int>), _items);
}
public override SqlObject VisitJoinCollectionExpression([NotNull] sqlParser.JoinCollectionExpressionContext context)
{
Contract.Requires(context != null);
SqlCollectionExpression left = (SqlCollectionExpression)this.Visit(context.collection_expression(0));
SqlCollectionExpression right = (SqlCollectionExpression)this.Visit(context.collection_expression(1));
return(SqlJoinCollectionExpression.Create(left, right));
}
public void VisitSqlCollectionExpression_Empty()
{
var items = new Expression[0];
var sqlCollectionExpression = new SqlCollectionExpression(typeof(List <object>), items);
SqlGeneratingExpressionVisitor.GenerateSql(sqlCollectionExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(SELECT NULL WHERE 1 = 0)"));
}
public void VisitSqlCollectionExpression()
{
var items = new Expression[] { Expression.Constant(7), new SqlLiteralExpression("Hello"), new SqlLiteralExpression(12) };
var sqlCollectionExpression = new SqlCollectionExpression(typeof(List <object>), items);
SqlGeneratingExpressionVisitor.GenerateSql(sqlCollectionExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(@1, 'Hello', 12)"));
Assert.That(_commandBuilder.GetCommandParameters(), Is.EqualTo(new[] { new CommandParameter("@1", 7) }));
}
public void VisitConstantExpression_WithCollection_ReturnsSqlCollectionExpression()
{
var constantExpression = Expression.Constant(new[] { 1, 2, 3 });
var result = SqlPreparationExpressionVisitor.TranslateExpression(constantExpression, _context, _stageMock, _methodCallTransformerProvider);
var expectedExpression = new SqlCollectionExpression(
typeof(int[]), new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) });
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, result);
}
public virtual Expression VisitSqlCollectionExpression(SqlCollectionExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
_commandBuilder.Append("(");
if (expression.Items.Count == 0)
{
_commandBuilder.Append("SELECT NULL WHERE 1 = 0");
}
_commandBuilder.AppendSeparated(", ", expression.Items, (cb, item) => VisitExpression(item));
_commandBuilder.Append(")");
return(expression);
}
/// <summary>
/// Create a FROM clause from a set of FROM parameter bindings.
/// </summary>
/// <returns>The created FROM clause.</returns>
private SqlFromClause CreateFrom(SqlCollectionExpression inputCollectionExpression)
{
bool first = true;
foreach (Binding paramDef in this.fromParameters.GetBindings())
{
// If input collection expression is provided, the first binding,
// which is the input paramter name, should be omitted.
if (first)
{
first = false;
if (inputCollectionExpression != null)
{
continue;
}
}
ParameterExpression parameter = paramDef.Parameter;
SqlCollection paramBinding = paramDef.ParameterDefinition;
SqlIdentifier identifier = SqlIdentifier.Create(parameter.Name);
SqlCollectionExpression collExpr;
if (!paramDef.IsInCollection)
{
SqlCollection collection = paramBinding ?? SqlInputPathCollection.Create(identifier, null);
SqlIdentifier alias = paramBinding == null ? null : identifier;
collExpr = SqlAliasedCollectionExpression.Create(collection, alias);
}
else
{
collExpr = SqlArrayIteratorCollectionExpression.Create(identifier, paramBinding);
}
if (inputCollectionExpression != null)
{
inputCollectionExpression = SqlJoinCollectionExpression.Create(inputCollectionExpression, collExpr);
}
else
{
inputCollectionExpression = collExpr;
}
}
SqlFromClause fromClause = SqlFromClause.Create(inputCollectionExpression);
return(fromClause);
}
private static void AssertEvaluation(
IEnumerable <CosmosElement> expected,
SqlCollectionExpression collectionExpression,
IEnumerable <CosmosElement> dataSource)
{
IEnumerable <CosmosElement> actual = collectionExpression.Accept(DataSourceEvaluator.Singleton, dataSource);
if (expected.Count() != actual.Count())
{
Assert.Fail($"Expected had {expected.Count()} results while Actual has {actual.Count()} results.");
}
IEnumerable <Tuple <CosmosElement, CosmosElement> > expectedActuals = expected.Zip(actual, (first, second) => new Tuple <CosmosElement, CosmosElement>(first, second));
foreach (Tuple <CosmosElement, CosmosElement> expectedActual in expectedActuals)
{
Assert.AreEqual(expectedActual.Item1, expectedActual.Item2);
}
}
public static SqlJoinCollectionExpression Create(
SqlCollectionExpression leftExpression,
SqlCollectionExpression rightExpression)
{
return(new SqlJoinCollectionExpression(leftExpression, rightExpression));
}
public static SqlJoinCollectionExpression Create(
SqlCollectionExpression left,
SqlCollectionExpression right) => new SqlJoinCollectionExpression(left, right);
