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);