ibatis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jgbut...@apache.org
Subject svn commit: r833820 [7/7] - in /ibatis/java/ibator/trunk/core/ibator-systests-ibatis3: ./ src/ src/main/ src/main/java/ src/main/java/ibatortest/ src/main/java/ibatortest/execute/ src/main/java/ibatortest/execute/miscellaneous/ src/main/resources/ src/...
Date Sun, 08 Nov 2009 04:08:24 GMT
Added: ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/hierarchical/java5/UpdateByExampleTest.java
URL: http://svn.apache.org/viewvc/ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/hierarchical/java5/UpdateByExampleTest.java?rev=833820&view=auto
==============================================================================
--- ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/hierarchical/java5/UpdateByExampleTest.java (added)
+++ ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/hierarchical/java5/UpdateByExampleTest.java Sun Nov  8 04:08:23 2009
@@ -0,0 +1,866 @@
+/*
+ *  Copyright 2009 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package ibatortest.execute.hierarchical.java5;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import ibatortest.AbstractTest;
+import ibatortest.generated.hierarchical.java5.dao.AwfulTableMapper;
+import ibatortest.generated.hierarchical.java5.dao.FieldsblobsMapper;
+import ibatortest.generated.hierarchical.java5.dao.FieldsonlyMapper;
+import ibatortest.generated.hierarchical.java5.dao.PkblobsMapper;
+import ibatortest.generated.hierarchical.java5.dao.PkfieldsMapper;
+import ibatortest.generated.hierarchical.java5.dao.PkfieldsblobsMapper;
+import ibatortest.generated.hierarchical.java5.dao.PkonlyMapper;
+import ibatortest.generated.hierarchical.java5.model.AwfulTable;
+import ibatortest.generated.hierarchical.java5.model.AwfulTableExample;
+import ibatortest.generated.hierarchical.java5.model.Fieldsblobs;
+import ibatortest.generated.hierarchical.java5.model.FieldsblobsExample;
+import ibatortest.generated.hierarchical.java5.model.FieldsblobsWithBLOBs;
+import ibatortest.generated.hierarchical.java5.model.Fieldsonly;
+import ibatortest.generated.hierarchical.java5.model.FieldsonlyExample;
+import ibatortest.generated.hierarchical.java5.model.PkblobsExample;
+import ibatortest.generated.hierarchical.java5.model.PkblobsKey;
+import ibatortest.generated.hierarchical.java5.model.PkblobsWithBLOBs;
+import ibatortest.generated.hierarchical.java5.model.Pkfields;
+import ibatortest.generated.hierarchical.java5.model.PkfieldsExample;
+import ibatortest.generated.hierarchical.java5.model.Pkfieldsblobs;
+import ibatortest.generated.hierarchical.java5.model.PkfieldsblobsExample;
+import ibatortest.generated.hierarchical.java5.model.PkfieldsblobsWithBLOBs;
+import ibatortest.generated.hierarchical.java5.model.PkonlyExample;
+import ibatortest.generated.hierarchical.java5.model.PkonlyKey;
+
+import java.util.List;
+
+import org.apache.ibatis.session.SqlSession;
+import org.junit.Test;
+
+/**
+ * 
+ * @author Jeff Butler
+ *
+ */
+public class UpdateByExampleTest extends AbstractTest {
+
+    @Test
+    public void testFieldsOnlyUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            FieldsonlyMapper mapper = sqlSession.getMapper(FieldsonlyMapper.class);
+            Fieldsonly record = new Fieldsonly();
+            record.setDoublefield(11.22);
+            record.setFloatfield(33.44);
+            record.setIntegerfield(5);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setDoublefield(44.55);
+            record.setFloatfield(66.77);
+            record.setIntegerfield(8);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setDoublefield(88.99);
+            record.setFloatfield(100.111);
+            record.setIntegerfield(9);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setDoublefield(99d);
+            FieldsonlyExample example = new FieldsonlyExample();
+            example.createCriteria().andIntegerfieldGreaterThan(5);
+            
+            int rows = mapper.updateByExampleSelective(record, example);
+            assertEquals(2, rows);
+
+            example.clear();
+            example.createCriteria().andIntegerfieldEqualTo(5);
+            List<Fieldsonly> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            record = answer.get(0);
+            assertEquals(record.getDoublefield(), 11.22, 0.0);
+            assertEquals(record.getFloatfield(), 33.44, 0.0);
+            assertEquals(record.getIntegerfield().intValue(), 5);
+            
+            example.clear();
+            example.createCriteria().andIntegerfieldEqualTo(8);
+            answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            record = (Fieldsonly) answer.get(0);
+            assertEquals(record.getDoublefield(), 99d, 0.0);
+            assertEquals(record.getFloatfield(), 66.77, 0.0);
+            assertEquals(record.getIntegerfield().intValue(), 8);
+            
+            example.clear();
+            example.createCriteria().andIntegerfieldEqualTo(9);
+            answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            record = (Fieldsonly) answer.get(0);
+            assertEquals(record.getDoublefield(), 99d, 0.0);
+            assertEquals(record.getFloatfield(), 100.111, 0.0);
+            assertEquals(record.getIntegerfield().intValue(), 9);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testFieldsOnlyUpdateByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            FieldsonlyMapper mapper = sqlSession.getMapper(FieldsonlyMapper.class);
+            Fieldsonly record = new Fieldsonly();
+            record.setDoublefield(11.22);
+            record.setFloatfield(33.44);
+            record.setIntegerfield(5);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setDoublefield(44.55);
+            record.setFloatfield(66.77);
+            record.setIntegerfield(8);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setDoublefield(88.99);
+            record.setFloatfield(100.111);
+            record.setIntegerfield(9);
+            mapper.insert(record);
+
+            record = new Fieldsonly();
+            record.setIntegerfield(22);
+            FieldsonlyExample example = new FieldsonlyExample();
+            example.createCriteria().andIntegerfieldEqualTo(5);
+            
+            int rows = mapper.updateByExample(record, example);
+            assertEquals(1, rows);
+
+            example.clear();
+            example.createCriteria().andIntegerfieldEqualTo(22);
+            List<Fieldsonly> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            record = answer.get(0);
+            assertNull(record.getDoublefield());
+            assertNull(record.getFloatfield());
+            assertEquals(record.getIntegerfield().intValue(), 22);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKOnlyUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            PkonlyMapper mapper = sqlSession.getMapper(PkonlyMapper.class);
+            PkonlyKey key = new PkonlyKey();
+            key.setId(1);
+            key.setSeqNum(3);
+            mapper.insert(key);
+
+            key = new PkonlyKey();
+            key.setId(5);
+            key.setSeqNum(6);
+            mapper.insert(key);
+
+            key = new PkonlyKey();
+            key.setId(7);
+            key.setSeqNum(8);
+            mapper.insert(key);
+
+            PkonlyExample example = new PkonlyExample();
+            example.createCriteria().andIdGreaterThan(4);
+            key = new PkonlyKey();
+            key.setSeqNum(3);
+            int rows = mapper.updateByExampleSelective(key, example);
+            assertEquals(2, rows);
+
+            example.clear();
+            example.createCriteria()
+                .andIdEqualTo(5)
+                .andSeqNumEqualTo(3);
+            
+            rows = mapper.countByExample(example);
+            assertEquals(1, rows);
+            
+            example.clear();
+            example.createCriteria()
+                .andIdEqualTo(7)
+                .andSeqNumEqualTo(3);
+            
+            rows = mapper.countByExample(example);
+            assertEquals(1, rows);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKOnlyUpdateByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            PkonlyMapper mapper = sqlSession.getMapper(PkonlyMapper.class);
+            PkonlyKey key = new PkonlyKey();
+            key.setId(1);
+            key.setSeqNum(3);
+            mapper.insert(key);
+
+            key = new PkonlyKey();
+            key.setId(5);
+            key.setSeqNum(6);
+            mapper.insert(key);
+
+            key = new PkonlyKey();
+            key.setId(7);
+            key.setSeqNum(8);
+            mapper.insert(key);
+
+            PkonlyExample example = new PkonlyExample();
+            example.createCriteria()
+                .andIdEqualTo(7);
+            key = new PkonlyKey();
+            key.setSeqNum(3);
+            key.setId(22);
+            int rows = mapper.updateByExample(key, example);
+            assertEquals(1, rows);
+
+            example.clear();
+            example.createCriteria()
+                .andIdEqualTo(22)
+                .andSeqNumEqualTo(3);
+            
+            rows = mapper.countByExample(example);
+            assertEquals(1, rows);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKFieldsUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkfieldsMapper mapper = sqlSession.getMapper(PkfieldsMapper.class);
+            Pkfields record = new Pkfields();
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+    
+            record = new Pkfields();
+            record.setFirstname("Bob");
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+    
+            mapper.insert(record);
+
+            record = new Pkfields();
+            record.setFirstname("Fred");
+            PkfieldsExample example = new PkfieldsExample();
+            example.createCriteria().andLastnameLike("J%");
+            int rows = mapper.updateByExampleSelective(record, example);
+            assertEquals(1, rows);
+            
+            example.clear();
+            example.createCriteria()
+                .andFirstnameEqualTo("Fred")
+                .andLastnameEqualTo("Jones")
+                .andId1EqualTo(3)
+                .andId2EqualTo(4);
+    
+            rows = mapper.countByExample(example);
+            assertEquals(1, rows);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKFieldsUpdateByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkfieldsMapper mapper = sqlSession.getMapper(PkfieldsMapper.class);
+            Pkfields record = new Pkfields();
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+    
+            record = new Pkfields();
+            record.setFirstname("Bob");
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+    
+            mapper.insert(record);
+
+            record = new Pkfields();
+            record.setFirstname("Fred");
+            record.setId1(3);
+            record.setId2(4);
+            PkfieldsExample example = new PkfieldsExample();
+            example.createCriteria()
+                .andId1EqualTo(3)
+                .andId2EqualTo(4);
+            
+            int rows = mapper.updateByExample(record, example);
+            assertEquals(1, rows);
+            
+            example.clear();
+            example.createCriteria()
+                .andFirstnameEqualTo("Fred")
+                .andLastnameIsNull()
+                .andId1EqualTo(3)
+                .andId2EqualTo(4);
+    
+            rows = mapper.countByExample(example);
+            assertEquals(1, rows);
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKBlobsUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkblobsMapper mapper = sqlSession.getMapper(PkblobsMapper.class);
+            PkblobsWithBLOBs record = new PkblobsWithBLOBs();
+            record.setId(3);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkblobsWithBLOBs();
+            record.setId(6);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            PkblobsWithBLOBs newRecord = new PkblobsWithBLOBs();
+            newRecord.setBlob1(generateRandomBlob());
+            
+            PkblobsExample example = new PkblobsExample();
+            example.createCriteria().andIdGreaterThan(4);
+            int rows = mapper.updateByExampleSelective(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<PkblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(6, returnedRecord.getId().intValue());
+            assertTrue(blobsAreEqual(newRecord.getBlob1(), returnedRecord.getBlob1()));
+            assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2()));
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKBlobsUpdateByExampleWithoutBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkblobsMapper mapper = sqlSession.getMapper(PkblobsMapper.class);
+            PkblobsWithBLOBs record = new PkblobsWithBLOBs();
+            record.setId(3);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkblobsWithBLOBs();
+            record.setId(6);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            PkblobsKey newRecord = new PkblobsKey();
+            newRecord.setId(8);
+            
+            PkblobsExample example = new PkblobsExample();
+            example.createCriteria().andIdGreaterThan(4);
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<PkblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(8, returnedRecord.getId().intValue());
+            assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1()));
+            assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2()));
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKBlobsUpdateByExampleWithBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkblobsMapper mapper = sqlSession.getMapper(PkblobsMapper.class);
+            PkblobsWithBLOBs record = new PkblobsWithBLOBs();
+            record.setId(3);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkblobsWithBLOBs();
+            record.setId(6);
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            PkblobsWithBLOBs newRecord = new PkblobsWithBLOBs();
+            newRecord.setId(8);
+            
+            PkblobsExample example = new PkblobsExample();
+            example.createCriteria().andIdGreaterThan(4);
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<PkblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(8, returnedRecord.getId().intValue());
+            assertNull(returnedRecord.getBlob1());
+            assertNull(returnedRecord.getBlob2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKFieldsBlobsUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkfieldsblobsMapper mapper = sqlSession.getMapper(PkfieldsblobsMapper.class);
+            PkfieldsblobsWithBLOBs record = new PkfieldsblobsWithBLOBs();
+            record.setId1(3);
+            record.setId2(4);
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkfieldsblobsWithBLOBs();
+            record.setId1(5);
+            record.setId2(6);
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+
+            PkfieldsblobsWithBLOBs newRecord = new PkfieldsblobsWithBLOBs();
+            newRecord.setFirstname("Fred");
+            PkfieldsblobsExample example = new PkfieldsblobsExample();
+            example.createCriteria().andId1NotEqualTo(3);
+            int rows = mapper.updateByExampleSelective(newRecord, example);
+            assertEquals(1, rows);
+    
+            List<PkfieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkfieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+            assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(record.getLastname(), returnedRecord.getLastname());
+            assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1()));
+            
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKFieldsBlobsUpdateByExampleWithoutBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkfieldsblobsMapper mapper = sqlSession.getMapper(PkfieldsblobsMapper.class);
+            PkfieldsblobsWithBLOBs record = new PkfieldsblobsWithBLOBs();
+            record.setId1(3);
+            record.setId2(4);
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkfieldsblobsWithBLOBs();
+            record.setId1(5);
+            record.setId2(6);
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+
+            Pkfieldsblobs newRecord = new Pkfieldsblobs();
+            newRecord.setId1(5);
+            newRecord.setId2(8);
+            newRecord.setFirstname("Fred");
+            PkfieldsblobsExample example = new PkfieldsblobsExample();
+            example.createCriteria().andId1EqualTo(5);
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+    
+            List<PkfieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkfieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getId1(), returnedRecord.getId1());
+            assertEquals(newRecord.getId2(), returnedRecord.getId2());
+            assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname());
+            assertNull(returnedRecord.getLastname());
+            assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1()));
+            
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testPKFieldsBlobsUpdateByExampleWithBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            PkfieldsblobsMapper mapper = sqlSession.getMapper(PkfieldsblobsMapper.class);
+            PkfieldsblobsWithBLOBs record = new PkfieldsblobsWithBLOBs();
+            record.setId1(3);
+            record.setId2(4);
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new PkfieldsblobsWithBLOBs();
+            record.setId1(5);
+            record.setId2(6);
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            mapper.insert(record);
+
+            PkfieldsblobsWithBLOBs newRecord = new PkfieldsblobsWithBLOBs();
+            newRecord.setId1(3);
+            newRecord.setId2(8);
+            newRecord.setFirstname("Fred");
+            PkfieldsblobsExample example = new PkfieldsblobsExample();
+            example.createCriteria().andId1EqualTo(3);
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+    
+            List<PkfieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            PkfieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getId1(), returnedRecord.getId1());
+            assertEquals(newRecord.getId2(), returnedRecord.getId2());
+            assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname());
+            assertNull(returnedRecord.getLastname());
+            assertNull(returnedRecord.getBlob1());
+            
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testFieldsBlobsUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            FieldsblobsMapper mapper = sqlSession.getMapper(FieldsblobsMapper.class);
+            FieldsblobsWithBLOBs record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+
+            FieldsblobsWithBLOBs newRecord = new FieldsblobsWithBLOBs();
+            newRecord.setLastname("Doe");
+            FieldsblobsExample example = new FieldsblobsExample();
+            example.createCriteria().andFirstnameLike("S%");
+            int rows = mapper.updateByExampleSelective(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<FieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            FieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(record.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(newRecord.getLastname(), returnedRecord.getLastname());
+            assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1()));
+            assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2()));
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testFieldsBlobsUpdateByExampleWithoutBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            FieldsblobsMapper mapper = sqlSession.getMapper(FieldsblobsMapper.class);
+            FieldsblobsWithBLOBs record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+
+            Fieldsblobs newRecord = new Fieldsblobs();
+            newRecord.setFirstname("Scott");
+            newRecord.setLastname("Doe");
+            FieldsblobsExample example = new FieldsblobsExample();
+            example.createCriteria().andFirstnameLike("S%");
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<FieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            FieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(newRecord.getLastname(), returnedRecord.getLastname());
+            assertTrue(blobsAreEqual(record.getBlob1(), returnedRecord.getBlob1()));
+            assertTrue(blobsAreEqual(record.getBlob2(), returnedRecord.getBlob2()));
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testFieldsBlobsUpdateByExampleWithBLOBs() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            FieldsblobsMapper mapper = sqlSession.getMapper(FieldsblobsMapper.class);
+            FieldsblobsWithBLOBs record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Jeff");
+            record.setLastname("Smith");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+    
+            record = new FieldsblobsWithBLOBs();
+            record.setFirstname("Scott");
+            record.setLastname("Jones");
+            record.setBlob1(generateRandomBlob());
+            record.setBlob2(generateRandomBlob());
+            mapper.insert(record);
+
+            FieldsblobsWithBLOBs newRecord = new FieldsblobsWithBLOBs();
+            newRecord.setFirstname("Scott");
+            newRecord.setLastname("Doe");
+            FieldsblobsExample example = new FieldsblobsExample();
+            example.createCriteria().andFirstnameLike("S%");
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+            
+            List<FieldsblobsWithBLOBs> answer = mapper.selectByExampleWithBLOBs(example);
+            assertEquals(1, answer.size());
+            
+            FieldsblobsWithBLOBs returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(newRecord.getLastname(), returnedRecord.getLastname());
+            assertNull(returnedRecord.getBlob1());
+            assertNull(returnedRecord.getBlob2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testAwfulTableUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            AwfulTableMapper mapper = sqlSession.getMapper(AwfulTableMapper.class);
+            AwfulTable record = new AwfulTable();
+            record.seteMail("fred@fred.com");
+            record.setEmailaddress("alsofred@fred.com");
+            record.setFirstFirstName("fred1");
+            record.setFrom("from field");
+            record.setId1(1);
+            record.setId2(2);
+            record.setId5(5);
+            record.setId6(6);
+            record.setId7(7);
+            record.setSecondFirstName("fred2");
+            record.setThirdFirstName("fred3");
+    
+            mapper.insert(record);
+    
+            record = new AwfulTable();
+            record.seteMail("fred2@fred.com");
+            record.setEmailaddress("alsofred2@fred.com");
+            record.setFirstFirstName("fred11");
+            record.setFrom("from from field");
+            record.setId1(11);
+            record.setId2(22);
+            record.setId5(55);
+            record.setId6(66);
+            record.setId7(77);
+            record.setSecondFirstName("fred22");
+            record.setThirdFirstName("fred33");
+    
+            mapper.insert(record);
+    
+            AwfulTable newRecord = new AwfulTable();
+            newRecord.setFirstFirstName("Alonzo");
+            AwfulTableExample example = new AwfulTableExample();
+            example.createCriteria().andEMailLike("fred2@%");
+            int rows = mapper.updateByExampleSelective(newRecord, example);
+            assertEquals(1, rows);
+    
+            List<AwfulTable> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+
+            AwfulTable returnedRecord = answer.get(0);
+            
+            assertEquals(record.getCustomerId(), returnedRecord.getCustomerId());
+            assertEquals(record.geteMail(), returnedRecord.geteMail());
+            assertEquals(record.getEmailaddress(), returnedRecord.getEmailaddress());
+            assertEquals(newRecord.getFirstFirstName(), returnedRecord.getFirstFirstName());
+            assertEquals(record.getFrom(), returnedRecord.getFrom());
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+            assertEquals(record.getId5(), returnedRecord.getId5());
+            assertEquals(record.getId6(), returnedRecord.getId6());
+            assertEquals(record.getId7(), returnedRecord.getId7());
+            assertEquals(record.getSecondFirstName(), returnedRecord.getSecondFirstName());
+            assertEquals(record.getThirdFirstName(), returnedRecord.getThirdFirstName());
+            
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testAwfulTableUpdateByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+    
+        try {
+            AwfulTableMapper mapper = sqlSession.getMapper(AwfulTableMapper.class);
+            AwfulTable record = new AwfulTable();
+            record.seteMail("fred@fred.com");
+            record.setEmailaddress("alsofred@fred.com");
+            record.setFirstFirstName("fred1");
+            record.setFrom("from field");
+            record.setId1(1);
+            record.setId2(2);
+            record.setId5(5);
+            record.setId6(6);
+            record.setId7(7);
+            record.setSecondFirstName("fred2");
+            record.setThirdFirstName("fred3");
+    
+            mapper.insert(record);
+    
+            record = new AwfulTable();
+            record.seteMail("fred2@fred.com");
+            record.setEmailaddress("alsofred2@fred.com");
+            record.setFirstFirstName("fred11");
+            record.setFrom("from from field");
+            record.setId1(11);
+            record.setId2(22);
+            record.setId5(55);
+            record.setId6(66);
+            record.setId7(77);
+            record.setSecondFirstName("fred22");
+            record.setThirdFirstName("fred33");
+    
+            mapper.insert(record);
+    
+            AwfulTable newRecord = new AwfulTable();
+            newRecord.setFirstFirstName("Alonzo");
+            newRecord.setCustomerId(58);
+            newRecord.setId1(111);
+            newRecord.setId2(222);
+            newRecord.setId5(555);
+            newRecord.setId6(666);
+            newRecord.setId7(777);
+            AwfulTableExample example = new AwfulTableExample();
+            example.createCriteria().andEMailLike("fred2@%");
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+
+            example.clear();
+            example.createCriteria().andCustomerIdEqualTo(58);
+            List<AwfulTable> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+
+            AwfulTable returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getCustomerId(), returnedRecord.getCustomerId());
+            assertNull(returnedRecord.geteMail());
+            assertNull(returnedRecord.getEmailaddress());
+            assertEquals(newRecord.getFirstFirstName(), returnedRecord.getFirstFirstName());
+            assertNull(returnedRecord.getFrom());
+            assertEquals(newRecord.getId1(), returnedRecord.getId1());
+            assertEquals(newRecord.getId2(), returnedRecord.getId2());
+            assertEquals(newRecord.getId5(), returnedRecord.getId5());
+            assertEquals(newRecord.getId6(), returnedRecord.getId6());
+            assertEquals(newRecord.getId7(), returnedRecord.getId7());
+            assertNull(returnedRecord.getSecondFirstName());
+            assertNull(returnedRecord.getThirdFirstName());
+        } finally {
+            sqlSession.close();
+        }
+    }
+}

Added: ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/miscellaneous/MiscellaneousTest.java
URL: http://svn.apache.org/viewvc/ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/miscellaneous/MiscellaneousTest.java?rev=833820&view=auto
==============================================================================
--- ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/miscellaneous/MiscellaneousTest.java (added)
+++ ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/java/ibatortest/execute/miscellaneous/MiscellaneousTest.java Sun Nov  8 04:08:23 2009
@@ -0,0 +1,1020 @@
+/*
+ *  Copyright 2009 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package ibatortest.execute.miscellaneous;
+
+import static org.junit.Assert.*;
+import ibatortest.AbstractTest;
+import ibatortest.generated.miscellaneous.dao.MyObjectMapper;
+import ibatortest.generated.miscellaneous.dao.RegexrenameMapper;
+import ibatortest.generated.miscellaneous.model.Anotherawfultable;
+import ibatortest.generated.miscellaneous.model.MyObject;
+import ibatortest.generated.miscellaneous.model.MyObjectCriteria;
+import ibatortest.generated.miscellaneous.model.MyObjectKey;
+import ibatortest.generated.miscellaneous.model.Regexrename;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.ibatis.session.SqlSession;
+import org.junit.Test;
+
+/**
+ * @author Jeff Butler
+ * 
+ */
+public class MiscellaneousTest extends AbstractTest {
+
+    @Test
+    public void testMyObjectinsertMyObject() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            record.setStartDate(new Date());
+            record.setDecimal100field(10L);
+            record.setDecimal155field(15.12345);
+            record.setDecimal60field(6);
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setId1(1);
+            record.setId2(2);
+            record.setLastname("Butler");
+
+            MyTime myTime = new MyTime();
+            myTime.setHours(12);
+            myTime.setMinutes(34);
+            myTime.setSeconds(05);
+            record.setTimefield(myTime);
+            record.setTimestampfield(new Date());
+
+            mapper.insert(record);
+
+            MyObjectKey key = new MyObjectKey();
+            key.setId1(1);
+            key.setId2(2);
+
+            MyObject returnedRecord = mapper.selectByPrimaryKey(key);
+            assertNotNull(returnedRecord);
+
+            assertTrue(datesAreEqual(record.getStartDate(), returnedRecord
+                    .getStartDate()));
+            assertEquals(record.getDecimal100field(), returnedRecord
+                    .getDecimal100field());
+            assertEquals(record.getDecimal155field(), returnedRecord
+                    .getDecimal155field());
+            assertEquals(record.getDecimal60field(), returnedRecord
+                    .getDecimal60field());
+            assertEquals(record.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+            assertEquals(record.getLastname(), returnedRecord.getLastname());
+            assertEquals(record.getTimefield(), returnedRecord.getTimefield());
+            assertEquals(record.getTimestampfield(), returnedRecord
+                    .getTimestampfield());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectUpdateByPrimaryKey() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+
+            mapper.insert(record);
+
+            fn = new FirstName();
+            fn.setValue("Scott");
+            record.setFirstname(fn);
+            record.setLastname("Jones");
+
+            int rows = mapper.updateByPrimaryKey(record);
+            assertEquals(1, rows);
+
+            MyObjectKey key = new MyObjectKey();
+            key.setId1(1);
+            key.setId2(2);
+
+            MyObject record2 = mapper.selectByPrimaryKey(key);
+
+            assertEquals(record.getFirstname(), record2.getFirstname());
+            assertEquals(record.getLastname(), record2.getLastname());
+            assertEquals(record.getId1(), record2.getId1());
+            assertEquals(record.getId2(), record2.getId2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectUpdateByPrimaryKeySelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setDecimal60field(5);
+            record.setId1(1);
+            record.setId2(2);
+
+            mapper.insert(record);
+
+            MyObject newRecord = new MyObject();
+            newRecord.setId1(1);
+            newRecord.setId2(2);
+            fn = new FirstName();
+            fn.setValue("Scott");
+            newRecord.setFirstname(fn);
+            record.setStartDate(new Date());
+
+            int rows = mapper.updateByPrimaryKeySelective(newRecord);
+            assertEquals(1, rows);
+
+            MyObjectKey key = new MyObjectKey();
+            key.setId1(1);
+            key.setId2(2);
+
+            MyObject returnedRecord = mapper.selectByPrimaryKey(key);
+
+            assertTrue(datesAreEqual(newRecord.getStartDate(), returnedRecord
+                    .getStartDate()));
+            assertEquals(record.getDecimal100field(), returnedRecord
+                    .getDecimal100field());
+            assertEquals(record.getDecimal155field(), returnedRecord
+                    .getDecimal155field());
+
+            // with columns mapped to primitive types, the column is always
+            // updated
+            assertEquals(newRecord.getDecimal60field(), returnedRecord
+                    .getDecimal60field());
+
+            assertEquals(newRecord.getFirstname(), returnedRecord
+                    .getFirstname());
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+            assertEquals(record.getLastname(), returnedRecord.getLastname());
+            assertEquals(record.getTimefield(), returnedRecord.getTimefield());
+            assertEquals(record.getTimestampfield(), returnedRecord
+                    .getTimestampfield());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testMyObjectDeleteByPrimaryKey() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+
+            mapper.insert(record);
+
+            MyObjectKey key = new MyObjectKey();
+            key.setId1(1);
+            key.setId2(2);
+
+            int rows = mapper.deleteByPrimaryKey(key);
+            assertEquals(1, rows);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            List answer = mapper.selectByExample(example);
+            assertEquals(0, answer.size());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testMyObjectDeleteByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bob");
+            record.setFirstname(fn);
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            List answer = mapper.selectByExample(example);
+            assertEquals(2, answer.size());
+
+            example = new MyObjectCriteria();
+            example.createCriteria().andLastnameLike("J%");
+            int rows = mapper.deleteByExample(example);
+            assertEquals(1, rows);
+
+            example = new MyObjectCriteria();
+            answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectSelectByPrimaryKey() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bob");
+            record.setFirstname(fn);
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+            mapper.insert(record);
+
+            MyObjectKey key = new MyObjectKey();
+            key.setId1(3);
+            key.setId2(4);
+            MyObject newRecord = mapper.selectByPrimaryKey(key);
+
+            assertNotNull(newRecord);
+            assertEquals(record.getFirstname(), newRecord.getFirstname());
+            assertEquals(record.getLastname(), newRecord.getLastname());
+            assertEquals(record.getId1(), newRecord.getId1());
+            assertEquals(record.getId2(), newRecord.getId2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testMyObjectSelectByExampleLike() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            fn = new FirstName();
+            fn.setValue("B%");
+            example.createCriteria().andFirstnameLike(fn);
+            example.setOrderByClause("ID1, ID2");
+            List answer = mapper.selectByExample(example);
+            assertEquals(3, answer.size());
+            MyObject returnedRecord = (MyObject) answer.get(0);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(1, returnedRecord.getId2().intValue());
+            returnedRecord = (MyObject) answer.get(1);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(2, returnedRecord.getId2().intValue());
+            returnedRecord = (MyObject) answer.get(2);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testMyObjectSelectByExampleNotLike() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            fn = new FirstName();
+            fn.setValue("B%");
+            example.createCriteria().andFirstnameNotLike(fn);
+            example.setOrderByClause("ID1, ID2");
+            List answer = mapper.selectByExample(example);
+            assertEquals(3, answer.size());
+            MyObject returnedRecord = (MyObject) answer.get(0);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(1, returnedRecord.getId2().intValue());
+            returnedRecord = (MyObject) answer.get(1);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(2, returnedRecord.getId2().intValue());
+            returnedRecord = (MyObject) answer.get(2);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testMyObjectSelectByExampleComplexLike() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            fn = new FirstName();
+            fn.setValue("B%");
+            example.createCriteria().andFirstnameLike(fn).andId2EqualTo(3);
+            fn = new FirstName();
+            fn.setValue("W%");
+            example.or(example.createCriteria().andFirstnameLike(fn));
+
+            example.setOrderByClause("ID1, ID2");
+            List answer = mapper.selectByExample(example);
+            assertEquals(2, answer.size());
+            MyObject returnedRecord = (MyObject) answer.get(0);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(2, returnedRecord.getId2().intValue());
+            returnedRecord = (MyObject) answer.get(1);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectSelectByExampleIn() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            List<Integer> ids = new ArrayList<Integer>();
+            ids.add(1);
+            ids.add(3);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            example.createCriteria().andId2In(ids);
+
+            example.setOrderByClause("ID1, ID2");
+            List<MyObject> answer = mapper.selectByExample(example);
+            assertEquals(4, answer.size());
+            MyObject returnedRecord = answer.get(0);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(1, returnedRecord.getId2().intValue());
+            assertEquals("Flintstone", returnedRecord.getLastname());
+            
+            returnedRecord = answer.get(1);
+            assertEquals(1, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+            assertEquals("Flintstone", returnedRecord.getLastname());
+            
+            returnedRecord = answer.get(2);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(1, returnedRecord.getId2().intValue());
+            assertEquals("Rubble", returnedRecord.getLastname());
+            
+            returnedRecord = answer.get(3);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+            assertEquals("Rubble", returnedRecord.getLastname());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectSelectByExampleBetween() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            example.createCriteria().andId2Between(1, 3);
+
+            example.setOrderByClause("ID1, ID2");
+            List<MyObject> answer = mapper.selectByExample(example);
+            assertEquals(6, answer.size());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectSelectByExampleTimeEquals() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            record.setStartDate(new Date());
+            record.setDecimal100field(10L);
+            record.setDecimal155field(15.12345);
+            record.setDecimal60field(6);
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setId1(1);
+            record.setId2(2);
+            record.setLastname("Butler");
+
+            MyTime myTime = new MyTime();
+            myTime.setHours(12);
+            myTime.setMinutes(34);
+            myTime.setSeconds(05);
+            record.setTimefield(myTime);
+            record.setTimestampfield(new Date());
+
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            example.createCriteria().andTimefieldEqualTo(myTime);
+            List<MyObject> results = mapper.selectByExample(example);
+            assertEquals(1, results.size());
+            MyObject returnedRecord = results.get(0);
+
+            assertTrue(datesAreEqual(record.getStartDate(), returnedRecord
+                    .getStartDate()));
+            assertEquals(record.getDecimal100field(), returnedRecord
+                    .getDecimal100field());
+            assertEquals(record.getDecimal155field(), returnedRecord
+                    .getDecimal155field());
+            assertEquals(record.getDecimal60field(), returnedRecord
+                    .getDecimal60field());
+            assertEquals(record.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+            assertEquals(record.getLastname(), returnedRecord.getLastname());
+            assertEquals(record.getTimefield(), returnedRecord.getTimefield());
+            assertEquals(record.getTimestampfield(), returnedRecord
+                    .getTimestampfield());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testFieldIgnored() {
+        try {
+            MyObject.class.getDeclaredField("decimal30field");
+            fail("decimal30field should be ignored");
+        } catch (NoSuchFieldException e) {
+            // ignore (normal case)
+        }
+    }
+
+    @Test
+    public void testMyObjectUpdateByExampleSelective() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bob");
+            record.setFirstname(fn);
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+
+            mapper.insert(record);
+
+            MyObject newRecord = new MyObject();
+            newRecord.setLastname("Barker");
+            
+            MyObjectCriteria example = new MyObjectCriteria();
+            fn = new FirstName();
+            fn.setValue("B%");
+            example.createCriteria().andFirstnameLike(fn);
+            int rows = mapper.updateByExampleSelective(newRecord, example);
+            assertEquals(1, rows);
+
+            List<MyObject> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            
+            MyObject returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getLastname(), returnedRecord.getLastname());
+            assertEquals(record.getFirstname(), returnedRecord.getFirstname());
+            assertEquals(record.getId1(), returnedRecord.getId1());
+            assertEquals(record.getId2(), returnedRecord.getId2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectUpdateByExample() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Jeff");
+            record.setFirstname(fn);
+            record.setLastname("Smith");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bob");
+            record.setFirstname(fn);
+            record.setLastname("Jones");
+            record.setId1(3);
+            record.setId2(4);
+
+            mapper.insert(record);
+
+            MyObject newRecord = new MyObject();
+            newRecord.setLastname("Barker");
+            newRecord.setId1(3);
+            newRecord.setId2(4);
+            
+            MyObjectCriteria example = new MyObjectCriteria();
+            example.createCriteria()
+                .andId1EqualTo(3)
+                .andId2EqualTo(4);
+            int rows = mapper.updateByExample(newRecord, example);
+            assertEquals(1, rows);
+
+            List<MyObject> answer = mapper.selectByExample(example);
+            assertEquals(1, answer.size());
+            
+            MyObject returnedRecord = answer.get(0);
+            
+            assertEquals(newRecord.getLastname(), returnedRecord.getLastname());
+            assertNull(returnedRecord.getFirstname());
+            assertEquals(newRecord.getId1(), returnedRecord.getId1());
+            assertEquals(newRecord.getId2(), returnedRecord.getId2());
+        } finally {
+            sqlSession.close();
+        }
+    }
+    
+    @Test
+    public void testRegexRenameInsert() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+        
+        try {
+            RegexrenameMapper mapper = sqlSession.getMapper(RegexrenameMapper.class);
+            Regexrename record = new Regexrename();
+            record.setAddress("123 Main Street");
+            record.setId(22);
+            record.setName("Fred");
+            record.setZipCode("99999");
+            
+            mapper.insert(record);
+            
+            Regexrename returnedRecord = mapper.selectByPrimaryKey(22);
+            
+            assertEquals(record.getAddress(), returnedRecord.getAddress());
+            assertEquals(record.getId(), returnedRecord.getId());
+            assertEquals(record.getName(), returnedRecord.getName());
+            assertEquals(record.getZipCode(), returnedRecord.getZipCode());
+        } finally {
+            sqlSession.close();
+        }
+    }
+    
+    @Test
+    public void testAnotherAwfulTableInsert() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+        
+        try {
+            Anotherawfultable record = new Anotherawfultable();
+            record.setId(5);
+            record.setSelect("select");
+            record.setInsert("insert");
+            
+            sqlSession.insert("ANOTHERAWFULTABLE.insert", record);
+            
+            Anotherawfultable key = new Anotherawfultable();
+            key.setId(5);
+            
+            Anotherawfultable returnedRecord = (Anotherawfultable)
+                sqlSession.selectOne("ANOTHERAWFULTABLE.selectByPrimaryKey",
+                        key);
+            
+            assertEquals(record.getId(), returnedRecord.getId());
+            assertEquals(record.getSelect(), returnedRecord.getSelect());
+            assertEquals(record.getInsert(), returnedRecord.getInsert());
+            assertEquals(record.getUpdate(), returnedRecord.getUpdate());
+            assertEquals(record.getDelete(), returnedRecord.getDelete());
+        } finally {
+            sqlSession.close();
+        }
+    }
+
+    @Test
+    public void testMyObjectSelectByExampleLikeInsensitive() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+
+        try {
+            MyObjectMapper mapper = sqlSession.getMapper(MyObjectMapper.class);
+            MyObject record = new MyObject();
+            FirstName fn = new FirstName();
+            fn.setValue("Fred");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Wilma");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Pebbles");
+            record.setFirstname(fn);
+            record.setLastname("Flintstone");
+            record.setId1(1);
+            record.setId2(3);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Barney");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(1);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Betty");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(2);
+            mapper.insert(record);
+
+            record = new MyObject();
+            fn = new FirstName();
+            fn.setValue("Bamm Bamm");
+            record.setFirstname(fn);
+            record.setLastname("Rubble");
+            record.setId1(2);
+            record.setId2(3);
+            mapper.insert(record);
+
+            MyObjectCriteria example = new MyObjectCriteria();
+            example.createCriteria().andLastnameLike("RU%");
+            example.setOrderByClause("ID1, ID2");
+            List<MyObject> answer = mapper.selectByExample(example);
+            assertEquals(0, answer.size());
+            
+            example.clear();
+            example.createCriteria().andLastnameLikeInsensitive("RU%");
+            answer = mapper.selectByExample(example);
+            assertEquals(3, answer.size());
+            
+            MyObject returnedRecord = answer.get(0);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(1, returnedRecord.getId2().intValue());
+            returnedRecord = answer.get(1);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(2, returnedRecord.getId2().intValue());
+            returnedRecord = answer.get(2);
+            assertEquals(2, returnedRecord.getId1().intValue());
+            assertEquals(3, returnedRecord.getId2().intValue());
+        } finally {
+            sqlSession.close();
+        }
+    }
+}

Added: ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/resources/ibatortest/MapperConfig.xml
URL: http://svn.apache.org/viewvc/ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/resources/ibatortest/MapperConfig.xml?rev=833820&view=auto
==============================================================================
--- ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/resources/ibatortest/MapperConfig.xml (added)
+++ ibatis/java/ibator/trunk/core/ibator-systests-ibatis3/src/test/resources/ibatortest/MapperConfig.xml Sun Nov  8 04:08:23 2009
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<!DOCTYPE configuration
+    PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
+    "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
+<configuration>
+
+  <settings>
+    <setting name="cacheEnabled" value="true"/>
+    <setting name="lazyLoadingEnabled" value="false"/>
+    <setting name="multipleResultSetsEnabled" value="true"/>
+    <setting name="useColumnLabel" value="true"/>
+    <setting name="useGeneratedKeys" value="false"/>
+    <setting name="defaultExecutorType" value="SIMPLE"/>
+    <setting name="defaultStatementTimeout" value="25000"/>
+  </settings>
+
+  <environments default="development">
+    <environment id="development">
+      <transactionManager type="JDBC">
+        <property name="" value=""/>
+      </transactionManager>
+      <dataSource type="UNPOOLED">
+        <property name="driver" value="org.hsqldb.jdbcDriver"/>
+        <property name="url" value="jdbc:hsqldb:mem:aname"/>
+        <property name="username" value="sa"/>
+      </dataSource>
+    </environment>
+  </environments>
+
+  <mappers>
+    <mapper resource="ibatortest/generated/conditional/java5/xml/AwfulTableMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/FieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/FieldsonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/PkblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/PkfieldsMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/PkfieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/conditional/java5/xml/PkonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/AwfulTableMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/FieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/FieldsonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/PkblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/PkfieldsMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/PkfieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/flat/java5/xml/PkonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/AwfulTableMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/FieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/FieldsonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/PkblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/PkfieldsMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/PkfieldsblobsMapper.xml" />
+    <mapper resource="ibatortest/generated/hierarchical/java5/xml/PkonlyMapper.xml" />
+    <mapper resource="ibatortest/generated/miscellaneous/xml/AnotherawfultableMapper.xml" />
+    <mapper resource="ibatortest/generated/miscellaneous/xml/MyObjectMapper.xml" />
+    <mapper resource="ibatortest/generated/miscellaneous/xml/RegexrenameMapper.xml" />
+  </mappers>
+
+</configuration>



Mime
View raw message