* The default server side implementation of EbeanServer.

*/

  private static final Logger logger = LoggerFactory.getLogger(DefaultServer.class);

  private static final int IGNORE_LEADING_ELEMENTS = 5;

 

  private static final String AVAJE_EBEAN = Ebean.class.getName().substring(0, 15);

 

  private final ServerConfig serverConfig;

 

  private final String serverName;

  private final DatabasePlatform databasePlatform;

  private final AdminAutofetch adminAutofetch;

  private final TransactionManager transactionManager;

  private final TransactionScopeManager transactionScopeManager;

  private final int maxCallStack;

  /**

   * Ebean defaults this to true but for EJB compatible behaviour set this to

   * false;

   */

  private final boolean rollbackOnChecked;

 

  /**

   * Handles the save, delete, updateSql CallableSql.

   */

  private final Persister persister;

  private final OrmQueryEngine queryEngine;

  private final RelationalQueryEngine relationalQueryEngine;

  private final ServerCacheManager serverCacheManager;

  private final BeanDescriptorManager beanDescriptorManager;

  private final DiffHelp diffHelp = new DiffHelp();

  private final AutoFetchManager autoFetchManager;

  private final CQueryEngine cqueryEngine;

  //@Deprecated

  private DdlGenerator ddlGenerator;

  private final ExpressionFactory expressionFactory;

  private final SpiBackgroundExecutor backgroundExecutor;

  private final DefaultBeanLoader beanLoader;

  private final EncryptKeyManager encryptKeyManager;

  private final JsonContext jsonContext;

  private final MetaInfoManager metaInfoManager;

 

  /**

   * The MBean name used to register Ebean.

   */

  private String mbeanName;

  /**

   * The MBeanServer Ebean is registered with.

   */

  private MBeanServer mbeanServer;

  /**

   * Flag set when the server has shutdown.

   */

  private boolean shutdown;

 

  /**

   * The default batch size for lazy loading beans or collections.

   */

  private int lazyLoadBatchSize;

  /**

   * The query batch size

   */

  private int queryBatchSize;

  /**

   * JDBC driver specific handling for JDBC batch execution.

   */

  private PstmtBatch pstmtBatch;

  /**

   * holds plugins (e.g. ddl generator) detected by the service loader

   */

  private List<SpiEbeanPlugin> ebeanPlugins;

  private final boolean collectQueryOrigins;

 

  private final boolean collectQueryStatsByNode;

  /**

   * Cache used to collect statistics based on ObjectGraphNode (used to highlight lazy loading origin points).

   */

  protected final ConcurrentHashMap<ObjectGraphNode, CObjectGraphNodeStatistics> objectGraphStats;

  /**

   * Create the DefaultServer.

   */

  public DefaultServer(InternalConfiguration config, ServerCacheManager cache) {

    this.serverConfig = config.getServerConfig();

    this.objectGraphStats = new ConcurrentHashMap<ObjectGraphNode, CObjectGraphNodeStatistics>();

    this.metaInfoManager = new DefaultMetaInfoManager(this);

    this.serverCacheManager = cache;

    this.pstmtBatch = config.getPstmtBatch();

    this.databasePlatform = config.getDatabasePlatform();

    this.backgroundExecutor = config.getBackgroundExecutor();

   

    this.serverName = serverConfig.getName();

    this.lazyLoadBatchSize = serverConfig.getLazyLoadBatchSize();

    this.queryBatchSize = serverConfig.getQueryBatchSize();

    this.cqueryEngine = config.getCQueryEngine();

    this.expressionFactory = config.getExpressionFactory();

    this.encryptKeyManager = serverConfig.getEncryptKeyManager();

    this.beanDescriptorManager = config.getBeanDescriptorManager();

    beanDescriptorManager.setEbeanServer(this);

    this.collectQueryOrigins = serverConfig.isCollectQueryOrigins();

    this.collectQueryStatsByNode = serverConfig.isCollectQueryStatsByNode();

    this.maxCallStack = GlobalProperties.getInt("ebean.maxCallStack", 5);

    this.rollbackOnChecked = GlobalProperties.getBoolean("ebean.transaction.rollbackOnChecked", true);

    this.transactionManager = config.getTransactionManager();

    this.transactionScopeManager = config.getTransactionScopeManager();

    this.persister = config.createPersister(this);

    this.queryEngine = config.createOrmQueryEngine();

    this.relationalQueryEngine = config.createRelationalQueryEngine();

    this.autoFetchManager = config.createAutoFetchManager(this);

    this.adminAutofetch = new MAdminAutofetch(autoFetchManager);

    this.beanLoader = new DefaultBeanLoader(this);

    this.jsonContext = config.createJsonContext(this);

    loadAndInitializePlugins(config);

   

    // Register with the JVM Shutdown hook

    ShutdownManager.registerEbeanServer(this);

  }

  protected void loadAndInitializePlugins(InternalConfiguration config) {

   

    List<SpiEbeanPlugin> spiPlugins = new ArrayList<SpiEbeanPlugin>();

    final Iterator<SpiEbeanPlugin> plugins = ServiceLoader.load(SpiEbeanPlugin.class).iterator();

    while (plugins.hasNext()) {

      SpiEbeanPlugin plugin = plugins.next();

      spiPlugins.add(plugin);

      plugin.setup(this, this.getDatabasePlatform(), config.getServerConfig());

      if (plugin instanceof DdlGenerator) {

        // backwards compatible

        ddlGenerator = (DdlGenerator)plugin;

      }

    }

   

    if (ddlGenerator == null) {

      // ServiceLoader not finding ddlGenerator (typically OSGi)

      ddlGenerator = new DdlGenerator();

      spiPlugins.add(ddlGenerator);

      ddlGenerator.setup(this, this.getDatabasePlatform(), config.getServerConfig());

    }

    ebeanPlugins = Collections.unmodifiableList(spiPlugins);

  }

  public List<SpiEbeanPlugin> getSpiEbeanPlugins() {

    return ebeanPlugins;

  }

  public void executePlugins(boolean online) {

    for(SpiEbeanPlugin plugin : ebeanPlugins) {

      plugin.execute(online);

    }

  }

  @Override

  public boolean isCollectQueryOrigins() {

    return collectQueryOrigins;

  }

  public int getLazyLoadBatchSize() {

    return lazyLoadBatchSize;

  }

  public PstmtBatch getPstmtBatch() {

    return pstmtBatch;

  }

  public ServerConfig getServerConfig() {

    return serverConfig;

  }

  public DatabasePlatform getDatabasePlatform() {

    return databasePlatform;

  }

 

  @Override

  public MetaInfoManager getMetaInfoManager() {

    return metaInfoManager;

  }

  public BackgroundExecutor getBackgroundExecutor() {

    return backgroundExecutor;

  }

  public ExpressionFactory getExpressionFactory() {

    return expressionFactory;

  }

  public DdlGenerator getDdlGenerator() {

    return ddlGenerator;

  }

  public AdminAutofetch getAdminAutofetch() {

    return adminAutofetch;

  }

  public AutoFetchManager getAutoFetchManager() {

    return autoFetchManager;

  }

  /**

   * Run any initialisation required before registering with the ClusterManager.

   */

  public void initialise() {

    if (encryptKeyManager != null) {

      encryptKeyManager.initialise();

    }

    List<BeanDescriptor<?>> list = beanDescriptorManager.getBeanDescriptorList();

    for (int i = 0; i < list.size(); i++) {

      list.get(i).cacheInitialise();

    }

  }

  /**

   * Start any services after registering with the ClusterManager.

   */

  public void start() {

  }

  public void registerMBeans(MBeanServer mbeanServer, int uniqueServerId) {

    this.mbeanServer = mbeanServer;

    this.mbeanName = "Ebean:server=" + serverName + uniqueServerId;

    ObjectName autofetchName;

    try {

      autofetchName = new ObjectName(mbeanName + ",key=AutoFetch");

    } catch (Exception e) {

      String msg = "Failed to register the JMX beans for Ebean server [" + serverName + "].";

      logger.error(msg, e);

      return;

    }

    try {

      mbeanServer.registerMBean(adminAutofetch, autofetchName);

    } catch (InstanceAlreadyExistsException e) {

      // tomcat webapp reloading

      String msg = "JMX beans for Ebean server [" + serverName + "] already registered. Will try unregister/register" + e.getMessage();

      logger.warn(msg);

      try {

        mbeanServer.unregisterMBean(autofetchName);

        mbeanServer.registerMBean(adminAutofetch, autofetchName);

      } catch (Exception ae) {

        String amsg = "Unable to unregister/register the JMX beans for Ebean server [" + serverName + "].";

        logger.error(amsg, ae);

      }

    } catch (Exception e) {

      String msg = "Error registering MBean[" + mbeanName + "]";

      logger.error(msg, e);

    }

  }

  /**

   * Shutting down via JVM Shutdown hook.

   */

  public void shutdownManaged() {

    synchronized (this) {

      shutdownInternal(true, false);

    }

  }

  /**

   * Shutting down manually.

   */

  public void shutdown(boolean shutdownDataSource, boolean deregisterDriver) {

    synchronized (this) {

      // Unregister from JVM Shutdown hook

      ShutdownManager.unregisterEbeanServer(this);

      shutdownInternal(shutdownDataSource, deregisterDriver);

    }

  }

  /**

   * Shutdown the services like threads and DataSource.

   */

  private void shutdownInternal(boolean shutdownDataSource, boolean deregisterDriver) {

    logger.debug("Shutting down EbeanServer " + getName());

    if (shutdown) {

      // Already shutdown

      return;

    }

    try {

      if (mbeanServer != null) {

        mbeanServer.unregisterMBean(new ObjectName(mbeanName + ",key=AutoFetch"));

      }

    } catch (Exception e) {

      logger.error("Error unregistering Ebean " + mbeanName, e);

    }

    // shutdown autofetch profile collection

    autoFetchManager.shutdown();

    // shutdown background threads

    backgroundExecutor.shutdown();

    // shutdown DataSource (if its an Ebean one)

    transactionManager.shutdown(shutdownDataSource, deregisterDriver);

    shutdown = true;

  }

 

  /**

   * Return the server name.

   */

  public String getName() {

    return serverName;

  }

  public BeanState getBeanState(Object bean) {

    if (bean instanceof EntityBean) {

      return new DefaultBeanState((EntityBean) bean);

    }

    // Not an entity bean

    return null;

  }

  /**

   * Run the cache warming queries on all beans that have them defined.

   */

  public void runCacheWarming() {

    List<BeanDescriptor<?>> descList = beanDescriptorManager.getBeanDescriptorList();

    for (int i = 0; i < descList.size(); i++) {

      descList.get(i).runCacheWarming();

    }

  }

  public void runCacheWarming(Class<?> beanType) {

    BeanDescriptor<?> desc = beanDescriptorManager.getBeanDescriptor(beanType);

    if (desc == null) {

      String msg = "Is " + beanType + " an entity? Could not find a BeanDescriptor";

      throw new PersistenceException(msg);

    } else {

      desc.runCacheWarming();

    }

  }

  /**

   * Compile a query. Only valid for ORM queries.

   */

  public <T> CQuery<T> compileQuery(Query<T> query, Transaction t) {

    SpiOrmQueryRequest<T> qr = createQueryRequest(Type.SUBQUERY, query, t);

    OrmQueryRequest<T> orm = (OrmQueryRequest<T>) qr;

    return cqueryEngine.buildQuery(orm);

  }

  public CQueryEngine getQueryEngine() {

    return cqueryEngine;

  }

  public ServerCacheManager getServerCacheManager() {

    return serverCacheManager;

  }

  /**

   * Return the Profile Listener.

   */

  public AutoFetchManager getProfileListener() {

    return autoFetchManager;

  }

  /**

   * Return the Relational query engine.

   */

  public RelationalQueryEngine getRelationalQueryEngine() {

    return relationalQueryEngine;

  }

  public void refreshMany(Object parentBean, String propertyName, Transaction t) {

    beanLoader.refreshMany(checkEntityBean(parentBean), propertyName, t);

  }

  public void refreshMany(Object parentBean, String propertyName) {

    beanLoader.refreshMany(checkEntityBean(parentBean), propertyName);

  }

  public void loadMany(LoadManyRequest loadRequest) {

    beanLoader.loadMany(loadRequest);

  }

  public void loadMany(BeanCollection<?> bc, boolean onlyIds) {

    beanLoader.loadMany(bc, onlyIds);

  }

  public void refresh(Object bean) {

    beanLoader.refresh(checkEntityBean(bean));

  }

  public void loadBean(LoadBeanRequest loadRequest) {

    beanLoader.loadBean(loadRequest);

  }

  public void loadBean(EntityBeanIntercept ebi) {

    beanLoader.loadBean(ebi);

  }

  public Map<String, ValuePair> diff(Object a, Object b) {

    if (a == null) {

      return null;

    }

    BeanDescriptor<?> desc = getBeanDescriptor(a.getClass());

    return diffHelp.diff(a, b, desc);

  }

  /**

   * Process committed beans from another framework or server in another

   * cluster.

   * <p>

   * This notifies this instance of the framework that beans have been committed

   * externally to it. Either by another framework or clustered server. It needs

   * to maintain its cache and text indexes appropriately.

   * </p>

   */

  public void externalModification(TransactionEventTable tableEvent) {

    SpiTransaction t = transactionScopeManager.get();

    if (t != null) {

      t.getEvent().add(tableEvent);

    } else {

      transactionManager.externalModification(tableEvent);

    }

  }

  /**

   * Developer informing eBean that tables where modified outside of eBean.

   * Invalidate the cache etc as required.

   */

  public void externalModification(String tableName, boolean inserts, boolean updates, boolean deletes) {

    TransactionEventTable evt = new TransactionEventTable();

    evt.add(tableName, inserts, updates, deletes);

    externalModification(evt);

  }

  /**

   * Clear the query execution statistics.

   */

  public void clearQueryStatistics() {

    for (BeanDescriptor<?> desc : getBeanDescriptors()) {

      desc.clearQueryStatistics();

    }

  }

  /**

   * Create a new EntityBean bean.

   * <p>

   * This will generally return a subclass of the parameter 'type' which

   * additionally implements the EntityBean interface. That is, the returned

   * bean is typically an instance of a dynamically generated class.

   * </p>

   */

  @SuppressWarnings("unchecked")

  public <T> T createEntityBean(Class<T> type) {

    BeanDescriptor<T> desc = getBeanDescriptor(type);

    return (T) desc.createEntityBean();

  }

  /**

   * Return a Reference bean.

   * <p>

   * If a current transaction is active then this will check the Context of that

   * transaction to see if the bean is already loaded. If it is already loaded

   * then it will returned that object.

   * </p>

   */

  @SuppressWarnings({ "unchecked", "rawtypes" })

  public <T> T getReference(Class<T> type, Object id) {

    if (id == null) {

      throw new NullPointerException("The id is null");

    }

    BeanDescriptor desc = getBeanDescriptor(type);

    // convert the id type if necessary

    id = desc.convertId(id);

    Object ref = null;

    PersistenceContext ctx = null;

    SpiTransaction t = transactionScopeManager.get();

    if (t != null) {

      // first try the persistence context

      ctx = t.getPersistenceContext();

      ref = ctx.get(type, id);

    }

    if (ref == null) {

      InheritInfo inheritInfo = desc.getInheritInfo();

      if (inheritInfo != null) {

        // we actually need to do a query because

        // we don't know the type without the

        // discriminator value

        BeanProperty idProp = desc.getIdProperty();

        if (idProp == null) {

          throw new PersistenceException("No ID properties for this type? " + desc);         

        }

       

        // just select the id properties and

        // the discriminator column (auto added)

        Query<T> query = createQuery(type);

        query.select(idProp.getName()).setId(id);

        ref = query.findUnique();

      } else {

        // use the default reference options

        ref = desc.createReference(null, id);

      }

      if (ctx != null && (ref instanceof EntityBean)) {

        // Not putting a vanilla reference in the persistence context

        ctx.put(id, ref);

      }

    }

    return (T) ref;

  }

  /**

   * Creates a new Transaction that is NOT stored in TransactionThreadLocal. Use

   * this when you want a thread to have a second independent transaction.

   */

  public Transaction createTransaction() {

    return transactionManager.createTransaction(true, -1);

  }

  /**

   * Create a transaction additionally specify the Isolation level.

   * <p>

   * Note that this transaction is not stored in a thread local.

   * </p>

   */

  public Transaction createTransaction(TxIsolation isolation) {

    return transactionManager.createTransaction(true, isolation.getLevel());

  }

  public <T> T execute(TxCallable<T> c) {

    return execute(null, c);

  }

  public <T> T execute(TxScope scope, TxCallable<T> c) {

    ScopeTrans scopeTrans = createScopeTrans(scope);

    try {

      return c.call();

    } catch (Error e) {

      throw scopeTrans.caughtError(e);

    } catch (RuntimeException e) {

      throw scopeTrans.caughtThrowable(e);

    } finally {

      scopeTrans.onFinally();

    }

  }

  public void execute(TxRunnable r) {

    execute(null, r);

  }

  public void execute(TxScope scope, TxRunnable r) {

    ScopeTrans scopeTrans = createScopeTrans(scope);

    try {

      r.run();

    } catch (Error e) {

      throw scopeTrans.caughtError(e);

    } catch (RuntimeException e) {

      throw scopeTrans.caughtThrowable(e);

    } finally {

      scopeTrans.onFinally();

    }

  }

  /**

   * Determine whether to create a new transaction or not.

   * <p>

   * This will also potentially throw exceptions for MANDATORY and NEVER types.

   * </p>

   */

  private boolean createNewTransaction(SpiTransaction t, TxScope scope) {

    TxType type = scope.getType();

    switch (type) {

    case REQUIRED:

      return t == null;

    case REQUIRES_NEW:

      return true;

    case MANDATORY:

      if (t == null) {

        throw new PersistenceException("Transaction missing when MANDATORY");

      }

      return true;

    case NEVER:

      if (t != null) {

        throw new PersistenceException("Transaction exists for Transactional NEVER");

      }

      return false;

    case SUPPORTS:

      return false;

    case NOT_SUPPORTED:

      throw new RuntimeException("NOT_SUPPORTED should already be handled?");

    default:

      throw new RuntimeException("Should never get here?");

    }

  }

  public ScopeTrans createScopeTrans(TxScope txScope) {

    if (txScope == null) {

      // create a TxScope with default settings

      txScope = new TxScope();

    }

    SpiTransaction suspended = null;

    // get current transaction from ThreadLocal or equivalent

    SpiTransaction t = transactionScopeManager.get();

    boolean newTransaction;

    if (txScope.getType().equals(TxType.NOT_SUPPORTED)) {

      // Suspend existing transaction and

      // run without a transaction in scope

      newTransaction = false;

      suspended = t;

      t = null;

    } else {

      // create a new Transaction based on TxType and t

      newTransaction = createNewTransaction(t, txScope);

      if (newTransaction) {

        // suspend existing transaction (if there is one)

        suspended = t;

        // create a new transaction

        int isoLevel = -1;

        TxIsolation isolation = txScope.getIsolation();

        if (isolation != null) {

          isoLevel = isolation.getLevel();

        }

        t = transactionManager.createTransaction(true, isoLevel);

      }

    }

    // replace the current transaction ... ScopeTrans.onFinally()

    // has the job of restoring the suspended transaction

    transactionScopeManager.replace(t);

    return new ScopeTrans(rollbackOnChecked, newTransaction, t, txScope, suspended, transactionScopeManager);

  }

  /**

   * Returns the current transaction (or null) from the scope.

   */

  public SpiTransaction getCurrentServerTransaction() {

    return transactionScopeManager.get();

  }

  /**

   * Start a transaction.

   * <p>

   * Note that the transaction is stored in a ThreadLocal variable.

   * </p>

   */

  public Transaction beginTransaction() {

    // start an explicit transaction

    SpiTransaction t = transactionManager.createTransaction(true, -1);

    transactionScopeManager.set(t);

    return t;

  }

  /**

   * Start a transaction with a specific Isolation Level.

   * <p>

   * Note that the transaction is stored in a ThreadLocal variable.

   * </p>

   */

  public Transaction beginTransaction(TxIsolation isolation) {

    // start an explicit transaction

    SpiTransaction t = transactionManager.createTransaction(true, isolation.getLevel());

    transactionScopeManager.set(t);

    return t;

  }

  /**

   * Return the current transaction or null if there is not one currently in

   * scope.

   */

  public Transaction currentTransaction() {

    return transactionScopeManager.get();

  }

  /**

   * Commit the current transaction.

   */

  public void commitTransaction() {

    transactionScopeManager.commit();

  }

  /**

   * Rollback the current transaction.

   */

  public void rollbackTransaction() {

    transactionScopeManager.rollback();

  }

  /**

   * If the current transaction has already been committed do nothing otherwise

   * rollback the transaction.

   * <p>

   * Useful to put in a finally block to ensure the transaction is ended, rather

   * than a rollbackTransaction() in each catch block.

   * </p>

   * <p>

   * Code example:<br />

   *

   * <pre>

   * &lt;code&gt;

   * Ebean.startTransaction();

   * try {

   *   // do some fetching and or persisting

   *

   *   // commit at the end

   *   Ebean.commitTransaction();

   *

   * } finally {

   *   // if commit didn't occur then rollback the transaction

   *   Ebean.endTransaction();

   * }

   * &lt;/code&gt;

   * </pre>

   *

   * </p>

   */

  public void endTransaction() {

    transactionScopeManager.end();

  }

  /**

   * return the next unique identity value.

   * <p>

   * Uses the BeanDescriptor deployment information to determine the sequence to

   * use.

   * </p>

   */

  public Object nextId(Class<?> beanType) {

    BeanDescriptor<?> desc = getBeanDescriptor(beanType);

    return desc.nextId(null);

  }

  @SuppressWarnings("unchecked")

  public <T> void sort(List<T> list, String sortByClause) {

    if (list == null) {

      throw new NullPointerException("list is null");

    }

    if (sortByClause == null) {

      throw new NullPointerException("sortByClause is null");

    }

    if (list.size() == 0) {

      // don't need to sort an empty list

      return;

    }

    // use first bean in the list as the correct type

    Class<T> beanType = (Class<T>) list.get(0).getClass();

    BeanDescriptor<T> beanDescriptor = getBeanDescriptor(beanType);

    if (beanDescriptor == null) {

      String m = "BeanDescriptor not found, is [" + beanType + "] an entity bean?";

      throw new PersistenceException(m);

    }

    beanDescriptor.sort(list, sortByClause);

  }

  public <T> Query<T> createQuery(Class<T> beanType) throws PersistenceException {

    return createQuery(beanType, null);

  }

  public <T> Query<T> createNamedQuery(Class<T> beanType, String namedQuery) throws PersistenceException {

    BeanDescriptor<?> desc = getBeanDescriptor(beanType);

    if (desc == null) {

      throw new PersistenceException("Is " + beanType.getName() + " an Entity Bean? BeanDescriptor not found?");

    }

    DeployNamedQuery deployQuery = desc.getNamedQuery(namedQuery);

    if (deployQuery == null) {

      throw new PersistenceException("named query " + namedQuery + " was not found for " + desc.getFullName());

    }

    // this will parse the query

    return new DefaultOrmQuery<T>(beanType, this, expressionFactory, deployQuery);

  }

  public <T> Filter<T> filter(Class<T> beanType) {

    BeanDescriptor<T> desc = getBeanDescriptor(beanType);

    if (desc == null) {

      String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";

      throw new PersistenceException(m);

    }

    return new ElFilter<T>(desc);

  }

  public <T> CsvReader<T> createCsvReader(Class<T> beanType) {

    BeanDescriptor<T> descriptor = getBeanDescriptor(beanType);

    if (descriptor == null) {

      throw new NullPointerException("BeanDescriptor for " + beanType.getName() + " not found");

    }

    return new TCsvReader<T>(this, descriptor);

  }

  public <T> Query<T> find(Class<T> beanType) {

    return createQuery(beanType);

  }

  public <T> Query<T> createQuery(Class<T> beanType, String query) {

    BeanDescriptor<?> desc = getBeanDescriptor(beanType);

    if (desc == null) {

      String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";

      throw new PersistenceException(m);

    }

    switch (desc.getEntityType()) {

    case SQL:

      if (query != null) {

        throw new PersistenceException("You must used Named queries for this Entity " + desc.getFullName());

      }

      // use the "default" SqlSelect

      DeployNamedQuery defaultSqlSelect = desc.getNamedQuery("default");

      return new DefaultOrmQuery<T>(beanType, this, expressionFactory, defaultSqlSelect);

    default:

      return new DefaultOrmQuery<T>(beanType, this, expressionFactory, query);

    }

  }

  public <T> Update<T> createNamedUpdate(Class<T> beanType, String namedUpdate) {

    BeanDescriptor<?> desc = getBeanDescriptor(beanType);

    if (desc == null) {

      String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";

      throw new PersistenceException(m);

    }

    DeployNamedUpdate deployUpdate = desc.getNamedUpdate(namedUpdate);

    if (deployUpdate == null) {

      throw new PersistenceException("named update " + namedUpdate + " was not found for " + desc.getFullName());

    }

    return new DefaultOrmUpdate<T>(beanType, this, desc.getBaseTable(), deployUpdate);

  }

  public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) {

    BeanDescriptor<?> desc = getBeanDescriptor(beanType);

    if (desc == null) {

      String m = beanType.getName() + " is NOT an Entity Bean registered with this server?";

      throw new PersistenceException(m);

    }

    return new DefaultOrmUpdate<T>(beanType, this, desc.getBaseTable(), ormUpdate);

  }

  public SqlQuery createSqlQuery(String sql) {

    return new DefaultRelationalQuery(this, sql);

  }

  public SqlQuery createNamedSqlQuery(String namedQuery) {

    DNativeQuery nq = beanDescriptorManager.getNativeQuery(namedQuery);

    if (nq == null) {

      throw new PersistenceException("SqlQuery " + namedQuery + " not found.");

    }

    return new DefaultRelationalQuery(this, nq.getQuery());

  }

  public SqlUpdate createSqlUpdate(String sql) {

    return new DefaultSqlUpdate(this, sql);

  }

  public CallableSql createCallableSql(String sql) {

    return new DefaultCallableSql(this, sql);

  }

  public SqlUpdate createNamedSqlUpdate(String namedQuery) {

    DNativeQuery nq = beanDescriptorManager.getNativeQuery(namedQuery);

    if (nq == null) {

      throw new PersistenceException("SqlUpdate " + namedQuery + " not found.");

    }

    return new DefaultSqlUpdate(this, nq.getQuery());

  }

  public <T> T find(Class<T> beanType, Object uid) {

    return find(beanType, uid, null);

  }

  /**

   * Find a bean using its unique id.

   */

  public <T> T find(Class<T> beanType, Object id, Transaction t) {

    if (id == null) {

      throw new NullPointerException("The id is null");

    }

    Query<T> query = createQuery(beanType).setId(id);

    return findId(query, t);

  }

  private <T> SpiOrmQueryRequest<T> createQueryRequest(Type type, Query<T> query, Transaction t) {

    SpiQuery<T> spiQuery = (SpiQuery<T>) query;

    spiQuery.setType(type);

    BeanDescriptor<T> desc = beanDescriptorManager.getBeanDescriptor(spiQuery.getBeanType());

    spiQuery.setBeanDescriptor(desc);

    return createQueryRequest(desc, spiQuery, t);

  }

  public <T> SpiOrmQueryRequest<T> createQueryRequest(BeanDescriptor<T> desc, SpiQuery<T> query, Transaction t) {

    if (desc.isAutoFetchTunable() && !query.isSqlSelect()) {

      // its a tunable query

      if (autoFetchManager.tuneQuery(query)) {

        // was automatically tuned by Autofetch

      } else {

        // use deployment FetchType.LAZY/EAGER annotations

        // to define the 'default' select clause

        query.setDefaultSelectClause();

      }

    }