MentaBean

Rev

Rev 185 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
22 soliveira 1
/*
2
 * This program is free software: you can redistribute it and/or modify
3
 * it under the terms of the GNU General Public License as published by
4
 * the Free Software Foundation, either version 3 of the License, or
5
 * (at your option) any later version.
6
 *
7
 * This program is distributed in the hope that it will be useful,
8
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 * GNU General Public License for more details.
11
 *
12
 * You should have received a copy of the GNU General Public License
13
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 *
15
 * MentaBean => http://www.mentabean.org
16
 * Author: Sergio Oliveira Jr. (sergio.oliveira.jr@gmail.com)
17
 */
15 soliveira 18
package org.mentabean.jdbc;
19
 
20
import java.sql.Connection;
21
import java.sql.PreparedStatement;
22
import java.sql.ResultSet;
23
import java.sql.SQLException;
16 soliveira 24
import java.text.SimpleDateFormat;
25
import java.util.Date;
19 soliveira 26
import java.util.List;
15 soliveira 27
 
28
import junit.framework.Assert;
29
 
16 soliveira 30
import org.junit.BeforeClass;
15 soliveira 31
import org.junit.Test;
61 soliveira 32
import org.mentabean.AutoBeanConfig;
16 soliveira 33
import org.mentabean.BeanConfig;
21 soliveira 34
import org.mentabean.BeanException;
16 soliveira 35
import org.mentabean.BeanManager;
36
import org.mentabean.BeanSession;
37
import org.mentabean.DBTypes;
167 soliveira 38
import org.mentabean.sql.TableAlias;
38 soliveira 39
import org.mentabean.type.EnumIdType;
118 soliveira 40
import org.mentabean.util.PropertiesProxy;
171 soliveira 41
import org.mentabean.util.SQLBuilder;
61 soliveira 42
import org.mentabean.util.SQLUtils;
15 soliveira 43
 
56 soliveira 44
public class AnsiSQLBeanSessionTest extends AbstractBeanSessionTest {
18 soliveira 45
 
16 soliveira 46
        private static final SimpleDateFormat BD_FORMATTER = new SimpleDateFormat("yyyy-MM-dd");
18 soliveira 47
 
16 soliveira 48
        @BeforeClass
49
        public static void setup() {
54 soliveira 50
                AnsiSQLBeanSession.DEBUG = false; // turn on to see SQL generated
16 soliveira 51
        }
18 soliveira 52
 
16 soliveira 53
        private static class User {
18 soliveira 54
 
19 soliveira 55
                public static enum Status {
56
                        BASIC, PREMIUM, GOLD
57
                }
58
 
79 soliveira 59
                private long id;
16 soliveira 60
                private String username;
61
                private Date birthdate;
208 erico 62
                private Status status;
16 soliveira 63
                private boolean deleted;
64
                private Date insertTime;
18 soliveira 65
 
66
                public User() {
67
                }
68
 
79 soliveira 69
                public User(long id) {
18 soliveira 70
                        this.id = id;
71
                }
72
 
16 soliveira 73
                public User(String username, String birthdate) {
74
                        this.username = username;
17 soliveira 75
                        this.birthdate = fromString(birthdate);
208 erico 76
                        this.status = Status.BASIC;
17 soliveira 77
                }
18 soliveira 78
 
17 soliveira 79
                private static Date fromString(String date) {
16 soliveira 80
                        try {
17 soliveira 81
                                return BD_FORMATTER.parse(date);
18 soliveira 82
                        } catch (Exception e) {
17 soliveira 83
                                throw new IllegalArgumentException("Cannot parse date: " + date);
16 soliveira 84
                        }
85
                }
18 soliveira 86
 
17 soliveira 87
                public void setBirthdate(String date) {
88
                        setBirthdate(fromString(date));
89
                }
18 soliveira 90
 
79 soliveira 91
                public long getId() {
18 soliveira 92
                        return id;
93
                }
94
 
79 soliveira 95
                public void setId(long id) {
18 soliveira 96
                        this.id = id;
97
                }
98
 
16 soliveira 99
                public String getUsername() {
18 soliveira 100
                        return username;
101
                }
102
 
16 soliveira 103
                public void setUsername(String username) {
18 soliveira 104
                        this.username = username;
105
                }
106
 
16 soliveira 107
                public Date getBirthdate() {
18 soliveira 108
                        return birthdate;
109
                }
110
 
16 soliveira 111
                public void setBirthdate(Date birthdate) {
18 soliveira 112
                        this.birthdate = birthdate;
113
                }
114
 
16 soliveira 115
                public boolean isDeleted() {
18 soliveira 116
                        return deleted;
117
                }
118
 
16 soliveira 119
                public void setDeleted(boolean deleted) {
18 soliveira 120
                        this.deleted = deleted;
121
                }
122
 
16 soliveira 123
                public Date getInsertTime() {
18 soliveira 124
                        return insertTime;
125
                }
126
 
16 soliveira 127
                public void setInsertTime(Date insertTime) {
18 soliveira 128
                        this.insertTime = insertTime;
129
                }
19 soliveira 130
 
131
                public void setStatus(Status status) {
132
                        this.status = status;
133
                }
134
 
135
                public Status getStatus() {
136
                        return status;
137
                }
15 soliveira 138
        }
18 soliveira 139
 
16 soliveira 140
        private void createTables(Connection conn) throws SQLException {
18 soliveira 141
 
21 soliveira 142
                execUpdate(conn, "create table Users(id integer primary key auto_increment, username varchar(25), bd datetime, status varchar(20), deleted tinyint, insert_time timestamp)");
143
                execUpdate(conn, "create table Posts(id integer primary key auto_increment, user_id integer, title varchar(200), body text, insert_time timestamp)");
16 soliveira 144
        }
18 soliveira 145
 
16 soliveira 146
        private BeanConfig getUserBeanConfig() {
18 soliveira 147
 
16 soliveira 148
                // programmatic configuration for the bean... (no annotation or XML)
18 soliveira 149
 
16 soliveira 150
                BeanConfig config = new BeanConfig(User.class, "Users");
118 soliveira 151
 
152
                User userProps = PropertiesProxy.create(User.class);
153
 
208 erico 154
                config.pk(userProps.getId(), DBTypes.AUTOINCREMENT)
155
                        .field(userProps.getUsername(), DBTypes.STRING)
156
                        .field(userProps.getBirthdate(), "bd", DBTypes.DATE) // note that the database column name is different
157
                        .field(userProps.getStatus(), DBTypes.ENUMVALUE.from(User.Status.class))
158
                        .field(userProps.isDeleted(), DBTypes.BOOLEANINT)
159
                        .field(userProps.getInsertTime(), "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);
18 soliveira 160
 
16 soliveira 161
                return config;
162
        }
18 soliveira 163
 
15 soliveira 164
        @Test
21 soliveira 165
        public void testCRUD() throws SQLException { // CRUD = ISUD = Insert, Select, Update, Delete
18 soliveira 166
 
16 soliveira 167
                BeanManager beanManager = new BeanManager();
168
                BeanConfig userConfig = getUserBeanConfig();
169
                beanManager.addBeanConfig(userConfig);
18 soliveira 170
 
16 soliveira 171
                Connection conn = null;
15 soliveira 172
                PreparedStatement stmt = null;
173
                ResultSet rset = null;
18 soliveira 174
 
15 soliveira 175
                try {
18 soliveira 176
 
16 soliveira 177
                        conn = getConnection();
178
                        BeanSession session = new H2BeanSession(beanManager, conn);
18 soliveira 179
 
16 soliveira 180
                        createTables(conn);
18 soliveira 181
 
16 soliveira 182
                        // INSERT:
18 soliveira 183
 
16 soliveira 184
                        User u = new User("saoj", "1980-03-01");
19 soliveira 185
                        u.setStatus(User.Status.GOLD);
18 soliveira 186
 
16 soliveira 187
                        session.insert(u);
18 soliveira 188
 
16 soliveira 189
                        Assert.assertEquals(1, u.getId());
190
                        Assert.assertEquals("saoj", u.getUsername());
191
                        Assert.assertEquals("1980-03-01", BD_FORMATTER.format(u.getBirthdate()));
192
                        Assert.assertEquals(false, u.isDeleted());
19 soliveira 193
                        Assert.assertEquals(User.Status.GOLD, u.getStatus());
18 soliveira 194
 
16 soliveira 195
                        // SELECT:
18 soliveira 196
 
16 soliveira 197
                        u = new User(1);
18 soliveira 198
 
16 soliveira 199
                        boolean loaded = session.load(u);
18 soliveira 200
 
16 soliveira 201
                        Assert.assertEquals(true, loaded);
18 soliveira 202
 
16 soliveira 203
                        Assert.assertEquals(1, u.getId());
204
                        Assert.assertEquals("saoj", u.getUsername());
205
                        Assert.assertEquals("1980-03-01", BD_FORMATTER.format(u.getBirthdate()));
206
                        Assert.assertEquals(false, u.isDeleted());
19 soliveira 207
                        Assert.assertEquals(User.Status.GOLD, u.getStatus());
16 soliveira 208
                        Assert.assertTrue((new Date()).getTime() >= u.getInsertTime().getTime());
18 soliveira 209
 
16 soliveira 210
                        // UPDATE:
18 soliveira 211
 
16 soliveira 212
                        u.setUsername("soliveira");
18 soliveira 213
 
16 soliveira 214
                        int modified = session.update(u);
18 soliveira 215
 
16 soliveira 216
                        Assert.assertEquals(1, modified);
18 soliveira 217
 
16 soliveira 218
                        Assert.assertEquals(1, u.getId());
219
                        Assert.assertEquals("soliveira", u.getUsername());
220
                        Assert.assertEquals("1980-03-01", BD_FORMATTER.format(u.getBirthdate()));
221
                        Assert.assertEquals(false, u.isDeleted());
19 soliveira 222
                        Assert.assertEquals(User.Status.GOLD, u.getStatus());
16 soliveira 223
                        Assert.assertTrue((new Date()).getTime() >= u.getInsertTime().getTime());
18 soliveira 224
 
16 soliveira 225
                        // make sure the new username was saved in the database
18 soliveira 226
 
16 soliveira 227
                        u = new User(1);
18 soliveira 228
 
16 soliveira 229
                        loaded = session.load(u);
18 soliveira 230
 
16 soliveira 231
                        Assert.assertEquals(true, loaded);
18 soliveira 232
 
16 soliveira 233
                        Assert.assertEquals(1, u.getId());
234
                        Assert.assertEquals("soliveira", u.getUsername());
235
                        Assert.assertEquals("1980-03-01", BD_FORMATTER.format(u.getBirthdate()));
236
                        Assert.assertEquals(false, u.isDeleted());
19 soliveira 237
                        Assert.assertEquals(User.Status.GOLD, u.getStatus());
16 soliveira 238
                        Assert.assertTrue((new Date()).getTime() >= u.getInsertTime().getTime());
18 soliveira 239
 
16 soliveira 240
                        // DELETE:
18 soliveira 241
 
16 soliveira 242
                        boolean deleted = session.delete(u);
18 soliveira 243
 
16 soliveira 244
                        Assert.assertEquals(true, deleted);
18 soliveira 245
 
16 soliveira 246
                        // make sure the bean is deleted from the database...
18 soliveira 247
 
16 soliveira 248
                        u = new User(1);
18 soliveira 249
 
16 soliveira 250
                        loaded = session.load(u);
18 soliveira 251
 
16 soliveira 252
                        Assert.assertEquals(false, loaded);
18 soliveira 253
 
15 soliveira 254
                } finally {
18 soliveira 255
 
15 soliveira 256
                        close(stmt, rset);
257
                        close(conn);
258
                }
259
        }
18 soliveira 260
 
17 soliveira 261
        @Test
262
        public void testDynUpdate() throws SQLException {
18 soliveira 263
 
17 soliveira 264
                BeanManager beanManager = new BeanManager();
265
                BeanConfig userConfig = getUserBeanConfig();
266
                beanManager.addBeanConfig(userConfig);
18 soliveira 267
 
17 soliveira 268
                Connection conn = null;
269
                PreparedStatement stmt = null;
270
                ResultSet rset = null;
18 soliveira 271
 
17 soliveira 272
                try {
18 soliveira 273
 
17 soliveira 274
                        conn = getConnection();
275
                        BeanSession session = new H2BeanSession(beanManager, conn);
18 soliveira 276
 
17 soliveira 277
                        createTables(conn);
18 soliveira 278
 
17 soliveira 279
                        // First insert, so we can test the update after...
280
                        User u = new User("saoj", "1980-03-01");
281
                        session.insert(u);
18 soliveira 282
 
17 soliveira 283
                        Assert.assertEquals(1, u.getId());
284
                        Assert.assertEquals("saoj", u.getUsername());
285
                        Assert.assertEquals("1980-03-01", BD_FORMATTER.format(u.getBirthdate()));
286
                        Assert.assertEquals(false, u.isDeleted());
18 soliveira 287
 
17 soliveira 288
                        // UNATTACHED UPDATE:
18 soliveira 289
 
290
                        u = new User(1); // note that bean was NOT loaded, in other words,
291
                                                                // it was NOT attached to session
17 soliveira 292
                        u.setUsername("soliveira");
18 soliveira 293
 
294
                        int modified = session.update(u); // only properties that are
295
                                                                                                // considered SET will be
296
                                                                                                // updated
17 soliveira 297
                        Assert.assertEquals(1, modified);
298
 
299
                        // make sure it was written to the database
300
                        u = new User(1);
301
                        boolean loaded = session.load(u);
302
                        Assert.assertEquals(true, loaded);
303
 
304
                        Assert.assertEquals("soliveira", u.getUsername());
18 soliveira 305
 
17 soliveira 306
                        // ATTACHED UPDATE:
18 soliveira 307
 
17 soliveira 308
                        u = new User(1);
309
                        loaded = session.load(u);
310
                        Assert.assertEquals(true, loaded);
311
 
18 soliveira 312
                        u.setUsername(u.getUsername()); // setting, but nothing is
313
                                                                                        // changing...
314
 
17 soliveira 315
                        modified = session.update(u); // nothing should happen here...
316
                        Assert.assertEquals(0, modified);
18 soliveira 317
 
17 soliveira 318
                        // UNATTACHED UPDATED ALL:
18 soliveira 319
 
320
                        u = new User(1); // note that bean was NOT loaded, in other words,
321
                                                                // it was NOT attached to session
17 soliveira 322
                        u.setUsername("julia");
18 soliveira 323
 
17 soliveira 324
                        modified = session.updateAll(u);
18 soliveira 325
 
17 soliveira 326
                        Assert.assertEquals(1, modified);
18 soliveira 327
 
328
                        // everything was written to the database, even the fields that were
329
                        // NOT set
17 soliveira 330
                        // as a result, some fields were nullified
18 soliveira 331
 
17 soliveira 332
                        u = new User(1);
333
                        loaded = session.load(u);
334
                        Assert.assertEquals(true, loaded);
335
                        Assert.assertEquals("julia", u.getUsername());
336
                        Assert.assertNull(u.getBirthdate());
337
                        Assert.assertNull(u.getInsertTime());
18 soliveira 338
 
17 soliveira 339
                        // ATTACHED UPDATE ALL:
18 soliveira 340
 
17 soliveira 341
                        u = new User(1);
342
                        loaded = session.load(u);
343
                        Assert.assertEquals(true, loaded);
18 soliveira 344
 
17 soliveira 345
                        u.setBirthdate("1980-02-02");
18 soliveira 346
 
17 soliveira 347
                        modified = session.updateAll(u);
18 soliveira 348
 
17 soliveira 349
                        Assert.assertEquals(1, modified);
18 soliveira 350
 
351
                        // everything was written to the database, even the fields that were
352
                        // NOT set
353
 
17 soliveira 354
                        u = new User(1);
355
                        loaded = session.load(u);
356
                        Assert.assertEquals(true, loaded);
357
                        Assert.assertEquals("julia", u.getUsername());
358
                        Assert.assertEquals("1980-02-02", BD_FORMATTER.format(u.getBirthdate()));
359
                        Assert.assertNull(u.getInsertTime());
18 soliveira 360
 
17 soliveira 361
                } finally {
18 soliveira 362
 
17 soliveira 363
                        close(stmt, rset);
364
                        close(conn);
365
                }
366
        }
18 soliveira 367
 
17 soliveira 368
        @Test
369
        public void testMultipleInserts() throws SQLException {
18 soliveira 370
 
17 soliveira 371
                BeanManager beanManager = new BeanManager();
372
                BeanConfig userConfig = getUserBeanConfig();
373
                beanManager.addBeanConfig(userConfig);
18 soliveira 374
 
17 soliveira 375
                Connection conn = null;
18 soliveira 376
 
17 soliveira 377
                try {
18 soliveira 378
 
17 soliveira 379
                        conn = getConnection();
380
                        BeanSession session = new H2BeanSession(beanManager, conn);
18 soliveira 381
 
17 soliveira 382
                        createTables(conn);
18 soliveira 383
 
384
                        for (int i = 0; i < 10; i++) {
17 soliveira 385
                                User u = new User();
386
                                u.setUsername("saoj" + (i + 1));
387
                                u.setBirthdate("1990-01-1" + i);
18 soliveira 388
 
17 soliveira 389
                                session.insert(u);
18 soliveira 390
 
17 soliveira 391
                                Assert.assertEquals(i + 1, u.getId());
392
                        }
393
                } finally {
394
                        close(conn);
395
                }
396
        }
18 soliveira 397
 
17 soliveira 398
        @Test
399
        public void testLoadList() throws SQLException {
18 soliveira 400
 
17 soliveira 401
                BeanManager beanManager = new BeanManager();
402
                BeanConfig userConfig = getUserBeanConfig();
403
                beanManager.addBeanConfig(userConfig);
18 soliveira 404
 
17 soliveira 405
                Connection conn = null;
18 soliveira 406
 
17 soliveira 407
                try {
18 soliveira 408
 
17 soliveira 409
                        conn = getConnection();
410
                        BeanSession session = new H2BeanSession(beanManager, conn);
18 soliveira 411
 
17 soliveira 412
                        createTables(conn);
18 soliveira 413
 
414
                        for (int i = 0; i < 10; i++) {
17 soliveira 415
                                User u = new User();
416
                                u.setUsername("saoj" + (i + 1));
417
                                u.setBirthdate("1990-01-1" + i);
19 soliveira 418
                                u.setStatus(User.Status.BASIC);
18 soliveira 419
 
17 soliveira 420
                                session.insert(u);
18 soliveira 421
 
17 soliveira 422
                                Assert.assertEquals(i + 1, u.getId());
423
                        }
18 soliveira 424
 
19 soliveira 425
                        // now set one user to GOLD
426
 
427
                        User u = new User(5);
428
                        boolean loaded = session.load(u);
429
                        Assert.assertEquals(true, loaded);
430
                        u.setStatus(User.Status.GOLD);
431
                        int modified = session.update(u);
432
                        Assert.assertEquals(1, modified);
433
 
434
                        // first count to see if we are excluding the golad...
435
 
436
                        u = new User();
437
                        u.setStatus(User.Status.BASIC);
438
 
439
                        int total = session.countList(u);
440
 
441
                        Assert.assertEquals(9, total);
442
 
443
                        // now load a list of all BASIC users
444
 
445
                        u = new User();
446
                        u.setStatus(User.Status.BASIC);
447
 
448
                        List<User> users = session.loadList(u);
449
 
450
                        Assert.assertEquals(9, users.size());
451
 
452
                        // check that the GOLD user was not loaded...
453
 
454
                        for (User user : users) {
455
                                Assert.assertTrue(user.getId() != 5);
456
                        }
457
 
17 soliveira 458
                } finally {
459
                        close(conn);
460
                }
461
        }
18 soliveira 462
 
21 soliveira 463
        private static class Post {
464
 
465
                private int id;
466
                private User user;
467
                private String title;
468
                private String body;
469
                private Date insertTime;
470
 
471
                public Post() {
472
                }
473
 
474
                public Post(int id) {
475
                        this.id = id;
476
                }
477
 
178 soliveira 478
                public Post(User user, String title, String text) {
479
                        this.user = user;
21 soliveira 480
                        this.title = title;
31 soliveira 481
                        this.body = text;
21 soliveira 482
                }
483
 
484
                public int getId() {
485
                        return id;
486
                }
487
 
488
                public void setId(int id) {
489
                        this.id = id;
490
                }
491
 
492
                public User getUser() {
493
                        return user;
494
                }
495
 
496
                public void setUser(User user) {
497
                        this.user = user;
498
                }
499
 
500
                public String getTitle() {
501
                        return title;
502
                }
503
 
504
                public void setTitle(String title) {
505
                        this.title = title;
506
                }
507
 
508
                public String getBody() {
509
                        return body;
510
                }
511
 
512
                public void setBody(String body) {
513
                        this.body = body;
514
                }
515
 
516
                public Date getInsertTime() {
517
                        return insertTime;
518
                }
519
 
520
                public void setInsertTime(Date insertTime) {
521
                        this.insertTime = insertTime;
522
                }
523
        }
524
 
35 soliveira 525
        private void getPostBeanConfig(BeanManager beanManager) {
61 soliveira 526
 
35 soliveira 527
                // Fluent API
61 soliveira 528
 
178 soliveira 529
                beanManager
530
                .bean(Post.class, "Posts")
531
                .pk("id", DBTypes.AUTOINCREMENT)
532
                .field("user.id", "user_id", DBTypes.LONG)
533
                .field("title", DBTypes.STRING).field("body", DBTypes.STRING)
534
                .field("insertTime", "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);
21 soliveira 535
        }
536
 
537
        @Test
538
        public void testOneToOneRelationshipCRUD() throws SQLException {
539
 
540
                BeanManager beanManager = new BeanManager();
541
                BeanConfig userConfig = getUserBeanConfig();
35 soliveira 542
                getPostBeanConfig(beanManager);
21 soliveira 543
                beanManager.addBeanConfig(userConfig);
544
 
545
                Connection conn = null;
546
                PreparedStatement stmt = null;
547
                ResultSet rset = null;
548
 
549
                try {
550
 
551
                        conn = getConnection();
33 soliveira 552
                        BeanSession session = new H2BeanSession(beanManager, conn);
21 soliveira 553
 
554
                        createTables(conn);
555
 
556
                        User u = new User("saoj", "1980-01-02");
557
                        session.insert(u);
558
 
559
                        Assert.assertEquals(1, u.getId());
560
 
561
                        // Now insert a post for this user...
178 soliveira 562
                        Post p = new Post(new User(1), "Test", "This is a test!");
21 soliveira 563
                        session.insert(p);
564
 
565
                        Assert.assertEquals(1, p.getId());
566
 
567
                        // Load from the database...
568
                        p = new Post(1);
569
                        boolean loaded = session.load(p);
570
                        Assert.assertEquals("Test", p.getTitle());
178 soliveira 571
                        Assert.assertEquals(1, p.getUser().getId());
572
                        Assert.assertNotNull(p.getUser()); // loads user with id only
573
                        Assert.assertEquals(1, p.getUser().getId());
574
                        Assert.assertNull(p.getUser().getUsername());
21 soliveira 575
 
576
                        // Load user for this post... (let's do our manual lazy loading)
178 soliveira 577
                        u = new User(p.getUser().getId());
21 soliveira 578
                        loaded = session.load(u);
579
                        Assert.assertEquals(true, loaded);
580
                        p.setUser(u); // manual lazy loading (forget about automatic lazy loading, you want control!)
581
 
582
                        // Use JOIN to load all dependencies with a single query... (you know how to make a join, right?)
583
 
584
                        p = new Post(1);
585
 
586
                        StringBuilder query = new StringBuilder(256);
587
                        query.append("select ");
588
                        query.append(session.buildSelect(Post.class, "p"));
589
                        query.append(", ");
590
                        query.append(session.buildSelect(User.class, "u"));
591
                        query.append(" from Posts p join Users u on p.user_id = u.id");
592
                        query.append(" where p.id = ?");
593
 
115 soliveira 594
                        stmt = SQLUtils.prepare(conn, query.toString(), p.getId());
595
 
21 soliveira 596
                        rset = stmt.executeQuery();
597
 
598
                        if (rset.next()) {
599
 
600
                                session.populateBean(rset, p, "p");
601
 
602
                                u = new User();
603
 
604
                                session.populateBean(rset, u, "u");
605
 
606
                                p.setUser(u); // manual lazy loading (we prefer to have control!)
607
                        }
608
 
609
                        Assert.assertEquals(1, p.getId());
610
                        Assert.assertEquals("Test", p.getTitle());
611
                        Assert.assertEquals(1, u.getId());
612
                        Assert.assertEquals("saoj", p.getUser().getUsername());
613
                        Assert.assertTrue((new Date()).getTime() >= p.getInsertTime().getTime());
614
 
615
                        rset.close();
616
                        stmt.close();
617
 
618
                        // Deleting => No cascade deletes, if you want that implement in the database level...
619
 
620
                        u = new User(1);
621
                        boolean deleted = session.delete(u);
622
                        Assert.assertEquals(true, deleted);
623
 
624
                        // Post of course is still there...
625
                        p = new Post(1);
626
                        loaded = session.load(p);
627
                        Assert.assertEquals(true, loaded);
178 soliveira 628
                        Assert.assertEquals(1, p.getUser().getId()); // of course this user is gone!
21 soliveira 629
 
630
                        u = new User(1);
631
                        loaded = session.load(u);
632
                        Assert.assertEquals(false, loaded); // use was deleted above...
633
 
634
                } finally {
635
                        close(stmt, rset);
636
                        close(conn);
637
                }
638
        }
639
 
640
        @Test
167 soliveira 641
        public void testOneToOneRelationshipCRUDWithTableAlias() throws SQLException {
642
 
643
                BeanManager beanManager = new BeanManager();
644
                BeanConfig userConfig = getUserBeanConfig();
645
                getPostBeanConfig(beanManager);
646
                beanManager.addBeanConfig(userConfig);
647
 
648
                Connection conn = null;
649
                PreparedStatement stmt = null;
650
                ResultSet rset = null;
651
 
652
                try {
653
 
654
                        conn = getConnection();
655
                        BeanSession session = new H2BeanSession(beanManager, conn);
656
 
657
                        createTables(conn);
658
 
659
                        User u = new User("saoj", "1980-01-02");
660
                        session.insert(u);
661
 
662
                        Assert.assertEquals(1, u.getId());
663
 
664
                        // Now insert a post for this user...
178 soliveira 665
                        Post p = new Post(new User(1), "Test", "This is a test!");
167 soliveira 666
                        session.insert(p);
667
 
668
                        Assert.assertEquals(1, p.getId());
669
 
670
                        // Load from the database...
671
                        p = new Post(1);
672
                        boolean loaded = session.load(p);
673
                        Assert.assertEquals("Test", p.getTitle());
178 soliveira 674
                        Assert.assertEquals(1, p.getUser().getId());
675
                        Assert.assertNotNull(p.getUser());
676
                        Assert.assertEquals(1, p.getUser().getId());
677
                        Assert.assertNull(p.getUser().getUsername());
167 soliveira 678
 
679
                        // Load user for this post... (let's do our manual lazy loading)
178 soliveira 680
                        u = new User(p.getUser().getId());
167 soliveira 681
                        loaded = session.load(u);
682
                        Assert.assertEquals(true, loaded);
683
                        p.setUser(u); // manual lazy loading (forget about automatic lazy loading, you want control!)
684
 
685
                        // Use JOIN to load all dependencies with a single query... (you know how to make a join, right?)
686
 
687
                        p = new Post(1);
688
 
689
                        TableAlias<Post> postAlias = session.createTableAlias(Post.class, "p");
690
                        TableAlias<User> userAlias = session.createTableAlias(User.class, "u");
691
 
692
                        StringBuilder query = new StringBuilder(256);
693
                        query.append("select ");
694
                        query.append(postAlias.columns());
695
                        query.append(", ");
696
                        query.append(userAlias.columns());
697
                        query.append(" from ").append(postAlias.tableName());
698
                        query.append(" join ").append(userAlias.tableName());
699
                        query.append(" on ");
178 soliveira 700
                        query.append(postAlias.column(postAlias.pxy().getUser().getId())).append(" = ").append(userAlias.column(userAlias.pxy().getId()));
167 soliveira 701
                        query.append(" where ");
702
                        query.append(postAlias.column(postAlias.pxy().getId()));
703
                        query.append(" = ?");
704
 
705
                        stmt = SQLUtils.prepare(conn, query.toString(), p.getId());
706
 
707
                        rset = stmt.executeQuery();
708
 
709
                        if (rset.next()) {
710
 
711
                                session.populateBean(rset, p, "p");
712
 
713
                                u = new User();
714
 
715
                                session.populateBean(rset, u, "u");
716
 
717
                                p.setUser(u); // manual lazy loading (we prefer to have control!)
718
                        }
719
 
720
                        Assert.assertEquals(1, p.getId());
721
                        Assert.assertEquals("Test", p.getTitle());
722
                        Assert.assertEquals(1, u.getId());
723
                        Assert.assertEquals("saoj", p.getUser().getUsername());
724
                        Assert.assertTrue((new Date()).getTime() >= p.getInsertTime().getTime());
725
 
726
                        rset.close();
727
                        stmt.close();
728
 
729
                        // Deleting => No cascade deletes, if you want that implement in the database level...
730
 
731
                        u = new User(1);
732
                        boolean deleted = session.delete(u);
733
                        Assert.assertEquals(true, deleted);
734
 
735
                        // Post of course is still there...
736
                        p = new Post(1);
737
                        loaded = session.load(p);
738
                        Assert.assertEquals(true, loaded);
178 soliveira 739
                        Assert.assertEquals(1, p.getUser().getId()); // of course this user is gone!
167 soliveira 740
 
741
                        u = new User(1);
742
                        loaded = session.load(u);
743
                        Assert.assertEquals(false, loaded); // use was deleted above...
744
 
745
                } finally {
746
                        close(stmt, rset);
747
                        close(conn);
748
                }
749
        }
750
 
171 soliveira 751
        @Test
752
        public void testSQLBuilder() throws SQLException {
753
 
754
                BeanManager beanManager = new BeanManager();
755
                BeanConfig userConfig = getUserBeanConfig();
756
                getPostBeanConfig(beanManager);
757
                beanManager.addBeanConfig(userConfig);
758
 
759
                Connection conn = null;
760
                PreparedStatement stmt = null;
761
                ResultSet rset = null;
762
 
763
                try {
764
 
765
                        conn = getConnection();
766
                        BeanSession session = new H2BeanSession(beanManager, conn);
767
 
768
                        createTables(conn);
769
 
770
                        User u = new User("saoj", "1980-01-02");
771
                        session.insert(u);
772
 
773
                        Assert.assertEquals(1, u.getId());
774
 
775
                        // Now insert a post for this user...
178 soliveira 776
                        Post p = new Post(new User(1), "Test", "This is a test!");
171 soliveira 777
                        session.insert(p);
778
 
779
                        Assert.assertEquals(1, p.getId());
780
 
781
                        // Load from the database...
782
                        p = new Post(1);
783
                        boolean loaded = session.load(p);
784
                        Assert.assertEquals("Test", p.getTitle());
178 soliveira 785
                        Assert.assertEquals(1, p.getUser().getId());
786
                        Assert.assertNotNull(p.getUser());
787
                        Assert.assertEquals(1, p.getUser().getId());
788
                        Assert.assertNull(p.getUser().getUsername());
171 soliveira 789
 
790
                        // Load user for this post... (let's do our manual lazy loading)
178 soliveira 791
                        u = new User(p.getUser().getId());
171 soliveira 792
                        loaded = session.load(u);
793
                        Assert.assertEquals(true, loaded);
794
                        p.setUser(u); // manual lazy loading (forget about automatic lazy loading, you want control!)
795
 
796
                        // Use JOIN to load all dependencies with a single query... (you know how to make a join, right?)
797
 
798
                        p = new Post(1);
799
 
800
                        TableAlias<Post> postAlias = session.createTableAlias(Post.class, "p");
801
                        TableAlias<User> userAlias = session.createTableAlias(User.class, "u");
802
                        Post post = postAlias.pxy();
803
                        User user = userAlias.pxy();
804
 
805
                        SQLBuilder query = new SQLBuilder(256, postAlias, userAlias);
806
                        query.append("select ");
807
                        query.append(postAlias.columns());
808
                        query.append(", ");
809
                        query.append(userAlias.columns());
810
                        query.append(" from ").append(postAlias.tableName());
811
                        query.append(" join ").append(userAlias.tableName());
812
                        query.append(" on ");
178 soliveira 813
                        // query.append(postAlias.column(postAlias.pxy().getUser().getId())).append(" = ").append(userAlias.column(userAlias.pxy().getId()));
814
                        query.column(post.getUser().getId()).append(" = ").column(user.getId());
171 soliveira 815
                        query.append(" where ");
816
                        // query.append(postAlias.column(postAlias.pxy().getId()));
817
                        query.column(post.getId());
818
                        query.append(" = ?");
819
 
820
                        stmt = SQLUtils.prepare(conn, query.toString(), p.getId());
821
 
822
                        rset = stmt.executeQuery();
823
 
824
                        if (rset.next()) {
825
 
826
                                session.populateBean(rset, p, "p");
827
 
828
                                u = new User();
829
 
830
                                session.populateBean(rset, u, "u");
831
 
832
                                p.setUser(u); // manual lazy loading (we prefer to have control!)
833
                        }
834
 
835
                        Assert.assertEquals(1, p.getId());
836
                        Assert.assertEquals("Test", p.getTitle());
837
                        Assert.assertEquals(1, u.getId());
838
                        Assert.assertEquals("saoj", p.getUser().getUsername());
839
                        Assert.assertTrue((new Date()).getTime() >= p.getInsertTime().getTime());
840
 
841
                        rset.close();
842
                        stmt.close();
843
 
844
                        // Deleting => No cascade deletes, if you want that implement in the database level...
845
 
846
                        u = new User(1);
847
                        boolean deleted = session.delete(u);
848
                        Assert.assertEquals(true, deleted);
849
 
850
                        // Post of course is still there...
851
                        p = new Post(1);
852
                        loaded = session.load(p);
853
                        Assert.assertEquals(true, loaded);
178 soliveira 854
                        Assert.assertEquals(1, p.getUser().getId()); // of course this user is gone!
171 soliveira 855
 
856
                        u = new User(1);
857
                        loaded = session.load(u);
858
                        Assert.assertEquals(false, loaded); // use was deleted above...
859
 
860
                } finally {
861
                        close(stmt, rset);
862
                        close(conn);
863
                }
864
        }
167 soliveira 865
 
866
        @Test
181 erico 867
        public void testSQLBuilder2() throws SQLException {
868
 
869
                BeanManager beanManager = new BeanManager();
870
                BeanConfig userConfig = getUserBeanConfig();
871
                getPostBeanConfig(beanManager);
872
                beanManager.addBeanConfig(userConfig);
873
 
874
                Connection conn = null;
875
                PreparedStatement stmt = null;
876
                ResultSet rset = null;
877
 
878
                try {
879
 
880
                        conn = getConnection();
881
                        BeanSession session = new H2BeanSession(beanManager, conn);
882
 
883
                        createTables(conn);
884
 
885
                        User u = new User("saoj", "1980-01-02");
886
                        session.insert(u);
887
 
888
                        Assert.assertEquals(1, u.getId());
889
 
890
                        // Now insert a post for this user...
891
                        Post p = new Post(new User(1), "Test", "This is a test!");
892
                        session.insert(p);
893
 
894
                        Assert.assertEquals(1, p.getId());
895
 
896
                        // Load from the database...
897
                        p = new Post(1);
898
                        boolean loaded = session.load(p);
899
                        Assert.assertEquals("Test", p.getTitle());
900
                        Assert.assertEquals(1, p.getUser().getId());
901
                        Assert.assertNotNull(p.getUser());
902
                        Assert.assertEquals(1, p.getUser().getId());
903
                        Assert.assertNull(p.getUser().getUsername());
904
 
905
                        // Load user for this post... (let's do our manual lazy loading)
906
                        u = new User(p.getUser().getId());
907
                        loaded = session.load(u);
908
                        Assert.assertEquals(true, loaded);
909
                        p.setUser(u); // manual lazy loading (forget about automatic lazy loading, you want control!)
910
 
911
                        // Use JOIN to load all dependencies with a single query... (you know how to make a join, right?)
912
 
913
                        p = new Post(1);
914
 
915
                        TableAlias<Post> postAlias = session.createTableAlias(Post.class, "p");
916
                        TableAlias<User> userAlias = session.createTableAlias(User.class, "u");
917
                        Post post = postAlias.pxy();
918
                        User user = userAlias.pxy();
919
 
920
                        SQLBuilder query = new SQLBuilder(256, postAlias, userAlias);
921
                        query.append("select ");
922
                        query.append(postAlias.columnsMinus(post.getTitle()));
923
                        query.append(", ");
924
                        query.append(userAlias.columns());
925
                        query.append(" from ").append(postAlias.tableName());
926
                        query.append(" join ").append(userAlias.tableName());
927
                        query.append(" on ");
928
                        // query.append(postAlias.column(postAlias.pxy().getUser().getId())).append(" = ").append(userAlias.column(userAlias.pxy().getId()));
929
                        query.column(post.getUser().getId()).append(" = ").column(user.getId());
930
                        query.append(" where ");
931
                        // query.append(postAlias.column(postAlias.pxy().getId()));
932
                        query.column(post.getId());
933
                        query.append(" = ?");
934
 
935
                        stmt = SQLUtils.prepare(conn, query.toString(), p.getId());
936
 
937
                        rset = stmt.executeQuery();
938
 
939
                        if (rset.next()) {
940
 
941
                                //XXX aqui daria erro pois a session não vai conseguir popular p_title
942
                                //É por isso que o Alias do QueryBuilder tem o seu próprio populateBean,
943
                                //pois ele já sabe quais propriedades foram informadas..
944
                                //session.populateBean(rset, p, "p");
945
 
946
                                //XXX "minus" repetitivo...
947
                                session.populateBeanMinus(rset, p, "p", post.getTitle());
948
 
949
                                //possível solução.. fazer um populateBean no TableAlias que já pegasse
950
                                //o prefix e também as properties que devem retornar
951
                                //algo como:
952
                                //postAlias.populateBean(rset, p);
953
 
954
                                u = new User();
955
 
956
                                session.populateBean(rset, u, "u");
957
 
958
                                p.setUser(u); // manual lazy loading (we prefer to have control!)
959
                        }
960
 
961
                        Assert.assertEquals(1, p.getId());
962
                        Assert.assertNull(p.getTitle());
963
                        Assert.assertEquals(1, u.getId());
964
                        Assert.assertEquals("saoj", p.getUser().getUsername());
965
                        Assert.assertTrue((new Date()).getTime() >= p.getInsertTime().getTime());
966
 
967
                        rset.close();
968
                        stmt.close();
969
 
970
                        // Deleting => No cascade deletes, if you want that implement in the database level...
971
 
972
                        u = new User(1);
973
                        boolean deleted = session.delete(u);
974
                        Assert.assertEquals(true, deleted);
975
 
976
                        // Post of course is still there...
977
                        p = new Post(1);
978
                        loaded = session.load(p);
979
                        Assert.assertEquals(true, loaded);
980
                        Assert.assertEquals(1, p.getUser().getId()); // of course this user is gone!
981
 
982
                        u = new User(1);
983
                        loaded = session.load(u);
984
                        Assert.assertEquals(false, loaded); // use was deleted above...
985
 
986
                } finally {
987
                        close(stmt, rset);
988
                        close(conn);
989
                }
990
        }
991
 
992
        @Test
993
        public void testSQLBuilder3() throws SQLException {
994
 
995
                BeanManager beanManager = new BeanManager();
996
                BeanConfig userConfig = getUserBeanConfig();
997
                getPostBeanConfig(beanManager);
998
                beanManager.addBeanConfig(userConfig);
999
 
1000
                Connection conn = null;
1001
                PreparedStatement stmt = null;
1002
                ResultSet rset = null;
1003
 
1004
                try {
1005
 
1006
                        conn = getConnection();
1007
                        BeanSession session = new H2BeanSession(beanManager, conn);
1008
 
1009
                        createTables(conn);
1010
 
1011
                        User u = new User("erico", "1991-01-31");
1012
                        session.insert(u);
1013
 
1014
                        TableAlias<User> userAlias1 = session.createTableAlias(User.class, "u");
1015
                        TableAlias<User> userAlias2 = session.createTableAlias(User.class, "u2");
1016
                        User user1 = userAlias1.pxy();
1017
                        User user2 = userAlias2.pxy();
1018
 
1019
                        SQLBuilder query = new SQLBuilder(userAlias1, userAlias2);
1020
                        query.append("select ");
1021
                        query.append(userAlias1.columns());
1022
                        query.append(" from ").append(userAlias1.tableName());
1023
                        query.append(" where ").column(user1.getId());
1024
                        query.append(" in (select ").column(user2.getId());
1025
                        query.append(" from ").append(userAlias2.tableName());
1026
                        query.append(")");
1027
 
1028
                        Assert.assertTrue(query.toString().contains("(select u2.id"));
1029
                        stmt = SQLUtils.prepare(conn, query.toString());
1030
 
1031
                        rset = stmt.executeQuery();
1032
 
1033
                        if (rset.next()) {
1034
 
1035
                                u = new User();
1036
 
1037
                                session.populateBean(rset, u, "u");
1038
                        }
1039
 
1040
                        Assert.assertEquals(1, u.getId());
1041
                        Assert.assertEquals("erico", u.getUsername());
1042
 
1043
                } finally {
1044
                        close(stmt);
1045
                        close(conn);
1046
                }
1047
        }
1048
 
1049
        @Test
21 soliveira 1050
        public void testLoadUnique() throws SQLException {
1051
 
1052
                BeanManager beanManager = new BeanManager();
1053
                BeanConfig userConfig = getUserBeanConfig();
1054
                beanManager.addBeanConfig(userConfig);
1055
 
1056
                Connection conn = null;
1057
 
1058
                try {
1059
 
1060
                        conn = getConnection();
1061
                        BeanSession session = new H2BeanSession(beanManager, conn);
1062
 
1063
                        createTables(conn);
1064
 
1065
                        User u1 = new User("saoj", "1983-01-02");
1066
                        session.insert(u1);
1067
 
1068
                        User u = new User();
1069
                        u.setUsername("saoj");
1070
 
1071
                        u = session.loadUnique(u);
1072
 
1073
                        Assert.assertEquals(1, u.getId());
1074
                        Assert.assertEquals("saoj", u.getUsername());
1075
 
1076
                        // now add another one and try again...
1077
 
1078
                        User u2 = new User("saoj", "1967-01-03");
1079
                        session.insert(u2);
1080
 
1081
                        u = new User();
1082
                        u.setUsername("saoj");
1083
 
1084
                        boolean ok = false;
1085
 
1086
                        try {
1087
 
1088
                                u = session.loadUnique(u);
1089
 
1090
                                ok = true; // cannot come here...
1091
 
1092
                        } catch (BeanException e) {
1093
 
1094
                                ok = false;
1095
                        }
1096
 
1097
                        Assert.assertEquals(false, ok);
208 erico 1098
 
1099
                        //loadUnique specifying properties
1100
                        u = new User();
1101
                        u.setBirthdate("1967-01-03");
1102
 
1103
                        User proxy = PropertiesProxy.create(User.class);
1104
                        u = session.loadUnique(u, proxy.getUsername()); //only username
1105
 
1106
                        Assert.assertNull(u.getBirthdate());
1107
                        Assert.assertNull(u.getInsertTime());
1108
                        Assert.assertNull(u.getStatus());
1109
                        Assert.assertEquals(2, u.getId()); //always load the pk 
1110
                        Assert.assertNotNull(u.getUsername());
1111
 
1112
                        //loadUnique specifying 'minus' properties
1113
                        u = new User();
1114
                        u.setBirthdate("1967-01-03");
1115
                        u = session.loadUniqueMinus(u, proxy.getUsername(), proxy.getId()); //not load username nor pk (mentabean must ignore this)
1116
 
1117
                        Assert.assertNotNull(u.getBirthdate());
1118
                        Assert.assertNotNull(u.getInsertTime());
1119
                        Assert.assertNotNull(u.getStatus());
1120
                        Assert.assertEquals(2, u.getId()); //always load the pk... I mean, always
1121
                        Assert.assertNull(u.getUsername());    
21 soliveira 1122
 
1123
                } finally {
1124
                        close(conn);
1125
                }
1126
        }
61 soliveira 1127
 
36 soliveira 1128
        @Test
1129
        public void testSettingProperties() throws SQLException {
61 soliveira 1130
 
36 soliveira 1131
                BeanManager beanManager = new BeanManager();
1132
                BeanConfig userConfig = getUserBeanConfig();
1133
                beanManager.addBeanConfig(userConfig);
21 soliveira 1134
 
36 soliveira 1135
                Connection conn = null;
1136
 
1137
                try {
1138
 
1139
                        conn = getConnection();
1140
                        BeanSession session = new H2BeanSession(beanManager, conn);
61 soliveira 1141
 
36 soliveira 1142
                        createTables(conn);
61 soliveira 1143
 
36 soliveira 1144
                        User saoj = new User("saoj", "1980-01-01");
1145
                        session.insert(saoj);
61 soliveira 1146
 
36 soliveira 1147
                        User julia = new User("julia", "1980-03-03");
1148
                        session.insert(julia);
61 soliveira 1149
 
36 soliveira 1150
                        // delete "saoj" by making deleted equals to false
1151
                        saoj.setDeleted(true);
1152
                        int modified = session.update(saoj);
1153
                        Assert.assertEquals(1, modified);
61 soliveira 1154
 
36 soliveira 1155
                        // load all non-deleted users...
1156
                        User u = new User();
208 erico 1157
                        u.setStatus(User.Status.BASIC);                
36 soliveira 1158
                        u.setDeleted(false);
1159
                        List<User> nonDeletedUsers = session.loadList(u);
1160
                        Assert.assertFalse(nonDeletedUsers.size() == 1); // THIS DOES NOT WORK because isDeleted() returns a boolean primitive
1161
                        Assert.assertEquals(2, nonDeletedUsers.size()); // it will return everything because the deleted = false condition was never detected
61 soliveira 1162
 
36 soliveira 1163
                        // to fix, let's change the property to return a Boolean
1164
                        beanManager.addBeanConfig(getUser2BeanConfig());
61 soliveira 1165
 
36 soliveira 1166
                        // now try again
1167
                        User2 u2 = new User2();
1168
                        u2.setDeleted(false);
1169
                        List<User2> nonDeletedUsers2 = session.loadList(u2);
1170
                        Assert.assertEquals(1, nonDeletedUsers2.size()); // now only ONE is returned, the non-deleted one...
61 soliveira 1171
 
36 soliveira 1172
                } finally {
1173
                        close(conn);
1174
                }
1175
        }
61 soliveira 1176
 
36 soliveira 1177
        private static class User2 {
1178
 
1179
                public static enum Status {
1180
                        BASIC, PREMIUM, GOLD
1181
                }
1182
 
1183
                private int id;
1184
                private String username;
1185
                private Date birthdate;
1186
                private Status status = Status.BASIC;
1187
                private boolean deleted;
1188
                private Date insertTime;
1189
 
1190
                public User2() {
1191
                }
1192
 
1193
                public User2(int id) {
1194
                        this.id = id;
1195
                }
1196
 
1197
                public User2(String username, String birthdate) {
1198
                        this.username = username;
1199
                        this.birthdate = fromString(birthdate);
1200
                }
1201
 
1202
                private static Date fromString(String date) {
1203
                        try {
1204
                                return BD_FORMATTER.parse(date);
1205
                        } catch (Exception e) {
1206
                                throw new IllegalArgumentException("Cannot parse date: " + date);
1207
                        }
1208
                }
1209
 
1210
                public void setBirthdate(String date) {
1211
                        setBirthdate(fromString(date));
1212
                }
1213
 
1214
                public int getId() {
1215
                        return id;
1216
                }
1217
 
1218
                public void setId(int id) {
1219
                        this.id = id;
1220
                }
1221
 
1222
                public String getUsername() {
1223
                        return username;
1224
                }
1225
 
1226
                public void setUsername(String username) {
1227
                        this.username = username;
1228
                }
1229
 
1230
                public Date getBirthdate() {
1231
                        return birthdate;
1232
                }
1233
 
1234
                public void setBirthdate(Date birthdate) {
1235
                        this.birthdate = birthdate;
1236
                }
1237
 
1238
                public Boolean isDeleted() {
1239
                        return deleted;
1240
                }
1241
 
1242
                public void setDeleted(boolean deleted) {
1243
                        this.deleted = deleted;
1244
                }
1245
 
1246
                public Date getInsertTime() {
1247
                        return insertTime;
1248
                }
1249
 
1250
                public void setInsertTime(Date insertTime) {
1251
                        this.insertTime = insertTime;
1252
                }
1253
 
1254
                public void setStatus(Status status) {
1255
                        this.status = status;
1256
                }
1257
 
1258
                public Status getStatus() {
1259
                        return status;
1260
                }
1261
        }
61 soliveira 1262
 
36 soliveira 1263
        private BeanConfig getUser2BeanConfig() {
1264
 
1265
                // programmatic configuration for the bean... (no annotation or XML)
1266
 
1267
                BeanConfig config = new BeanConfig(User2.class, "Users");
1268
                config.pk("id", DBTypes.AUTOINCREMENT);
1269
                config.field("username", DBTypes.STRING);
1270
                config.field("birthdate", "bd", DBTypes.DATE); // note that the database column name is different
57 soliveira 1271
                config.field("status", DBTypes.ENUMVALUE.from(User2.Status.class));
36 soliveira 1272
                config.field("deleted", DBTypes.BOOLEANINT);
56 soliveira 1273
                config.field("insertTime", "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);
36 soliveira 1274
 
1275
                return config;
1276
        }
61 soliveira 1277
 
38 soliveira 1278
        @Test
1279
        public void testEnumIdType() throws SQLException {
61 soliveira 1280
 
38 soliveira 1281
                BeanManager beanManager = new BeanManager();
1282
                BeanConfig userConfig = getUser3BeanConfig();
1283
                beanManager.addBeanConfig(userConfig);
36 soliveira 1284
 
38 soliveira 1285
                Connection conn = null;
36 soliveira 1286
 
38 soliveira 1287
                try {
1288
 
1289
                        conn = getConnection();
1290
                        BeanSession session = new H2BeanSession(beanManager, conn);
61 soliveira 1291
 
38 soliveira 1292
                        execUpdate(conn, "create table Users(id integer primary key auto_increment, username varchar(25), bd datetime, status integer, deleted tinyint, insert_time timestamp)");
61 soliveira 1293
 
38 soliveira 1294
                        User3 u = new User3("saoj", "1980-03-03");
1295
                        u.setStatus(User3.Status.GOLD);
1296
                        session.insert(u);
61 soliveira 1297
 
38 soliveira 1298
                        // now load and see if we get the same status...
1299
                        u = new User3(1);
1300
                        boolean loaded = session.load(u);
1301
                        Assert.assertEquals(true, loaded);
1302
                        Assert.assertEquals(User3.Status.GOLD, u.getStatus());
61 soliveira 1303
 
38 soliveira 1304
                } finally {
1305
                        close(conn);
1306
                }
1307
        }
61 soliveira 1308
 
38 soliveira 1309
        private static class User3 {
1310
 
1311
                public static enum Status {
1312
                        BASIC(1), PREMIUM(2), GOLD(3);
61 soliveira 1313
 
38 soliveira 1314
                        private final int id;
61 soliveira 1315
 
38 soliveira 1316
                        private Status(int id) {
1317
                                this.id = id;
1318
                        }
61 soliveira 1319
 
1320
                        public int getId() {
1321
                                return id;
1322
                        }
1323
 
38 soliveira 1324
                        public static Status fromId(int id) {
61 soliveira 1325
                                for (Status s : Status.values()) {
1326
                                        if (s.getId() == id) {
1327
                                                return s;
1328
                                        }
38 soliveira 1329
                                }
1330
                                return null;
1331
                        }
1332
                }
1333
 
1334
                private int id;
1335
                private String username;
1336
                private Date birthdate;
1337
                private Status status = Status.BASIC;
1338
                private boolean deleted;
1339
                private Date insertTime;
1340
 
1341
                public User3() {
1342
                }
1343
 
1344
                public User3(int id) {
1345
                        this.id = id;
1346
                }
1347
 
1348
                public User3(String username, String birthdate) {
1349
                        this.username = username;
1350
                        this.birthdate = fromString(birthdate);
1351
                }
1352
 
1353
                private static Date fromString(String date) {
1354
                        try {
1355
                                return BD_FORMATTER.parse(date);
1356
                        } catch (Exception e) {
1357
                                throw new IllegalArgumentException("Cannot parse date: " + date);
1358
                        }
1359
                }
1360
 
1361
                public void setBirthdate(String date) {
1362
                        setBirthdate(fromString(date));
1363
                }
1364
 
1365
                public int getId() {
1366
                        return id;
1367
                }
1368
 
1369
                public void setId(int id) {
1370
                        this.id = id;
1371
                }
1372
 
1373
                public String getUsername() {
1374
                        return username;
1375
                }
1376
 
1377
                public void setUsername(String username) {
1378
                        this.username = username;
1379
                }
1380
 
1381
                public Date getBirthdate() {
1382
                        return birthdate;
1383
                }
1384
 
1385
                public void setBirthdate(Date birthdate) {
1386
                        this.birthdate = birthdate;
1387
                }
1388
 
1389
                public Boolean isDeleted() {
1390
                        return deleted;
1391
                }
1392
 
1393
                public void setDeleted(boolean deleted) {
1394
                        this.deleted = deleted;
1395
                }
1396
 
1397
                public Date getInsertTime() {
1398
                        return insertTime;
1399
                }
1400
 
1401
                public void setInsertTime(Date insertTime) {
1402
                        this.insertTime = insertTime;
1403
                }
1404
 
1405
                public void setStatus(Status status) {
1406
                        this.status = status;
1407
                }
1408
 
1409
                public Status getStatus() {
1410
                        return status;
1411
                }
1412
        }
61 soliveira 1413
 
38 soliveira 1414
        private BeanConfig getUser3BeanConfig() {
1415
 
1416
                // programmatic configuration for the bean... (no annotation or XML)
1417
 
1418
                BeanConfig config = new BeanConfig(User3.class, "Users");
1419
                config.pk("id", DBTypes.AUTOINCREMENT);
1420
                config.field("username", DBTypes.STRING);
1421
                config.field("birthdate", "bd", DBTypes.DATE); // note that the database column name is different
1422
                config.field("status", new EnumIdType(User3.Status.class));
1423
                config.field("deleted", DBTypes.BOOLEANINT);
56 soliveira 1424
                config.field("insertTime", "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);
38 soliveira 1425
 
1426
                return config;
1427
        }
61 soliveira 1428
 
56 soliveira 1429
        @Test
61 soliveira 1430
        public void testCreateTable() throws SQLException {
1431
 
1432
                BeanManager beanManager = new BeanManager();
1433
                BeanConfig userConfig = getUser4BeanConfig();
1434
                beanManager.addBeanConfig(userConfig);
1435
 
1436
                Connection conn = null;
1437
 
1438
                try {
1439
 
1440
                        conn = getConnection();
1441
                        BeanSession session = new H2BeanSession(beanManager, conn);
1442
 
1443
                        Assert.assertFalse(SQLUtils.checkIfTableExists(conn, "Users"));
1444
 
1445
                        session.createTables();
1446
 
1447
                        Assert.assertTrue(SQLUtils.checkIfTableExists(conn, "Users"));
1448
 
1449
                } finally {
1450
                        close(conn);
1451
                }
1452
        }
1453
 
1454
        @Test
1455
        public void testAutoBeanConfig() throws SQLException {
1456
 
1457
                BeanManager beanManager = new BeanManager();
1458
                BeanConfig userConfig = new AutoBeanConfig(User4.class, "Users");
1459
                beanManager.addBeanConfig(userConfig);
1460
 
1461
                userConfig.pk("id", DBTypes.AUTOINCREMENT); // override since PK and autoincrement cannot be discovered by reflection...
1462
 
1463
                Connection conn = null;
1464
 
1465
                try {
1466
 
1467
                        conn = getConnection();
1468
                        BeanSession session = new H2BeanSession(beanManager, conn);
1469
 
1470
                        // execUpdate(conn, "create table Users(id integer primary key auto_increment, username varchar(25), birthdate datetime, status integer, deleted tinyint, insert_time timestamp, update_time timestamp)");
1471
                        session.createTables();
1472
 
1473
                        User4 u = new User4("saoj", "1980-03-03");
1474
                        u.setStatus(User4.Status.GOLD);
1475
                        session.insert(u);
1476
 
1477
                        // now load and see if we get the same status...
1478
                        u = new User4(1);
1479
                        boolean loaded = session.load(u);
1480
                        Assert.assertEquals(true, loaded);
1481
                        Assert.assertEquals(User4.Status.GOLD, u.getStatus());
1482
 
1483
                        // update_time must be null
1484
                        Assert.assertNull(u.getUpdateTime());
1485
 
1486
                } finally {
1487
                        close(conn);
1488
                }
1489
        }
1490
 
1491
        @Test
56 soliveira 1492
        public void testNowOnUpdate() throws SQLException {
61 soliveira 1493
 
56 soliveira 1494
                BeanManager beanManager = new BeanManager();
1495
                BeanConfig userConfig = getUser4BeanConfig();
1496
                beanManager.addBeanConfig(userConfig);
1497
 
1498
                Connection conn = null;
1499
 
1500
                try {
1501
 
1502
                        conn = getConnection();
1503
                        BeanSession session = new H2BeanSession(beanManager, conn);
61 soliveira 1504
 
56 soliveira 1505
                        execUpdate(conn, "create table Users(id integer primary key auto_increment, username varchar(25), bd datetime, status integer, deleted tinyint, insert_time timestamp, update_time timestamp)");
61 soliveira 1506
 
56 soliveira 1507
                        User4 u = new User4("saoj", "1980-03-03");
1508
                        u.setStatus(User4.Status.GOLD);
1509
                        session.insert(u);
61 soliveira 1510
 
56 soliveira 1511
                        // now load and see if we get the same status...
1512
                        u = new User4(1);
1513
                        boolean loaded = session.load(u);
1514
                        Assert.assertEquals(true, loaded);
1515
                        Assert.assertEquals(User4.Status.GOLD, u.getStatus());
61 soliveira 1516
 
56 soliveira 1517
                        // update_time must be null
1518
                        Assert.assertNull(u.getUpdateTime());
61 soliveira 1519
 
56 soliveira 1520
                        // now update..
1521
                        u.setUsername("saoj1");
1522
                        session.update(u);
61 soliveira 1523
 
56 soliveira 1524
                        // update_time is still null, you need to load !!!
1525
                        Assert.assertNull(u.getUpdateTime());
61 soliveira 1526
 
56 soliveira 1527
                        session.load(u);
1528
                        Assert.assertNotNull(u.getUpdateTime());
61 soliveira 1529
 
56 soliveira 1530
                } finally {
1531
                        close(conn);
1532
                }
1533
        }
61 soliveira 1534
 
56 soliveira 1535
        private static class User4 {
1536
 
1537
                public static enum Status {
1538
                        BASIC(1), PREMIUM(2), GOLD(3);
61 soliveira 1539
 
56 soliveira 1540
                        private final int id;
61 soliveira 1541
 
56 soliveira 1542
                        private Status(int id) {
1543
                                this.id = id;
1544
                        }
61 soliveira 1545
 
1546
                        public int getId() {
1547
                                return id;
1548
                        }
1549
 
56 soliveira 1550
                        public static Status fromId(int id) {
61 soliveira 1551
                                for (Status s : Status.values()) {
1552
                                        if (s.getId() == id) {
1553
                                                return s;
1554
                                        }
56 soliveira 1555
                                }
1556
                                return null;
1557
                        }
1558
                }
1559
 
1560
                private int id;
1561
                private String username;
1562
                private Date birthdate;
1563
                private Status status = Status.BASIC;
1564
                private boolean deleted;
1565
                private Date insertTime;
1566
                private Date updateTime;
61 soliveira 1567
 
56 soliveira 1568
                public Date getUpdateTime() {
61 soliveira 1569
                        return updateTime;
1570
                }
56 soliveira 1571
 
1572
                public void setUpdateTime(Date updateTime) {
61 soliveira 1573
                        this.updateTime = updateTime;
1574
                }
56 soliveira 1575
 
1576
                public User4() {
1577
                }
1578
 
1579
                public User4(int id) {
1580
                        this.id = id;
1581
                }
1582
 
1583
                public User4(String username, String birthdate) {
1584
                        this.username = username;
1585
                        this.birthdate = fromString(birthdate);
1586
                }
1587
 
1588
                private static Date fromString(String date) {
1589
                        try {
1590
                                return BD_FORMATTER.parse(date);
1591
                        } catch (Exception e) {
1592
                                throw new IllegalArgumentException("Cannot parse date: " + date);
1593
                        }
1594
                }
1595
 
1596
                public void setBirthdate(String date) {
1597
                        setBirthdate(fromString(date));
1598
                }
1599
 
1600
                public int getId() {
1601
                        return id;
1602
                }
1603
 
1604
                public void setId(int id) {
1605
                        this.id = id;
1606
                }
1607
 
1608
                public String getUsername() {
1609
                        return username;
1610
                }
1611
 
1612
                public void setUsername(String username) {
1613
                        this.username = username;
1614
                }
1615
 
1616
                public Date getBirthdate() {
1617
                        return birthdate;
1618
                }
1619
 
1620
                public void setBirthdate(Date birthdate) {
1621
                        this.birthdate = birthdate;
1622
                }
1623
 
1624
                public Boolean isDeleted() {
1625
                        return deleted;
1626
                }
1627
 
1628
                public void setDeleted(boolean deleted) {
1629
                        this.deleted = deleted;
1630
                }
1631
 
1632
                public Date getInsertTime() {
1633
                        return insertTime;
1634
                }
1635
 
1636
                public void setInsertTime(Date insertTime) {
1637
                        this.insertTime = insertTime;
1638
                }
1639
 
1640
                public void setStatus(Status status) {
1641
                        this.status = status;
1642
                }
1643
 
1644
                public Status getStatus() {
1645
                        return status;
1646
                }
1647
        }
61 soliveira 1648
 
56 soliveira 1649
        private BeanConfig getUser4BeanConfig() {
1650
 
1651
                // programmatic configuration for the bean... (no annotation or XML)
1652
 
1653
                BeanConfig config = new BeanConfig(User4.class, "Users");
1654
                config.pk("id", DBTypes.AUTOINCREMENT);
61 soliveira 1655
                config.field("username", DBTypes.STRING.size(50).nullable(false));
56 soliveira 1656
                config.field("birthdate", "bd", DBTypes.DATE); // note that the database column name is different
1657
                config.field("status", new EnumIdType(User4.Status.class));
1658
                config.field("deleted", DBTypes.BOOLEANINT);
1659
                config.field("insertTime", "insert_time", DBTypes.NOW_ON_INSERT_TIMESTAMP);
1660
                config.field("updateTime", "update_time", DBTypes.NOW_ON_UPDATE_TIMESTAMP);
1661
 
1662
                return config;
1663
        }
183 erico 1664
 
1665
 
1666
        /*
1667
         * Testing sublevels
1668
         */
1669
 
1670
        public static class Foo {
1671
 
1672
                private long id;
1673
                private Bar bar;
184 erico 1674
                private String test;
1675
                private Bean bean;
183 erico 1676
 
184 erico 1677
                public Foo() {}
1678
 
185 erico 1679
                public Foo(long id, String test, Bean bean) {
1680
                        super();
1681
                        this.id = id;
1682
                        this.test = test;
1683
                        this.bean = bean;
1684
                }
1685
 
184 erico 1686
                public Foo(long id) {
1687
                        this.id = id;
1688
                }
1689
 
183 erico 1690
                public long getId() {
1691
                        return id;
1692
                }
1693
                public void setId(long id) {
1694
                        this.id = id;
1695
                }
1696
                public Bar getBar() {
1697
                        return bar;
1698
                }
1699
                public void setBar(Bar bar) {
1700
                        this.bar = bar;
1701
                }
184 erico 1702
                public String getTest() {
1703
                        return test;
1704
                }
1705
                public void setTest(String test) {
1706
                        this.test = test;
1707
                }
1708
                public Bean getBean() {
1709
                        return bean;
1710
                }
1711
                public void setBean(Bean bean) {
1712
                        this.bean = bean;
1713
                }
183 erico 1714
        }
1715
 
184 erico 1716
        public static class Bean {
1717
 
1718
                private long id;
1719
 
185 erico 1720
                public Bean(long id) {
1721
                        this.id = id;
1722
                }
1723
 
1724
                public Bean() {}
1725
 
184 erico 1726
                public long getId() {
1727
                        return id;
1728
                }
1729
 
1730
                public void setId(long id) {
1731
                        this.id = id;
1732
                }
185 erico 1733
 
1734
                @Override
1735
                public String toString() {
1736
                        return "Bean: "+id;
1737
                }
184 erico 1738
        }
1739
 
183 erico 1740
        public static class Bar {
1741
 
1742
                private String name;
1743
                private Item item;
1744
 
1745
                public String getName() {
1746
                        return name;
1747
                }
1748
                public void setName(String name) {
1749
                        this.name = name;
1750
                }
1751
                public Item getItem() {
1752
                        return item;
1753
                }
1754
                public void setItem(Item item) {
1755
                        this.item = item;
1756
                }
1757
        }
1758
 
1759
        public static class Item {
1760
 
1761
                private SubItem subItem;
61 soliveira 1762
 
183 erico 1763
                public SubItem getSubItem() {
1764
                        return subItem;
1765
                }
1766
 
1767
                public void setSubItem(SubItem subItem) {
1768
                        this.subItem = subItem;
1769
                }
1770
        }
1771
 
1772
        public static class SubItem {
1773
 
1774
                private String name;
1775
 
1776
                public String getName() {
1777
                        return name;
1778
                }
1779
 
1780
                public void setName(String name) {
1781
                        this.name = name;
1782
                }
1783
        }
1784
 
1785
        private BeanConfig getSublevelsBeanConfig() {
1786
 
1787
                Foo foo = PropertiesProxy.create(Foo.class);
1788
                BeanConfig config = new BeanConfig(Foo.class, "foo")
1789
                .pk(foo.getId(), "idfoo", DBTypes.LONG)
184 erico 1790
                .field(foo.getTest(), DBTypes.STRING)
1791
                .field(foo.getBean().getId(), "idbean", DBTypes.LONG)
183 erico 1792
                .field(foo.getBar().getItem().getSubItem().getName(), "namebar", DBTypes.STRING);
1793
 
1794
                return config;
1795
        }
1796
 
1797
        private Foo createEmptyFoo() {
1798
 
1799
                Foo foo = new Foo();
1800
                foo.setBar(new Bar());
1801
                foo.getBar().setItem(new Item());
1802
                foo.getBar().getItem().setSubItem(new SubItem());
1803
                return foo;
1804
        }
1805
 
1806
        @Test
1807
        public void testSublevels() {
1808
 
1809
                Connection conn = null;
1810
                BeanManager beanManager = new BeanManager();
1811
                beanManager.addBeanConfig(getSublevelsBeanConfig());
1812
 
1813
                try {
1814
 
1815
                        conn = getConnection();
1816
                        BeanSession session = new H2BeanSession(beanManager, conn);
1817
 
1818
                        session.createTables();
1819
 
1820
                        Foo foo = createEmptyFoo();
1821
                        foo.getBar().getItem().getSubItem().setName("Test one");
1822
                        foo.setId(1);
184 erico 1823
                        foo.setTest("Test one");
183 erico 1824
                        session.insert(foo);
1825
 
1826
                        foo.getBar().getItem().getSubItem().setName("Test two");
1827
                        foo.setId(2);
184 erico 1828
                        foo.setTest("Test two");
183 erico 1829
                        session.insert(foo);
1830
 
1831
                        foo.setId(0);
184 erico 1832
                        foo.setTest(null);
183 erico 1833
                        int count = session.countList(foo);
1834
                        Assert.assertEquals(1, count);
1835
 
1836
                        //here, if we don't force the creation of instances, a NPE will thrown
1837
                        //getDeepestBean(bean, chain, true); --> findMethodToGet
1838
                        count = session.countList(new Foo());
1839
                        Assert.assertEquals(2, count);
1840
 
184 erico 1841
                        foo = createEmptyFoo();
1842
                        foo.setId(1);
1843
                        foo.setTest("Test three");
1844
                        session.update(foo);
1845
 
1846
                        Foo fooBD = new Foo();
1847
                        fooBD.setId(1);
1848
                        session.load(fooBD);
1849
                        Assert.assertEquals("Test one", fooBD.getBar().getItem().getSubItem().getName());
1850
                        Assert.assertEquals("Test three", fooBD.getTest());
1851
 
1852
                        foo = new Foo();
1853
                        foo.setId(1);
1854
                        foo.setTest("Test four");
1855
                        session.update(foo);
1856
 
1857
                        fooBD = new Foo();
1858
                        fooBD.setId(1);
1859
                        session.load(fooBD);
1860
                        Assert.assertEquals("Test one", fooBD.getBar().getItem().getSubItem().getName());
1861
                        Assert.assertEquals("Test four", fooBD.getTest());
1862
 
1863
                        Foo proto = new Foo();
1864
                        List<Foo> listBD = session.loadList(proto);
1865
                        Assert.assertEquals(2, listBD.size());
1866
                        Assert.assertNull(listBD.get(0).getBean());
1867
                        Assert.assertNull(listBD.get(1).getBean());
1868
 
1869
                        Foo proxy = PropertiesProxy.create(Foo.class);
1870
                        foo = new Foo(1);
1871
                        foo.setTest("Test five");
1872
                        foo.setBean(new Bean());
1873
                        foo.getBean().setId(3);
1874
                        session.update(foo, proxy.getBean().getId());
1875
 
1876
                        session.load(fooBD = new Foo(1));
1877
                        Assert.assertEquals("Test five", fooBD.getTest());
1878
                        Assert.assertEquals(3, fooBD.getBean().getId());
1879
 
1880
                        foo = new Foo(1);
1881
                        //forcing bean to null 
1882
                        session.update(foo, proxy.getBean().getId());
1883
                        session.load(fooBD = new Foo(1));
1884
                        Assert.assertNull(fooBD.getBean());
1885
                        Assert.assertNotNull(fooBD.getBar().getItem().getSubItem().getName());
1886
 
1887
                        foo = new Foo(1);
1888
                        session.update(foo, proxy.getBean().getId(), proxy.getBar().getItem().getSubItem().getName());
1889
                        session.load(fooBD = new Foo(1));
1890
                        Assert.assertNull(fooBD.getBean());
1891
                        Assert.assertNull(fooBD.getBar());
1892
 
1893
                        foo = createEmptyFoo();
1894
                        foo.setId(1);
1895
                        foo.getBar().getItem().getSubItem().setName("Not null");
1896
                        session.update(foo, proxy.getBar().getItem().getSubItem().getName());
1897
                        session.load(fooBD = new Foo(1));
1898
                        Assert.assertNull(fooBD.getBean());
1899
                        Assert.assertEquals("Not null", fooBD.getBar().getItem().getSubItem().getName());
1900
 
1901
                        foo = createEmptyFoo();
1902
                        foo.setId(1);
1903
                        session.update(foo, proxy.getBar().getItem().getSubItem().getName());
1904
                        session.load(fooBD = new Foo(1));
1905
                        Assert.assertNull(fooBD.getBar());
1906
 
185 erico 1907
                        /*
1908
                         * testing using attached update
1909
                         */
1910
                        foo = createEmptyFoo();
1911
                        foo.setId(5);
1912
                        foo.setTest("Attached test");
1913
                        foo.setBean(new Bean());
1914
                        foo.getBean().setId(5);
1915
                        foo.getBar().getItem().getSubItem().setName("Anything");
1916
                        session.insert(foo);
1917
 
1918
                        fooBD = new Foo(foo.getId());
1919
                        session.load(fooBD);
1920
                        fooBD.setTest("Attached test - updated");
1921
                        session.update(fooBD);
1922
                        session.load(fooBD);
1923
                        Assert.assertEquals("Attached test - updated", fooBD.getTest());
1924
                        Assert.assertNotNull(fooBD.getBean());
1925
                        Assert.assertNotNull(fooBD.getBar());
1926
 
1927
                } catch (Exception e) {
1928
                        throw new BeanException(e);
183 erico 1929
                } finally {
1930
                        close(conn);
1931
                }
1932
        }
185 erico 1933
 
1934
        private BeanManager getNullFKsManager() {
1935
 
1936
                BeanManager manager = new BeanManager();
183 erico 1937
 
185 erico 1938
                Foo fooPxy = PropertiesProxy.create(Foo.class);
1939
                BeanConfig fooConfig = new BeanConfig(Foo.class, "foo")
1940
                .pk(fooPxy.getId(), "idfoo", DBTypes.LONG)
1941
                .field(fooPxy.getBean().getId(), "idbean", DBTypes.LONG)
1942
                .field(fooPxy.getTest(), DBTypes.STRING);
1943
                manager.addBeanConfig(fooConfig);
1944
 
1945
                Bean barPxy = PropertiesProxy.create(Bean.class);
1946
                BeanConfig beanConfig = new BeanConfig(Bean.class, "bean")
1947
                .pk(barPxy.getId(), DBTypes.LONG);
1948
                manager.addBeanConfig(beanConfig);
1949
 
1950
                return manager;
1951
        }
1952
 
1953
        @Test
1954
        public void testNullFKs() {
1955
 
1956
                Connection conn = null;
1957
                BeanManager beanManager = getNullFKsManager();
1958
 
1959
                try {
1960
 
1961
                        conn = getConnection();
1962
                        BeanSession session = new H2BeanSession(beanManager, conn);
1963
 
1964
                        session.createTables();
1965
                        SQLUtils.prepare(conn, "alter table foo add foreign key(idbean) references bean");
1966
 
1967
                        Bean bean = new Bean(1);
1968
                        session.insert(bean);
1969
 
1970
                        Foo foo = new Foo(1, "Foo UM", bean);
1971
                        session.insert(foo);
1972
 
1973
                        foo = new Foo(2, "Foo DOIS", null);
1974
                        session.insert(foo);
1975
 
1976
                        Foo fooBD = new Foo(2);
1977
                        session.load(fooBD);
1978
                        Assert.assertNull(fooBD.getBean());
1979
                        fooBD.setTest("Foo DOIS - updated");
1980
                        session.update(fooBD);
1981
                        session.load(fooBD = new Foo(2));
1982
                        Assert.assertEquals("Foo DOIS - updated", fooBD.getTest());
1983
                        Assert.assertNull(fooBD.getBean());
1984
 
1985
                        fooBD = new Foo(1);
1986
                        session.load(fooBD);
1987
                        Assert.assertNotNull(fooBD.getBean());
1988
                        Assert.assertEquals(1, fooBD.getBean().getId());
1989
 
1990
                        fooBD.setTest(null);
1991
                        session.update(fooBD);
1992
                        session.load(fooBD = new Foo(1));
1993
                        Assert.assertNull(fooBD.getTest());
1994
 
1995
                        fooBD.setBean(null);
1996
                        fooBD.setTest("Foo UM");
1997
                        session.update(fooBD);
1998
                        session.load(fooBD = new Foo(1));
1999
                        Assert.assertEquals("Foo UM", fooBD.getTest());
2000
                        Assert.assertNull(fooBD.getBean());
2001
 
2002
                        fooBD.setTest("Foo UM - alterado");
2003
                        session.update(fooBD);
2004
                        session.load(fooBD = new Foo(1));
2005
                        Assert.assertEquals("Foo UM - alterado", fooBD.getTest());
2006
                        Assert.assertNull(fooBD.getBean());
2007
 
2008
                } catch (Exception e) {
2009
                        throw new BeanException(e);
2010
                } finally {
2011
                        close(conn);
2012
                }
2013
        }
2014
 
15 soliveira 2015
}