Esempio n. 1
0
        void PrepareFilterParameter()
        {
            if (IsFilter())
            {
                // Handle collection-filter compilation.
                // filter-implied FROM element is already converted by HqlFilterPreprocessor

                // Create a parameter specification for the collection filter...
                IType         collectionFilterKeyType      = _sessionFactoryHelper.RequireQueryableCollection(_collectionFilterRole).KeyType;
                ParameterNode collectionFilterKeyParameter = (ParameterNode)adaptor.Create(PARAM, "?");
                CollectionFilterKeyParameterSpecification collectionFilterKeyParameterSpec = new CollectionFilterKeyParameterSpecification(
                    _collectionFilterRole, collectionFilterKeyType, _positionalParameterCount++
                    );
                collectionFilterKeyParameter.HqlParameterSpecification = collectionFilterKeyParameterSpec;
                _parameters.Add(collectionFilterKeyParameterSpec);
            }
        }
Esempio n. 2
0
        void PrepareFromClauseInputTree(IASTNode fromClauseInput, ITreeNodeStream input)
        {
            if (IsFilter())
            {
                // Handle collection-fiter compilation.
                // IMPORTANT NOTE: This is modifying the INPUT (HQL) tree, not the output tree!
                IQueryableCollection persister = _sessionFactoryHelper.GetCollectionPersister(_collectionFilterRole);
                IType collectionElementType    = persister.ElementType;
                if (!collectionElementType.IsEntityType)
                {
                    throw new QueryException("collection of values in filter: this");
                }

                string collectionElementEntityName = persister.ElementPersister.EntityName;

                IASTNode fromElement = (IASTNode)adaptor.Create(FILTER_ENTITY, collectionElementEntityName);
                IASTNode alias       = (IASTNode)adaptor.Create(ALIAS, "this");

                ((HqlSqlWalkerTreeNodeStream)input).InsertChild(fromClauseInput, fromElement);
                ((HqlSqlWalkerTreeNodeStream)input).InsertChild(fromClauseInput, alias);

//				fromClauseInput.AddChild(fromElement);
//				fromClauseInput.AddChild(alias);

                // Show the modified AST.
                if (log.IsDebugEnabled)
                {
                    log.Debug("prepareFromClauseInputTree() : Filter - Added 'this' as a from element...");
                }

                // Create a parameter specification for the collection filter...
                IType         collectionFilterKeyType      = _sessionFactoryHelper.RequireQueryableCollection(_collectionFilterRole).KeyType;
                ParameterNode collectionFilterKeyParameter = (ParameterNode)adaptor.Create(PARAM, "?");
                CollectionFilterKeyParameterSpecification collectionFilterKeyParameterSpec = new CollectionFilterKeyParameterSpecification(
                    _collectionFilterRole, collectionFilterKeyType, _positionalParameterCount++
                    );
                collectionFilterKeyParameter.HqlParameterSpecification = collectionFilterKeyParameterSpec;
                _parameters.Add(collectionFilterKeyParameterSpec);
            }
        }
Esempio n. 3
0
        public void AddWhereFragment(
            JoinFragment joinFragment,
            SqlString whereFragment,
            QueryNode query,
            FromElement fromElement,
            HqlSqlWalker hqlSqlWalker)
        {
            if (whereFragment == null)
            {
                return;
            }

            if (!fromElement.UseWhereFragment && !joinFragment.HasThetaJoins)
            {
                return;
            }

            whereFragment = whereFragment.Trim();
            if (StringHelper.IsEmpty(whereFragment.ToString()))
            {
                return;
            }

            // Forcefully remove leading ands from where fragments; the grammar will
            // handle adding them
            if (whereFragment.StartsWithCaseInsensitive("and"))
            {
                whereFragment = whereFragment.Substring(4);
            }

            log.Debug("Using unprocessed WHERE-fragment [" + whereFragment + "]");

            SqlFragment fragment = (SqlFragment)Create(HqlSqlWalker.SQL_TOKEN, whereFragment.ToString());

            fragment.SetJoinFragment(joinFragment);
            fragment.FromElement = fromElement;

            if (fromElement.IndexCollectionSelectorParamSpec != null)
            {
                fragment.AddEmbeddedParameter(fromElement.IndexCollectionSelectorParamSpec);
                fromElement.IndexCollectionSelectorParamSpec = null;
            }

            if (hqlSqlWalker.IsFilter())
            {
                //if (whereFragment.IndexOfCaseInsensitive("?") >= 0)
                if (whereFragment.ToString().IndexOf("?") >= 0)
                {
                    IType collectionFilterKeyType = hqlSqlWalker.SessionFactoryHelper
                                                    .RequireQueryableCollection(hqlSqlWalker.CollectionFilterRole)
                                                    .KeyType;
                    CollectionFilterKeyParameterSpecification paramSpec = new CollectionFilterKeyParameterSpecification(
                        hqlSqlWalker.CollectionFilterRole,
                        collectionFilterKeyType,
                        0
                        );
                    fragment.AddEmbeddedParameter(paramSpec);
                }
            }

            JoinProcessor.ProcessDynamicFilterParameters(
                whereFragment,
                fragment,
                hqlSqlWalker
                );

            log.Debug("Using processed WHERE-fragment [" + fragment.Text + "]");

            // Filter conditions need to be inserted before the HQL where condition and the
            // theta join node.  This is because org.hibernate.loader.Loader binds the filter parameters first,
            // then it binds all the HQL query parameters, see org.hibernate.loader.Loader.processFilterParameters().
            if (fragment.FromElement.IsFilter || fragment.HasFilterCondition)
            {
                if (_filters == null)
                {
                    // Find or create the WHERE clause
                    IASTNode where = (IASTNode)query.WhereClause;
                    // Create a new FILTERS node as a parent of all filters
                    _filters = Create(HqlSqlWalker.FILTERS, "{filter conditions}");
                    // Put the FILTERS node before the HQL condition and theta joins
                    where.InsertChild(0, _filters);
                }

                // add the current fragment to the FILTERS node
                _filters.AddChild(fragment);
            }
            else
            {
                if (_thetaJoins == null)
                {
                    // Find or create the WHERE clause
                    IASTNode where = (IASTNode)query.WhereClause;

                    // Create a new THETA_JOINS node as a parent of all filters
                    _thetaJoins = Create(HqlSqlWalker.THETA_JOINS, "{theta joins}");

                    // Put the THETA_JOINS node before the HQL condition, after the filters.
                    if (_filters == null)
                    {
                        where.InsertChild(0, _thetaJoins);
                    }
                    else
                    {
                        _filters.AddSibling(_thetaJoins);
                    }
                }

                // add the current fragment to the THETA_JOINS node
                _thetaJoins.AddChild(fragment);
            }
        }