private void InitStatementString(IOuterJoinLoadable elementPersister, string alias, int batchSize, SqlString subquery)
        {
            int joins = CountEntityPersisters(associations);

            Suffixes = BasicLoader.GenerateSuffixes(joins + 1);

            int collectionJoins = CountCollectionPersisters(associations) + 1;

            CollectionSuffixes = BasicLoader.GenerateSuffixes(joins + 1, collectionJoins);

            SqlStringBuilder whereString = WhereString(oneToManyPersister.GenerateTableAliasForKeyColumns(alias), oneToManyPersister.KeyColumnNames, subquery, batchSize);
            string           filter      = oneToManyPersister.FilterFragment(alias, EnabledFilters);

            whereString.Insert(0, StringHelper.MoveAndToBeginning(filter));

            JoinFragment     ojf    = MergeOuterJoins(associations);
            SqlSelectBuilder select =
                new SqlSelectBuilder(Factory).SetSelectClause(
                    oneToManyPersister.SelectFragment(null, null, alias, Suffixes[joins], CollectionSuffixes[0], true)
                    + SelectString(associations)).SetFromClause(elementPersister.FromTableFragment(alias)
                                                                + oneToManyPersister.FromJoinFragment(alias, true, true)).SetWhereClause(
                    whereString.ToSqlString()).SetOuterJoins(ojf.ToFromFragmentString,
                                                             ojf.ToWhereFragmentString
                                                             + elementPersister.WhereJoinFragment(alias, true, true));

            select.SetOrderByClause(OrderBy(associations, oneToManyPersister.GetSQLOrderByString(alias)));

            if (Factory.Settings.IsCommentsEnabled)
            {
                select.SetComment("load one-to-many " + oneToManyPersister.Role);
            }

            SqlString = select.ToSqlString();
        }
        private void SetFields(ICriteriaQuery criteriaQuery)
        {
            //Persister is required, so let's use it as "initialized marker"
            if (Persister != null)
            {
                return;
            }

            if (!(criteriaQuery is ISupportEntityProjectionCriteriaQuery entityProjectionQuery))
            {
                throw new ArgumentException(
                          $"Projecting to entities requires a '{criteriaQuery.GetType().FullName}' type to implement " +
                          $"{nameof(ISupportEntityProjectionCriteriaQuery)} interface.",
                          nameof(criteriaQuery));
            }

            var criteria = entityProjectionQuery.RootCriteria;

            if (!Lazy)
            {
                entityProjectionQuery.RegisterEntityProjection(this);
            }

            if (_entityType == null)
            {
                _entityType = criteria.GetRootEntityTypeIfAvailable();
            }

            if (_entityAlias == null)
            {
                _entityAlias = criteria.Alias;
            }

            Persister = criteriaQuery.Factory.GetEntityPersister(_entityType.FullName) as IQueryable;
            if (Persister == null)
            {
                throw new HibernateException($"Projecting to entities requires a '{typeof(IQueryable).FullName}' persister, '{_entityType.FullName}' does not have one.");
            }

            ICriteria subcriteria = criteria.GetCriteriaByAlias(_entityAlias);

            if (subcriteria == null)
            {
                throw new HibernateException($"Criteria\\QueryOver alias '{_entityAlias}' for entity projection is not found.");
            }

            TableAlias = criteriaQuery.GetSQLAlias(
                subcriteria,
                Persister.IdentifierPropertyName ?? string.Empty);

            ColumnAliasSuffix = BasicLoader.GenerateSuffix(criteriaQuery.GetIndexForAlias());

            _identifierColumnAliases = Persister.GetIdentifierAliases(ColumnAliasSuffix);

            _types = new IType[] { TypeFactory.ManyToOne(Persister.EntityName, true) };
        }
示例#3
0
        private void InitStatementString(string alias, int batchSize, SqlString subquery)
        {
            int joins           = CountEntityPersisters(associations);
            int collectionJoins = CountCollectionPersisters(associations) + 1;

            Suffixes           = BasicLoader.GenerateSuffixes(joins);
            CollectionSuffixes = BasicLoader.GenerateSuffixes(joins, collectionJoins);

            SqlStringBuilder whereString = WhereString(alias, collectionPersister.KeyColumnNames, subquery, batchSize);

            string manyToManyOrderBy = string.Empty;
            string filter            = collectionPersister.FilterFragment(alias, EnabledFilters);

            if (collectionPersister.IsManyToMany)
            {
                // from the collection of associations, locate OJA for the
                // ManyToOne corresponding to this persister to fully
                // define the many-to-many; we need that OJA so that we can
                // use its alias here
                // TODO : is there a better way here?
                IAssociationType associationType = (IAssociationType)collectionPersister.ElementType;
                foreach (OuterJoinableAssociation oja in associations)
                {
                    if (oja.JoinableType == associationType)
                    {
                        // we found it
                        filter            += collectionPersister.GetManyToManyFilterFragment(oja.RHSAlias, EnabledFilters);
                        manyToManyOrderBy += collectionPersister.GetManyToManyOrderByString(oja.RHSAlias);
                    }
                }
            }

            whereString.Insert(0, StringHelper.MoveAndToBeginning(filter));
            JoinFragment ojf = MergeOuterJoins(associations);

            SqlSelectBuilder select =
                new SqlSelectBuilder(Factory)
                .SetSelectClause(collectionPersister.SelectFragment(alias, CollectionSuffixes[0])
                                 + SelectString(associations))
                .SetFromClause(collectionPersister.TableName, alias)
                .SetWhereClause(whereString.ToSqlString())
                .SetOuterJoins(ojf.ToFromFragmentString, ojf.ToWhereFragmentString);

            select.SetOrderByClause(OrderBy(associations, MergeOrderings(collectionPersister.GetSQLOrderByString(alias), manyToManyOrderBy)));

            if (Factory.Settings.IsCommentsEnabled)
            {
                select.SetComment("load collection " + collectionPersister.Role);
            }

            SqlString = select.ToSqlString();
        }
 private string GenerateEntitySuffix()
 {
     return(BasicLoader.GenerateSuffixes(entitySuffixSeed++, 1)[0]);
 }
示例#5
0
 void Awake()
 {
     base.Awake();
     loader         = FindObjectOfType <BasicLoader>();
     loader.Loaded += OnLoad;
 }