boolean isInitialized = rs.next(); if ( !isInitialized ) { value.initialize( 0 ); final PreparedStatement insertPreparedStatement = prepareStatement( connection, ); try { value.bind( insertPreparedStatement, 1 ); executeUpdate( insertPreparedStatement, statsCollector ); value.initialize( rs, 0 ); ); try { value.copy().increment().bind( updatePreparedStatement, 1 ); value.bind( updatePreparedStatement, 2 );
@Override public synchronized Serializable generate(AccessCallback callback) { final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() ); if ( generationState.lastSourceValue == null || ! generationState.value.lt( generationState.upperLimitValue ) ) { generationState.lastSourceValue = callback.getNextValue(); generationState.upperLimitValue = generationState.lastSourceValue.copy().add( incrementSize ); generationState.value = generationState.lastSourceValue.copy(); // handle cases where initial-value is less that one (hsqldb for instance). while ( generationState.value.lt( 1 ) ) { generationState.value.increment(); } } return generationState.value.makeValueThenIncrement(); }
IntegralDataTypeHolder holder = makeHolder(); try { holder.increment(); fail(); holder.add( 1 ); fail(); holder.decrement(); fail(); holder.subtract( 1 ); fail(); holder.multiplyBy( holder ); fail(); holder.multiplyBy( 1 ); fail(); holder.eq( holder ); fail(); holder.eq( 1 ); fail(); holder.lt( holder ); fail();
@Override public synchronized Serializable generate(AccessCallback callback) { final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() ); if ( generationState.lo > generationState.maxLo ) { generationState.lastSourceValue = callback.getNextValue(); generationState.lo = generationState.lastSourceValue.eq( 0 ) ? 1 : 0; generationState.hi = generationState.lastSourceValue.copy().multiplyBy( generationState.maxLo + 1 ); } generationState.value = generationState.hi.copy().add( generationState.lo++ ); return generationState.value.makeValue(); }
@Override public synchronized Serializable generate(AccessCallback callback) { final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() ); if ( generationState.lastSourceValue == null ) { // first call, so initialize ourselves. we need to read the database // value and set up the 'bucket' boundaries generationState.lastSourceValue = callback.getNextValue(); while ( generationState.lastSourceValue.lt( 1 ) ) { generationState.lastSourceValue = callback.getNextValue(); } // upperLimit defines the upper end of the bucket values generationState.upperLimit = generationState.lastSourceValue.copy().multiplyBy( incrementSize ).increment(); // initialize value to the low end of the bucket generationState.value = generationState.upperLimit.copy().subtract( incrementSize ); } else if ( ! generationState.upperLimit.gt( generationState.value ) ) { generationState.lastSourceValue = callback.getNextValue(); generationState.upperLimit = generationState.lastSourceValue.copy().multiplyBy( incrementSize ).increment(); generationState.value = generationState.upperLimit.copy().subtract( incrementSize ); } return generationState.value.makeValueThenIncrement(); }
@Override public synchronized Serializable generate(AccessCallback callback) { final GenerationState generationState = locateGenerationState( callback.getTenantIdentifier() ); if ( generationState.hiValue == null ) { generationState.value = callback.getNextValue(); // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... if ( generationState.value.lt( 1 ) ) { log.pooledOptimizerReportedInitialValue( generationState.value ); } // the call to obtain next-value just gave us the initialValue if ( ( initialValue == -1 && generationState.value.lt( incrementSize ) ) || generationState.value.eq( initialValue ) ) { generationState.hiValue = callback.getNextValue(); } else { generationState.hiValue = generationState.value; generationState.value = generationState.hiValue.copy().subtract( incrementSize - 1 ); } } else if ( generationState.value.gt( generationState.hiValue ) ) { generationState.hiValue = callback.getNextValue(); generationState.value = generationState.hiValue.copy().subtract( incrementSize - 1 ); } return generationState.value.makeValueThenIncrement(); }
@Test public void testBasicHiloAlgorithm() { // mimic an initialValue of 1 and increment of 20 final long initialValue = 1; final long incrementSize = 2; // initialization IntegralDataTypeHolder lastSourceValue = makeHolder().initialize( 1 ); IntegralDataTypeHolder upperLimit = lastSourceValue.copy().multiplyBy( incrementSize ).increment(); IntegralDataTypeHolder value = upperLimit.copy().subtract( incrementSize ); assertEquals( 1, lastSourceValue.makeValue().longValue() ); assertEquals( 3, upperLimit.makeValue().longValue() ); assertEquals( 1, value.makeValue().longValue() ); value.increment(); value.increment(); assertFalse( upperLimit.gt( value ) ); // at which point we would "clock over" lastSourceValue.increment(); upperLimit = lastSourceValue.copy().multiplyBy( incrementSize ).increment(); assertEquals( 2, lastSourceValue.makeValue().longValue() ); assertEquals( 5, upperLimit.makeValue().longValue() ); assertEquals( 3, value.makeValue().longValue() ); } }
try { if ( rs.next() ) { previousValueHolder.initialize( rs, 0L ).increment(); previousValueHolder.initialize( 1L ); LOG.debugf( "First free id: %s", previousValueHolder.makeValue() );
@Override public synchronized Serializable generate(final SharedSessionContractImplementor session, Object obj) { // maxLo < 1 indicates a hilo generator with no hilo :? if ( maxLo < 1 ) { //keep the behavior consistent even for boundary usages IntegralDataTypeHolder value = null; while ( value == null || value.lt( 0 ) ) { value = super.generateHolder( session ); } return value.makeValue(); } return hiloOptimizer.generate( new AccessCallback() { @Override public IntegralDataTypeHolder getNextValue() { return generateHolder( session ); } @Override public String getTenantIdentifier() { return session.getTenantIdentifier(); } } ); }
@Override public Object getDefaultValue(Object currentValue) { return IdentifierGeneratorHelper.getIntegralDataTypeHolder( currentValue.getClass() ) .initialize( -1L ) .makeValue(); }
public void testIncrement() { IntegralDataTypeHolder holder = makeHolder(); holder.initialize( 0 ); int i = 0; for ( ; i < 5008; i++ ) { holder.increment(); } assertEquals( holder.copy().initialize( i ), holder ); } @Test
protected IntegralDataTypeHolder generateHolder(SharedSessionContractImplementor session) { try { PreparedStatement st = session.getJdbcCoordinator().getStatementPreparer().prepareStatement( sql ); try { ResultSet rs = session.getJdbcCoordinator().getResultSetReturn().extract( st ); try { rs.next(); IntegralDataTypeHolder result = buildHolder(); result.initialize( rs, 1 ); LOG.debugf( "Sequence identifier generated: %s", result ); return result; } finally { session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( rs, st ); } } finally { session.getJdbcCoordinator().getLogicalConnection().getResourceRegistry().release( st ); session.getJdbcCoordinator().afterStatementExecution(); } } catch (SQLException sqle) { throw session.getJdbcServices().getSqlExceptionHelper().convert( sqle, "could not get next sequence value", sql ); } }
@Override public Serializable generate(AccessCallback callback) { // IMPL NOTE : this method is called concurrently and is // not synchronized. It is very important to work on the // local variable: the field lastSourceValue is not // reliable as it might be mutated by multipled threads. // The lastSourceValue field is only accessed by tests, // so this is not a concern. IntegralDataTypeHolder value = callback.getNextValue(); lastSourceValue = value; return value.makeValue(); }
@Override public synchronized IntegralDataTypeHolder getLastSourceValue() { return noTenantGenerationState().lastSourceValue.copy(); }
@Override public synchronized Serializable generate(AccessCallback callback) { if ( lastSourceValue == null ) { // first call, so initialize ourselves. we need to read the database // value and set up the 'bucket' boundaries lastSourceValue = callback.getNextValue(); while ( lastSourceValue.lt( 1 ) ) { lastSourceValue = callback.getNextValue(); } // upperLimit defines the upper end of the bucket values upperLimit = lastSourceValue.copy().multiplyBy( incrementSize ).increment(); // initialize value to the low end of the bucket value = upperLimit.copy().subtract( incrementSize ); } else if ( ! upperLimit.gt( value ) ) { lastSourceValue = callback.getNextValue(); upperLimit = lastSourceValue.copy().multiplyBy( incrementSize ).increment(); } return value.makeValueThenIncrement(); }
@Override public synchronized Serializable generate(AccessCallback callback) { if ( hiValue == null ) { value = callback.getNextValue(); // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... if (value.lt(1)) LOG.pooledOptimizerReportedInitialValue(value); // the call to obtain next-value just gave us the initialValue if ( ( initialValue == -1 && value.lt( incrementSize ) ) || value.eq( initialValue ) ) { hiValue = callback.getNextValue(); } else { hiValue = value; value = hiValue.copy().subtract( incrementSize ); } } else if ( ! hiValue.gt( value ) ) { hiValue = callback.getNextValue(); value = hiValue.copy().subtract( incrementSize ); } return value.makeValueThenIncrement(); }
ResultSet rs = st.executeQuery(); try { if (rs.next()) previousValueHolder.initialize(rs, 0L).increment(); else previousValueHolder.initialize(1L); sql = null; if ( LOG.isDebugEnabled() ) { LOG.debugf( "First free id: %s", previousValueHolder.makeValue() );