public override IList GetResultList(IList results, IResultTransformer resultTransformer) { // meant to handle dynamic instantiation queries... HolderInstantiator holderInstantiator = HolderInstantiator.GetHolderInstantiator(_selectNewTransformer, resultTransformer, _queryReturnAliases); if (holderInstantiator.IsRequired) { for (int i = 0; i < results.Count; i++) { var row = (Object[])results[i]; Object result = holderInstantiator.Instantiate(row); results[i] = result; } if (!HasSelectNew && resultTransformer != null) { return(resultTransformer.TransformList(results)); } else { return(results); } } else { return(results); } }
internal async Task <IEnumerable> GetEnumerableAsync(QueryParameters queryParameters, IEventSource session, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); CheckQuery(queryParameters); bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled; var stopWath = new Stopwatch(); if (statsEnabled) { stopWath.Start(); } var cmd = await(PrepareQueryCommandAsync(queryParameters, false, session, cancellationToken)).ConfigureAwait(false); // This DbDataReader is disposed of in EnumerableImpl.Dispose var rs = await(GetResultSetAsync(cmd, queryParameters.HasAutoDiscoverScalarTypes, false, queryParameters.RowSelection, session, cancellationToken)).ConfigureAwait(false); HolderInstantiator hi = HolderInstantiator.GetHolderInstantiator(_selectNewTransformer, queryParameters.ResultTransformer, _queryReturnAliases); IEnumerable result = new EnumerableImpl(rs, cmd, session, queryParameters.IsReadOnly(session), _queryTranslator.ReturnTypes, _queryTranslator.GetColumnNames(), queryParameters.RowSelection, hi); if (statsEnabled) { stopWath.Stop(); session.Factory.StatisticsImplementor.QueryExecuted("HQL: " + _queryTranslator.QueryString, 0, stopWath.Elapsed); // NH: Different behavior (H3.2 use QueryLoader in AST parser) we need statistic for orginal query too. // probably we have a bug some where else for statistic RowCount session.Factory.StatisticsImplementor.QueryExecuted(QueryIdentifier, 0, stopWath.Elapsed); } return(result); }
protected virtual IList GetResultList(IList results) { for (int i = 0, len = results.Count; i < len; ++i) { IList subList = (IList)results[i]; QueryParameters parameter = Parameters[i]; HolderInstantiator holderInstantiator = GetHolderInstantiator(parameter); if (holderInstantiator.IsRequired) { for (int j = 0; j < subList.Count; j++) { object[] row = subList[j] as object[] ?? new[] { subList[j] }; subList[j] = holderInstantiator.Instantiate(row); } IResultTransformer transformer = holderInstantiator.ResultTransformer; if (transformer != null) { results[i] = transformer.TransformList(subList); } } } return(results); }
internal IEnumerable GetEnumerable(QueryParameters queryParameters, IEventSource session) { CheckQuery(queryParameters); bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled; var stopWath = new Stopwatch(); if (statsEnabled) { stopWath.Start(); } var cmd = PrepareQueryCommand(queryParameters, false, session); // This DbDataReader is disposed of in EnumerableImpl.Dispose var rs = GetResultSet(cmd, queryParameters, session, null); HolderInstantiator hi = HolderInstantiator.GetHolderInstantiator(_selectNewTransformer, queryParameters.ResultTransformer, _queryReturnAliases); IEnumerable result = new EnumerableImpl(rs, cmd, session, queryParameters.IsReadOnly(session), _queryTranslator.ReturnTypes, _queryTranslator.GetColumnNames(), queryParameters.RowSelection, hi); if (statsEnabled) { stopWath.Stop(); session.Factory.StatisticsImplementor.QueryExecuted("HQL: " + _queryTranslator.QueryString, 0, stopWath.Elapsed); // NH: Different behavior (H3.2 use QueryLoader in AST parser) we need statistic for orginal query too. // probably we have a bug some where else for statistic RowCount session.Factory.StatisticsImplementor.QueryExecuted(QueryIdentifier, 0, stopWath.Elapsed); } return(result); }
public EnumerableImpl(DbDataReader reader, DbCommand cmd, IEventSource session, bool readOnly, IType[] types, string[][] columnNames, RowSelection selection, HolderInstantiator holderInstantiator) : this(reader, cmd, session, readOnly, types, columnNames, selection, holderInstantiator.ResultTransformer, holderInstantiator.QueryReturnAliases) { }
private IList GetTransformedResults(IList source, HolderInstantiator holderInstantiator) { if (!holderInstantiator.IsRequired) { return(source); } for (int j = 0; j < source.Count; j++) { object[] row = source[j] as object[] ?? new[] { source[j] }; source[j] = holderInstantiator.Instantiate(row); } return(holderInstantiator.ResultTransformer.TransformList(source)); }
/// <summary> /// Create an <see cref="IEnumerable"/> wrapper over an <see cref="IDataReader"/>. /// </summary> /// <param name="reader">The <see cref="IDataReader"/> to enumerate over.</param> /// <param name="cmd">The <see cref="IDbCommand"/> used to create the <see cref="IDataReader"/>.</param> /// <param name="sess">The <see cref="ISession"/> to use to load objects.</param> /// <param name="types">The <see cref="IType"/>s contained in the <see cref="IDataReader"/>.</param> /// <param name="columnNames">The names of the columns in the <see cref="IDataReader"/>.</param> /// <param name="selection">The <see cref="RowSelection"/> that should be applied to the <see cref="IDataReader"/>.</param> /// <param name="holderInstantiator">Instantiator of the result holder (used for "select new SomeClass(...)" queries).</param> /// <remarks> /// The <see cref="IDataReader"/> should already be positioned on the first record in <see cref="RowSelection"/>. /// </remarks> public EnumerableImpl(IDataReader reader, IDbCommand cmd, ISessionImplementor sess, IType[] types, string[][] columnNames, RowSelection selection, HolderInstantiator holderInstantiator) { _reader = reader; _cmd = cmd; _sess = sess; _types = types; _names = columnNames; _selection = selection; _holderInstantiator = holderInstantiator; _single = _types.Length == 1; }
/// <summary> /// Create an <see cref="IEnumerable"/> wrapper over an <see cref="DbDataReader"/>. /// </summary> /// <param name="reader">The <see cref="DbDataReader"/> to enumerate over.</param> /// <param name="cmd">The <see cref="DbCommand"/> used to create the <see cref="DbDataReader"/>.</param> /// <param name="session">The <see cref="ISession"/> to use to load objects.</param> /// <param name="readOnly"></param> /// <param name="types">The <see cref="IType"/>s contained in the <see cref="DbDataReader"/>.</param> /// <param name="columnNames">The names of the columns in the <see cref="DbDataReader"/>.</param> /// <param name="selection">The <see cref="RowSelection"/> that should be applied to the <see cref="DbDataReader"/>.</param> /// <param name="holderInstantiator">Instantiator of the result holder (used for "select new SomeClass(...)" queries).</param> /// <remarks> /// The <see cref="DbDataReader"/> should already be positioned on the first record in <see cref="RowSelection"/>. /// </remarks> public EnumerableImpl(DbDataReader reader, DbCommand cmd, IEventSource session, bool readOnly, IType[] types, string[][] columnNames, RowSelection selection, HolderInstantiator holderInstantiator) { _reader = reader; _cmd = cmd; _session = session; _readOnly = readOnly; _types = types; _names = columnNames; _selection = selection; _holderInstantiator = holderInstantiator; _single = _types.Length == 1; }
public override IList GetResultList(IList results, IResultTransformer resultTransformer) { // meant to handle dynamic instantiation queries...(Copy from QueryLoader) HolderInstantiator holderInstantiator = HolderInstantiator.GetHolderInstantiator(null, resultTransformer, ReturnAliasesForTransformer); if (holderInstantiator.IsRequired) { for (int i = 0; i < results.Count; i++) { object[] row = (object[])results[i]; object result = holderInstantiator.Instantiate(row); results[i] = result; } return(resultTransformer.TransformList(results)); } else { return(results); } }
protected override IResultTransformer ResolveResultTransformer(IResultTransformer resultTransformer) { return(HolderInstantiator.ResolveResultTransformer(null, resultTransformer)); }
private void Initialize(SelectClause selectClause) { IList <FromElement> fromElementList = selectClause.FromElementsForLoad; _hasScalars = selectClause.IsScalarSelect; _scalarColumnNames = selectClause.ColumnNames; //sqlResultTypes = selectClause.getSqlResultTypes(); _queryReturnTypes = selectClause.QueryReturnTypes; _selectNewTransformer = HolderInstantiator.CreateSelectNewTransformer(selectClause.Constructor, selectClause.IsMap, selectClause.IsList); _queryReturnAliases = selectClause.QueryReturnAliases; IList <FromElement> collectionFromElements = selectClause.CollectionFromElements; if (collectionFromElements != null && collectionFromElements.Count != 0) { int length = collectionFromElements.Count; _collectionPersisters = new IQueryableCollection[length]; _collectionOwners = new int[length]; _collectionSuffixes = new string[length]; for (int i = 0; i < length; i++) { FromElement collectionFromElement = collectionFromElements[i]; _collectionPersisters[i] = collectionFromElement.QueryableCollection; _collectionOwners[i] = fromElementList.IndexOf(collectionFromElement.Origin); // collectionSuffixes[i] = collectionFromElement.getColumnAliasSuffix(); // collectionSuffixes[i] = Integer.toString( i ) + "_"; _collectionSuffixes[i] = collectionFromElement.CollectionSuffix; } } int size = fromElementList.Count; _entityPersisters = new IQueryable[size]; _entityEagerPropertyFetches = new bool[size]; _entityAliases = new String[size]; _sqlAliases = new String[size]; _sqlAliasSuffixes = new String[size]; _includeInSelect = new bool[size]; _owners = new int[size]; _ownerAssociationTypes = new EntityType[size]; for (int i = 0; i < size; i++) { FromElement element = fromElementList[i]; _entityPersisters[i] = (IQueryable)element.EntityPersister; if (_entityPersisters[i] == null) { throw new InvalidOperationException("No entity persister for " + element); } _entityEagerPropertyFetches[i] = element.IsAllPropertyFetch; _sqlAliases[i] = element.TableAlias; _entityAliases[i] = element.ClassAlias; _sqlAliasByEntityAlias.Add(_entityAliases[i], _sqlAliases[i]); // TODO should we just collect these like with the collections above? _sqlAliasSuffixes[i] = (size == 1) ? "" : i + "_"; // sqlAliasSuffixes[i] = element.getColumnAliasSuffix(); _includeInSelect[i] = !element.IsFetch; if (_includeInSelect[i]) { _selectLength++; } _owners[i] = -1; //by default if (element.IsFetch) { if (element.IsCollectionJoin || element.QueryableCollection != null) { // This is now handled earlier in this method. } else if (element.DataType.IsEntityType) { var entityType = (EntityType)element.DataType; if (entityType.IsOneToOne) { _owners[i] = fromElementList.IndexOf(element.Origin); } _ownerAssociationTypes[i] = entityType; } } } //NONE, because its the requested lock mode, not the actual! _defaultLockModes = ArrayHelper.Fill(LockMode.None, size); }