Exemplo n.º 1
0
/**
 * The root of the persistence model.
 *
 * @author hceylan
 * @since $version
 */
public class MetamodelImpl implements Metamodel {

  private static class GeneratorThreadFactory implements ThreadFactory {

    private static volatile int nextThreadNo = 1;

    /** {@inheritDoc} */
    @Override
    public Thread newThread(Runnable r) {
      final Thread thread =
          new Thread(r, "Id Generator - " + GeneratorThreadFactory.nextThreadNo++);

      thread.setPriority(Thread.MAX_PRIORITY);

      return thread;
    }
  }

  private static final BLogger LOG = BLoggerFactory.getLogger(MetamodelImpl.class);

  // TODO Consider making this configurable
  private static final long POLL_TIMEOUT = 60;

  private EntityManagerFactoryImpl emf;
  private final JdbcAdaptor jdbcAdaptor;

  private final Map<Class<?>, BasicTypeImpl<?>> basics = Maps.newHashMap();
  private final Map<Class<?>, MappedSuperclassType<?>> mappedSuperclasses = Maps.newHashMap();
  private final Map<Class<?>, EmbeddableType<?>> embeddables = Maps.newHashMap();
  private final Map<Class<?>, EntityTypeImpl<?>> entities = Maps.newHashMap();
  private final Map<String, EntityTypeImpl<?>> entitiesByName = Maps.newHashMap();
  private final Map<String, NamedQueryMetadata> namedQueries = Maps.newHashMap();

  private final CallbackManager callbackManager;

  private final Map<String, SequenceGenerator> sequenceGenerators = Maps.newHashMap();
  private final Map<String, TableGenerator> tableGenerators = Maps.newHashMap();

  private final Map<String, SequenceQueue> sequenceQueues = Maps.newHashMap();
  private final Map<String, TableIdQueue> tableIdQueues = Maps.newHashMap();

  private ThreadPoolExecutor idGeneratorExecuter;

  /**
   * @param entityManagerFactory the entity manager factory
   * @param jdbcAdaptor the JDBC Adaptor
   * @param metadata the metadata
   * @since $version
   * @author hceylan
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public MetamodelImpl(
      EntityManagerFactoryImpl entityManagerFactory,
      JdbcAdaptor jdbcAdaptor,
      MetadataImpl metadata) {
    super();

    this.emf = entityManagerFactory;
    this.jdbcAdaptor = jdbcAdaptor;

    final List<ManagedTypeMetadata> entities = Lists.newArrayList(metadata.getEntityMappings());
    final List<ManagedTypeMetadata> sortedEntities = Lists.newArrayList();

    // sort so that the embeddables are first
    Collections.sort(
        entities,
        new Comparator<ManagedTypeMetadata>() {

          @Override
          public int compare(ManagedTypeMetadata o1, ManagedTypeMetadata o2) {
            if (o1 instanceof EmbeddableMetadata) {
              return -1;
            }

            if (o2 instanceof EmbeddableMetadata) {
              return 1;
            }

            return 0;
          }
        });

    // sort by inheritance
    try {
      while (entities.size() > 0) {
        for (final Iterator<ManagedTypeMetadata> i = entities.iterator(); i.hasNext(); ) {
          final ManagedTypeMetadata entity = i.next();
          final Class<?> c1 = this.emf.getClassloader().loadClass(entity.getClassName());

          boolean independent = true;
          for (final ManagedTypeMetadata entity2 : entities) {
            if (entity == entity2) {
              continue;
            }

            final Class<?> c2 = this.emf.getClassloader().loadClass(entity2.getClassName());

            if (c2.isAssignableFrom(c1)) {
              independent = false;
              break;
            }
          }

          if (independent) {
            i.remove();
            sortedEntities.add(entity);
          }
        }
      }
    } catch (final Exception e) {
    } // not possible at this stage

    for (final ManagedTypeMetadata type : sortedEntities) {
      try {
        final Class<?> clazz = this.emf.getClassloader().loadClass(type.getClassName());

        ManagedTypeImpl<?> parent = null;

        // locate the parent
        Class<?> currentClass = clazz.getSuperclass();
        while ((currentClass != Object.class) && (parent == null)) {
          parent = this.managedType(currentClass);
          currentClass = currentClass.getSuperclass();
        }

        if (type instanceof EntityMetadata) {
          // make sure it extends an identifiable type
          if ((parent != null) && !(parent instanceof IdentifiableTypeImpl)) {
            throw new MappingException(
                "Entities can only extend MappedSuperclasses or other Entities.",
                type.getLocator(),
                parent.getLocator());
          }

          final EntityTypeImpl entity =
              new EntityTypeImpl(this, (IdentifiableTypeImpl) parent, clazz, (EntityMetadata) type);

          this.entities.put(entity.getJavaType(), entity);
          this.entitiesByName.put(entity.getName(), entity);
          this.entitiesByName.put(entity.getJavaType().getName(), entity);
        } else if (type instanceof MappedSuperclassMetadata) {
          // make sure it extends a mapped superclass type
          if ((parent != null) && !(parent instanceof MappedSuperclassTypeImpl)) {
            throw new MappingException(
                "MappedSuperclasses can only extend other MappedSuperclasses.",
                type.getLocator(),
                parent.getLocator());
          }

          final MappedSuperclassTypeImpl mappedSuperclass =
              new MappedSuperclassTypeImpl(
                  this, (MappedSuperclassTypeImpl) parent, clazz, (MappedSuperclassMetadata) type);
          this.mappedSuperclasses.put(mappedSuperclass.getJavaType(), mappedSuperclass);
        }
        if (type instanceof EmbeddableMetadata) {
          // make sure it extends a embeddable type
          if ((parent != null) && !(parent instanceof EmbeddableTypeImpl)) {
            throw new MappingException(
                "Embeddables can only extend a other Embeddables.",
                type.getLocator(),
                parent.getLocator());
          }

          final EmbeddableTypeImpl embeddable =
              new EmbeddableTypeImpl(this, clazz, (EmbeddableMetadata) type);
          this.embeddables.put(embeddable.getJavaType(), embeddable);
        }

      } catch (final ClassNotFoundException e) {
      } // not possible at this time
    }

    this.callbackManager = new CallbackManager(metadata.getEntityListeners());

    this.addNamedQueries(metadata.getNamedQueries());
    for (final ManagedTypeMetadata entity : entities) {
      if (entity instanceof EntityMetadata) {
        this.addNamedQueries(((EntityMetadata) entity).getNamedQueries());
      }
    }
  }

  /**
   * Adds the named queries to the metamodel.
   *
   * @param namedQueries
   * @since $version
   * @author hceylan
   */
  private void addNamedQueries(List<NamedQueryMetadata> namedQueries) {
    for (final NamedQueryMetadata namedQuery : namedQueries) {
      final NamedQueryMetadata existing = this.namedQueries.put(namedQuery.getName(), namedQuery);
      if (existing != null) {
        throw new MappingException(
            "Duplicate named query with the name: " + namedQuery.getName(),
            existing.getLocator(),
            namedQuery.getLocator());
      }
    }
  }

  /**
   * Adds the sequence generator to the metamodel
   *
   * @param metadata the generator metadata
   * @since $version
   * @author hceylan
   */
  public synchronized void addSequenceGenerator(SequenceGeneratorMetadata metadata) {
    final SequenceGenerator sequenceGenerator = new SequenceGenerator(metadata);
    this.sequenceGenerators.put(sequenceGenerator.getName(), sequenceGenerator);
  }

  /**
   * Adds the sequence generator to the metamodel
   *
   * @param metadata the generator metadata
   * @since $version
   * @author hceylan
   */
  public synchronized void addTableGenerator(TableGeneratorMetadata metadata) {
    final TableGenerator tableGenerator = new TableGenerator(metadata);

    this.tableGenerators.put(tableGenerator.getName(), tableGenerator);
  }

  /**
   * Creates of returns an existing {@link BasicTypeImpl} of <code>clazz</code>
   *
   * @param clazz the class
   * @return the basic type
   * @param <T> the java type of the basic type
   * @since $version
   * @author hceylan
   */
  @SuppressWarnings("unchecked")
  public <T> BasicTypeImpl<T> createBasicType(Class<T> clazz) {
    final BasicTypeImpl<T> basicType = (BasicTypeImpl<T>) this.basics.get(clazz);
    if (basicType != null) {
      return basicType;
    }

    return this.lazyCreateBasicType(clazz);
  }

  /**
   * Drops all the tables in the database.
   *
   * @param datasource the datasource
   * @since $version
   * @author hceylan
   */
  public void dropAllTables(DataSource datasource) {
    final Set<AbstractTable> tables = Sets.newHashSet();

    for (final EntityTypeImpl<?> entity : this.entities.values()) {

      // collect the entity tables
      for (final EntityTable table : entity.getTables()) {
        // if table belongs to parent then skip
        if (table.getEntity() != entity) {
          continue;
        }

        tables.add(table);
      }

      // collect the join tables
      for (final AssociationMapping<?, ?, ?> mapping : entity.getAssociations()) {
        final JoinTable table = mapping.getTable();

        // skip not applicable tables
        if ((table == null) || (table.getEntity() != entity)) {
          continue;
        }

        tables.add(table);
      }

      // collect the join tables
      for (final PluralMapping<?, ?, ?> mapping : entity.getMappingsPlural()) {
        if (!mapping.isAssociation()) {
          final AbstractTable table = (AbstractTable) mapping.getTable();
          if (table != null) {
            tables.add(table);
          }
        }
      }
    }

    try {
      this.jdbcAdaptor.dropAllForeignKeys(datasource, tables);
      this.jdbcAdaptor.dropAllTables(datasource, tables);
      this.jdbcAdaptor.dropAllSequences(datasource, this.sequenceGenerators.values());
    } catch (final SQLException e) {
      throw new PersistenceException("Cannot drop tables", e);
    }
  }

  /** {@inheritDoc} */
  @Override
  @SuppressWarnings("unchecked")
  public <X> EmbeddableTypeImpl<X> embeddable(Class<X> clazz) {
    return (EmbeddableTypeImpl<X>) this.embeddables.get(clazz);
  }

  /** {@inheritDoc} */
  @Override
  @SuppressWarnings("unchecked")
  public <X> EntityTypeImpl<X> entity(Class<X> clazz) {
    return (EntityTypeImpl<X>) this.entities.get(clazz);
  }

  /**
   * Returns the entity by name.
   *
   * @param name the simple or fully qualified name of the entity.
   * @param <X> the type of the entity
   * @return the entity or null
   * @since $version
   * @author hceylan
   */
  @SuppressWarnings("unchecked")
  public <X> EntityTypeImpl<X> entity(String name) {
    return (EntityTypeImpl<X>) this.entitiesByName.get(name);
  }

  /**
   * Fires the callbacks.
   *
   * @param instance the instance
   * @param type the type
   * @since $version
   * @author hceylan
   */
  public void fireCallbacks(Object instance, EntityListenerType type) {
    this.callbackManager.fireCallbacks(instance, type);
  }

  /**
   * Returns the callback manager of the metamodel.
   *
   * @return the callback manager of the metamodel
   * @since $version
   * @author hceylan
   */
  public CallbackManager getCallbackManager() {
    return this.callbackManager;
  }

  /** {@inheritDoc} */
  @Override
  public Set<EmbeddableType<?>> getEmbeddables() {
    return Sets.newHashSet(this.embeddables.values());
  }

  /** {@inheritDoc} */
  @Override
  public Set<EntityType<?>> getEntities() {
    final Set<EntityType<?>> entities = Sets.newHashSet();

    for (final EntityType<?> entity : this.entities.values()) {
      entities.add(entity);
    }

    return entities;
  }

  /**
   * Returns the entity that corresponds to clazz's parant chain.
   *
   * @param clazz the class
   * @return the entity
   * @since $version
   * @author hceylan
   */
  public EntityTypeImpl<?> getEntity(Class<?> clazz) {
    EntityTypeImpl<?> entity = null;

    while ((entity == null) && (clazz != Object.class)) {
      entity = this.entity(clazz);
      if (entity != null) {
        break;
      }
      clazz = clazz.getSuperclass();
    }

    return entity;
  }

  /**
   * Returns the entity manager factory.
   *
   * @return the entity manager factory
   * @since $version
   * @author hceylan
   */
  public EntityManagerFactoryImpl getEntityManagerFactory() {
    return this.emf;
  }

  /**
   * Returns the identifiable types.
   *
   * @return the identifiable types
   * @since $version
   * @author hceylan
   */
  public Set<IdentifiableType<?>> getIdentifiables() {
    final Set<IdentifiableType<?>> identifiables = Sets.newHashSet();

    identifiables.addAll(this.mappedSuperclasses.values());
    identifiables.addAll(this.entities.values());

    return identifiables;
  }

  /**
   * Returns the JDBC Adaptor.
   *
   * @return the JDBC Adaptor
   * @since $version
   * @author hceylan
   */
  public JdbcAdaptor getJdbcAdaptor() {
    return this.jdbcAdaptor;
  }

  /** {@inheritDoc} */
  @Override
  public Set<ManagedType<?>> getManagedTypes() {
    final Set<ManagedType<?>> managedTypes = Sets.newHashSet();

    managedTypes.addAll(this.embeddables.values());
    managedTypes.addAll(this.mappedSuperclasses.values());
    managedTypes.addAll(this.entities.values());

    return managedTypes;
  }

  /**
   * Returns the set of named queries.
   *
   * @return the set of named queries
   * @since $version
   * @author hceylan
   */
  public Collection<NamedQueryMetadata> getNamedQueries() {
    return this.namedQueries.values();
  }

  /**
   * Returns the next sequence for the generator.
   *
   * @param generator the generator
   * @return the next sequence for the generator
   * @since $version
   * @author hceylan
   */
  public Long getNextSequence(String generator) {
    try {
      return this.sequenceQueues.get(generator).poll(MetamodelImpl.POLL_TIMEOUT, TimeUnit.SECONDS);
    } catch (final InterruptedException e) {
      throw new PersistenceException(
          "Unable to retrieve next sequence "
              + generator
              + " in allowed "
              + MetamodelImpl.POLL_TIMEOUT
              + " seconds");
    }
  }

  /**
   * Returns the next table value for the generator.
   *
   * @param generator the generator
   * @return the next table value for the generator
   * @since $version
   * @author hceylan
   */
  public Long getNextTableValue(String generator) {
    try {
      return this.tableIdQueues.get(generator).poll(MetamodelImpl.POLL_TIMEOUT, TimeUnit.SECONDS);
    } catch (final InterruptedException e) {
      throw new PersistenceException(
          "Unable to retrieve next sequence "
              + generator
              + " in allowed "
              + MetamodelImpl.POLL_TIMEOUT
              + " seconds");
    }
  }

  @SuppressWarnings({"unchecked", "rawtypes"})
  private synchronized <X> BasicTypeImpl<X> lazyCreateBasicType(Class<X> clazz) {
    // skip if annotated with @Entity, @MappedSuperClass or @Embeddable
    if ((clazz.getAnnotation(Entity.class) != null) //
        || (clazz.getAnnotation(MappedSuperclass.class) != null) //
        || (clazz.getAnnotation(Embeddable.class) != null)) {

      return null;
    }

    if (Serializable.class.isAssignableFrom(clazz) || clazz.isPrimitive()) {
      final BasicTypeImpl basicType = new BasicTypeImpl(this, clazz);
      this.basics.put(clazz, basicType);

      return basicType;
    }

    return null;
  }

  /** {@inheritDoc} */
  @Override
  @SuppressWarnings("unchecked")
  public <X> ManagedTypeImpl<X> managedType(Class<X> clazz) {
    ManagedTypeImpl<X> managedType = (ManagedTypeImpl<X>) this.embeddables.get(clazz);
    if (managedType != null) {
      return managedType;
    }

    managedType = (ManagedTypeImpl<X>) this.mappedSuperclasses.get(clazz);
    if (managedType != null) {
      return managedType;
    }

    return (ManagedTypeImpl<X>) this.entities.get(clazz);
  }

  /**
   * Performs the foreign key DDL operations.
   *
   * @param datasource the datasource
   * @param ddlMode the DDL Mode
   * @param entity the entity to perform DDL against
   * @throws BatooException thrown in case of an underlying exception
   * @since $version
   * @author hceylan
   */
  public void performForeignKeysDdl(
      DataSource datasource, DDLMode ddlMode, EntityTypeImpl<?> entity) {
    if ((ddlMode == DDLMode.NONE)) {
      return;
    }

    MetamodelImpl.LOG.info(
        "Performing foreign key DDL operations for entiy {0}, mode {1}", entity.getName(), ddlMode);

    for (final EntityTable table : entity.getTables()) {
      // skip parent tables
      if (table.getEntity() != entity) {
        continue;
      }

      MetamodelImpl.LOG.info(
          "Performing foreign key DDL operations for table {0}, mode {1}",
          table.getQName(), ddlMode);

      for (final ForeignKey foreignKey : table.getForeignKeys()) {
        this.jdbcAdaptor.createForeignKey(datasource, foreignKey);
      }
    }

    for (final AssociationMapping<?, ?, ?> mapping : entity.getAssociations()) {
      final JoinTable table = mapping.getTable();
      // skip not applicable join tables
      if ((table == null) || (table.getEntity() != entity)) {
        continue;
      }

      MetamodelImpl.LOG.info(
          "Performing foreign key DDL operations for join table {0}, mode {1}",
          table.getQName(), ddlMode);

      for (final ForeignKey foreignKey : table.getForeignKeys()) {
        this.jdbcAdaptor.createForeignKey(datasource, foreignKey);
      }
    }

    for (final PluralMapping<?, ?, ?> mapping : entity.getMappingsPlural()) {
      if (!mapping.isAssociation()) {
        final AbstractTable table = (AbstractTable) mapping.getTable();
        MetamodelImpl.LOG.info(
            "Performing foreign key DDL operations for join table {0}, mode {1}",
            table.getQName(), ddlMode);

        for (final ForeignKey foreignKey : table.getForeignKeys()) {
          this.jdbcAdaptor.createForeignKey(datasource, foreignKey);
        }
      }
    }
  }

  /**
   * Performs the sequence generators DDL operations.
   *
   * @param datasource the datasource
   * @param ddlMode the DDL Mode
   * @since $version
   * @author hceylan
   */
  public void performSequencesDdl(DataSource datasource, DDLMode ddlMode) {
    for (final SequenceGenerator sequenceGenerator : this.sequenceGenerators.values()) {
      MetamodelImpl.LOG.info(
          "Performing DDL operations for sequence generators for {0}, mode {1}",
          sequenceGenerator.getName(), ddlMode);

      this.jdbcAdaptor.createSequenceIfNecessary(datasource, sequenceGenerator);
    }
  }

  /**
   * Performs the table generator DDL operations.
   *
   * @param datasource the datasource
   * @param ddlMode the DDL Mode
   * @since $version
   * @author hceylan
   */
  public void performTableGeneratorsDdl(DataSource datasource, DDLMode ddlMode) {
    for (final TableGenerator tableGenerator : this.tableGenerators.values()) {
      MetamodelImpl.LOG.info(
          "Performing DDL operations for sequence generators for mode table {1}, mode {0}",
          tableGenerator.getName(), ddlMode);

      this.jdbcAdaptor.createTableGeneratorIfNecessary(datasource, tableGenerator);
    }
  }

  /**
   * Performs the table DDL operations.
   *
   * @param datasource the datasource
   * @param ddlMode the DDL Mode
   * @param entity the entity to perform DDL against
   * @throws BatooException thrown in case of an underlying exception
   * @since $version
   * @author hceylan
   */
  public void performTablesDdl(DataSource datasource, DDLMode ddlMode, EntityTypeImpl<?> entity) {
    MetamodelImpl.LOG.info(
        "Performing DDL operations for entity {0}, mode {1}", entity.getName(), ddlMode);

    // create the entity tables
    for (final EntityTable table : entity.getTables()) {
      // if table belongs to parent then skip
      if (table.getEntity() != entity) {
        continue;
      }

      MetamodelImpl.LOG.info(
          "Performing DDL operations for {0}, mode {1}", table.getQName(), ddlMode);

      this.jdbcAdaptor.createOrUpdateTable(table, datasource, ddlMode);
    }

    // create the join tables
    for (final AssociationMapping<?, ?, ?> mapping : entity.getAssociations()) {
      final JoinTable table = mapping.getTable();

      // skip not applicable tables
      if ((table == null) || (table.getEntity() != entity)) {
        continue;
      }

      this.jdbcAdaptor.createOrUpdateTable(mapping.getTable(), datasource, ddlMode);
    }

    // create the join tables
    for (final PluralMapping<?, ?, ?> mapping : entity.getMappingsPlural()) {
      if (!mapping.isAssociation()) {
        final AbstractTable table = (AbstractTable) mapping.getTable();

        this.jdbcAdaptor.createOrUpdateTable(table, datasource, ddlMode);
      }
    }
  }

  /**
   * Prefills the id generators.
   *
   * @param datasource the datasource to use
   * @since $version
   * @author hceylan
   */
  public void preFillGenerators(DataSource datasource) {
    final int nThreads = Runtime.getRuntime().availableProcessors();

    this.idGeneratorExecuter =
        new ThreadPoolExecutor(
            1,
            nThreads, //
            30,
            TimeUnit.SECONDS, //
            new LinkedBlockingQueue<Runnable>(), //
            new GeneratorThreadFactory());

    for (final SequenceGenerator generator : this.sequenceGenerators.values()) {
      this.sequenceQueues.put(
          generator.getName(),
          new SequenceQueue(
              this.jdbcAdaptor,
              datasource,
              this.idGeneratorExecuter,
              generator.getSequenceName(),
              generator.getAllocationSize()));
    }

    for (final TableGenerator generator : this.tableGenerators.values()) {
      this.tableIdQueues.put(
          generator.getName(),
          new TableIdQueue(this.jdbcAdaptor, datasource, this.idGeneratorExecuter, generator));
    }
  }

  /**
   * Stops the id generators.
   *
   * @since $version
   * @author hceylan
   */
  public void stopIdGenerators() {
    this.idGeneratorExecuter.shutdownNow();
    try {
      this.idGeneratorExecuter.awaitTermination(5, TimeUnit.SECONDS);
    } catch (final Exception e) {
    }
  }

  /**
   * Returns the type corresponding to the <code>clazz</code>.
   *
   * @param clazz the class of the type
   * @param <X> the expected type of the type
   * @return the type
   * @since $version
   * @author hceylan
   */
  @SuppressWarnings("unchecked")
  public <X> TypeImpl<X> type(Class<X> clazz) {
    final BasicTypeImpl<?> basic = this.basics.get(clazz);
    if (basic != null) {
      return (TypeImpl<X>) basic;
    }

    return this.managedType(clazz);
  }

  /**
   * Updates the callback availability.
   *
   * @param availability the callback availability
   * @return the callback availability
   * @since $version
   * @author hceylan
   */
  public CallbackAvailability updateAvailability(CallbackAvailability availability) {
    return availability.updateAvailability(this.callbackManager);
  }
}
Exemplo n.º 2
0
/**
 * @author hceylan
 * @since $version
 */
public class PreparedStatementProxy implements PreparedStatement {

  /**
   * The configuration type indicating how sql printing should be.
   *
   * @author hceylan
   * @since $version
   */
  public static enum SqlLoggingType {
    /** SQLs are not printed. */
    NONE, //

    /** SQLs are printed to the standard error. */
    STDERR, //

    /** SQLs are printed to the standard output. */
    STDOUT
  }

  private static final BLogger LOG = BLoggerFactory.getLogger("org.batoo.jpa.SQL");

  private static AtomicLong no = new AtomicLong(0);

  private long statementNo = -1;
  private long executionNo = -1;
  private final String sql;
  private final long slowSqlThreshold;
  private final PreparedStatement statement;

  private Object[] parameters;
  private ParameterMetaData parameterMetaData;

  private boolean debug;
  private final PrintStream sqlStream;

  /**
   * @param sql the SQL
   * @param statement the delegate statement
   * @param slowSqlThreshold the time to decide if SQL is deemed as slow
   * @param sqlLoggingType the type of the sql logging
   * @since $version
   * @author hceylan
   */
  public PreparedStatementProxy(
      String sql,
      PreparedStatement statement,
      long slowSqlThreshold,
      SqlLoggingType sqlLoggingType) {
    super();

    this.sql = sql;
    this.statement = statement;
    this.slowSqlThreshold = slowSqlThreshold;

    switch (sqlLoggingType) {
      case STDERR:
        this.sqlStream = System.err;
        break;
      case STDOUT:
        this.sqlStream = System.out;
        break;
      default:
        this.sqlStream = null;
    }

    this.debug = PreparedStatementProxy.LOG.isDebugEnabled();
  }

  /** {@inheritDoc} */
  @Override
  public void addBatch() throws SQLException {
    this.statement.addBatch();
  }

  /** {@inheritDoc} */
  @Override
  public void addBatch(String sql) throws SQLException {
    this.statement.addBatch();
  }

  /** {@inheritDoc} */
  @Override
  public void cancel() throws SQLException {
    this.statement.cancel();
  }

  /** {@inheritDoc} */
  @Override
  public void clearBatch() throws SQLException {
    this.statement.clearBatch();
  }

  /** {@inheritDoc} */
  @Override
  public void clearParameters() throws SQLException {
    this.statement.clearParameters();
  }

  /** {@inheritDoc} */
  @Override
  public void clearWarnings() throws SQLException {
    this.statement.clearWarnings();
  }

  /** {@inheritDoc} */
  @Override
  public void close() throws SQLException {
    this.statement.close();
  }

  /** {@inheritDoc} */
  @Override
  public void closeOnCompletion() throws SQLException {
    this.statement.closeOnCompletion();
  }

  /** {@inheritDoc} */
  @Override
  public boolean execute() throws SQLException {
    return this.statement.execute();
  }

  /** {@inheritDoc} */
  @Override
  public boolean execute(String sql) throws SQLException {
    return this.statement.execute();
  }

  /** {@inheritDoc} */
  @Override
  public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
    return this.statement.execute(sql, autoGeneratedKeys);
  }

  /** {@inheritDoc} */
  @Override
  public boolean execute(String sql, int[] columnIndexes) throws SQLException {
    return this.statement.execute(sql, columnIndexes);
  }

  /** {@inheritDoc} */
  @Override
  public boolean execute(String sql, String[] columnNames) throws SQLException {
    return this.statement.execute(sql, columnNames);
  }

  /** {@inheritDoc} */
  @Override
  public int[] executeBatch() throws SQLException {
    return this.statement.executeBatch();
  }

  /** {@inheritDoc} */
  @Override
  public ResultSet executeQuery() throws SQLException {
    if ((this.sqlStream == null) && !this.debug) {
      return this.statement.executeQuery();
    }

    if (this.statementNo == -1) {
      this.statementNo = PreparedStatementProxy.no.incrementAndGet();
    }

    this.executionNo++;

    PreparedStatementProxy.LOG.debug(
        "{0}:{1} executeQuery(){2}",
        this.statementNo,
        this.executionNo,
        PreparedStatementProxy.LOG.lazyBoxed(this.sql, this.parameters));

    final long start = System.currentTimeMillis();
    try {
      return this.statement.executeQuery();
    } finally {
      final long time = System.currentTimeMillis() - start;

      if (time > this.slowSqlThreshold) {
        PreparedStatementProxy.LOG.warn(
            new OperationTookLongTimeWarning(),
            "{0}:{1} {2} msecs, executeQuery()",
            this.statementNo,
            this.executionNo,
            time);
      } else {
        PreparedStatementProxy.LOG.trace(
            "{0}:{1} {2} msecs, executeQuery()", this.statementNo, this.executionNo, time);
      }
    }
  }

  /** {@inheritDoc} */
  @Override
  public ResultSet executeQuery(String sql) throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public int executeUpdate() throws SQLException {
    if ((this.sqlStream == null) && !this.debug) {
      return this.statement.executeUpdate();
    }

    if (this.statementNo == -1) {
      this.statementNo = PreparedStatementProxy.no.incrementAndGet();
    }

    this.executionNo++;

    PreparedStatementProxy.LOG.debug(
        "{0}:{1} executeUpdate(){2}",
        this.statementNo,
        this.executionNo,
        PreparedStatementProxy.LOG.lazyBoxed(this.sql, this.parameters));
    if (this.sqlStream != null) {
      this.sqlStream.println(
          MessageFormat.format(
              "{0}:{1} executeUpdate(){2}",
              this.statementNo,
              this.executionNo,
              PreparedStatementProxy.LOG.lazyBoxed(this.sql, this.parameters)));
    }

    final long start = System.currentTimeMillis();
    try {
      return this.statement.executeUpdate();
    } finally {
      final long time = System.currentTimeMillis() - start;
      if (time > this.slowSqlThreshold) {
        if (this.sqlStream != null) {
          this.sqlStream.println(
              MessageFormat.format(
                  "{0}:{1} {2} msecs, executeUpdate()", this.statementNo, this.executionNo, time));

          new OperationTookLongTimeWarning().printStackTrace(this.sqlStream);
        }

        PreparedStatementProxy.LOG.warn(
            new OperationTookLongTimeWarning(),
            "{0}:{1} {2} msecs, executeUpdate()",
            this.statementNo,
            this.executionNo,
            time);
      } else {
        if (this.sqlStream != null) {
          this.sqlStream.println(
              MessageFormat.format(
                  "{0}:{1} {2} msecs, executeUpdate()", this.statementNo, this.executionNo, time));
        }

        PreparedStatementProxy.LOG.debug(
            "{0}:{1} {2} msecs, executeUpdate()", this.statementNo, this.executionNo, time);
      }
    }
  }

  /** {@inheritDoc} */
  @Override
  public int executeUpdate(String sql) throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int executeUpdate(String sql, String[] columnNames) throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public Connection getConnection() throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public int getFetchDirection() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int getFetchSize() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public ResultSet getGeneratedKeys() throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public int getMaxFieldSize() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int getMaxRows() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public ResultSetMetaData getMetaData() throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public boolean getMoreResults() throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /** {@inheritDoc} */
  @Override
  public boolean getMoreResults(int current) throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /** {@inheritDoc} */
  @Override
  public ParameterMetaData getParameterMetaData() throws SQLException {
    if (this.parameterMetaData != null) {
      return this.parameterMetaData;
    }

    this.parameterMetaData = this.statement.getParameterMetaData();

    if (this.parameters == null) {
      this.parameters = new Object[this.parameterMetaData.getParameterCount()];
    }

    return this.parameterMetaData;
  }

  /** {@inheritDoc} */
  @Override
  public int getQueryTimeout() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public ResultSet getResultSet() throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public int getResultSetConcurrency() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int getResultSetHoldability() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int getResultSetType() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public int getUpdateCount() throws SQLException {
    this.throwNotImplemented();
    return 0;
  }

  /** {@inheritDoc} */
  @Override
  public SQLWarning getWarnings() throws SQLException {
    this.throwNotImplemented();
    return null;
  }

  /** {@inheritDoc} */
  @Override
  public boolean isClosed() throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /** {@inheritDoc} */
  @Override
  public boolean isCloseOnCompletion() throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /** {@inheritDoc} */
  @Override
  public boolean isPoolable() throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /** {@inheritDoc} */
  @Override
  public boolean isWrapperFor(Class<?> iface) throws SQLException {
    this.throwNotImplemented();
    return false;
  }

  /**
   * Resets the prepared statement and returns itself
   *
   * @return self
   * @since $version
   * @author hceylan
   */
  public PreparedStatement reset() {
    this.debug = PreparedStatementProxy.LOG.isDebugEnabled();

    return this;
  }

  /** {@inheritDoc} */
  @Override
  public void setArray(int parameterIndex, Array x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBlob(int parameterIndex, Blob x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBlob(int parameterIndex, InputStream inputStream, long length)
      throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBoolean(int parameterIndex, boolean x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setByte(int parameterIndex, byte x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setBytes(int parameterIndex, byte[] x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setCharacterStream(int parameterIndex, Reader reader, int length)
      throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setCharacterStream(int parameterIndex, Reader reader, long length)
      throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setClob(int parameterIndex, Clob x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setClob(int parameterIndex, Reader reader) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setCursorName(String name) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setDate(int parameterIndex, Date x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setDouble(int parameterIndex, double x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setEscapeProcessing(boolean enable) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setFetchDirection(int direction) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setFetchSize(int rows) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setFloat(int parameterIndex, float x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setInt(int parameterIndex, int x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setLong(int parameterIndex, long x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setMaxFieldSize(int max) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setMaxRows(int max) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNCharacterStream(int parameterIndex, Reader value, long length)
      throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNClob(int parameterIndex, NClob value) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNClob(int parameterIndex, Reader reader) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNString(int parameterIndex, String value) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setNull(int parameterIndex, int sqlType) throws SQLException {
    if ((this.debug || (this.sqlStream != null)) && (this.parameters != null)) {
      this.parameters[parameterIndex - 1] = null;
    }

    this.statement.setNull(parameterIndex, sqlType);
  }

  /** {@inheritDoc} */
  @Override
  public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setObject(int parameterIndex, Object x) throws SQLException {
    if ((this.debug || (this.sqlStream != null)) && (this.parameters != null)) {
      this.parameters[parameterIndex - 1] = x;
    }

    this.statement.setObject(parameterIndex, x);
  }

  /** {@inheritDoc} */
  @Override
  public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
      throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setPoolable(boolean poolable) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setQueryTimeout(int seconds) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setRef(int parameterIndex, Ref x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setRowId(int parameterIndex, RowId x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setShort(int parameterIndex, short x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setString(int parameterIndex, String x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setTime(int parameterIndex, Time x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
    this.throwNotImplemented();
  }

  /** {@inheritDoc} */
  @Override
  public void setURL(int parameterIndex, URL x) throws SQLException {
    this.throwNotImplemented();
  }

  private void throwNotImplemented() {
    throw new NotImplementedException();
  }

  /** {@inheritDoc} */
  @Override
  public <T> T unwrap(Class<T> iface) throws SQLException {
    this.throwNotImplemented();
    return null;
  }
}