public static FromExpressionInfo AnalyzeFromExpression(
Expression fromExpression,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
OrderingExtractionPolicy orderingExtractionPolicy)
{
ArgumentUtility.CheckNotNull("fromExpression", fromExpression);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("provider", provider);
ArgumentUtility.CheckNotNull("context", context);
var visitor = new SqlPreparationFromExpressionVisitor(generator, stage, provider, context, tableGenerator, orderingExtractionPolicy);
visitor.Visit(fromExpression);
if (visitor.FromExpressionInfo != null)
{
return(visitor.FromExpressionInfo.Value);
}
var message = string.Format(
"Error parsing expression '{0}'. Expressions of type '{1}' cannot be used as the SqlTables of a from clause.",
fromExpression,
fromExpression.Type.Name);
throw new NotSupportedException(message);
}
public FromExpressionInfo CreateSqlTableForStatement(
SqlStatement sqlStatement,
Func <ITableInfo, SqlTable> tableCreator,
OrderingExtractionPolicy orderingExtractionPolicy)
{
ArgumentUtility.CheckNotNull("sqlStatement", sqlStatement);
ArgumentUtility.CheckNotNull("tableCreator", tableCreator);
if (sqlStatement.Orderings.Count == 0)
{
var tableInfo = new ResolvedSubStatementTableInfo(_uniqueIdentifierGenerator.GetUniqueIdentifier("q"), sqlStatement);
var sqlTable = tableCreator(tableInfo);
return(new FromExpressionInfo(sqlTable, new Ordering[0], new SqlTableReferenceExpression(sqlTable), null));
}
// If we have orderings, we need to:
// - Build a nested projection that includes the original orderings if OrderingExtractionPolicy.ExtractOrderingsIntoProjection is specified.
// - Create a substatement clearing orderings, unless a TOP expression is present.
// - Put it into a SqlTable.
// - Put a reference to everything in the select projection (i.e., the original projection and the extracted orderings) into a
// FromExpressionInfo and return that.
var newSelectProjection = sqlStatement.SelectProjection;
if (orderingExtractionPolicy == OrderingExtractionPolicy.ExtractOrderingsIntoProjection)
{
newSelectProjection = GetNewSelectExpressionWithOrderings(sqlStatement);
}
var tableWithSubStatement = CreateSqlCompatibleSubStatementTable(sqlStatement, newSelectProjection, tableCreator);
return(GetFromExpressionInfoForSubStatement(sqlStatement, tableWithSubStatement));
}
protected void MoveCurrentStatementToSqlTable(
SqlStatementBuilder sqlStatementBuilder,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
ISqlPreparationStage stage,
OrderingExtractionPolicy orderingExtractionPolicy = OrderingExtractionPolicy.ExtractOrderingsIntoProjection)
{
// Ensure that select clause is named - usually SqlPreparationQueryModelVisitor would do this, but it hasn't done it yet
sqlStatementBuilder.SelectProjection = new NamedExpression(null, sqlStatementBuilder.SelectProjection);
var oldStatement = sqlStatementBuilder.GetStatementAndResetBuilder();
var fromExpressionInfo = stage.PrepareFromExpression(
new SqlSubStatementExpression(oldStatement),
context,
tableGenerator,
orderingExtractionPolicy);
sqlStatementBuilder.SqlTables.Add(fromExpressionInfo.SqlTable);
sqlStatementBuilder.SelectProjection = fromExpressionInfo.ItemSelector;
sqlStatementBuilder.Orderings.AddRange(fromExpressionInfo.ExtractedOrderings);
Assertion.DebugAssert(fromExpressionInfo.WhereCondition == null);
// the new statement is an identity query that selects the result of its subquery, so it starts with the same data type
sqlStatementBuilder.DataInfo = oldStatement.DataInfo;
AddMappingForItemExpression(context, oldStatement.DataInfo, fromExpressionInfo.ItemSelector);
}
public new void MoveCurrentStatementToSqlTable(
SqlStatementBuilder sqlStatementBuilder,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
ISqlPreparationStage stage,
OrderingExtractionPolicy orderingExtractionPolicy)
{
base.MoveCurrentStatementToSqlTable(sqlStatementBuilder, context, tableGenerator, stage, orderingExtractionPolicy);
}
public TestableSqlPreparationFromExpressionVisitor(
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
OrderingExtractionPolicy orderingExtractionPolicy)
: base(generator, stage, provider, context, tableGenerator, orderingExtractionPolicy)
{
}
public virtual FromExpressionInfo PrepareFromExpression(
Expression fromExpression,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
OrderingExtractionPolicy orderingExtractionPolicy)
{
return(SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
fromExpression, this, _uniqueIdentifierGenerator, _methodCallTransformerProvider, context, tableGenerator,
orderingExtractionPolicy));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <ISqlPreparationStage>();
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_methodCallTransformerProvider = CompoundMethodCallTransformerProvider.CreateDefault();
_someOrderingExtractionPolicy = Some.Item(
OrderingExtractionPolicy.ExtractOrderingsIntoProjection,
OrderingExtractionPolicy.DoNotExtractOrderings);
_tableGenerator = info => new SqlTable(info, JoinSemantics.Inner);
}
protected SqlPreparationFromExpressionVisitor(
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
OrderingExtractionPolicy orderingExtractionPolicy)
: base(context, stage, provider)
{
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("tableGenerator", tableGenerator);
_generator = generator;
_tableGenerator = tableGenerator;
_orderingExtractionPolicy = orderingExtractionPolicy;
FromExpressionInfo = null;
}
