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);
}
