/** * 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); } }
/** * @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; } }