public override void Visit(SqlSelectItem sqlSelectItem)
{
sqlSelectItem.Expression.Accept(this);
if (sqlSelectItem.Alias != null)
{
this.writer.Write(" AS ");
sqlSelectItem.Alias.Accept(this);
}
}
public override int Visit(SqlSelectItem sqlSelectItem)
{
int hashCode = SqlSelectItemHashCode;
hashCode = CombineHashes(hashCode, sqlSelectItem.Expression.Accept(this));
if (sqlSelectItem.Alias != null)
{
hashCode = CombineHashes(hashCode, sqlSelectItem.Alias.Accept(this));
}
return(hashCode);
}
public override SqlSelectSpec Visit(SqlSelectListSpec selectSpec)
{
List <SqlSelectItem> selectItems = new List <SqlSelectItem>();
foreach (SqlSelectItem selectItem in selectSpec.Items)
{
selectItems.Add(SqlSelectItem.Create(
selectItem.Expression.Accept(this.scalarExpressionTransformer),
selectItem.Alias));
}
return(SqlSelectListSpec.Create(selectItems));
}
public override SqlObject VisitSelect_list_spec([NotNull] sqlParser.Select_list_specContext context)
{
Contract.Requires(context != null);
List <SqlSelectItem> sqlSelectItems = new List <SqlSelectItem>();
foreach (sqlParser.Select_itemContext selectItemContext in context.select_item())
{
SqlSelectItem selectItem = (SqlSelectItem)this.Visit(selectItemContext);
sqlSelectItems.Add(selectItem);
}
return(SqlSelectListSpec.Create(sqlSelectItems.ToImmutableArray()));
}
public override SqlObject VisitSelect_item([NotNull] sqlParser.Select_itemContext context)
{
Contract.Requires(context != null);
SqlScalarExpression sqlScalarExpression = (SqlScalarExpression)this.Visit(context.scalar_expression());
SqlIdentifier alias;
if (context.IDENTIFIER() != null)
{
alias = SqlIdentifier.Create(context.IDENTIFIER().GetText());
}
else
{
alias = default;
}
return(SqlSelectItem.Create(sqlScalarExpression, alias));
}
public override bool Visit(SqlSelectItem first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlSelectItem second))
{
return(false);
}
if (!Equals(first.Alias, second.Alias))
{
return(false);
}
if (!Equals(first.Expression, second.Expression))
{
return(false);
}
return(true);
}
/// <summary>
/// Repackages and passes an expression from an aggregate subquery back to the parent query.
/// </summary>
private SqlExpression CreateAggregateMappingExpression(SqlQuery parentQuery, SqlTable proxyTable, SqlExpression sqlExpr)
{
var subQuery = proxyTable.SubQuery.Queries[0];
string alias = parentQuery.AliasManager.CreateAlias("aggCol");
var groupByColumn = new SqlSelectItem
{
Expression = sqlExpr,
Alias = alias
};
subQuery.SelectClause.Items.Add(groupByColumn);
subQuery.GroupByClause.Expressions.Add(groupByColumn.Expression);
// Register an expression that can be used to access the group-by expression
string mappedSql = GetColumnSql(proxyTable, alias);
var mappedSqlExpr = new SqlExpression(mappedSql);
SqlExpression.CopyTransforms(sqlExpr, mappedSqlExpr);
mappedSqlExpr.DatabaseType = sqlExpr.DatabaseType;
return(mappedSqlExpr);
}
public abstract void Visit(SqlSelectItem sqlObject);
public override SqlObject Visit(SqlSelectItem sqlSelectItem)
{
return(SqlSelectItem.Create(
sqlSelectItem.Expression.Accept(this) as SqlScalarExpression,
sqlSelectItem.Alias?.Accept(this) as SqlIdentifier));
}
public abstract TResult Visit(SqlSelectItem sqlObject);
public void SqlSelectListSpecTest()
{
CosmosObject john = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["name"] = CosmosString.Create("John"),
["age"] = CosmosNumber64.Create(25)
});
CosmosObject johnWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = john
});
// { c.name, c.age }
SqlScalarExpression cDotName = TestUtils.CreatePathExpression("c", "name");
SqlScalarExpression cDotAge = TestUtils.CreatePathExpression("c", "age");
SqlSelectListSpec listSpec = SqlSelectListSpec.Create(
SqlSelectItem.Create(cDotName),
SqlSelectItem.Create(cDotAge));
AssertEvaluation(john, listSpec, johnWrapped);
// { c.name AS nameAlias }
CosmosObject johnAliased = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["nameAlias"] = CosmosString.Create("John"),
});
SqlSelectListSpec listSpecWithAlias = SqlSelectListSpec.Create(SqlSelectItem.Create(cDotName, SqlIdentifier.Create("nameAlias")));
AssertEvaluation(johnAliased, listSpecWithAlias, johnWrapped);
// { 3 + 5 }
CosmosObject johnNonPropertyName = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["$1"] = CosmosNumber64.Create(8)
});
SqlLiteralScalarExpression five = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(5));
SqlLiteralScalarExpression three = SqlLiteralScalarExpression.Create(SqlNumberLiteral.Create(3));
SqlBinaryScalarExpression fivePlusThree = SqlBinaryScalarExpression.Create(SqlBinaryScalarOperatorKind.Add, five, three);
SqlSelectListSpec listSpecNonMember = SqlSelectListSpec.Create(SqlSelectItem.Create(fivePlusThree));
AssertEvaluation(johnNonPropertyName, listSpecNonMember);
// { 3 + 5 AS Five Plus Three }
CosmosObject johnNonPropertyNameAliased = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["Five Plus Three"] = CosmosNumber64.Create(8)
});
SqlSelectListSpec listSpecNonMemberAliased = SqlSelectListSpec.Create(SqlSelectItem.Create(fivePlusThree, SqlIdentifier.Create("Five Plus Three")));
AssertEvaluation(johnNonPropertyNameAliased, listSpecNonMemberAliased);
// { c.blah[0] }
CosmosObject numberIndex = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["blah"] = CosmosArray.Create(
new List <CosmosElement>()
{
CosmosNumber64.Create(0),
CosmosNumber64.Create(1),
CosmosNumber64.Create(2)
})
});
CosmosObject numberIndexWrapped = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["c"] = numberIndex
});
CosmosObject numberIndexEval = CosmosObject.Create(new Dictionary <string, CosmosElement>
{
["$1"] = CosmosNumber64.Create(0)
});
SqlScalarExpression cDotBlah0 = TestUtils.CreatePathExpression("c", "blah", 0);
SqlSelectListSpec numberIndexSpec = SqlSelectListSpec.Create(SqlSelectItem.Create(cDotBlah0));
AssertEvaluation(numberIndexEval, numberIndexSpec, numberIndexWrapped);
}
public abstract TOutput Visit(SqlSelectItem sqlObject, TArg input);
/// <summary>
/// Generates SqlTable and sub query for an aggregation.
/// </summary>
/// <param name="structuredQuery">The structured query.</param>
/// <param name="entity">The AggregateEntity that represents the aggregation in the 'from' tree.</param>
/// <param name="parentTable">The table that this aggregation joins up to. Can be null if the aggregation is being performed at the top level.</param>
/// <param name="sqlQuery">The query object.</param>
/// <returns>
/// The table
/// </returns>
private EntityTables RegisterAggregateEntity(StructuredQuery structuredQuery, AggregateEntity entity, SqlTable parentTable, SqlQuery sqlQuery)
{
if (entity.GroupedEntity == null)
{
throw new Exception("Aggregate entity must have GroupedEntity set.");
}
if (entity.RelatedEntities.Count > 0)
{
throw new Exception("Aggregate entity should not have related entities."); // note: no logical reason not to, however it's likely indicative of a bug elsewhere
}
// Establish sub query
// Note that sub query has its distinct reference manager for tracking tables and other elements.
SqlQuery subquery = sqlQuery.CreateSubQuery( );
subquery.ParentQuery = sqlQuery;
sqlQuery.Subqueries.Add(subquery);
// Get joining table for the entity being grouped
EntityTables childTables =
BuildEntityTableJoinTree(structuredQuery, entity.GroupedEntity, parentTable, subquery); //hmm
SqlTable childTable = childTables.HeadTable;
subquery.FromClause.RootTable = childTable;
// Note: we passed in parentTable above so that the child can learn about the joining column
// However, it will actually try to join to the table when we don't want it to, so need to manually unlink it afterwards.
childTable.Parent = null;
if (parentTable != null)
{
parentTable.Children.Remove(childTable);
}
// Create the proxy table
// Note: parentTable may be null for root aggregate
SqlTable proxyTable = sqlQuery.CreateJoinedTable("", // not applicable
"ag", parentTable, JoinHint.Unspecified, childTable.JoinColumn, parentTable?.IdColumn);
//if the used condition under current aggregate grouped entity or related entities, set joinhint to requried
if (structuredQuery.Conditions.Any(c => c.Operator != ConditionType.Unspecified &&
c.Operator != ConditionType.IsNull &&
ConditionContainArgument(c) &&
c.Expression is ResourceDataColumn &&
MatchGroupedEntityNode(((ResourceDataColumn)c.Expression).NodeId, entity.GroupedEntity)
))
{
proxyTable.JoinHint = JoinHint.Required;
}
//TODO, this hacky code is resolved a special sql query issue (bug 24406), both Pete and me agree with this is not the best solution, but can fix current bug
//TODO, we can remove this hacky code when report builder allows set the aggregated field in analyzer.
ConvertConditionExpressionToAggregate(structuredQuery.Conditions, entity);
proxyTable.SubQuery = new SqlUnion(subquery);
subquery.ProxyTable = proxyTable;
// Proxy the join column through the sub query select statement
// (If it actually joins to something)
if (childTable.JoinColumn != null)
{
string joinColumnAlias = sqlQuery.AliasManager.CreateAlias("aggCol");
string joinColumnSql = GetColumnSql(childTable, childTable.JoinColumn);
var joinColumn = new SqlSelectItem
{
Expression = new SqlExpression
{
Sql = joinColumnSql
},
Alias = joinColumnAlias
};
subquery.SelectClause.Items.Add(joinColumn);
subquery.GroupByClause.Expressions.Add(joinColumn.Expression);
proxyTable.JoinColumn = joinColumnAlias;
var idExpr = new IdExpression
{
NodeId = entity.GroupedEntity.NodeId
};
sqlQuery.References.RegisterMappedExpression(idExpr, joinColumn.Expression);
}
// Add additional grouping columns
if (entity.GroupBy != null && entity.GroupBy.Count > 0)
{
proxyTable.GroupByMap = new Dictionary <ScalarExpression, SqlExpression>();
foreach (ScalarExpression expr in entity.GroupBy)
{
try
{
SqlExpression sqlExpr;
if (TryConvertExpression(expr, subquery, false, out sqlExpr))
{
if (!_querySettings.FullAggregateClustering)
{
// If we're not clustering everywhere, then explicitly cluster in summarize group-bys still.
sqlExpr = ApplyClusterOperation(sqlExpr, expr.ClusterOperation, sqlQuery);
}
proxyTable.GroupByMap[expr] = sqlExpr;
var mappedSqlExpr = CreateAggregateMappingExpression(sqlQuery, proxyTable, sqlExpr);
sqlQuery.References.RegisterMappedExpression(expr, mappedSqlExpr);
if (sqlExpr.OrderingSqlCallback != null && sqlExpr.OrderingSqlRequiresGrouping)
{
mappedSqlExpr.OrderingSqlCallback =
exprTmp =>
CreateAggregateOrderbyMappingExpression(sqlQuery, proxyTable, sqlExpr.OrderingSql).Sql;
}
}
}
catch
{
}
}
}
// Return proxy table
return(new EntityTables(proxyTable));
}
