public virtual IQuery GetNamedQuery(string queryName)
{
using (new SessionIdLoggingContext(SessionId))
{
CheckAndUpdateSessionStatus();
NamedQueryDefinition nqd = factory.GetNamedQuery(queryName);
IQuery query;
if (nqd != null)
{
string queryString = nqd.QueryString;
query = new QueryImpl(queryString, nqd.FlushMode, this, GetHQLQueryPlan(queryString.ToQueryExpression(), false).ParameterMetadata);
query.SetComment("named HQL query " + queryName);
}
else
{
NamedSQLQueryDefinition nsqlqd = factory.GetNamedSQLQuery(queryName);
if (nsqlqd == null)
{
throw new MappingException("Named query not known: " + queryName);
}
query = new SqlQueryImpl(nsqlqd, this,
factory.QueryPlanCache.GetSQLParameterMetadata(nsqlqd.QueryString));
query.SetComment("named native SQL query " + queryName);
nqd = nsqlqd;
}
InitQuery(query, nqd);
return(query);
}
}
public virtual IQuery GetNamedSQLQuery(string name)
{
using (new SessionIdLoggingContext(SessionId))
{
CheckAndUpdateSessionStatus();
NamedSQLQueryDefinition nsqlqd = factory.GetNamedSQLQuery(name);
if (nsqlqd == null)
{
throw new MappingException("Named SQL query not known: " + name);
}
IQuery query = new SqlQueryImpl(nsqlqd, this,
factory.QueryPlanCache.GetSQLParameterMetadata(nsqlqd.QueryString));
query.SetComment("named native SQL query " + name);
InitQuery(query, nsqlqd);
return(query);
}
}
public void AddSqlQuery(HbmSqlQuery querySchema)
{
mappings.AddSecondPass(delegate
{
string queryName = querySchema.name;
string queryText = querySchema.GetText();
bool cacheable = querySchema.cacheable;
string region = querySchema.cacheregion;
int timeout = string.IsNullOrEmpty(querySchema.timeout) ? RowSelection.NoValue : int.Parse(querySchema.timeout);
int fetchSize = querySchema.fetchsizeSpecified ? querySchema.fetchsize : -1;
bool readOnly = querySchema.readonlySpecified ? querySchema.@readonly : false;
string comment = null;
bool callable = querySchema.callable;
string resultSetRef = querySchema.resultsetref;
FlushMode flushMode = FlushModeConverter.GetFlushMode(querySchema);
CacheMode?cacheMode = (querySchema.cachemodeSpecified)
? querySchema.cachemode.ToCacheMode()
: null;
IDictionary <string, string> parameterTypes = new LinkedHashMap <string, string>();
IList <string> synchronizedTables = GetSynchronizedTables(querySchema);
NamedSQLQueryDefinition namedQuery;
if (string.IsNullOrEmpty(resultSetRef))
{
ResultSetMappingDefinition definition =
new ResultSetMappingBinder(Mappings).Create(querySchema);
namedQuery = new NamedSQLQueryDefinition(queryText,
definition.GetQueryReturns(), synchronizedTables, cacheable, region, timeout,
fetchSize, flushMode, cacheMode, readOnly, comment, parameterTypes, callable);
}
else
{
// TODO: check there is no actual definition elemnents when a ref is defined
namedQuery = new NamedSQLQueryDefinition(queryText,
resultSetRef, synchronizedTables, cacheable, region, timeout, fetchSize,
flushMode, cacheMode, readOnly, comment, parameterTypes, callable);
}
log.Debug("Named SQL query: {0} -> {1}", queryName, namedQuery.QueryString);
mappings.AddSQLQuery(queryName, namedQuery);
});
}
/// <summary> Constructs a SQLQueryImpl given a sql query defined in the mappings. </summary>
/// <param name="queryDef">The representation of the defined sql-query. </param>
/// <param name="session">The session to which this SQLQueryImpl belongs. </param>
/// <param name="parameterMetadata">Metadata about parameters found in the query. </param>
internal SqlQueryImpl(NamedSQLQueryDefinition queryDef, ISessionImplementor session, ParameterMetadata parameterMetadata)
: base(queryDef.QueryString, queryDef.FlushMode, session, parameterMetadata)
{
if (!string.IsNullOrEmpty(queryDef.ResultSetRef))
{
ResultSetMappingDefinition definition = session.Factory.GetResultSetMapping(queryDef.ResultSetRef);
if (definition == null)
{
throw new MappingException("Unable to find resultset-ref definition: " + queryDef.ResultSetRef);
}
queryReturns = new List <INativeSQLQueryReturn>(definition.GetQueryReturns());
}
else
{
queryReturns = new List <INativeSQLQueryReturn>(queryDef.QueryReturns);
}
querySpaces = queryDef.QuerySpaces;
callable = queryDef.IsCallable;
}
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 void AddSQLQuery(string name, NamedSQLQueryDefinition query)
{
CheckQueryExists(name);
sqlqueries[name] = query;
}
