try { //create all the new entries Iterator entries = collection.entries(this); if ( entries.hasNext() ) { collection.preInsert( this ); int i = 0; int count = 0; while ( entries.hasNext() ) { 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++; } catch ( SQLException sqle ) { if ( useBatch ) { session.getBatcher().abortBatch( sqle ); } throw sqle; } finally { if ( !useBatch ) { session.getBatcher().closeStatement( st ); } } } i++; } if ( log.isDebugEnabled() ) { log.debug( "done inserting collection: " + count + " rows inserted" ); } } else { if ( log.isDebugEnabled() ) { log.debug( "collection was empty" ); } } } catch ( SQLException sqle ) { throw JDBCExceptionHelper.convert( sqlExceptionConverter, sqle, "could not insert collection: " + MessageHelper.collectionInfoString( this, id, getFactory() ), getSQLInsertRowString() ); }
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 ) { if ( useBatch ) { session.getBatcher().abortBatch( sqle ); } throw sqle; } finally { if ( !useBatch ) { session.getBatcher().closeStatement( st ); } } } i++; } if ( log.isDebugEnabled() ) { log.debug( "done inserting rows: " + count + " inserted" ); } } catch ( SQLException sqle ) { throw JDBCExceptionHelper.convert( sqlExceptionConverter, sqle, "could not insert collection rows: " + MessageHelper.collectionInfoString( this, id, getFactory() ), getSQLInsertRowString() ); }
Clone fragments detected by clone detection tool
File path: /hibernate-distribution-3.3.2.GA/project/core/src/main/java/org/hibernate/persister/collection/AbstractCollectionPersister.java File path: /hibernate-distribution-3.3.2.GA/project/core/src/main/java/org/hibernate/persister/collection/AbstractCollectionPersister.java
Method name: void recreate(PersistentCollection, Serializable, SessionImplementor) Method name: void insertRows(PersistentCollection, Serializable, SessionImplementor)
Number of AST nodes: 40 Number of AST nodes: 38
1
try {
1
try {
2
				//create all the new entries
2
				//insert all the new entries
3
				Iterator entries = collection.entries(this);
3
				
4
				if ( entries.hasNext() ) {
5
					collection.preInsert( this );
6
					int i = 0;
7
					int count = 0;
8
					while ( entries.hasNext() ) {
9
						final Object entry = entries.next();
10
						if (
4
collection.preInsert( this );
11
 collection.entryExists( entry, i ) ) {
5
				Iterator entries = collection.entr
12
							int offset = 1;
13
							PreparedStatement st = null;
14
			
6
ies( this );
15
				Expectation expectation = Expectations.appropriateExpectation( getInsertCheckStyle() );
7
				Expectation expectation = Expectations.appropriateExpectation( getInsertCheckStyle() );
16
							boolean callable = isInsertCallable();
8
				boolean callable = isInsertCallable();
17
							boolean useBatch = expectation.canBeBatched();
9
				boolean useBatch = expectation.canBeBatched();
18
							String sql = getSQLInsertRowString();
10
				String sql = getSQLInsertRowString();
19
							if ( useBatch
11
				int i = 0;
12
				int count = 0;
13
				while ( entries.hasNext() ) {
14
					int offset = 1;
15
					Object entry = entries.next();
16
					PreparedStatement st = null;
17
					if ( collection.needsInserting( entry, i, elementType ) ) {
18
						if ( useBatch ) {
20
 ) {
19
							if ( st == null ) {
21
								if ( callable ) {
20
								if ( callable ) {
22
									st = session.getBatcher().prepareBatchCallableStatement( sql );
21
									st = session.getBatcher().prepareBatchCallableStatement( sql );
23
								}
22
								}
24
								else {
23
								else {
25
									st = session.getBatcher().prepareBatchStatement( sql );
24
									st = session.getBatcher().prepareBatchStatement( sql );
26
								}
25
								}
27
							}
26
							}
28
						
27
						}
29
	else {
28
						else {
30
								if ( callable ) {
29
							if ( callable ) {
31
									st = session.getBatcher().prepareCallableStatement( sql );
30
								st = session.getBatcher().prepareCallableStatement( sql );
32
								}
31
							}
33
								else {
32
							else {
34
									st = session.getBatcher().prepareStatement( sql );
33
								st = session.getBatcher().prepareStatement( sql );
35
								}
34
							}
36
							}
35
						}
37
							try {
36
						try {
38
								offset+= expectation.prepare( st );
37
							offset += expectation.prepare( st );
39
								//TODO: copy/paste from insertRows()
38
							//TODO: copy/paste from recreate()
40
								int loc = writeKey( st, id, offset, session );
39
							offset = writeKey( st, id, offset, session );
41
								if ( hasIdentifier ) {
40
							if ( hasIdentifier ) {
42
									loc = writeIdentifier( st, collection.getIdentifier(entry, i), loc, session );
41
								offset = writeIdentifier( st, collection.getIdentifier(entry, i), offset, session );
43
								}
42
							}
44
								if ( hasIndex /*&& !indexIsFormula*/ ) {
43
							if ( hasIndex /*&& !indexIsFormula*/ ) {
45
									loc = writeIndex( st, collection.getIndex(entry, i, this), loc, session );
44
								offset = writeIndex( st, collection.getIndex(entry, i, this), offset, session );
46
								}
45
							}
47
								loc = writeElement(st, collection.getElement(entry), loc, session );
46
							writeElement(st, collection.getElement(entry), offset, session );
48
								if ( useBatch ) {
47
							if ( useBatch ) {
49
									session.getBatcher().addToBatch( expectation );
48
								session.getBatcher().addToBatch( expectation );
50
								}
49
							}
51
								else {
50
							else {
52
									expectation.verifyOutcome( st.executeUpdate(), st, -1 );
51
								expectation.verifyOutcome( st.executeUpdate(), st, -1 );
53
								}
52
							
53
}
54
								collection.afterRowInsert( this, entry, i );
54
							collection.afterRowInsert( this, entry, i );
55
								count++;
55
							count++;
56
							}
56
						}
57
							catch ( SQLException sqle ) {
57
						catch ( SQLException sqle ) {
58
								if ( useBatch ) {
58
							if ( useBatch ) {
59
									session.getBatcher().abortBatch( sqle );
59
								session.getBatcher().abortBatch( sqle );
60
								}
60
							}
61
								throw sqle;
61
							throw sqle;
62
							}
62
						}
63
							finally {
63
						finally {
64
								if ( !useBatch ) {
64
							if ( !useBatch ) {
65
									session.getBatcher().closeStatement( st );
65
								session.getBatcher().closeStatement( st );
66
								}
66
							}
67
							}
67
						}
68
						}
68
					}
69
						i++;
69
					i++;
70
					}
70
				
71
}
71
					if ( log.isDebugEnabled() ) {
72
				if ( log.isDebugEnabled() ) {
72
						log.debug( "done inserting collection: " + count + " rows inserted" );
73
					log.debug( "done inserting rows: " + count + " inserted" );
73
					}
74
				
74
				}
75
				else {
76
					if ( log.isDebugEnabled() ) {
77
						log.debug( "collection was empty" );
78
					}
79
				}
75
}
80
			}
76
			}
81
			catch ( SQLException sqle ) {
77
			catch ( SQLException sqle ) {
82
				throw JDBCExceptionHelper.convert(
78
				throw JDBCExceptionHelper.convert(
83
				        sqlExceptionConverter,
79
				        sqlExceptionConverter,
84
				        sqle,
80
				        sqle,
85
				        "could not insert collection: " + 
81
				        "could not insert collection rows: " + 
86
				        MessageHelper.collectionInfoString( this, id, getFactory() ),
82
				        MessageHelper.collectionInfoString( this, id, getFactory() ),
87
				        getSQLInsertRowString()
83
				        getSQLInsertRowString()
88
					);
84
					);
89
			}
85
			}
Summary
Number of common nesting structure subtrees3
Number of refactorable cases2
Number of non-refactorable cases1
Time elapsed for finding largest common nesting structure subtrees (ms)3.2
Clones locationClones are declared in the same class
Number of node comparisons80
  1. {Refactorable}
    Mapping Summary
    Number of mapped statements3
    Number of unmapped statements in the first code fragment0
    Number of unmapped statements in the second code fragment0
    Time elapsed for statement mapping (ms)8.9
    Clone typeType 1
    Mapped Statements
    ID Statement ID Statement
    20
    if (callable)
    20
    if (callable)
    21
    st = session.getBatcher().prepareBatchCallableStatement(sql);
    21
    st = session.getBatcher().prepareBatchCallableStatement(sql);
    else
    else
    22
    st = session.getBatcher().prepareBatchStatement(sql);
    22
    st = session.getBatcher().prepareBatchStatement(sql);
    Precondition Violations (0)
    Row Violation
  2. {Refactorable}
    Mapping Summary
    Number of mapped statements3
    Number of unmapped statements in the first code fragment0
    Number of unmapped statements in the second code fragment0
    Time elapsed for statement mapping (ms)26.1
    Clone typeType 2
    Mapped Statements
    ID Statement ID Statement
    23
    if (callable)
    20
    if (callable)
    24
    st = session.getBatcher().prepareCallableStatement(sql);
    24
    st = session.getBatcher().prepareCallableStatement(sql);
    21
    st = session.getBatcher().prepareBatchCallableStatement(sql);
    Differences
    Expression1Expression2Difference
    prepareCallableStatementprepareBatchCallableStatementMETHOD_INVOCATION_NAME_MISMATCH
    Preondition Violations
    Expression session.getBatcher().prepareCallableStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression session.getBatcher().prepareBatchCallableStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    21
    st = session.getBatcher().prepareBatchCallableStatement(sql);
    else
    else
    25
    st = session.getBatcher().prepareStatement(sql);
    25
    st = session.getBatcher().prepareStatement(sql);
    22
    st = session.getBatcher().prepareBatchStatement(sql);
    Differences
    Expression1Expression2Difference
    prepareStatementprepareBatchStatementMETHOD_INVOCATION_NAME_MISMATCH
    Preondition Violations
    Expression session.getBatcher().prepareStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression session.getBatcher().prepareBatchStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    22
    st = session.getBatcher().prepareBatchStatement(sql);
    Precondition Violations (4)
    Row Violation
    1Expression session.getBatcher().prepareCallableStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    2Expression session.getBatcher().prepareBatchCallableStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    3Expression session.getBatcher().prepareStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    4Expression session.getBatcher().prepareBatchStatement(sql) cannot be parameterized, because it has dependencies to/from statements that will be extracted
  1. {Non-refactorable}
    Mapping Summary
    Number of mapped statements1
    Number of unmapped statements in the first code fragment1
    Number of unmapped statements in the second code fragment3
    Time elapsed for statement mapping (ms)4.0
    Clone typeType 3
    Mapped Statements
    ID Statement ID Statement
                                                                            
    27
    offset += expectation.prepare(st);
                                                                                        
    28
    offset = writeKey(st, id, offset, session);
    Preondition Violations
    Unmatched statement offset=writeKey(st,id,offset,session); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    28
    offset = writeKey(st, id, offset, session);
    42
    if (log.isDebugEnabled())
    42
    if (log.isDebugEnabled())
    29
    if (hasIdentifier)
    Differences
    Expression1Expression2Difference
    log.isDebugEnabled()hasIdentifierTYPE_COMPATIBLE_REPLACEMENT
    29
    if (hasIdentifier)
                                                                                                                                                                    
    30
    offset = writeIdentifier(st, collection.getIdentifier(entry, i), offset, session);
    Preondition Violations
    Unmatched statement offset=writeIdentifier(st,collection.getIdentifier(entry,i),offset,session); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    Unmatched statement offset=writeIdentifier(st,collection.getIdentifier(entry,i),offset,session); cannot be moved before or after the extracted code, because it throws exception(s) that should be caught by a try block that will be extracted
    30
    offset = writeIdentifier(st, collection.getIdentifier(entry, i), offset, session);
    43
    log.debug("collection was empty");
    43
    log.debug("collection was empty");
    Preondition Violations
    Unmatched statement log.debug("collection was empty"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
                                                                                
    Precondition Violations (5)
    Row Violation
    1Unmatched statement offset=writeKey(st,id,offset,session); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    2Unmatched statement offset=writeIdentifier(st,collection.getIdentifier(entry,i),offset,session); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    3Unmatched statement offset=writeIdentifier(st,collection.getIdentifier(entry,i),offset,session); cannot be moved before or after the extracted code, because it throws exception(s) that should be caught by a try block that will be extracted
    4Unmatched statement log.debug("collection was empty"); cannot be moved before the extracted code, because it has control dependencies from statements that will be extracted
    5The refactoring of the clones is infeasible, because the number of macthed statements is equal to zero