private void FlattenSubQuery(SubQueryExpression subQueryExpression, MainFromClause fromClause,
QueryModel queryModel)
{
// Create a new client-side select for the outer
// TODO - don't like calling GetGenericArguments here...
var clientSideSelect = new ClientSideSelect(new NonAggregatingGroupBySelectRewriter().Visit(queryModel.SelectClause.Selector, subQueryExpression.Type.GetGenericArguments()[0], queryModel.MainFromClause));
// Replace the outer select clause...
queryModel.SelectClause = subQueryExpression.QueryModel.SelectClause;
MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
CopyFromClauseData(innerMainFromClause, fromClause);
foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
{
queryModel.BodyClauses.Add(bodyClause);
}
// Move the result operator up
if (queryModel.ResultOperators.Count != 0)
{
throw new NotImplementedException();
}
queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0]));
queryModel.ResultOperators.Add(clientSideSelect);
}
/// <summary>
/// Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
/// </summary>
/// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
/// <returns>A clone of this clause.</returns>
public MainFromClause Clone(CloneContext cloneContext)
{
var clone = new MainFromClause(ItemName, ItemType, FromExpression);
cloneContext.QuerySourceMapping.AddMapping(this, new QuerySourceReferenceExpression(clone));
return(clone);
}
public void NamedEntity ()
{
// from c in Cooks select c [with name = "inner"]
var subMainFromClause = new MainFromClause ("c", typeof(Cook), Expression.Constant (Cooks));
var subSelectClause = new SelectClause (new NamedExpression ("inner", new QuerySourceReferenceExpression (subMainFromClause)));
var subQuery = new QueryModel (subMainFromClause, subSelectClause);
// from x in (subQuery) where x.ID == null select x
var outerMainFromClause = new MainFromClause ("x", typeof(Cook), new SubQueryExpression (subQuery));
var outerWhereClause = new WhereClause(Expression.Equal(Expression.MakeMemberAccess (new QuerySourceReferenceExpression (outerMainFromClause), typeof (Cook).GetProperty ("ID")), Expression.Constant (1)));
var outerSelectClause = new SelectClause (new QuerySourceReferenceExpression (outerMainFromClause));
var outerQuery = new QueryModel (outerMainFromClause, outerSelectClause);
outerQuery.BodyClauses.Add (outerWhereClause);
CheckQuery (
outerQuery,
"SELECT [q0].[inner_ID] AS [ID],[q0].[inner_FirstName] AS [FirstName],[q0].[inner_Name] AS [Name],"
+ "[q0].[inner_IsStarredCook] AS [IsStarredCook],[q0].[inner_IsFullTimeCook] AS [IsFullTimeCook],"
+ "[q0].[inner_SubstitutedID] AS [SubstitutedID],[q0].[inner_KitchenID] AS [KitchenID],"
+ "[q0].[inner_KnifeID] AS [KnifeID],[q0].[inner_KnifeClassID] AS [KnifeClassID] "
+ "FROM (SELECT [t1].[ID] AS [inner_ID],"
+ "[t1].[FirstName] AS [inner_FirstName],[t1].[Name] AS [inner_Name],[t1].[IsStarredCook] AS [inner_IsStarredCook],"
+ "[t1].[IsFullTimeCook] AS [inner_IsFullTimeCook],[t1].[SubstitutedID] AS [inner_SubstitutedID],"
+ "[t1].[KitchenID] AS [inner_KitchenID],[t1].[KnifeID] AS [inner_KnifeID],[t1].[KnifeClassID] AS [inner_KnifeClassID] "
+ "FROM [CookTable] AS [t1]) AS [q0] WHERE ([q0].[inner_ID] = @1)",
new CommandParameter("@1", 1));
}
public virtual void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("fromClause", fromClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
// nothing to do here
}
public void SetUp ()
{
_mainFromClause = ExpressionHelper.CreateMainFromClause_Int();
_selectClause = ExpressionHelper.CreateSelectClause();
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_querySourceMapping = new QuerySourceMapping();
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
Log.Trace(m => m("Original QueryModel: {0}", queryModel));
new AggressiveSubQueryFromClauseFlattener().VisitMainFromClause(fromClause, queryModel);
Log.Trace(m => m("Transformed QueryModel after AggressiveSubQueryFromClauseFlattener: {0}", queryModel));
base.VisitMainFromClause(fromClause, queryModel);
}
public void SetUp ()
{
_detailSource = ExpressionHelper.CreateQueryable<Kitchen>();
_sectorSource = ExpressionHelper.CreateQueryable<Restaurant>();
var query = from s1 in ExpressionHelper.CreateQueryable<Cook>()
from sd in
(from sector in _sectorSource
where sector.ID > 10
select sector.SubKitchen)
from s2 in s1.Assistants
where sd.Name == "Maths"
select new NonTransformedTuple<Cook, Kitchen> (s1, sd);
_queryModel = ExpressionHelper.ParseQuery (query);
_mainFromClause = _queryModel.MainFromClause;
_additionalFromClause1 = (AdditionalFromClause) _queryModel.BodyClauses[0];
_additionalFromClause2 = (AdditionalFromClause) _queryModel.BodyClauses[1];
_whereClause = (WhereClause) _queryModel.BodyClauses[2];
_selectClause = _queryModel.SelectClause;
var subQueryExpressionA = (SubQueryExpression) _additionalFromClause1.FromExpression;
_innerMainFromClauseA = subQueryExpressionA.QueryModel.MainFromClause;
_innerWhereClauseA = (WhereClause) subQueryExpressionA.QueryModel.BodyClauses[0];
_visitor = new SubQueryFromClauseFlattener();
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
if (subQueryExpression != null)
FlattenSubQuery(subQueryExpression, fromClause, queryModel, 0);
base.VisitMainFromClause(fromClause, queryModel);
}
/// <summary>
/// 解析 from 语句
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause( MainFromClause fromClause, QueryModel queryModel )
{
string itemName = fromClause.ItemName == "<generated>_0" ? "T" : fromClause.ItemName.ToUpper();
this.queryPartsAggregator.FromParts.Add( string.Format( "{0}{1}{0} {2}", Constants.Quote, fromClause.ItemType.Name, itemName ) );
base.VisitMainFromClause( fromClause, queryModel );
}
public void SetUp ()
{
_oldFromClause = ExpressionHelper.CreateMainFromClause_Int ();
_newFromClause = ExpressionHelper.CreateMainFromClause_Int ();
_querySourceMapping = new QuerySourceMapping ();
_querySourceMapping.AddMapping (_oldFromClause, new QuerySourceReferenceExpression (_newFromClause));
}
/// <summary>
/// Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
/// </summary>
/// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
/// <returns>A clone of this clause.</returns>
public MainFromClause Clone (CloneContext cloneContext)
{
ArgumentUtility.CheckNotNull ("cloneContext", cloneContext);
var clone = new MainFromClause (ItemName, ItemType, FromExpression);
cloneContext.QuerySourceMapping.AddMapping (this, new QuerySourceReferenceExpression (clone));
return clone;
}
/// <summary>
/// 解析 from 语句
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause( MainFromClause fromClause, QueryModel queryModel )
{
string itemName = fromClause.ItemName.Contains( "<generated>" ) ? "t" : fromClause.ItemName.ToLower();
this.commandBuilder.FromParts.Add( string.Format( "{0}{1}{2} {3}", Constants.LeftQuote, fromClause.ItemType.Name, Constants.RightQuote, itemName ) );
base.VisitMainFromClause( fromClause, queryModel );
}
/// <summary>
/// Clones this clause, registering its clone with the <paramref name="cloneContext"/>.
/// </summary>
/// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
/// <returns>A clone of this clause.</returns>
public MainFromClause Clone(CloneContext cloneContext)
{
ArgumentUtility.CheckNotNull("cloneContext", cloneContext);
var clone = new MainFromClause(ItemName, ItemType, FromExpression);
cloneContext.QuerySourceMapping.AddMapping(this, new QuerySourceReferenceExpression(clone));
return(clone);
}
public void Initialize_WithNonConstantExpression ()
{
IQueryable querySource = ExpressionHelper.CreateQueryable<Cook> ();
var anonymous = new {source = querySource};
MemberExpression sourceExpression = Expression.MakeMemberAccess (Expression.Constant (anonymous), anonymous.GetType().GetProperty ("source"));
var fromClause = new MainFromClause ("s", typeof (Cook), sourceExpression);
Assert.That (fromClause.FromExpression, Is.SameAs (sourceExpression));
}
public void SetUp ()
{
_builder = new QueryModelBuilder();
_mainFromClause = ExpressionHelper.CreateMainFromClause_Int ();
_whereClause1 = ExpressionHelper.CreateWhereClause ();
_whereClause2 = ExpressionHelper.CreateWhereClause ();
_selectClause = ExpressionHelper.CreateSelectClause ();
_resultOperator1 = ExpressionHelper.CreateResultOperator ();
_resultOperator2 = ExpressionHelper.CreateResultOperator ();
}
private MainFromClause CreateMainFromClause (ClauseGenerationContext clauseGenerationContext)
{
var fromClause = new MainFromClause (
AssociatedIdentifier,
QuerySourceElementType,
ParsedExpression);
clauseGenerationContext.AddContextInfo (this, fromClause);
return fromClause;
}
public void SetUp ()
{
_fromClause1 = ExpressionHelper.CreateMainFromClause_Int ("i", typeof (int), ExpressionHelper.CreateIntQueryable ());
_fromClause2 = ExpressionHelper.CreateMainFromClause_Int ("j", typeof (int), ExpressionHelper.CreateIntQueryable ());
_keySelector = ExpressionHelper.Resolve<int, int> (_fromClause2, j => j % 3);
_elementSelector = ExpressionHelper.Resolve<int, string> (_fromClause1, i => i.ToString ());
_resultOperator = new GroupResultOperator ("groupings", _keySelector, _elementSelector);
_cloneContext = new CloneContext (new QuerySourceMapping ());
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
if (_type.IsAssignableFrom(fromClause.ItemType))
{
_querySource = fromClause;
}
else
{
base.VisitMainFromClause(fromClause, queryModel);
}
}
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
var luceneExpression = new LuceneIndexExpression();
luceneExpression.AttachIndex(fromClause.ItemType.GetContractId());
luceneExpression.Append(fromClause.ItemType.GetContractId());
_queryParts.AddFromPart(luceneExpression);
fromClause.ItemName = "EventInternal";
base.VisitMainFromClause(fromClause, queryModel);
}
public override void SetUp ()
{
base.SetUp ();
_cookSource = new MainSourceExpressionNode ("s", Expression.Constant (new[] { new Cook () }));
_cookClause = ExpressionHelper.CreateMainFromClause<Cook> ();
ClauseGenerationContext.AddContextInfo (_cookSource, _cookClause);
_ofTypeWithChefMethod = ReflectionUtility.GetMethod (() => ((IQueryable<Cook[]>) null).OfType<Chef> ());
_node = new OfTypeExpressionNode (CreateParseInfo (_cookSource, "s", _ofTypeWithChefMethod));
}
public void SetUp ()
{
_mapping = new QuerySourceMapping ();
_clause1 = ExpressionHelper.CreateMainFromClause_Int ();
_clause2 = ExpressionHelper.CreateMainFromClause_Int ();
_clause3 = ExpressionHelper.CreateMainFromClause_Int ();
_querySourceReferenceExpression1 = new QuerySourceReferenceExpression (_clause1);
_querySourceReferenceExpression2 = new QuerySourceReferenceExpression (_clause2);
_querySourceReferenceExpression3 = new QuerySourceReferenceExpression (_clause3);
}
public override void VisitMainFromClause (MainFromClause fromClause, QueryModel queryModel)
{
ArgumentUtility.CheckNotNull ("fromClause", fromClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
if (subQueryExpression != null)
FlattenSubQuery (subQueryExpression, fromClause, queryModel, 0);
base.VisitMainFromClause (fromClause, queryModel);
}
public void Initialize ()
{
IQueryable querySource = ExpressionHelper.CreateQueryable<Cook> ();
ConstantExpression constantExpression = Expression.Constant (querySource);
var fromClause = new MainFromClause ("s", typeof (Cook), constantExpression);
Assert.That (fromClause.ItemName, Is.EqualTo ("s"));
Assert.That (fromClause.ItemType, Is.SameAs (typeof (Cook)));
Assert.That (fromClause.FromExpression, Is.SameAs (constantExpression));
}
public override void VisitMainFromClause( MainFromClause fromClause, QueryModel queryModel )
{
var subQuery = fromClause.FromExpression as SubQueryExpression;
if( subQuery != null )
{
var query = subQuery.QueryModel;
VisitBodyClauses( query.BodyClauses, query );
base.VisitMainFromClause( fromClause, queryModel );
}
base.VisitMainFromClause( fromClause, queryModel );
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_source = ExpressionHelper.CreateMainFromClause<Cook>();
var source = new UnresolvedTableInfo (typeof (int));
_sqlTable = new SqlTable (source, JoinSemantics.Inner);
_parentContext = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
_parentSource = ExpressionHelper.CreateMainFromClause<Cook>();
_parentSqlTable = new SqlTable (new UnresolvedTableInfo (typeof (int)), JoinSemantics.Inner);
_sqlStatementBuilder = new SqlStatementBuilder();
_contextWithParent = new SqlPreparationContext (_parentContext, _sqlStatementBuilder);
}
public override void VisitMainFromClause(Remotion.Linq.Clauses.MainFromClause fromClause, QueryModel queryModel)
{
queries = new List <StringBuilder>();
NodeTypeAliasAttribute attribute = (NodeTypeAliasAttribute)fromClause.ItemType.GetCustomAttributes(typeof(NodeTypeAliasAttribute), false).FirstOrDefault();
if (attribute != null)
{
queries.Add(new StringBuilder(string.Format("nodeTypeAlias:{0}", attribute.Name)));
}
base.VisitMainFromClause(fromClause, queryModel);
}
public void TransformExpressions ()
{
var oldExpression = ExpressionHelper.CreateExpression ();
var newExpression = ExpressionHelper.CreateExpression ();
var clause = new MainFromClause ("x", typeof (Cook), oldExpression);
clause.TransformExpressions (ex =>
{
Assert.That (ex, Is.SameAs (oldExpression));
return newExpression;
});
Assert.That (clause.FromExpression, Is.SameAs (newExpression));
}
public void ReplacesTreePart_InSubQueries ()
{
var replacedNode = ExpressionHelper.CreateQueryable<Cook> ().Expression;
var replacementNode = Expression.Constant (null, typeof (Cook[]));
var subQueryMainFromClause = new MainFromClause ("c", typeof (Cook), replacedNode);
var subQuery = ExpressionHelper.CreateQueryModel (subQueryMainFromClause);
var tree = new SubQueryExpression (subQuery);
ReplacingExpressionVisitor.Replace (replacedNode, replacementNode, tree);
Assert.That (subQueryMainFromClause.FromExpression, Is.SameAs (replacementNode));
}
public void SetUp ()
{
// var query = from c in Customers select null
_mainFromClause = new MainFromClause ("c", typeof (DataContextTestClass.Customer), Expression.Constant (new DataContextTestClass.Customer[0]));
_selectClause = new SelectClause (Expression.Constant (null, typeof (DataContextTestClass.Customer)));
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_resolverStub = MockRepository.GenerateStub<IMappingResolver> ();
_resolverStub
.Stub (stub => stub.ResolveTableInfo (Arg<UnresolvedTableInfo>.Is.Anything, Arg<UniqueIdentifierGenerator>.Is.Anything))
.Return (new ResolvedSimpleTableInfo (typeof (DataContextTestClass.Customer), "CustomerTable", "t0"));
_resolverStub
.Stub (stub => stub.ResolveConstantExpression ((ConstantExpression) _selectClause.Selector))
.Return (_selectClause.Selector);
}
public void SetUp ()
{
_anonymousTypeCtor = typeof (AnonymousType<Cook, Cook>).GetConstructor (new[] { typeof (Cook), typeof (Cook) });
_fromClause1 = ExpressionHelper.CreateMainFromClause_Int ("s1", typeof (Cook), ExpressionHelper.CreateQueryable<Cook> ());
_querySource1 = new QuerySourceReferenceExpression (_fromClause1);
_fromClause2 = ExpressionHelper.CreateMainFromClause_Int ("s2", typeof (Cook), ExpressionHelper.CreateQueryable<Cook> ());
_querySource2 = new QuerySourceReferenceExpression (_fromClause2);
_itemExpression = Expression.New (
_anonymousTypeCtor,
new Expression[] { _querySource1, _querySource2 },
new MemberInfo[] { typeof (AnonymousType<Cook, Cook>).GetProperty ("a"), typeof (AnonymousType<Cook, Cook>).GetProperty ("b") });
}
public void SetUp ()
{
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_defaultStage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_mainFromClause = ExpressionHelper.CreateMainFromClause<Cook>();
_selectClause = ExpressionHelper.CreateSelectClause (_mainFromClause);
_orderByClause = ExpressionHelper.CreateOrderByClause();
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
_visitor = new TestableSqlPreparationQueryModelVisitor (_context, _stageMock);
_visitorPartialMock = MockRepository.GeneratePartialMock<TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
}
/// <summary>
/// Initializes a new instance of <see cref="QueryModel"/>
/// </summary>
/// <param name="mainFromClause">The <see cref="Clauses.MainFromClause"/> of the query. This is the starting point of the query, generating items
/// that are filtered and projected by the query.</param>
/// <param name="selectClause">The <see cref="SelectClause"/> of the query. This is the end point of
/// the query, it defines what is actually returned for each of the items coming from the <see cref="MainFromClause"/> and passing the
/// <see cref="BodyClauses"/>. After it, only the <see cref="ResultOperators"/> modify the result of the query.</param>
public QueryModel (MainFromClause mainFromClause, SelectClause selectClause)
{
ArgumentUtility.CheckNotNull ("mainFromClause", mainFromClause);
ArgumentUtility.CheckNotNull ("selectClause", selectClause);
_uniqueIdentifierGenerator = new UniqueIdentifierGenerator();
MainFromClause = mainFromClause;
SelectClause = selectClause;
BodyClauses = new ObservableCollection<IBodyClause>();
BodyClauses.CollectionChanged += BodyClauses_CollectionChanged;
ResultOperators = new ObservableCollection<ResultOperatorBase>();
ResultOperators.CollectionChanged += ResultOperators_CollectionChanged;
}
public void CopyFromSource ()
{
ConstantExpression constantExpression = Expression.Constant (ExpressionHelper.CreateQueryable<Cook> ());
var fromClause = new MainFromClause ("s", typeof (Cook), constantExpression);
ConstantExpression newExpression = Expression.Constant (ExpressionHelper.CreateQueryable<Kitchen>());
var sourceStub = MockRepository.GenerateStub<IFromClause>();
sourceStub.Stub (_ => _.ItemName).Return ("newItemName");
sourceStub.Stub (_ => _.ItemType).Return (typeof (Kitchen));
sourceStub.Stub (_ => _.FromExpression).Return (newExpression);
fromClause.CopyFromSource (sourceStub);
Assert.That (fromClause.ItemName, Is.EqualTo ("newItemName"));
Assert.That (fromClause.ItemType, Is.SameAs (typeof (Kitchen)));
Assert.That (fromClause.FromExpression, Is.SameAs (newExpression));
}
