private Map checkNamedQueries() throws HibernateException {
    Map errors = new HashMap();

    // Check named HQL queries
    log.debug("Checking " + namedQueries.size() + " named HQL queries");
    Iterator itr = namedQueries.entrySet().iterator();
    while (itr.hasNext()) {
      final Map.Entry entry = (Map.Entry) itr.next();
      final String queryName = (String) entry.getKey();
      final NamedQueryDefinition qd = (NamedQueryDefinition) entry.getValue();
      // 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.getQueryString(), false, CollectionHelper.EMPTY_MAP);
      } catch (QueryException e) {
        errors.put(queryName, e);
      } catch (MappingException e) {
        errors.put(queryName, e);
      }
    }

    log.debug("Checking " + namedSqlQueries.size() + " named SQL queries");
    itr = namedSqlQueries.entrySet().iterator();
    while (itr.hasNext()) {
      final Map.Entry entry = (Map.Entry) itr.next();
      final String queryName = (String) entry.getKey();
      final NamedSQLQueryDefinition qd = (NamedSQLQueryDefinition) entry.getValue();
      // 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.getResultSetRef() != null) {
          ResultSetMappingDefinition definition =
              (ResultSetMappingDefinition) sqlResultSetMappings.get(qd.getResultSetRef());
          if (definition == null) {
            throw new MappingException(
                "Unable to find resultset-ref definition: " + qd.getResultSetRef());
          }
          spec =
              new NativeSQLQuerySpecification(
                  qd.getQueryString(), definition.getQueryReturns(), qd.getQuerySpaces());
        } else {
          spec =
              new NativeSQLQuerySpecification(
                  qd.getQueryString(), qd.getQueryReturns(), qd.getQuerySpaces());
        }
        queryPlanCache.getNativeSQLQueryPlan(spec);
      } catch (QueryException e) {
        errors.put(queryName, e);
      } catch (MappingException e) {
        errors.put(queryName, e);
      }
    }

    return errors;
  }
  public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass) {
    try {
      /*
       * Get the named query.
       * If the named query is a SQL query, get the expected returned type from the query definition
       * or its associated result set mapping
       * If the named query is a HQL query, use getReturnType()
       */
      org.hibernate.Query namedQuery = getSession().getNamedQuery(name);
      // TODO clean this up to avoid downcasting
      final SessionFactoryImplementor factoryImplementor =
          (SessionFactoryImplementor) entityManagerFactory.getSessionFactory();
      final NamedSQLQueryDefinition queryDefinition = factoryImplementor.getNamedSQLQuery(name);
      try {
        if (queryDefinition != null) {
          Class<?> actualReturnedClass;

          final NativeSQLQueryReturn[] queryReturns;
          if (queryDefinition.getQueryReturns() != null) {
            queryReturns = queryDefinition.getQueryReturns();
          } else if (queryDefinition.getResultSetRef() != null) {
            final ResultSetMappingDefinition rsMapping =
                factoryImplementor.getResultSetMapping(queryDefinition.getResultSetRef());
            queryReturns = rsMapping.getQueryReturns();
          } else {
            throw new AssertionFailure(
                "Unsupported named query model. Please report the bug in Hibernate EntityManager");
          }
          if (queryReturns.length > 1) {
            throw new IllegalArgumentException(
                "Cannot create TypedQuery for query with more than one return");
          }
          final NativeSQLQueryReturn nativeSQLQueryReturn = queryReturns[0];
          if (nativeSQLQueryReturn instanceof NativeSQLQueryRootReturn) {
            final String entityClassName =
                ((NativeSQLQueryRootReturn) nativeSQLQueryReturn).getReturnEntityName();
            try {
              actualReturnedClass =
                  ReflectHelper.classForName(entityClassName, AbstractEntityManagerImpl.class);
            } catch (ClassNotFoundException e) {
              throw new AssertionFailure(
                  "Unable to instantiate class declared on named native query: "
                      + name
                      + " "
                      + entityClassName);
            }
            if (!resultClass.isAssignableFrom(actualReturnedClass)) {
              throw buildIncompatibleException(resultClass, actualReturnedClass);
            }
          } else {
            // TODO support other NativeSQLQueryReturn type. For now let it go.
          }
        } else {
          if (namedQuery.getReturnTypes().length != 1) {
            throw new IllegalArgumentException(
                "Cannot create TypedQuery for query with more than one return");
          }
          if (!resultClass.isAssignableFrom(namedQuery.getReturnTypes()[0].getReturnedClass())) {
            throw buildIncompatibleException(
                resultClass, namedQuery.getReturnTypes()[0].getReturnedClass());
          }
        }
        return new QueryImpl<T>(namedQuery, this);
      } catch (HibernateException he) {
        throw convert(he);
      }
    } catch (MappingException e) {
      throw new IllegalArgumentException("Named query not found: " + name);
    }
  }