Session s = openSession(); s.beginTransaction(); Person p = new Person( "steve" ); Address a = new Address( "123 Main", "Austin", "US", p ); s.persist( a ); s.persist( p ); s.getTransaction().commit(); s.close(); clearCounts(); p.getAddress().setStreetAddress( "321 Main" ); s = openSession(); s.beginTransaction(); p = ( Person ) s.merge( p ); s.getTransaction().commit(); s.close(); assertInsertCount( 0 ); assertUpdateCount( 0 ); // no cascade assertDeleteCount( 0 ); s = openSession(); s.beginTransaction(); s.delete( a ); s.delete( p ); s.getTransaction().commit(); s.close();
Session s = openSession(); s.beginTransaction(); VersionedEntity entity = new VersionedEntity( "entity", "entity" ); s.persist( entity ); s.getTransaction().commit(); s.close(); clearCounts(); // entity is now detached, but we have made no changes. so attempt to merge it // into this new session; this should cause no updates... s = openSession(); s.beginTransaction(); VersionedEntity mergedEntity = ( VersionedEntity ) s.merge( entity ); s.getTransaction().commit(); s.close(); assertUpdateCount( 0 ); assertInsertCount( 0 ); assertEquals( "unexpected version increment", entity.getVersion(), mergedEntity.getVersion() ); /////////////////////////////////////////////////////////////////////// // as a control measure, now update the node while it is detached and // make sure we get an update as a result... entity.setName( "new name" ); s = openSession(); s.beginTransaction(); entity = ( VersionedEntity ) s.merge( entity ); s.getTransaction().commit(); s.close(); assertUpdateCount( 1 ); assertInsertCount( 0 ); /////////////////////////////////////////////////////////////////////// cleanup();
Clone fragments detected by clone detection tool
File path: /hibernate-distribution-3.3.2.GA/project/testsuite/src/test/java/org/hibernate/test/ops/MergeTest.java File path: /hibernate-distribution-3.3.2.GA/project/testsuite/src/test/java/org/hibernate/test/ops/MergeTest.java
Method name: void testMergeBidiForeignKeyOneToOne() Method name: void testNoExtraUpdatesOnMergeVersioned()
Number of AST nodes: 24 Number of AST nodes: 24
1
Session s = openSession();
1
Session s = openSession();
2
        s.beginTransaction();
2
        s.beginTransaction();
3
		Person p = new Person( "steve" );
3
		VersionedEntity entity = new Version
4
		Address a = new Address( "123 Main", "Austin", "US", p );
5
		s.persist( a );
6
		s.persist( p );
7
		s.getTransaction().commit();
8
		s.close();
9
		clearCounts();
10
		p.getAddress().setStreetAddress( "321 Main" );
4
edEntity( "entity", "entity" );
5
		s.persist( entity );
6
		s.getTransaction().commit();
7
		s.close();
8
		clearCounts();
9
		// entity is now detached, but we have made no changes.  so attempt to merge it
10
		// into this new session; this should cause no updates...
11
		s = openSession();
11
		s = openSession();
12
        s.beginTransaction();
12
		s.beginTransaction();
13
		p = ( Person ) s.merge( p );
13
		VersionedEntity mergedEntity = ( VersionedEntity ) s.merge( entity );
14
		s.getTransaction().commit();
14
		s.getTransaction().commit();
15
		s.close();
15
		s.close();
16
		assertInsertCount( 0 );
16
		assert
17
		assertUpdateCount( 0 ); // no cascade
18
		assertDeleteCount( 0
17
UpdateCount( 0 );
18
		assertInsertCount( 0 );
19
        assertEquals( "unexpected version increment", entity.getVersion(), mergedEntity.getVersion() );
20
		///////////////////////////////////////////////////////////////////////
21
		// as a control measure, now update the node while it is detached and
22
		// make sure we get an update as a result...
19
 );
23
		entity.setName( "new name" );
20
		s = openSession();
24
		s = openSession();
21
        s.beginTransaction();
25
		s.beginTransaction();
22
		s.delete( a );
26
		
23
		s.delete( p );
27
entity = ( VersionedEntity ) s.merge( entity );
24
		s.getTransaction().commit();
28
		s.getTransaction().commit();
25
		s.close();
29
		s.close();
30
		assertUpdateCount( 1 );
31
		assertInsertCount( 0 );
32
		///////////////////////////////////////////////////////////////////////
33
		cleanup();
Summary
Number of common nesting structure subtrees1
Number of refactorable cases0
Number of non-refactorable cases1
Time elapsed for finding largest common nesting structure subtrees (ms)0.0
Clones locationClones are declared in the same class
Number of node comparisons200
  1. {Non-refactorable}
    Mapping Summary
    Number of mapped statements19
    Number of unmapped statements in the first code fragment5
    Number of unmapped statements in the second code fragment5
    Time elapsed for statement mapping (ms)0.0
    Clone typeType 2
    Mapped Statements
    ID Statement ID Statement
    1
    Session s = openSession();
    1
    Session s = openSession();
    2
    s.beginTransaction();
    2
    s.beginTransaction();
                                                                                                                                      
    3
    VersionedEntity entity = new VersionedEntity("entity", "entity");
    3
    Person p = new Person("steve");
                                                                    
    4
    Address a = new Address("123 Main", "Austin", "US", p);
                                                                                                              
    5
    s.persist(a);
    5
    s.persist(a);
    24
    cleanup();
    Differences
    Expression1Expression2Difference
    persistcleanupMETHOD_INVOCATION_NAME_MISMATCH
    s.persist(a)cleanup()ARGUMENT_NUMBER_MISMATCH
    sMISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression s.persist(a) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression s.persist(a) is a void method call, and thus it cannot be parameterized
    Expression cleanup() is a void method call, and thus it cannot be parameterized
    Expression s.persist(a) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression s.persist(a) is a void method call, and thus it cannot be parameterized
    Expression cleanup() is a void method call, and thus it cannot be parameterized
    24
    cleanup();
    6
    s.persist(p);
    6
    s.persist(p);
    4
    s.persist(entity);
    Differences
    Expression1Expression2Difference
    pentityVARIABLE_NAME_MISMATCH
    org.hibernate.test.ops.Personorg.hibernate.test.ops.VersionedEntityVARIABLE_TYPE_MISMATCH
    Preondition Violations
    Type org.hibernate.test.ops.Person of variable p does not match with type org.hibernate.test.ops.VersionedEntity of variable entity
    • Make classes org.hibernate.test.ops.Person and org.hibernate.test.ops.VersionedEntity extend a common superclass
    4
    s.persist(entity);
    7
    s.getTransaction().commit();
    5
    s.getTransaction().commit();
    8
    s.close();
    6
    s.close();
    9
    clearCounts();
    7
    clearCounts();
    10
    p.getAddress().setStreetAddress("321 Main");
    10
    p.getAddress().setStreetAddress("321 Main");
    15
    assertEquals("unexpected version increment", entity.getVersion(), mergedEntity.getVersion());
    Differences
    Expression1Expression2Difference
    setStreetAddressassertEqualsMETHOD_INVOCATION_NAME_MISMATCH
    p.getAddress().setStreetAddress("321 Main")assertEquals("unexpected version increment",entity.getVersion(),mergedEntity.getVersion())ARGUMENT_NUMBER_MISMATCH
    p.getAddress()MISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression p.getAddress().setStreetAddress("321 Main") is a void method call, and thus it cannot be parameterized
    Expression assertEquals("unexpected version increment",entity.getVersion(),mergedEntity.getVersion()) is a void method call, and thus it cannot be parameterized
    Expression p.getAddress().setStreetAddress("321 Main") is a void method call, and thus it cannot be parameterized
    Expression assertEquals("unexpected version increment",entity.getVersion(),mergedEntity.getVersion()) is a void method call, and thus it cannot be parameterized
    15
    assertEquals("unexpected version increment", entity.getVersion(), mergedEntity.getVersion());
    11
    s = openSession();
    8
    s = openSession();
    12
    s.beginTransaction();
    9
    s.beginTransaction();
                                                                                                                                        
    10
    VersionedEntity mergedEntity = (VersionedEntity)s.merge(entity);
    Preondition Violations
    Unmatched statement VersionedEntity mergedEntity=(VersionedEntity)s.merge(entity); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    10
    VersionedEntity mergedEntity = (VersionedEntity)s.merge(entity);
    13
    p = (Person)s.merge(p);
    13
    p = (Person)s.merge(p);
    Preondition Violations
    Unmatched statement p=(Person)s.merge(p); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                      
    14
    s.getTransaction().commit();
    11
    s.getTransaction().commit();
    15
    s.close();
    12
    s.close();
    16
    assertInsertCount(0);
    14
    assertInsertCount(0);
    17
    assertUpdateCount(0);
    13
    assertUpdateCount(0);
                                                                  
    16
    entity.setName("new name");
    18
    assertDeleteCount(0);
    18
    assertDeleteCount(0);
    23
    assertInsertCount(0);
    Differences
    Expression1Expression2Difference
    assertDeleteCountassertInsertCountMETHOD_INVOCATION_NAME_MISMATCH
    Preondition Violations
    Expression assertDeleteCount(0) is a void method call, and thus it cannot be parameterized
    Expression assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    23
    assertInsertCount(0);
    19
    s = openSession();
    17
    s = openSession();
    20
    s.beginTransaction();
    18
    s.beginTransaction();
                                                                                            
    19
    entity = (VersionedEntity)s.merge(entity);
    Preondition Violations
    Unmatched statement entity=(VersionedEntity)s.merge(entity); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    19
    entity = (VersionedEntity)s.merge(entity);
    21
    s.delete(a);
                                    
    22
    s.delete(p);
                                    
    23
    s.getTransaction().commit();
    20
    s.getTransaction().commit();
    24
    s.close();
    21
    s.close();
                                                      
    22
    assertUpdateCount(1);
    Precondition Violations (16)
    Row Violation
    1Expression s.persist(a) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    2Expression s.persist(a) is a void method call, and thus it cannot be parameterized
    3Expression cleanup() is a void method call, and thus it cannot be parameterized
    4Expression s.persist(a) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    5Expression s.persist(a) is a void method call, and thus it cannot be parameterized
    6Expression cleanup() is a void method call, and thus it cannot be parameterized
    7Type org.hibernate.test.ops.Person of variable p does not match with type org.hibernate.test.ops.VersionedEntity of variable entity
    8Expression p.getAddress().setStreetAddress("321 Main") is a void method call, and thus it cannot be parameterized
    9Expression assertEquals("unexpected version increment",entity.getVersion(),mergedEntity.getVersion()) is a void method call, and thus it cannot be parameterized
    10Expression p.getAddress().setStreetAddress("321 Main") is a void method call, and thus it cannot be parameterized
    11Expression assertEquals("unexpected version increment",entity.getVersion(),mergedEntity.getVersion()) is a void method call, and thus it cannot be parameterized
    12Unmatched statement VersionedEntity mergedEntity=(VersionedEntity)s.merge(entity); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    13Unmatched statement p=(Person)s.merge(p); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    14Expression assertDeleteCount(0) is a void method call, and thus it cannot be parameterized
    15Expression assertInsertCount(0) is a void method call, and thus it cannot be parameterized
    16Unmatched statement entity=(VersionedEntity)s.merge(entity); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted