public void NativeSQLQuerySpecificationEqualityOnReturns()
{
var spec1 = new NativeSQLQuerySpecification("select blah",
new[]
{
new NativeSQLQueryScalarReturn("alias1", NHibernateUtil.Character),
new NativeSQLQueryScalarReturn("alias2", NHibernateUtil.Decimal)
},
null);
var spec2 = new NativeSQLQuerySpecification("select blah",
new[]
{
// Aliases ordering matters, do not get them mixed. (But type does not matter, I guess this means
// a case with a same query having sames aliases but different types is never supposed to happen
// Note that Hibernate does test other properties as of this writing:
// https://github.com/hibernate/hibernate-orm/blob/master/hibernate-core/src/main/java/org/hibernate/engine/query/spi/sql/NativeSQLQueryScalarReturn.java
// And same on other INativeSQLQueryReturn implementations.
new NativeSQLQueryScalarReturn("alias1", NHibernateUtil.Character),
new NativeSQLQueryScalarReturn("alias2", NHibernateUtil.Decimal)
},
// Empty spaces array should be equivalent to null.
Array.Empty <string>());
Assert.IsTrue(spec1.Equals(spec2));
Assert.IsTrue(spec2.Equals(spec1));
}
protected internal virtual NativeSQLQueryPlan GetNativeSQLQueryPlan(NativeSQLQuerySpecification spec)
{
using (new SessionIdLoggingContext(SessionId))
{
return(factory.QueryPlanCache.GetNativeSQLQueryPlan(spec));
}
}
public SqlTranslator(ISQLQuery sqlQuery, ISessionFactoryImplementor sessionFactory)
{
var sqlQueryImpl = (SqlQueryImpl)sqlQuery;
NativeSQLQuerySpecification sqlQuerySpec = sqlQueryImpl.GenerateQuerySpecification(sqlQueryImpl.NamedParams);
var sqlCustomQuery = new SQLCustomQuery(sqlQuerySpec.SqlQueryReturns, sqlQuerySpec.QueryString, sqlQuerySpec.QuerySpaces, sessionFactory);
loader = new CustomLoader(sqlCustomQuery, sessionFactory);
}
public virtual IList <T> List <T>(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
{
using (new SessionIdLoggingContext(SessionId))
{
var results = new List <T>();
List(spec, queryParameters, results);
return(results);
}
}
public void NativeSQLQuerySpecificationInequalityOnQuery()
{
var spec1 = new NativeSQLQuerySpecification("select blah", null, null);
var spec2 = new NativeSQLQuerySpecification("select blargh", null, null);
TweakHashcode(spec2, spec1.GetHashCode());
Assert.IsFalse(spec1.Equals(spec2));
Assert.IsFalse(spec2.Equals(spec1));
}
public void NativeSQLQuerySpecificationEqualityOnQuery()
{
var spec1 = new NativeSQLQuerySpecification("select blah", null, null);
// Empty spaces array should be equivalent to null. Maybe results too but current implementation does not handle this.
var spec2 = new NativeSQLQuerySpecification("select blah", null, Array.Empty <string>());
Assert.IsTrue(spec1.Equals(spec2));
Assert.IsTrue(spec2.Equals(spec1));
}
public void NativeSQLQuerySpecificationEqualityOnSpaces()
{
var spec1 = new NativeSQLQuerySpecification("select blah", null,
new[] { "space1", "space2" });
var spec2 = new NativeSQLQuerySpecification("select blah", null,
new[] { "space1", "space2" });
Assert.IsTrue(spec1.Equals(spec2));
Assert.IsTrue(spec2.Equals(spec1));
}
public virtual async Task <IList> ListAsync(NativeSQLQuerySpecification spec, QueryParameters queryParameters, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (BeginProcess())
{
var results = new List <object>();
await(ListAsync(spec, queryParameters, results, cancellationToken)).ConfigureAwait(false);
return(results);
}
}
public override IList <T> List <T>(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
{
using (new SessionIdLoggingContext(SessionId))
{
// TODO pull up
List <T> results = new List <T>();
List(spec, queryParameters, results);
return(results);
}
}
public virtual async Task <IList <T> > ListAsync <T>(NativeSQLQuerySpecification spec, QueryParameters queryParameters, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (new SessionIdLoggingContext(SessionId))
{
var results = new List <T>();
await(ListAsync(spec, queryParameters, results, cancellationToken)).ConfigureAwait(false);
return(results);
}
}
public void NativeSQLQuerySpecificationInequalityOnSpaceOrderings()
{
var spec1 = new NativeSQLQuerySpecification("select blah", null,
new[] { "space1", "space2" });
var spec2 = new NativeSQLQuerySpecification("select blah", null,
new[] { "space2", "space1" });
TweakHashcode(spec2, spec1.GetHashCode());
Assert.IsFalse(spec1.Equals(spec2));
Assert.IsFalse(spec2.Equals(spec1));
}
public void WhenChangeSpace_NotEqualHashCode()
{
var sr1 = new NativeSQLQuerySpecification("SELECT * FROM SOMETHING", new INativeSQLQueryReturn[] { new NativeSQLQueryScalarReturn("myAlias", NHibernateUtil.Int32), new NativeSQLQueryScalarReturn("otherAlias", NHibernateUtil.Int32) }, new List <string> {
"SOMETHING"
});
var sr2 = new NativeSQLQuerySpecification("SELECT * FROM SOMETHING", new INativeSQLQueryReturn[] { new NativeSQLQueryScalarReturn("myAlias", NHibernateUtil.Int32), new NativeSQLQueryScalarReturn("otherAlias", NHibernateUtil.Int32) }, new List <string> {
"ANOTHER"
});
Assert.AreNotEqual(sr1.GetHashCode(), sr2.GetHashCode());
}
public void WhenChangeReturns_NotEqual()
{
var sr1 = new NativeSQLQuerySpecification("SELECT * FROM SOMETHING", new INativeSQLQueryReturn[] { new NativeSQLQueryScalarReturn("myAlias", NHibernateUtil.Int32), new NativeSQLQueryScalarReturn("otherAlias", NHibernateUtil.Int32) }, new List <string> {
"SOMETHING"
});
var sr2 = new NativeSQLQuerySpecification("SELECT * FROM SOMETHING", new INativeSQLQueryReturn[] { new NativeSQLQueryScalarReturn("myAliasChanged", NHibernateUtil.Int32), new NativeSQLQueryScalarReturn("otherAlias", NHibernateUtil.Int32) }, new List <string> {
"SOMETHING"
});
Assert.AreNotEqual(sr1, sr2);
}
public virtual void List(NativeSQLQuerySpecification spec, QueryParameters queryParameters, IList results)
{
using (new SessionIdLoggingContext(SessionId))
{
var query = new SQLCustomQuery(
spec.SqlQueryReturns,
spec.QueryString,
spec.QuerySpaces,
Factory);
ListCustomQuery(query, queryParameters, results);
}
}
public virtual async Task ListAsync(NativeSQLQuerySpecification spec, QueryParameters queryParameters, IList results, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (new SessionIdLoggingContext(SessionId))
{
var query = new SQLCustomQuery(
spec.SqlQueryReturns,
spec.QueryString,
spec.QuerySpaces,
Factory);
await(ListCustomQueryAsync(query, queryParameters, results, cancellationToken)).ConfigureAwait(false);
}
}
public void NativeSQLQuerySpecificationInequalityOnNullReturn()
{
var spec1 = new NativeSQLQuerySpecification("select blah", null, null);
var spec2 = new NativeSQLQuerySpecification("select blah",
new[]
{
new NativeSQLQueryScalarReturn("alias1", NHibernateUtil.Character)
},
null);
TweakHashcode(spec2, spec1.GetHashCode());
Assert.IsFalse(spec1.Equals(spec2));
Assert.IsFalse(spec2.Equals(spec1));
}
public override void List(IList results)
{
VerifyParameters();
IDictionary <string, TypedValue> namedParams = NamedParams;
NativeSQLQuerySpecification spec = GenerateQuerySpecification(namedParams);
QueryParameters qp = GetQueryParameters(namedParams);
Before();
try
{
Session.List(spec, qp, results);
}
finally
{
After();
}
}
public override IList <T> List <T>()
{
VerifyParameters();
IDictionary <string, TypedValue> namedParams = NamedParams;
NativeSQLQuerySpecification spec = GenerateQuerySpecification(namedParams);
QueryParameters qp = GetQueryParameters(namedParams);
Before();
try
{
return(Session.List <T>(spec, qp));
}
finally
{
After();
}
}
public override System.Data.DataSet QueryDataSet()
{
VerifyParameters();
IDictionary <string, TypedValue> namedParams = NamedParams;
NativeSQLQuerySpecification spec = GenerateQuerySpecification(namedParams);
QueryParameters qp = GetQueryParameters(namedParams);
Before();
try
{
return(Session.QueryDataSet(spec, qp));
}
finally
{
After();
}
//return base.QueryDataSet();
}
public override async Task <IList <T> > ListAsync <T>(CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
VerifyParameters();
IDictionary <string, TypedValue> namedParams = NamedParams;
NativeSQLQuerySpecification spec = GenerateQuerySpecification(namedParams);
QueryParameters qp = GetQueryParameters(namedParams);
Before();
try
{
return(await(Session.ListAsync <T>(spec, qp, cancellationToken)).ConfigureAwait(false));
}
finally
{
After();
}
}
public override int ExecuteNativeUpdate(NativeSQLQuerySpecification nativeSQLQuerySpecification, QueryParameters queryParameters)
{
using (BeginProcess())
{
queryParameters.ValidateParameters();
NativeSQLQueryPlan plan = GetNativeSQLQueryPlan(nativeSQLQuerySpecification);
bool success = false;
int result;
try
{
result = plan.PerformExecuteUpdate(queryParameters, this);
success = true;
}
finally
{
AfterOperation(success);
}
temporaryPersistenceContext.Clear();
return(result);
}
}
public override async Task <int> ExecuteNativeUpdateAsync(NativeSQLQuerySpecification nativeSQLQuerySpecification, QueryParameters queryParameters, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (BeginProcess())
{
queryParameters.ValidateParameters();
NativeSQLQueryPlan plan = GetNativeSQLQueryPlan(nativeSQLQuerySpecification);
bool success = false;
int result;
try
{
result = await(plan.PerformExecuteUpdateAsync(queryParameters, this, cancellationToken)).ConfigureAwait(false);
success = true;
}
finally
{
await(AfterOperationAsync(success, cancellationToken)).ConfigureAwait(false);
}
temporaryPersistenceContext.Clear();
return(result);
}
}
public NativeSQLQueryPlan GetNativeSQLQueryPlan(NativeSQLQuerySpecification spec)
{
var plan = (NativeSQLQueryPlan)planCache[spec];
if (plan == null)
{
if (log.IsDebugEnabled)
{
log.Debug("unable to locate native-sql query plan in cache; generating (" + spec.QueryString + ")");
}
plan = new NativeSQLQueryPlan(spec, factory);
planCache.Put(spec, plan);
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("located native-sql query plan in cache (" + spec.QueryString + ")");
}
}
return(plan);
}
public abstract int ExecuteNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters);
private IDictionary<string, HibernateException> CheckNamedQueries()
{
IDictionary<string, HibernateException> errors = new Dictionary<string, HibernateException>();
// Check named HQL queries
log.Debug("Checking " + namedQueries.Count + " named HQL queries");
foreach (KeyValuePair<string, NamedQueryDefinition> entry in namedQueries)
{
string queryName = entry.Key;
NamedQueryDefinition qd = entry.Value;
// this will throw an error if there's something wrong.
try
{
log.Debug("Checking named query: " + queryName);
//TODO: BUG! this currently fails for named queries for non-POJO entities
queryPlanCache.GetHQLQueryPlan(qd.QueryString, false, new CollectionHelper.EmptyMapClass<string, IFilter>());
}
catch (QueryException e)
{
errors[queryName] = e;
}
catch (MappingException e)
{
errors[queryName] = e;
}
}
log.Debug("Checking " + namedSqlQueries.Count + " named SQL queries");
foreach (KeyValuePair<string, NamedSQLQueryDefinition> entry in namedSqlQueries)
{
string queryName = entry.Key;
NamedSQLQueryDefinition qd = entry.Value;
// this will throw an error if there's something wrong.
try
{
log.Debug("Checking named SQL query: " + queryName);
// TODO : would be really nice to cache the spec on the query-def so as to not have to re-calc the hash;
// currently not doable though because of the resultset-ref stuff...
NativeSQLQuerySpecification spec;
if (qd.ResultSetRef != null)
{
ResultSetMappingDefinition definition = sqlResultSetMappings[qd.ResultSetRef];
if (definition == null)
{
throw new MappingException("Unable to find resultset-ref definition: " + qd.ResultSetRef);
}
spec = new NativeSQLQuerySpecification(qd.QueryString, definition.GetQueryReturns(), qd.QuerySpaces);
}
else
{
spec = new NativeSQLQuerySpecification(qd.QueryString, qd.QueryReturns, qd.QuerySpaces);
}
queryPlanCache.GetNativeSQLQueryPlan(spec);
}
catch (QueryException e)
{
errors[queryName] = e;
}
catch (MappingException e)
{
errors[queryName] = e;
}
}
return errors;
}
public NativeSQLQueryPlan(NativeSQLQuerySpecification specification, ISessionFactoryImplementor factory)
{
sourceQuery = specification.QueryString;
customQuery = new SQLCustomQuery(specification.SqlQueryReturns, specification.QueryString, specification.QuerySpaces, factory);
}
public override int ExecuteNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification, QueryParameters queryParameters);
public NativeSQLQueryPlan GetNativeSQLQueryPlan(NativeSQLQuerySpecification spec)
{
var plan = (NativeSQLQueryPlan)planCache[spec];
if (plan == null)
{
if (log.IsDebugEnabled)
{
log.Debug("unable to locate native-sql query plan in cache; generating (" + spec.QueryString + ")");
}
plan = new NativeSQLQueryPlan(spec, factory);
planCache.Put(spec, plan);
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("located native-sql query plan in cache (" + spec.QueryString + ")");
}
}
return plan;
}
public abstract Task <int> ExecuteNativeUpdateAsync(NativeSQLQuerySpecification specification, QueryParameters queryParameters, CancellationToken cancellationToken);
public NativeSQLQueryPlan(NativeSQLQuerySpecification specification, ISessionFactoryImplementor factory)
{
sourceQuery = specification.QueryString;
customQuery = new SQLCustomQuery(specification.SqlQueryReturns, specification.QueryString, specification.QuerySpaces, factory);
}
public override IList <T> List <T>(NativeSQLQuerySpecification spec, QueryParameters queryParameters);
private IDictionary <string, HibernateException> CheckNamedQueries()
{
IDictionary <string, HibernateException> errors = new Dictionary <string, HibernateException>();
// Check named HQL queries
log.Debug("Checking " + namedQueries.Count + " named HQL queries");
foreach (var entry in namedQueries)
{
string queryName = entry.Key;
NamedQueryDefinition qd = entry.Value;
// this will throw an error if there's something wrong.
try
{
log.Debug("Checking named query: " + queryName);
//TODO: BUG! this currently fails for named queries for non-POJO entities
queryPlanCache.GetHQLQueryPlan(qd.QueryString.ToQueryExpression(), false, new CollectionHelper.EmptyMapClass <string, IFilter>());
}
catch (QueryException e)
{
errors[queryName] = e;
}
catch (MappingException e)
{
errors[queryName] = e;
}
}
log.Debug("Checking " + namedSqlQueries.Count + " named SQL queries");
foreach (KeyValuePair <string, NamedSQLQueryDefinition> entry in namedSqlQueries)
{
string queryName = entry.Key;
NamedSQLQueryDefinition qd = entry.Value;
// this will throw an error if there's something wrong.
try
{
log.Debug("Checking named SQL query: " + queryName);
// TODO : would be really nice to cache the spec on the query-def so as to not have to re-calc the hash;
// currently not doable though because of the resultset-ref stuff...
NativeSQLQuerySpecification spec;
if (qd.ResultSetRef != null)
{
ResultSetMappingDefinition definition = sqlResultSetMappings[qd.ResultSetRef];
if (definition == null)
{
throw new MappingException("Unable to find resultset-ref definition: " + qd.ResultSetRef);
}
spec = new NativeSQLQuerySpecification(qd.QueryString, definition.GetQueryReturns(), qd.QuerySpaces);
}
else
{
spec = new NativeSQLQuerySpecification(qd.QueryString, qd.QueryReturns, qd.QuerySpaces);
}
queryPlanCache.GetNativeSQLQueryPlan(spec);
}
catch (QueryException e)
{
errors[queryName] = e;
}
catch (MappingException e)
{
errors[queryName] = e;
}
}
return(errors);
}
public override void List(NativeSQLQuerySpecification spec, QueryParameters queryParameters, IList results);