public Session(IResultTransformer resultTransformer, IDao<Bank> bankDao, IDao<LogModel> logDao, IDao<Customer> customerDao) : base(resultTransformer) { this.bankDao = bankDao; this.logDao = logDao; this.customerDao = customerDao; }
public void Init(ISession session, ISearchFactoryImplementor searchFactoryImplementor, IResultTransformer transformer, string[] aliases) { Init(session, searchFactoryImplementor); this.transformer = transformer; this.aliases = aliases; }
public Session(IResultTransformer resultTransformer, IDao<Bank> bankDao, IDao<LogModel> logDao, ISessionProviderFactory<NHibernateStatelessSession> sessionProviderFactory) : base(resultTransformer) { this.bankDao = bankDao; this.logDao = logDao; logSessionProvider = sessionProviderFactory.Build("LOG"); }
public static void SetResultTransformerIfNotNull(this ICriteria criteria, IResultTransformer transformer) { if (transformer != null) criteria.SetResultTransformer(transformer); else criteria.SetResultTransformer(new RootEntityResultTransformer()); }
public static HolderInstantiator GetHolderInstantiator(IResultTransformer selectNewTransformer, IResultTransformer customTransformer, string[] queryReturnAliases) { return new HolderInstantiator(ResolveResultTransformer(selectNewTransformer, customTransformer), queryReturnAliases); }
//this.Add("LinqProvider - LinQ Equals ", () => from model in accountDao.Query() where model.No == 0L select model); //this.Add("LinqProvider - LinQ Oracle Left Join", () => // from model in accountDao.Query() // from customer in bankDao.Query() // where model.Customer.Id == customer.Id.OraclePlus() // select model); public LinqProvider(IResultTransformer resultTransformer, IDao<Customer> customerDao, IDao<Account> accountDao) : base(resultTransformer) { this.customerDao = customerDao; this.accountDao = accountDao; inList = new[] {"Onur", "Oğuz"}; }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, IDataReader rs, ISessionImplementor session) { object[] result; string[] aliases; if (translator.HasProjection) { IType[] types = translator.ProjectedTypes; result = new object[types.Length]; string[] columnAliases = translator.ProjectedColumnAliases; for (int i = 0; i < result.Length; i++) { result[i] = types[i].NullSafeGet(rs, columnAliases[i], session, null); } aliases = translator.ProjectedAliases; } else { result = row; aliases = userAliases; } return translator.RootCriteria.ResultTransformer.TransformTuple(result, aliases); }
public HolderInstantiator( IResultTransformer transformer, string[] queryReturnAliases ) { this.transformer = transformer; this.queryReturnAliases = queryReturnAliases; }
public AutoMap(IResultTransformer resultTransformer, IDao<Bank> bankDao, IDao<Account> accountDao, IDao<Customer> customerDao, IMapper mapper) : base(resultTransformer) { this.bankDao = bankDao; this.accountDao = accountDao; this.customerDao = customerDao; this.mapper = mapper; }
private static IList<CustomerOrderHistory> GetCustomerOrderHistory(string customerId, IResultTransformer transformer) { var query = UnitOfWork.CurrentSession.GetNamedQuery("NSoft.NFramework.Data.NHibernateEx.Domain.Northwind.GetCustomerOrderHistory", new NHParameter("CustomerId", customerId, TypeFactory.GetStringType(255))); query.SetResultTransformer(transformer); return query.List<CustomerOrderHistory>(); }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool cacheable, string cacheRegion, string comment, bool isLookupByNaturalKey, IResultTransformer transformer) : this( positionalParameterTypes, positionalParameterValues, null, lockModes, rowSelection, false, cacheable, cacheRegion, comment, null, transformer) { NaturalKeyLookup = isLookupByNaturalKey; }
public QueryParameters(IDictionary<string, TypedValue> namedParameters, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, bool isLookupByNaturalKey, IResultTransformer transformer) : this( ArrayHelper.EmptyTypeArray, ArrayHelper.EmptyObjectArray, namedParameters, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, null, transformer) { // used by CriteriaTranslator NaturalKeyLookup = isLookupByNaturalKey; }
static CriteriaSpecification() { AliasToEntityMap = new AliasToEntityMapResultTransformer(); RootEntity = new RootEntityResultTransformer(); DistinctRootEntity = new DistinctRootEntityResultTransformer(); Projection = new PassThroughResultTransformer(); InnerJoin = JoinType.InnerJoin; FullJoin = JoinType.FullJoin; LeftJoin = JoinType.LeftOuterJoin; }
public static HolderInstantiator GetHolderInstantiator(IResultTransformer selectNewTransformer, IResultTransformer customTransformer, string[] queryReturnAliases) { //todo ÐÞ¸ÄÔ´Âë if (customTransformer != null) return new HolderInstantiator(customTransformer, queryReturnAliases); else return new HolderInstantiator(selectNewTransformer, queryReturnAliases); }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, TypedValue> namedParameters, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, object[] collectionKeys, object optionalObject, string optionalEntityName, object optionalId, IResultTransformer transformer) : this( positionalParameterTypes, positionalParameterValues, namedParameters, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, collectionKeys, transformer) { OptionalEntityName = optionalEntityName; OptionalId = optionalId; OptionalObject = optionalObject; }
public static HolderInstantiator CreateClassicHolderInstantiator(ConstructorInfo constructor, IResultTransformer transformer) { if (constructor != null) { return new HolderInstantiator(new AliasToBeanConstructorResultTransformer(constructor), null); } else { return new HolderInstantiator(transformer, null); } }
public static HolderInstantiator GetHolderInstantiator(IResultTransformer selectNewTransformer, IResultTransformer customTransformer, string[] queryReturnAliases) { if (selectNewTransformer != null) { return new HolderInstantiator(selectNewTransformer, queryReturnAliases); } else { return new HolderInstantiator(customTransformer, queryReturnAliases); } }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, TypedValue> namedParameters, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, object[] collectionKeys, IResultTransformer transformer) { _positionalParameterTypes = positionalParameterTypes; _positionalParameterValues = positionalParameterValues; _namedParameters = namedParameters; _lockModes = lockModes; _rowSelection = rowSelection; _cacheable = cacheable; _cacheRegion = cacheRegion; _comment = comment; _collectionKeys = collectionKeys; _isReadOnlyInitialized = isReadOnlyInitialized; _readOnly = readOnly; _resultTransformer = transformer; }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary <string, TypedValue> namedParameters, IDictionary <string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, object[] collectionKeys, IResultTransformer transformer) { PositionalParameterTypes = positionalParameterTypes ?? new IType[0]; PositionalParameterValues = positionalParameterValues ?? new object[0]; NamedParameters = namedParameters ?? new Dictionary <string, TypedValue>(1); LockModes = lockModes; RowSelection = rowSelection; Cacheable = cacheable; CacheRegion = cacheRegion; Comment = comment; CollectionKeys = collectionKeys; IsReadOnlyInitialized = isReadOnlyInitialized; this.readOnly = readOnly; ResultTransformer = transformer; }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, TypedValue> namedParameters, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, object[] collectionKeys, IResultTransformer transformer) { PositionalParameterTypes = positionalParameterTypes ?? new IType[0]; PositionalParameterValues = positionalParameterValues ?? new IType[0]; NamedParameters = namedParameters ?? new Dictionary<string, TypedValue>(1); LockModes = lockModes; RowSelection = rowSelection; Cacheable = cacheable; CacheRegion = cacheRegion; Comment = comment; CollectionKeys = collectionKeys; IsReadOnlyInitialized = isReadOnlyInitialized; this.readOnly = readOnly; ResultTransformer = transformer; }
public ICriteria SetResultTransformer(IResultTransformer resultTransformer) { ICriteriaEvent criteriaEvent = new SetResultTransformerEvent(resultTransformer); foreach (IShard shard in shards) { if (shardToCriteriaMap[shard] != null) { shardToCriteriaMap[shard].SetResultTransformer(resultTransformer); } else { shardToEventListMap[shard].Add(criteriaEvent); } } return(this); }
public override IList GetResultList(IList results, IResultTransformer resultTransformer) { // meant to handle dynamic instantiation queries...(Copy from QueryLoader) var returnAliases = ReturnAliasesForTransformer; if (resultTransformer != null) { for (var i = 0; i < results.Count; i++) { var row = (object[])results[i]; results[i] = resultTransformer.TransformTuple(row, returnAliases); } return(resultTransformer.TransformList(results)); } return(results); }
/// <summary> /// Re-transforms, if necessary, a List of values previously /// transformed by this (or an equivalent) CacheableResultTransformer. /// Each element of the list is re-transformed in place (i.e, List /// elements are replaced with re-transformed values) and the original /// List is returned. If re-transformation is unnecessary, the original List is returned /// unchanged. /// </summary> /// <param name="transformedResults">Results that were previously transformed.</param> /// <param name="aliases">The aliases that correspond to the untransformed tuple.</param> /// <param name="transformer">The transformer for the re-transformation.</param> /// <param name="includeInTuple"></param> /// <returns>transformedResults, with each element re-transformed (if necessary).</returns> public IList RetransformResults(IList transformedResults, string[] aliases, IResultTransformer transformer, bool[] includeInTuple) { if (transformer == null) { throw new ArgumentNullException("transformer"); } if (!this.Equals(Create(transformer, aliases, includeInTuple))) { throw new InvalidOperationException( "this CacheableResultTransformer is inconsistent with specified arguments; cannot re-transform" ); } bool requiresRetransform = true; string[] aliasesToUse = aliases == null ? null : Index(aliases); if (transformer.Equals(_actualTransformer)) { requiresRetransform = false; } else if (transformer is ITupleSubsetResultTransformer) { requiresRetransform = !((ITupleSubsetResultTransformer)transformer).IsTransformedValueATupleElement(aliasesToUse, _tupleLength); } if (requiresRetransform) { for (int i = 0; i < transformedResults.Count; i++) { object[] tuple = _actualTransformer.UntransformToTuple( transformedResults[i], _tupleSubsetLength == 1 ); transformedResults[i] = transformer.TransformTuple(tuple, aliasesToUse); } } return(transformedResults); }
private void TranslatePipeline(PipelineExpression node) { Translate(node.Source); var serializationExpression = node.Projector as ISerializationExpression; var fieldExpression = node.Projector as FieldExpression; // not IFieldExpression if (fieldExpression != null) { var info = new BsonSerializationInfo(fieldExpression.FieldName, fieldExpression.Serializer, fieldExpression.Serializer.ValueType); // We are projecting a field, however the server only responds // with documents. So we'll create a projector that reads a document // and then projects the field out of it. var parameter = Expression.Parameter(typeof(ProjectedObject), "document"); var projector = Expression.Lambda( Expression.Call( parameter, "GetValue", new Type[] { info.Serializer.ValueType }, Expression.Constant(info.ElementName), Expression.Constant(info.Serializer.ValueType.GetDefaultValue(), typeof(object))), parameter); var innerSerializer = new ProjectedObjectDeserializer(new[] { info }); _outputSerializer = (IBsonSerializer)Activator.CreateInstance( typeof(ProjectingDeserializer <,>).MakeGenericType(typeof(ProjectedObject), info.Serializer.ValueType), new object[] { innerSerializer, projector.Compile() }); } else if (serializationExpression != null) { _outputSerializer = serializationExpression.Serializer; } else { throw new NotSupportedException(); } _resultTransformer = node.ResultOperator as IResultTransformer; }
private static bool[] GetIncludeInTransform(IResultTransformer transformer, string[] aliases, bool[] includeInTuple) { if (!(transformer is ITupleSubsetResultTransformer resultTransformer)) { return(null); } var tupleLength = ArrayHelper.CountTrue(includeInTuple); if (aliases != null && aliases.Length != tupleLength) { throw new ArgumentException( $"If {nameof(aliases)} is not null, then the length of {nameof(aliases)}[] must equal the number " + $"of true elements in {nameof(includeInTuple)}; " + $"{nameof(aliases)}.Length={aliases.Length}; tuple 'true' length={tupleLength}", nameof(aliases)); } return(resultTransformer.IncludeInTransform(aliases, tupleLength)); }
public DataServiceV2(string databaseConnectionString, ISqlQueryBuilder sqlQueryBuilder, IResultTransformer resultTransformer) { if (String.IsNullOrWhiteSpace(databaseConnectionString)) { throw new ArgumentException("Argument is null or whitespace", nameof(databaseConnectionString)); } if (sqlQueryBuilder == null) { throw new ArgumentNullException(nameof(sqlQueryBuilder)); } if (resultTransformer == null) { throw new ArgumentNullException(nameof(resultTransformer)); } _connectionString = databaseConnectionString; _sqlQueryBuilder = sqlQueryBuilder; _resultTransformer = resultTransformer; }
public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary <string, TypedValue> namedParameters, IDictionary <string, LockMode> lockModes, RowSelection rowSelection, bool readOnly, bool cacheable, string cacheRegion, string comment, object[] collectionKeys, IResultTransformer transformer) { _positionalParameterTypes = positionalParameterTypes; _positionalParameterValues = positionalParameterValues; _namedParameters = namedParameters; _lockModes = lockModes; _rowSelection = rowSelection; _cacheable = cacheable; _cacheRegion = cacheRegion; _comment = comment; _collectionKeys = collectionKeys; _readOnly = readOnly; _resultTransformer = transformer; if (_positionalParameterLocations == null) { CreatePositionalParameterLocations(); } }
protected override NewExpression VisitNew(NewExpression expr) { NewExpression newExpr = base.VisitNew(expr); _transformer = new TypeSafeConstructorMemberInitResultTransformer(expr); var aggregators = expr.Arguments.Where(arg => arg is MethodCallExpression && SupportsMethod(((MethodCallExpression)arg).Method.Name)); if (aggregators.Any()) { foreach (var exp in expr.Arguments.Except(aggregators)) { string propertyName = MemberNameVisitor.GetMemberName(_rootCriteria, exp); if (!String.IsNullOrEmpty(propertyName)) { _projections.Add(NHProjections.GroupProperty(propertyName)); } } } return(newExpr); }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer customResultTransformer, IDataReader rs, ISessionImplementor session) { object[] result; if (translator.HasProjection) { IType[] types = translator.ProjectedTypes; result = new object[types.Length]; string[] columnAliases = translator.ProjectedColumnAliases; for (int i = 0, position = 0; i < result.Length; i++) { int numColumns = types[i].GetColumnSpan(session.Factory); if ( numColumns > 1 ) { string[] typeColumnAliases = ArrayHelper.Slice(columnAliases, position, numColumns); result[i] = types[i].NullSafeGet(rs, typeColumnAliases, session, null); } else { result[i] = types[i].NullSafeGet(rs, columnAliases[position], session, null); } position += numColumns; } } else { result = row; } if (customResultTransformer == null) { // apply the defaut transformer of criteria aka RootEntityResultTransformer return result[result.Length - 1]; } return result; }
protected internal override void AutoDiscoverTypes( DbDataReader rs, QueryParameters queryParameters, IResultTransformer forcedResultTransformer) { MetaData metadata = new MetaData(rs); List <string> aliases = new List <string>(); List <IType> types = new List <IType>(); rowProcessor.PrepareForAutoDiscovery(metadata); foreach (IResultColumnProcessor columnProcessor in rowProcessor.ColumnProcessors) { columnProcessor.PerformDiscovery(metadata, types, aliases); } ResultTypes = types.ToArray(); transformerAliases = aliases.ToArray(); if (forcedResultTransformer is CacheableResultTransformer cacheableResultTransformer) { cacheableResultTransformer.SupplyAutoDiscoveredParameters( queryParameters.ResultTransformer, transformerAliases); } }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer customResultTransformer, IDataReader rs, ISessionImplementor session) { object[] result; if (translator.HasProjection) { IType[] types = translator.ProjectedTypes; result = new object[types.Length]; string[] columnAliases = translator.ProjectedColumnAliases; for (int i = 0, position = 0; i < result.Length; i++) { int numColumns = types[i].GetColumnSpan(session.Factory); if (numColumns > 1) { string[] typeColumnAliases = ArrayHelper.Slice(columnAliases, position, numColumns); result[i] = types[i].NullSafeGet(rs, typeColumnAliases, session, null); } else { result[i] = types[i].NullSafeGet(rs, columnAliases[position], session, null); } position += numColumns; } } else { result = row; } if (customResultTransformer == null) { // apply the defaut transformer of criteria aka RootEntityResultTransformer return(result[result.Length - 1]); } return(result); }
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 virtual T Create(IEnumerable <SqlParameterWrapper> args, IResultTransformer transformer) { try { if (string.IsNullOrWhiteSpace(this.SqlInsert)) { throw new ArgumentException(ExceptionMessages.SpIsEmpty); } var query = this.Session.CreateSQLQuery(this.SqlInsert) .SetParameters(args); if (transformer != null) { query.SetResultTransformer(transformer); } return(query.UniqueResult <T>()); } catch (Exception e) { this.AfterFailCreate(e); throw; } }
/// <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="resultTransformer">The <see cref="IResultTransformer"/> that should be applied to a result row or <c>null</c>.</param> /// <param name="returnAliases">The aliases that correspond to a result row.</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, IResultTransformer resultTransformer, string[] returnAliases) { _reader = reader; _cmd = cmd; _session = session; _readOnly = readOnly; _types = types; _names = columnNames; _selection = selection; _single = _types.Length == 1; _resultTransformer = resultTransformer; _returnAliases = returnAliases; }
/// <summary> /// Copy all the internal attributes of the given CriteriaImpl /// except alter the root persistent class type to be the given one. /// </summary> /// <param name="persistentClass"></param> /// <param name="original"></param> public CriteriaImpl(System.Type persistentClass, CriteriaImpl original) { this.persistentClass = persistentClass; this.classByAlias = original.classByAlias; this.classByAlias[CriteriaUtil.RootAlias] = persistentClass; this.criteria = original.criteria; this.orderings = original.orderings; this.fetchModes = original.fetchModes; this.associationPathByAlias = original.associationPathByAlias; this.aliasByAssociationPath = original.aliasByAssociationPath; this.lockModes = original.lockModes; this.maxResults = original.maxResults; this.firstResult = original.firstResult; this.timeout = original.timeout; this.fetchSize = original.fetchSize; this.session = original.session; this.resultTransformer = original.resultTransformer; this.counter = original.counter; this.cacheable = original.cacheable; this.cacheRegion = original.cacheRegion; }
public virtual T Update(string sql, IEnumerable <SqlParameterWrapper> args, IResultTransformer transformer) { try { if (string.IsNullOrWhiteSpace(sql)) { throw new ArgumentException(ExceptionMessages.SpIsEmpty); } var query = this.Session.CreateSQLQuery(sql) .SetParameters(args); if (transformer != null) { query.SetResultTransformer(transformer); } return(query.UniqueResult <T>()); } catch (Exception e) { throw; } }
public virtual ICriteria Apply <TEntity, TKey>(ICriteria criteria, IResultTransformer transformer, bool requiredTransform) where TEntity : Entity <TKey> { if (this.SortParams == null || this.SortParams.Length == 0) { this.SortParams = new[] { SortParam.Create <TEntity>(x => x.Id, ListSortDirection.Ascending) } } ; if (this.Count > 0) { criteria.SetFirstResult(this.Offset).SetMaxResults(this.Count); } var projectionList = Projections.ProjectionList(); foreach (var field in this.Fields) { projectionList.Add(Projections.Property(field), field); } this.AddComputedProjections(projectionList); if (projectionList.Length != 0) { criteria.SetProjection(projectionList); } this.SetTransformer(criteria, requiredTransform, projectionList, transformer); foreach (var item in this.SortParams) { SetOrder(criteria, item); } return(this.ApplyCustomFilter(criteria)); }
/// <summary> /// Initializes a new instance of the <see cref="QueryKey"/> class. /// </summary> /// <param name="factory">the session factory for this query key, required to get the identifiers of entities that are used as values.</param> /// <param name="queryString">The query string.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="filters">The filters.</param> public QueryKey(ISessionFactoryImplementor factory, SqlString queryString, QueryParameters queryParameters, ISet<FilterKey> filters) { _factory = factory; _sqlQueryString = queryString; _types = queryParameters.PositionalParameterTypes; _values = queryParameters.PositionalParameterValues; RowSelection selection = queryParameters.RowSelection; if (selection != null) { _firstRow = selection.FirstRow; _maxRows = selection.MaxRows; } else { _firstRow = RowSelection.NoValue; _maxRows = RowSelection.NoValue; } _namedParameters = queryParameters.NamedParameters; _filters = filters; _customTransformer = queryParameters.ResultTransformer; _hashCode = ComputeHashCode(); }
/// <summary> /// Initializes a new instance of the <see cref="QueryKey"/> class. /// </summary> /// <param name="factory">the session factory for this query key, required to get the identifiers of entities that are used as values.</param> /// <param name="queryString">The query string.</param> /// <param name="queryParameters">The query parameters.</param> /// <param name="filters">The filters.</param> public QueryKey(ISessionFactoryImplementor factory, SqlString queryString, QueryParameters queryParameters, ISet filters) { this.factory = factory; sqlQueryString = queryString; types = queryParameters.PositionalParameterTypes; values = queryParameters.PositionalParameterValues; RowSelection selection = queryParameters.RowSelection; if (selection != null) { firstRow = selection.FirstRow; maxRows = selection.MaxRows; } else { firstRow = RowSelection.NoValue; maxRows = RowSelection.NoValue; } namedParameters = queryParameters.NamedParameters; this.filters = filters; this.customTransformer = queryParameters.ResultTransformer; this.hashCode = ComputeHashCode(); }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, IDataReader rs, ISessionImplementor session) { object[] result; string[] aliases; if (translator.HasProjection) { IType[] types = translator.ProjectedTypes; result = new object[types.Length]; string[] columnAliases = translator.ProjectedColumnAliases; for (int i = 0, position = 0; i < result.Length; i++) { int numColumns = types[i].GetColumnSpan(session.Factory); if ( numColumns > 1 ) { string[] typeColumnAliases = ArrayHelper.Slice(columnAliases, position, numColumns); result[i] = types[i].NullSafeGet(rs, typeColumnAliases, session, null); } else { result[i] = types[i].NullSafeGet(rs, columnAliases[position], session, null); } position += numColumns; } aliases = translator.ProjectedAliases; } else { result = row; aliases = userAliases; } return translator.RootCriteria.ResultTransformer.TransformTuple(result, aliases); }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, IDataReader rs, ISessionImplementor session) { object[] result; string[] aliases; if (translator.HasProjection) { IType[] types = translator.ProjectedTypes; result = new object[types.Length]; string[] columnAliases = translator.ProjectedColumnAliases; for (int i = 0, position = 0; i < result.Length; i++) { int numColumns = types[i].GetColumnSpan(session.Factory); if (numColumns > 1) { string[] typeColumnAliases = ArrayHelper.Slice(columnAliases, position, numColumns); result[i] = types[i].NullSafeGet(rs, typeColumnAliases, session, null); } else { result[i] = types[i].NullSafeGet(rs, columnAliases[position], session, null); } position += numColumns; } aliases = translator.ProjectedAliases; } else { result = row; aliases = userAliases; } return(translator.RootCriteria.ResultTransformer.TransformTuple(result, aliases)); }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, IDataReader rs, ISessionImplementor session) { row = ToResultRow(row); bool hasTransform = HasSelectNew || resultTransformer != null; if (_hasScalars) { string[][] scalarColumns = _scalarColumnNames; int queryCols = _queryReturnTypes.Length; if (!hasTransform && queryCols == 1) { return _queryReturnTypes[0].NullSafeGet(rs, scalarColumns[0], session, null); } else { row = new object[queryCols]; for (int i = 0; i < queryCols; i++) { row[i] = _queryReturnTypes[i].NullSafeGet(rs, scalarColumns[i], session, null); } return row; } } else if (!hasTransform) { return row.Length == 1 ? row[0] : row; } else { return row; } }
public AbstractMethodExecutionItemList(IResultTransformer resultTransformer) { this.resultTransformer = 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); }
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; } }
protected override IResultTransformer ResolveResultTransformer(IResultTransformer resultTransformer) { return(HolderInstantiator.ResolveResultTransformer(null, resultTransformer)); }
protected virtual IList GetResultList(IList results, IResultTransformer resultTransformer) { return results; }
public Enum(IResultTransformer resultTransformer, IDao<Customer> customerDao, IDao<CustomerType> customerTypeDao) : base(resultTransformer) { this.customerDao = customerDao; this.customerTypeDao = customerTypeDao; }
// Not ported: scroll protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, DbDataReader rs, ISessionImplementor session) { return(rowProcessor.BuildResultRow(row, rs, resultTransformer != null, session)); }
protected override async Task <object> GetResultColumnOrRowAsync(object[] row, IResultTransformer resultTransformer, DbDataReader rs, ISessionImplementor session, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); Object[] resultRow = await(GetResultRowAsync(row, rs, session, cancellationToken)).ConfigureAwait(false); bool hasTransform = HasSelectNew || resultTransformer != null; return(!hasTransform && resultRow.Length == 1 ? resultRow[0] : resultRow ); }
public IMultiQuery SetResultTransformer(IResultTransformer transformer) { ApplyActionToShards(q => q.SetResultTransformer(transformer)); return(this); }
protected override object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, DbDataReader rs, ISessionImplementor session) { return(row[row.Length - 1]); }
public Cascade_InSession(IResultTransformer resultTransformer, INHibernateStatefulDao<Account> accountDao, INHibernateStatefulDao<Customer> customerDao) : base(resultTransformer, accountDao, customerDao) { this.accountDao = accountDao; this.customerDao = customerDao; }
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); }
/// <summary> /// Get the actual object that is returned in the user-visible result list. /// </summary> /// <remarks> /// This empty implementation merely returns its first argument. This is /// overridden by some subclasses. /// </remarks> protected virtual object GetResultColumnOrRow(object[] row, IResultTransformer resultTransformer, IDataReader rs, ISessionImplementor session) { return row; }
public new IFullTextQuery SetResultTransformer(IResultTransformer transformer) { base.SetResultTransformer(transformer); this.resultTransformer = transformer; return(this); }
public Enum(IResultTransformer resultTransformer, IDao <Customer> customerDao, IDao <CustomerType> customerTypeDao) : base(resultTransformer) { this.customerDao = customerDao; this.customerTypeDao = customerTypeDao; }
public ICriteria SetResultTransformer(IResultTransformer tupleMapper) { resultTransformer = tupleMapper; return(this); }
public DetachedCriteria SetResultTransformer(IResultTransformer resultTransformer) { criteria.SetResultTransformer(resultTransformer); return(this); }
public ICriteria SetResultTransformer(IResultTransformer resultProcessor) { root.SetResultTransformer(resultProcessor); return(this); }