/**
   * Flushes all value caches contained within entities controlled by this <code>EntityManager
   * </code> instance. This does not actually remove the entities from the instance cache maintained
   * within this class. Rather, it simply dumps all of the field values cached within the entities
   * themselves (with the exception of the primary key value). This should be used in the case of a
   * complex process outside AO control which may have changed values in the database. If it is at
   * all possible to determine precisely which rows have been changed, the {@link
   * #flush(RawEntity...)} method should be used instead.
   */
  public void flushAll() {
    List<Map.Entry<RawEntity<?>, EntityProxy<? extends RawEntity<?>, ?>>> toFlush =
        new LinkedList<Map.Entry<RawEntity<?>, EntityProxy<? extends RawEntity<?>, ?>>>();

    proxyLock.readLock().lock();
    try {
      for (Map.Entry<RawEntity<?>, EntityProxy<? extends RawEntity<?>, ?>> proxy :
          proxies.entrySet()) {
        toFlush.add(proxy);
      }
    } finally {
      proxyLock.readLock().unlock();
    }

    for (Map.Entry<RawEntity<?>, EntityProxy<? extends RawEntity<?>, ?>> entry : toFlush) {
      entry.getValue().flushCache(entry.getKey());
    }

    relationsCache.flush();
  }
  /**
   * Flushes the value caches of the specified entities along with all of the relevant relations
   * cache entries. This should be called after a process outside of AO control may have modified
   * the values in the specified rows. This does not actually remove the entity instances themselves
   * from the instance cache. Rather, it just flushes all of their internally cached values (with
   * the exception of the primary key).
   */
  public void flush(RawEntity<?>... entities) {
    List<Class<? extends RawEntity<?>>> types =
        new ArrayList<Class<? extends RawEntity<?>>>(entities.length);
    Map<RawEntity<?>, EntityProxy<?, ?>> toFlush = new HashMap<RawEntity<?>, EntityProxy<?, ?>>();

    proxyLock.readLock().lock();
    try {
      for (RawEntity<?> entity : entities) {
        verify(entity);

        types.add(entity.getEntityType());
        toFlush.put(entity, proxies.get(entity));
      }
    } finally {
      proxyLock.readLock().unlock();
    }

    for (Entry<RawEntity<?>, EntityProxy<?, ?>> entry : toFlush.entrySet()) {
      entry.getValue().flushCache(entry.getKey());
    }

    relationsCache.remove(types.toArray(new Class[types.size()]));
  }
  /**
   * Deletes the specified entities from the database. DELETE statements are called on the rows in
   * the corresponding tables and the entities are removed from the instance cache. The entity
   * instances themselves are not invalidated, but it doesn't even make sense to continue using the
   * instance without a row with which it is paired.
   *
   * <p>This method does attempt to group the DELETE statements on a per-type basis. Thus, if you
   * pass 5 instances of <code>EntityA</code> and two instances of <code>EntityB</code>, the
   * following SQL prepared statements will be invoked:
   *
   * <pre>DELETE FROM entityA WHERE id IN (?,?,?,?,?);
   * DELETE FROM entityB WHERE id IN (?,?);</pre>
   *
   * <p>Thus, this method scales very well for large numbers of entities grouped into types.
   * However, the execution time increases linearly for each entity of unique type.
   *
   * @param entities A varargs array of entities to delete. Method returns immediately if length ==
   *     0.
   */
  @SuppressWarnings("unchecked")
  public void delete(RawEntity<?>... entities) throws SQLException {
    if (entities.length == 0) {
      return;
    }

    Map<Class<? extends RawEntity<?>>, List<RawEntity<?>>> organizedEntities =
        new HashMap<Class<? extends RawEntity<?>>, List<RawEntity<?>>>();

    for (RawEntity<?> entity : entities) {
      verify(entity);
      Class<? extends RawEntity<?>> type = getProxyForEntity(entity).getType();

      if (!organizedEntities.containsKey(type)) {
        organizedEntities.put(type, new LinkedList<RawEntity<?>>());
      }
      organizedEntities.get(type).add(entity);
    }

    entityCacheLock.writeLock().lock();
    try {
      DatabaseProvider provider = getProvider();
      Connection conn = provider.getConnection();
      try {
        for (Class<? extends RawEntity<?>> type : organizedEntities.keySet()) {
          List<RawEntity<?>> entityList = organizedEntities.get(type);

          StringBuilder sql = new StringBuilder("DELETE FROM ");

          tableNameConverterLock.readLock().lock();
          try {
            sql.append(provider.processID(tableNameConverter.getName(type)));
          } finally {
            tableNameConverterLock.readLock().unlock();
          }

          sql.append(" WHERE ")
              .append(provider.processID(Common.getPrimaryKeyField(type, getFieldNameConverter())))
              .append(" IN (?");

          for (int i = 1; i < entityList.size(); i++) {
            sql.append(",?");
          }
          sql.append(')');

          Logger.getLogger("net.java.ao").log(Level.INFO, sql.toString());
          PreparedStatement stmt = conn.prepareStatement(sql.toString());

          int index = 1;
          for (RawEntity<?> entity : entityList) {
            TypeManager.getInstance()
                .getType((Class) entity.getEntityType())
                .putToDatabase(this, stmt, index++, entity);
          }

          relationsCache.remove(type);
          stmt.executeUpdate();
          stmt.close();
        }
      } finally {
        conn.close();
      }

      for (RawEntity<?> entity : entities) {
        entityCache.remove(new CacheKey(Common.getPrimaryKeyValue(entity), entity.getEntityType()));
      }

      proxyLock.writeLock().lock();
      try {
        for (RawEntity<?> entity : entities) {
          proxies.remove(entity);
        }
      } finally {
        proxyLock.writeLock().unlock();
      }
    } finally {
      entityCacheLock.writeLock().unlock();
    }
  }
  /**
   * Creates a new entity of the specified type with the optionally specified initial parameters.
   * This method actually inserts a row into the table represented by the entity type and returns
   * the entity instance which corresponds to that row.
   *
   * <p>The {@link DBParam} object parameters are designed to allow the creation of entities which
   * have non-null fields which have no defalut or auto-generated value. Insertion of a row without
   * such field values would of course fail, thus the need for db params. The db params can also be
   * used to set the values for any field in the row, leading to more compact code under certain
   * circumstances.
   *
   * <p>Unless within a transaction, this method will commit to the database immediately and exactly
   * once per call. Thus, care should be taken in the creation of large numbers of entities. There
   * doesn't seem to be a more efficient way to create large numbers of entities, however one should
   * still be aware of the performance implications.
   *
   * <p>This method delegates the action INSERT action to {@link
   * DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, boolean, String,
   * DBParam...)}. This is necessary because not all databases support the JDBC <code>
   * RETURN_GENERATED_KEYS</code> constant (e.g. PostgreSQL and HSQLDB). Thus, the database provider
   * itself is responsible for handling INSERTion and retrieval of the correct primary key value.
   *
   * @param type The type of the entity to INSERT.
   * @param params An optional varargs array of initial values for the fields in the row. These
   *     values will be passed to the database within the INSERT statement.
   * @return The new entity instance corresponding to the INSERTed row.
   * @see net.java.ao.DBParam
   * @see net.java.ao.DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String,
   *     boolean, String, DBParam...)
   */
  public <T extends RawEntity<K>, K> T create(Class<T> type, DBParam... params)
      throws SQLException {
    T back = null;
    String table = null;

    tableNameConverterLock.readLock().lock();
    try {
      table = tableNameConverter.getName(type);
    } finally {
      tableNameConverterLock.readLock().unlock();
    }

    Set<DBParam> listParams = new HashSet<DBParam>();
    listParams.addAll(Arrays.asList(params));

    fieldNameConverterLock.readLock().lock();
    try {
      for (Method method : MethodFinder.getInstance().findAnnotation(Generator.class, type)) {
        Generator genAnno = method.getAnnotation(Generator.class);
        String field = fieldNameConverter.getName(method);
        ValueGenerator<?> generator;

        valGenCacheLock.writeLock().lock();
        try {
          if (valGenCache.containsKey(genAnno.value())) {
            generator = valGenCache.get(genAnno.value());
          } else {
            generator = genAnno.value().newInstance();
            valGenCache.put(genAnno.value(), generator);
          }
        } catch (InstantiationException e) {
          continue;
        } catch (IllegalAccessException e) {
          continue;
        } finally {
          valGenCacheLock.writeLock().unlock();
        }

        listParams.add(new DBParam(field, generator.generateValue(this)));
      }
      // <ian>
      Version version = type.getAnnotation(Version.class);
      if (version != null) {
        // Initialize version upon creation.
        String field = version.value();
        int initial = version.initial();
        listParams.add(new DBParam(field, initial));
      }
      // </ian>
    } finally {
      fieldNameConverterLock.readLock().unlock();
    }

    Connection conn = getProvider().getConnection();
    try {
      Method pkMethod = Common.getPrimaryKeyMethod(type);
      back =
          peer(
              type,
              provider.insertReturningKey(
                  this,
                  conn,
                  Common.getPrimaryKeyClassType(type),
                  Common.getPrimaryKeyField(type, getFieldNameConverter()),
                  pkMethod.getAnnotation(AutoIncrement.class) != null,
                  table,
                  listParams.toArray(new DBParam[listParams.size()])));
    } finally {
      conn.close();
    }

    relationsCache.remove(type);

    back.init();

    return back;
  }