Java Code Examples for org.hibernate.jdbc.Expectation

The following examples show how to use org.hibernate.jdbc.Expectation. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
@Override
public boolean check(int rows, Serializable id, int tableNumber,
					 Expectation expectation, PreparedStatement statement) throws HibernateException {
	return super.check(rows, id, tableNumber, expectation, statement);
}
 
Example 2
@Override
public boolean check(int rows, Serializable id, int tableNumber,
					 Expectation expectation, PreparedStatement statement) throws HibernateException {
	return super.check(rows, id, tableNumber, expectation, statement);
}
 
Example 3
default CompletionStage<?> insertReactive(
			Serializable id,
			Object[] fields,
			boolean[] notNull,
			int j,
			String sql,
			Object object,
			SharedSessionContractImplementor session) throws HibernateException {

		if ( delegate().isInverseTable( j ) ) {
			return CompletionStages.nullFuture();
		}

		//note: it is conceptually possible that a UserType could map null to
		//	  a non-null value, so the following is arguable:
		if ( delegate().isNullableTable( j ) && delegate().isAllNull( fields, j ) ) {
			return CompletionStages.nullFuture();
		}

		if ( log.isTraceEnabled() ) {
			log.tracev( "Inserting entity: {0}", infoString(delegate(), id, delegate().getFactory() ) );
			if ( j == 0 && delegate().isVersioned() ) {
				log.tracev( "Version: {0}", Versioning.getVersion( fields, delegate()) );
			}
		}

		// TODO : shouldn't inserts be Expectations.NONE?
		final Expectation expectation = appropriateExpectation( delegate().getInsertResultCheckStyles()[j] );
//		final int jdbcBatchSizeToUse = session.getConfiguredJdbcBatchSize();
//		final boolean useBatch = expectation.canBeBatched() &&
//				jdbcBatchSizeToUse > 1 &&
//				delegate.getIdentifierGenerator().supportsJdbcBatchInserts();

//		if ( useBatch && insertBatchKey == null ) {
//			insertBatchKey = new BasicBatchKey(
//					delegate.getEntityName() + "#INSERT",
//					expectation
//			);
//		}
//		final boolean callable = delegate.isInsertCallable( j );

		Object[] params = PreparedStatementAdaptor.bind( insert -> {
			boolean[][] insertable = delegate().getPropertyColumnInsertable();
			int index = delegate().dehydrate( null, fields, notNull, insertable, j, insert, session, false );
			delegate().getIdentifierType().nullSafeSet( insert, id, index, session );
		} );

		return getReactiveConnection( session )
				.update( sql, params )
				.thenAccept( count -> {
					try {
						expectation.verifyOutcome(count, new PreparedStatementAdaptor(), -1);
					}
					catch (SQLException e) {
						//can't actually occur!
						throw new JDBCException( "error while verifying result count", e );
					}
				});
	}
 
Example 4
default CompletionStage<?> deleteReactive(
			Serializable id,
			Object version,
			int j,
			Object object,
			String sql,
			SharedSessionContractImplementor session,
			Object[] loadedState) throws HibernateException {

		if ( delegate().isInverseTable( j ) ) {
			return CompletionStages.nullFuture();
		}
		final boolean useVersion = j == 0 && delegate().isVersioned();
//		final boolean callable = delegate.isDeleteCallable( j );
		final Expectation expectation = appropriateExpectation( delegate().getDeleteResultCheckStyles()[j] );
//		final boolean useBatch = j == 0 && delegate.isBatchable() && expectation.canBeBatched();
//		if ( useBatch && deleteBatchKey == null ) {
//			deleteBatchKey = new BasicBatchKey(
//					delegate.getEntityName() + "#DELETE",
//					expectation
//			);
//		}

		if ( log.isTraceEnabled() ) {
			log.tracev( "Deleting entity: {0}", infoString(delegate(), id, delegate().getFactory() ) );
			if ( useVersion ) {
				log.tracev( "Version: {0}", version );
			}
		}

		if ( delegate().isTableCascadeDeleteEnabled( j ) ) {
			if ( log.isTraceEnabled() ) {
				log.tracev( "Delete handled by foreign key constraint: {0}", delegate().getTableName( j ) );
			}
			//EARLY EXIT!
			return CompletionStages.nullFuture();
		}

		//Render the SQL query
		Object[] params = PreparedStatementAdaptor.bind( delete -> {
			int index = 1;

			index += expectation.prepare( delete );

			// Do the key. The key is immutable so we can use the _current_ object state - not necessarily
			// the state at the time the delete was issued
			delegate().getIdentifierType().nullSafeSet( delete, id, index, session );
			index += delegate().getIdentifierColumnSpan();

			// We should use the _current_ object state (ie. after any updates that occurred during flush)
			if ( useVersion ) {
				delegate().getVersionType().nullSafeSet( delete, version, index, session );
			}
			else if ( isAllOrDirtyOptimisticLocking() && loadedState != null ) {
				boolean[] versionability = delegate().getPropertyVersionability();
				Type[] types = delegate().getPropertyTypes();
				for (int i = 0; i < delegate().getEntityMetamodel().getPropertySpan(); i++ ) {
					if ( delegate().isPropertyOfTable( i, j ) && versionability[i] ) {
						// this property belongs to the table and it is not specifically
						// excluded from optimistic locking by optimistic-lock="false"
						boolean[] settable = types[i].toColumnNullness( loadedState[i], delegate().getFactory() );
						types[i].nullSafeSet( delete, loadedState[i], index, settable, session );
						index += ArrayHelper.countTrue( settable );
					}
				}
			}
		} );

		return getReactiveConnection(session)
				.update( sql, params )
				.thenAccept( count -> check( count, id, j, expectation, new PreparedStatementAdaptor() ) );
	}
 
Example 5
default CompletionStage<Boolean> updateReactive(
			final Serializable id,
			final Object[] fields,
			final Object[] oldFields,
			final Object rowId,
			final boolean[] includeProperty,
			final int j,
			final Object oldVersion,
			final Object object,
			final String sql,
			final SharedSessionContractImplementor session) throws HibernateException {

		final Expectation expectation = appropriateExpectation( delegate().getUpdateResultCheckStyles()[j] );
//		final int jdbcBatchSizeToUse = session.getConfiguredJdbcBatchSize();
//		final boolean useBatch = expectation.canBeBatched() && isBatchable() && jdbcBatchSizeToUse > 1;
//		if ( useBatch && updateBatchKey == null ) {
//			updateBatchKey = new BasicBatchKey(
//					delegate.getEntityName() + "#UPDATE",
//					expectation
//			);
//		}
//		final boolean callable = delegate.isUpdateCallable( j );
		final boolean useVersion = j == 0 && delegate().isVersioned();

		if ( log.isTraceEnabled() ) {
			log.tracev( "Updating entity: {0}", infoString(delegate(), id, delegate().getFactory() ) );
			if ( useVersion ) {
				log.tracev( "Existing version: {0} -> New version:{1}", oldVersion, fields[delegate().getVersionProperty()] );
			}
		}

//			if ( useBatch ) {
//				update = session
//						.getJdbcCoordinator()
//						.getBatch( updateBatchKey )
//						.getBatchStatement( sql, callable );
//			}

		Object[] params = PreparedStatementAdaptor.bind( update -> {
			int index = 1;
			index += expectation.prepare( update );

			//Now write the values of fields onto the prepared statement
			index = delegate().dehydrate(
					id,
					fields,
					rowId,
					includeProperty,
					delegate().getPropertyColumnUpdateable(),
					j,
					update,
					session,
					index,
					true
			);

			// Write any appropriate versioning conditional parameters
			if ( useVersion && delegate().getEntityMetamodel().getOptimisticLockStyle() == OptimisticLockStyle.VERSION ) {
				if ( delegate().checkVersion( includeProperty ) ) {
					delegate().getVersionType().nullSafeSet( update, oldVersion, index, session );
				}
			}
			else if ( isAllOrDirtyOptimisticLocking() && oldFields != null ) {
				boolean[] versionability = delegate().getPropertyVersionability(); //TODO: is this really necessary????
				boolean[] includeOldField = delegate().getEntityMetamodel().getOptimisticLockStyle() == OptimisticLockStyle.ALL
						? delegate().getPropertyUpdateability()
						: includeProperty;
				Type[] types = delegate().getPropertyTypes();
				for (int i = 0; i < delegate().getEntityMetamodel().getPropertySpan(); i++ ) {
					boolean include = includeOldField[i] &&
							delegate().isPropertyOfTable( i, j ) &&
							versionability[i]; //TODO: is this really necessary????
					if ( include ) {
						boolean[] settable = types[i].toColumnNullness( oldFields[i], delegate().getFactory() );
						types[i].nullSafeSet(
								update,
								oldFields[i],
								index,
								settable,
								session
						);
						index += ArrayHelper.countTrue( settable );
					}
				}
			}
		} );

//				if ( useBatch ) {
//					session.getJdbcCoordinator().getBatch( updateBatchKey ).addToBatch();
//					return true;
//				}

		return getReactiveConnection(session)
				.update( sql, params )
				.thenApply( count -> check( count, id, j, expectation, new PreparedStatementAdaptor() ) );
	}
 
Example 6
boolean check(
int rows,
Serializable id,
int tableNumber,
Expectation expectation,
PreparedStatement statement) throws HibernateException;
 
Example 7
@Override
public boolean check(int rows, Serializable id, int tableNumber,
					 Expectation expectation, PreparedStatement statement) throws HibernateException {
	return super.check(rows, id, tableNumber, expectation, statement);
}
 
Example 8
@Override
protected int doUpdateRows(Serializable id, PersistentCollection collection, SharedSessionContractImplementor session)
		throws HibernateException {
	if ( ArrayHelper.isAllFalse( elementColumnIsSettable ) ) {
		return 0;
	}

	try {
		final Expectation expectation = Expectations.appropriateExpectation( getUpdateCheckStyle() );
		final boolean callable = isUpdateCallable();
		final int jdbcBatchSizeToUse = session.getConfiguredJdbcBatchSize();
		boolean useBatch = expectation.canBeBatched() && jdbcBatchSizeToUse > 1;
		final Iterator entries = collection.entries( this );

		final List elements = new ArrayList();
		while ( entries.hasNext() ) {
			elements.add( entries.next() );
		}

		final String sql = getSQLUpdateRowString();
		int count = 0;
		if ( collection.isElementRemoved() ) {
			// the update should be done starting from the end to the list
			for ( int i = elements.size() - 1; i >= 0; i-- ) {
				count = doUpdateRow(
						id,
						collection,
						session,
						expectation,
						callable,
						useBatch,
						elements,
						sql,
						count,
						i
				);
			}
		}
		else {
			for ( int i = 0; i < elements.size(); i++ ) {
				count = doUpdateRow(
						id,
						collection,
						session,
						expectation,
						callable,
						useBatch,
						elements,
						sql,
						count,
						i
				);
			}
		}
		return count;
	}
	catch (SQLException sqle) {
		throw session.getJdbcServices().getSqlExceptionHelper().convert(
				sqle,
				"could not update collection rows: " + MessageHelper.collectionInfoString(
						this,
						collection,
						id,
						session
				),
				getSQLUpdateRowString()
		);
	}
}
 
Example 9
private int doUpdateRow(
		Serializable id,
		PersistentCollection collection,
		SharedSessionContractImplementor session,
		Expectation expectation, boolean callable, boolean useBatch, List elements, String sql, int count, int i)
		throws SQLException {
	PreparedStatement st;
	Object entry = elements.get( i );
	if ( collection.needsUpdating( entry, i, elementType ) ) {
		int offset = 1;

		if ( useBatch ) {
			if ( updateBatchKey == null ) {
				updateBatchKey = new BasicBatchKey(
						getRole() + "#UPDATE",
						expectation
				);
			}
			st = session
					.getJdbcCoordinator()
					.getBatch( updateBatchKey )
					.getBatchStatement( sql, callable );
		}
		else {
			st = session
					.getJdbcCoordinator()
					.getStatementPreparer()
					.prepareStatement( sql, callable );
		}

		try {
			offset += expectation.prepare( st );
			int loc = writeElement( st, collection.getElement( entry ), offset, session );
			if ( hasIdentifier ) {
				writeIdentifier( st, collection.getIdentifier( entry, i ), loc, session );
			}
			else {
				loc = writeKey( st, id, loc, session );
				if ( hasIndex && !indexContainsFormula ) {
					writeIndexToWhere( st, collection.getIndex( entry, i, this ), loc, session );
				}
				else {
					writeElementToWhere( st, collection.getSnapshotElement( entry, i ), loc, session );
				}
			}

			if ( useBatch ) {
				session.getJdbcCoordinator()
						.getBatch( updateBatchKey )
						.addToBatch();
			}
			else {
				expectation.verifyOutcome(
						session.getJdbcCoordinator().getResultSetReturn().executeUpdate(
								st
						), st, -1
				);
			}
		}
		catch (SQLException sqle) {
			if ( useBatch ) {
				session.getJdbcCoordinator().abortBatch();
			}
			throw sqle;
		}
		finally {
			if ( !useBatch ) {
				session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( st );
				session.getJdbcCoordinator().afterStatementExecution();
			}
		}
		count++;
	}
	return count;
}
 
Example 10
Source Project: lams   Source File: BasicBatchKey.java    License: GNU General Public License v2.0 4 votes vote down vote up
@Override
public Expectation getExpectation() {
	return expectation;
}
 
Example 11
public void addToBatch(Expectation expectation) throws SQLException, HibernateException {
	Counter counter = ( Counter ) batchSizes.get( currentBatch );
	counter.count++;
	System.out.println( "Adding to batch [" + batchSQL + "]" );
	super.addToBatch( expectation );
}
 
Example 12
Source Project: lams   Source File: BatchKey.java    License: GNU General Public License v2.0 2 votes vote down vote up
/**
 * Get the expectation pertaining to the outcome of the {@link Batch} associated with this key.
 *
 * @return The expectations
 */
Expectation getExpectation();
 
Example 13
Source Project: lams   Source File: BasicBatchKey.java    License: GNU General Public License v2.0 2 votes vote down vote up
/**
 * Constructs a BasicBatchKey
 *
 * @param comparison A string used to compare batch keys.
 * @param expectation The expectation for the batch
 */
public BasicBatchKey(String comparison, Expectation expectation) {
	this.comparison = comparison;
	this.statementCount = 1;
	this.expectation = expectation;
}