Package org.hibernate.jdbc

Examples of org.hibernate.jdbc.Expectation

166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
        try {
          int i = 0;
 
          Iterator entries = collection.entries( this );
          int offset = 1;
          Expectation expectation = Expectations.NONE;
          while ( entries.hasNext() ) {
 
            Object entry = entries.next();
            if ( collection.needsUpdating( entry, i, elementType ) ) {  // will still be issued when it used to be null
              if ( st == null ) {
                String sql = getSQLDeleteRowString();
                if ( isDeleteCallable() ) {
                  expectation = Expectations.appropriateExpectation( getDeleteCheckStyle() );
                  useBatch = expectation.canBeBatched();
                  st = useBatch
                      ? session.getBatcher().prepareBatchCallableStatement( sql )
                            : session.getBatcher().prepareCallableStatement( sql );
                  offset += expectation.prepare( st );
                }
                else {
                  st = session.getBatcher().prepareBatchStatement( getSQLDeleteRowString() );
                }
              }
              int loc = writeKey( st, id, offset, session );
              writeElementToWhere( st, collection.getSnapshotElement(entry, i), loc, session );
              if ( useBatch ) {
                session.getBatcher().addToBatch( expectation );
              }
              else {
                expectation.verifyOutcome( st.executeUpdate(), st, -1 );
              }
              count++;
            }
            i++;
          }
        }
        catch ( SQLException sqle ) {
          if ( useBatch ) {
            session.getBatcher().abortBatch( sqle );
          }
          throw sqle;
        }
        finally {
          if ( !useBatch ) {
            session.getBatcher().closeStatement( st );
          }
        }
      }
     
      if ( isRowInsertEnabled() ) {
        Expectation expectation = Expectations.appropriateExpectation( getInsertCheckStyle() );
        boolean callable = isInsertCallable();
        boolean useBatch = expectation.canBeBatched();
        String sql = getSQLInsertRowString();
        PreparedStatement st = null;
        // now update all changed or added rows fks
        try {
          int i = 0;
          Iterator entries = collection.entries( this );
          while ( entries.hasNext() ) {
            Object entry = entries.next();
            int offset = 1;
            if ( collection.needsUpdating( entry, i, elementType ) ) {
              if ( useBatch ) {
                if ( st == null ) {
                  if ( callable ) {
                    st = session.getBatcher().prepareBatchCallableStatement( sql );
                  }
                  else {
                    st = session.getBatcher().prepareBatchStatement( sql );
                  }
                }
              }
              else {
                if ( callable ) {
                  st = session.getBatcher().prepareCallableStatement( sql );
                }
                else {
                  st = session.getBatcher().prepareStatement( sql );
                }
              }

              offset += expectation.prepare( st );

              int loc = writeKey( st, id, offset, session );
              if ( hasIndex && !indexContainsFormula ) {
                loc = writeIndexToWhere( st, collection.getIndex( entry, i, this ), loc, session );
              }

              writeElementToWhere( st, collection.getElement( entry ), loc, session );

              if ( useBatch ) {
                session.getBatcher().addToBatch( expectation );
              }
              else {
                expectation.verifyOutcome( st.executeUpdate(), st, -1 );
              }
              count++;
            }
            i++;
          }
View Full Code Here
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
   
    if ( ArrayHelper.isAllFalse(elementColumnIsSettable) ) return 0;

    try {
      PreparedStatement st = null;
      Expectation expectation = Expectations.appropriateExpectation( getUpdateCheckStyle() );
      boolean callable = isUpdateCallable();
      boolean useBatch = expectation.canBeBatched();
      Iterator entries = collection.entries( this );
      String sql = getSQLUpdateRowString();
      int i = 0;
      int count = 0;
      while ( entries.hasNext() ) {
        Object entry = entries.next();
        if ( collection.needsUpdating( entry, i, elementType ) ) {
          int offset = 1;

          if ( useBatch ) {
            if ( st == null ) {
              if ( callable ) {
                st = session.getBatcher().prepareBatchCallableStatement( sql );
              }
              else {
                st = session.getBatcher().prepareBatchStatement( sql );
              }
            }
          }
          else {
            if ( callable ) {
              st = session.getBatcher().prepareCallableStatement( sql );
            }
            else {
              st = session.getBatcher().prepareStatement( sql );
            }
          }

          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.getBatcher().addToBatch( expectation );
            }
            else {
              expectation.verifyOutcome( st.executeUpdate(), st, -1 );
            }
          }
          catch ( SQLException sqle ) {
            if ( useBatch ) {
              session.getBatcher().abortBatch( sqle );
View Full Code Here
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
      if ( j == 0 && isVersioned() ) {
        log.trace( "Version: " + Versioning.getVersion( fields, this ) );
      }
    }

    Expectation expectation = Expectations.appropriateExpectation( insertResultCheckStyles[j] );
    boolean callable = isInsertCallable( j );
    // we can't batch joined inserts, *especially* not if it is an identity insert;
    // nor can we batch statements where the expectation is based on an output param
    final boolean useBatch = j == 0 && expectation.canBeBatched();
    try {

      // Render the SQL query
      final PreparedStatement insert;
      if ( useBatch ) {
        if ( callable ) {
          insert = session.getBatcher().prepareBatchCallableStatement( sql );
        }
        else {
          insert = session.getBatcher().prepareBatchStatement( sql );
        }
      }
      else {
        if ( callable ) {
          insert = session.getBatcher().prepareCallableStatement( sql );
        }
        else {
          insert = session.getBatcher().prepareStatement( sql );
        }
      }

      try {
        int index = 1;
        index += expectation.prepare( insert );

        // Write the values of fields onto the prepared statement - we MUST use the state at the time the
        // insert was issued (cos of foreign key constraints). Not necessarily the object's current state

        dehydrate( id, fields, null, notNull, propertyColumnInsertable, j, insert, session, index );

        if ( useBatch ) {
          // TODO : shouldnt inserts be Expectations.NONE?
          session.getBatcher().addToBatch( expectation );
        }
        else {
          expectation.verifyOutcome( insert.executeUpdate(), insert, -1 );
        }

      }
      catch ( SQLException sqle ) {
        if ( useBatch ) {
View Full Code Here
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
          final Object object,
          final String sql,
          final SessionImplementor session) throws HibernateException {

    final boolean useVersion = j == 0 && isVersioned();
    final Expectation expectation = Expectations.appropriateExpectation( updateResultCheckStyles[j] );
    final boolean callable = isUpdateCallable( j );
    final boolean useBatch = j == 0 && expectation.canBeBatched() && isBatchable(); //note: updates to joined tables can't be batched...

    if ( log.isTraceEnabled() ) {
      log.trace( "Updating entity: " + MessageHelper.infoString( this, id, getFactory() ) );
      if ( useVersion ) {
        log.trace( "Existing version: " + oldVersion + " -> New version: " + fields[getVersionProperty()] );
      }
    }

    try {

      int index = 1; // starting index
      final PreparedStatement update;
      if ( useBatch ) {
        if ( callable ) {
          update = session.getBatcher().prepareBatchCallableStatement( sql );
        }
        else {
          update = session.getBatcher().prepareBatchStatement( sql );
        }
      }
      else {
        if ( callable ) {
          update = session.getBatcher().prepareCallableStatement( sql );
        }
        else {
          update = session.getBatcher().prepareStatement( sql );
        }
      }

      try {

        index+= expectation.prepare( update );

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

        // Write any appropriate versioning conditional parameters
View Full Code Here
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
      return;
    }

    final boolean useVersion = j == 0 && isVersioned();
    final boolean callable = isDeleteCallable( j );
    final Expectation expectation = Expectations.appropriateExpectation( deleteResultCheckStyles[j] );
    final boolean useBatch = j == 0 && isBatchable() && expectation.canBeBatched();

    if ( log.isTraceEnabled() ) {
      log.trace( "Deleting entity: " + MessageHelper.infoString( this, id, getFactory() ) );
      if ( useVersion ) {
        log.trace( "Version: " + version );
      }
    }

    if ( isTableCascadeDeleteEnabled( j ) ) {
      if ( log.isTraceEnabled() ) {
        log.trace( "delete handled by foreign key constraint: " + getTableName( j ) );
      }
      return; //EARLY EXIT!
    }

    try {

      //Render the SQL query
      PreparedStatement delete;
      int index = 1;
      if ( useBatch ) {
        if ( callable ) {
          delete = session.getBatcher().prepareBatchCallableStatement( sql );
        }
        else {
          delete = session.getBatcher().prepareBatchStatement( sql );
        }
      }
      else {
        if ( callable ) {
          delete = session.getBatcher().prepareCallableStatement( sql );
        }
        else {
          delete = session.getBatcher().prepareStatement( sql );
        }
      }

      try {

        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
        getIdentifierType().nullSafeSet( delete, id, index, session );
        index += getIdentifierColumnSpan();
View Full Code Here
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
      // Remove all the old entries

      try {
        int offset = 1;
        PreparedStatement st = null;
        Expectation expectation = Expectations.appropriateExpectation( getDeleteAllCheckStyle() );
        boolean callable = isDeleteAllCallable();
        boolean useBatch = expectation.canBeBatched();
        String sql = getSQLDeleteString();
        if ( useBatch ) {
          if ( callable ) {
            st = session.getBatcher().prepareBatchCallableStatement( sql );
          }
          else {
            st = session.getBatcher().prepareBatchStatement( sql );
          }
        }
        else {
          if ( callable ) {
            st = session.getBatcher().prepareCallableStatement( sql );
          }
          else {
            st = session.getBatcher().prepareStatement( sql );
          }
        }


        try {
          offset+= expectation.prepare( st );

          writeKey( st, id, offset, session );
          if ( useBatch ) {
            session.getBatcher().addToBatch( expectation );
          }
          else {
            expectation.verifyOutcome( st.executeUpdate(), st, -1 );
          }
        }
        catch ( SQLException sqle ) {
          if ( useBatch ) {
            session.getBatcher().abortBatch( sqle );
View Full Code Here
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
            final Object entry = entries.next();
            if ( collection.entryExists( entry, i ) ) {
              int offset = 1;
              PreparedStatement st = null;
              Expectation expectation = Expectations.appropriateExpectation( getInsertCheckStyle() );
              boolean callable = isInsertCallable();
              boolean useBatch = expectation.canBeBatched();
              String sql = getSQLInsertRowString();

              if ( useBatch ) {
                if ( callable ) {
                  st = session.getBatcher().prepareBatchCallableStatement( sql );
                }
                else {
                  st = session.getBatcher().prepareBatchStatement( sql );
                }
              }
              else {
                if ( callable ) {
                  st = session.getBatcher().prepareCallableStatement( sql );
                }
                else {
                  st = session.getBatcher().prepareStatement( sql );
                }
              }


              try {
                offset+= expectation.prepare( st );

                //TODO: copy/paste from insertRows()
                int loc = writeKey( st, id, offset, session );
                if ( hasIdentifier ) {
                  loc = writeIdentifier( st, collection.getIdentifier(entry, i), loc, session );
                }
                if ( hasIndex /*&& !indexIsFormula*/ ) {
                  loc = writeIndex( st, collection.getIndex(entry, i, this), loc, session );
                }
                loc = writeElement(st, collection.getElement(entry), loc, session );

                if ( useBatch ) {
                  session.getBatcher().addToBatch( expectation );
                }
                else {
                  expectation.verifyOutcome( st.executeUpdate(), st, -1 );
                }

                collection.afterRowInsert( this, entry, i );
                count++;
              }
View Full Code Here
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
        if ( deletes.hasNext() ) {
          int offset = 1;
          int count = 0;
          while ( deletes.hasNext() ) {
            PreparedStatement st = null;
            Expectation expectation = Expectations.appropriateExpectation( getDeleteCheckStyle() );
            boolean callable = isDeleteCallable();
            boolean useBatch = expectation.canBeBatched();
            String sql = getSQLDeleteRowString();

            if ( useBatch ) {
              if ( callable ) {
                st = session.getBatcher().prepareBatchCallableStatement( sql );
              }
              else {
                st = session.getBatcher().prepareBatchStatement( sql );
              }
            }
            else {
              if ( callable ) {
                st = session.getBatcher().prepareCallableStatement( sql );
              }
              else {
                st = session.getBatcher().prepareStatement( sql );
              }
            }

            try {
              expectation.prepare( st );

              Object entry = deletes.next();
              int loc = offset;
              if ( hasIdentifier ) {
                writeIdentifier( st, entry, loc, session );
              }
              else {
                loc = writeKey( st, id, loc, session );
                if ( deleteByIndex ) {
                  writeIndexToWhere( st, entry, loc, session );
                }
                else {
                  writeElementToWhere( st, entry, loc, session );
                }
              }

              if ( useBatch ) {
                session.getBatcher().addToBatch( expectation );
              }
              else {
                expectation.verifyOutcome( st.executeUpdate(), st, -1 );
              }
              count++;
            }
            catch ( SQLException sqle ) {
              if ( useBatch ) {
View Full Code Here
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
      try {
        //insert all the new entries
        collection.preInsert( this );
        Iterator entries = collection.entries( this );
        Expectation expectation = Expectations.appropriateExpectation( getInsertCheckStyle() );
        boolean callable = isInsertCallable();
        boolean useBatch = expectation.canBeBatched();
        String sql = getSQLInsertRowString();
        int i = 0;
        int count = 0;
        while ( entries.hasNext() ) {
          int offset = 1;
          Object entry = entries.next();
          PreparedStatement st = null;
          if ( collection.needsInserting( entry, i, elementType ) ) {

            if ( useBatch ) {
              if ( st == null ) {
                if ( callable ) {
                  st = session.getBatcher().prepareBatchCallableStatement( sql );
                }
                else {
                  st = session.getBatcher().prepareBatchStatement( sql );
                }
              }
            }
            else {
              if ( callable ) {
                st = session.getBatcher().prepareCallableStatement( sql );
              }
              else {
                st = session.getBatcher().prepareStatement( sql );
              }
            }

            try {
              offset += expectation.prepare( st );
              //TODO: copy/paste from recreate()
              offset = writeKey( st, id, offset, session );
              if ( hasIdentifier ) {
                offset = writeIdentifier( st, collection.getIdentifier(entry, i), offset, session );
              }
              if ( hasIndex /*&& !indexIsFormula*/ ) {
                offset = writeIndex( st, collection.getIndex(entry, i, this), offset, session );
              }
              writeElement(st, collection.getElement(entry), offset, session );

              if ( useBatch ) {
                session.getBatcher().addToBatch( expectation );
              }
              else {
                expectation.verifyOutcome( st.executeUpdate(), st, -1 );
              }
              collection.afterRowInsert( this, entry, i );
              count++;
            }
            catch ( SQLException sqle ) {
View Full Code Here
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
      if ( j == 0 && isVersioned() ) {
        log.trace( "Version: " + Versioning.getVersion( fields, this ) );
      }
    }

    Expectation expectation = Expectations.appropriateExpectation( insertResultCheckStyles[j] );
    boolean callable = isInsertCallable( j );
    // we can't batch joined inserts, *especially* not if it is an identity insert;
    // nor can we batch statements where the expectation is based on an output param
    final boolean useBatch = j == 0 && expectation.canBeBatched();
    try {

      // Render the SQL query
      final PreparedStatement insert;
      if ( useBatch ) {
        if ( callable ) {
          insert = session.getBatcher().prepareBatchCallableStatement( sql );
        }
        else {
          insert = session.getBatcher().prepareBatchStatement( sql );
        }
      }
      else {
        if ( callable ) {
          insert = session.getBatcher().prepareCallableStatement( sql );
        }
        else {
          insert = session.getBatcher().prepareStatement( sql );
        }
      }

      try {
        int index = 1;
        index += expectation.prepare( insert );

        // Write the values of fields onto the prepared statement - we MUST use the state at the time the
        // insert was issued (cos of foreign key constraints). Not necessarily the object's current state

        dehydrate( id, fields, null, notNull, propertyColumnInsertable, j, insert, session, index );

        if ( useBatch ) {
          // TODO : shouldnt inserts be Expectations.NONE?
          session.getBatcher().addToBatch( expectation );
        }
        else {
          expectation.verifyOutcome( insert.executeUpdate(), insert, -1 );
        }

      }
      catch ( SQLException sqle ) {
        if ( useBatch ) {
View Full Code Here
TOP

Related Classes of org.hibernate.jdbc.Expectation

  • org.hibernate.persister.collection.AbstractCollectionPersister
  • org.hibernate.persister.collection.BasicCollectionPersister
  • org.hibernate.persister.collection.OneToManyPersister
  • org.hibernate.persister.entity.AbstractEntityPersister
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.