Пример #1
0
 /// <summary>Constrctor with subject passed.</summary>
 /// <param name="subject">Subject of this query.</param>
 internal Query(Identifier subject)
     : base()
 {
     _queryForm = QueryForms.Select;
     ObservableCollection<Prefix> prefixes = new ObservableCollection<Prefix>();
     prefixes.CollectionChanged += OnCollectionChanged;
     _prefixes = prefixes;
     ObservableCollection<ISelectableQueryComponent> select = new ObservableCollection<ISelectableQueryComponent>();
     select.CollectionChanged += OnCollectionChanged;
     _select = select;
     ObservableCollection<QueryElement> elements = new ObservableCollection<QueryElement>();
     elements.CollectionChanged += OnCollectionChanged;
     _elements = elements;
     _variableNamingStrategy = new UniqueVariableNamingStrategy(this);
     _variableNamingConvention = new CamelCaseVariableNamingConvention();
     if ((_subject = subject) != null)
     {
         _subject.OwnerQuery = this;
     }
 }
 /// <summary>Visit a identifier.</summary>
 /// <param name="identifier">Identifier to be visited.</param>
 protected override void VisitIdentifier(Identifier identifier)
 {
     _commandText.AppendFormat("?{0}", (_variableNameOverride.ContainsKey(identifier) ? _variableNameOverride[identifier] : identifier.Name));
 }
 /// <summary>Default constructor with aboutness and its source passed.</summary>
 /// <param name="about">Specifies an entity identifier given accesor uses.</param>
 /// <param name="sourceExpression">Source of this entity accessor.</param>
 /// <param name="entityAccessor">Strong entity accessor.</param>
 internal UnspecifiedEntityAccessor(Identifier about, Remotion.Linq.Clauses.FromClauseBase sourceExpression, StrongEntityAccessor entityAccessor)
     : base(about, sourceExpression)
 {
     _entityAccessor = entityAccessor;
 }
 /// <summary>Default constructor with aboutness assuming that a source is a variable.</summary>
 /// <param name="about">Points to the primary topic of given entity accessor.</param>
 /// <param name="entityAccessor">Strong entity accessor.</param>
 internal UnspecifiedEntityAccessor(Identifier about, StrongEntityAccessor entityAccessor)
     : base(about)
 {
     _entityAccessor = entityAccessor;
 }
Пример #5
0
 /// <summary>Constructor with subject and variable naming strategy passed.</summary>
 /// <param name="subject">Subject of this query.</param>
 /// <param name="variableNamingStrategy">Varialbe naming strategy.</param>
 internal Query(Identifier subject, IVariableNamingStrategy variableNamingStrategy)
     : this(subject)
 {
     _variableNamingStrategy = variableNamingStrategy;
     _variableNamingConvention = new CamelCaseVariableNamingConvention();
 }
 /// <summary>Visit a identifier.</summary>
 /// <param name="identifier">Identifier to be visited.</param>
 protected abstract void VisitIdentifier(Identifier identifier);
Пример #7
0
 /// <summary>Creates a new blank query that can act as a sub query for this instance.</summary>
 /// <param name="subject">Primary subject of the resulting query.</param>
 /// <remarks>This method doesn't add the resulting query as a sub query of this instance.</remarks>
 /// <returns>Query that can act as a sub query for this instance.</returns>
 public Query CreateSubQuery(Identifier subject)
 {
     Query result = new Query(subject, _variableNamingStrategy);
     result.OwnerQuery = this;
     return result;
 }
Пример #8
0
 /// <summary>Base constructor with component and alias passed.</summary>
 /// <param name="component">Component to be aliased.</param>
 /// <param name="name">Alias.</param>
 public Alias(IQueryComponent component, Identifier name)
     : base()
 {
     _component = component;
     _name = name;
 }
        /// <summary>Visits a select clause.</summary>
        /// <param name="selectClause">Select clause to be visited.</param>
        /// <param name="queryModel">Query model containing given select clause.</param>
        public override void VisitSelectClause(SelectClause selectClause, Remotion.Linq.QueryModel queryModel)
        {
            QuerySourceReferenceExpression querySource = FindQuerySource(selectClause.Selector);
            _visitor.VisitExpression(selectClause.Selector);
            QueryComponent component = _visitor.RetrieveComponent();
            _query = _visitor.Query;
            _mainFromComponent = _query.FindAllComponents<StrongEntityAccessor>().Where(item => item.SourceExpression == querySource.ReferencedQuerySource).First();
            if (_query.Subject == null)
            {
                _query.Subject = _mainFromComponent.About;
                UnboundConstrain genericConstrain = new UnboundConstrain(new Identifier("s"), new Identifier("p"), new Identifier("o"), _mainFromComponent.SourceExpression.FromExpression);
                _mainFromComponent.Elements.Insert(0, genericConstrain);
                _query.Select.Add(genericConstrain);
            }

            _subject = _query.Subject;
            queryModel.MainFromClause.Accept(this, queryModel);
            _query.Select.Add(_mainFromComponent);
            VisitBodyClauses(queryModel.BodyClauses, queryModel);
            VisitResultOperators(queryModel.ResultOperators, queryModel);
            OverrideSelector(component, selectClause.Selector);
        }
 internal EntityQueryModelVisitor(Query query, IEntityContext context)
 {
     _entityContext = context;
     _visitor = new EntityQueryVisitor(_query = (Query)(_result = query), _entityContext);
     _subject = null;
 }
        private void OverrideEntitySelector(Identifier identifier)
        {
            UnboundConstrain genericConstrain = new UnboundConstrain(identifier, new Identifier(identifier.Name + "P"), new Identifier(identifier.Name + "O"), _mainFromComponent.SourceExpression.FromExpression);
            _mainFromComponent.Elements.Add(genericConstrain);
            _query.Select.Clear();
            _query.Select.Add(genericConstrain);
            UnspecifiedEntityAccessor entityAccessor = new UnspecifiedEntityAccessor(identifier, _mainFromComponent);
            entityAccessor.Elements.Add(genericConstrain);
            _query.Select.Add(entityAccessor);
            int indexOf = -1;
            if ((indexOf = _query.Elements.IndexOf(_mainFromComponent)) != -1)
            {
                _query.Elements.RemoveAt(indexOf);
                _query.Elements.Insert(indexOf, entityAccessor);
            }
            else
            {
                _query.Elements.Add(entityAccessor);
            }

            if (_mainFromComponent.Elements[0] is UnboundConstrain)
            {
                _mainFromComponent.Elements.RemoveAt(0);
            }
        }
        /// <summary>Visits an additional from clause.</summary>
        /// <param name="fromClause">From clause to be visited.</param>
        /// <param name="queryModel">Query model containing given from clause.</param>
        /// <param name="index">Index of the where clause in the query model.</param>
        public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
        {
            VisitQuerableFromClause(fromClause, queryModel, index);
            StrongEntityAccessor entityAccessor = (fromClause.FromExpression is System.Linq.Expressions.ConstantExpression ? null : _visitor.GetEntityAccessor(fromClause));
            if (entityAccessor != null)
            {
                if ((entityAccessor.OwnerQuery == null) && (!_query.Elements.Contains(entityAccessor)))
                {
                    _query.Elements.Add(entityAccessor);
                }
            }
            else
            {
                NonEntityQueryModelVisitor modelVisitor = new NonEntityQueryModelVisitor(_visitor);
                modelVisitor.VisitAdditionalFromClause(fromClause, queryModel, index);
                if (modelVisitor.From is Identifier)
                {
                    _subject = (Identifier)modelVisitor.From;
                }
                else if (modelVisitor.From is IExpression)
                {
                    _auxFromComponent = (IExpression)modelVisitor.From;
                }
            }

            base.VisitAdditionalFromClause(fromClause, queryModel, index);
        }