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