1 package org.apache.ojb.broker; 2 3 import java.io.Serializable ; 4 import java.util.Collection ; 5 import java.util.Iterator ; 6 import java.util.List ; 7 import java.util.ArrayList ; 8 9 import org.apache.ojb.broker.metadata.ClassDescriptor; 10 import org.apache.ojb.broker.metadata.ObjectReferenceDescriptor; 11 import org.apache.ojb.broker.query.Criteria; 12 import org.apache.ojb.broker.query.Query; 13 import org.apache.ojb.broker.query.QueryFactory; 14 import org.apache.ojb.junit.PBTestCase; 15 import org.apache.commons.lang.builder.ToStringBuilder; 16 17 23 public class ReferenceTest extends PBTestCase 24 { 25 private static String REF_TEST_STRING = "refTest"; 26 27 public static void main(String [] args) 28 { 29 String [] arr = {ReferenceTest.class.getName()}; 30 junit.textui.TestRunner.main(arr); 31 } 32 33 public void tearDown() 34 { 35 if(broker != null) 36 { 37 changeRepositoryAutoSetting("ref", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT); 38 changeRepositoryAutoSetting("refA", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT); 39 changeRepositoryAutoSetting("refB", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT); 40 changeRepositoryAutoSetting("animal", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT); 41 broker.close(); 42 } 43 } 44 45 48 public void testQueryExtentsWithAutoRefreshEnabled() throws Exception 49 { 50 String name = "testQueryExtentsWithAutoRefreshEnabled_"+ System.currentTimeMillis(); 51 52 int cascadeObject = ObjectReferenceDescriptor.CASCADE_OBJECT; 53 ojbChangeReferenceSetting(ObjA.class, "ref", true, cascadeObject, cascadeObject, false); 54 ojbChangeReferenceSetting(ObjB.class, "ref", true, cascadeObject, cascadeObject, false); 55 56 ClassDescriptor cldA = broker.getClassDescriptor(ObjA.class); 57 ClassDescriptor cldB = broker.getClassDescriptor(ObjB.class); 58 boolean oldRefreshA = cldA.isAlwaysRefresh(); 59 boolean oldRefreshB = cldB.isAlwaysRefresh(); 60 cldA.setAlwaysRefresh(true); 61 cldB.setAlwaysRefresh(true); 62 63 try 64 { 65 ObjA objA = new ObjA(); 66 objA.setName(name); 67 ObjB objB = new ObjB(); 68 objB.setName(name); 69 ObjC objC = new ObjC(); 70 objC.setName(name); 71 72 ObjA objA2 = new ObjA(); 73 objA2.setName(name); 74 ObjB objB2 = new ObjB(); 75 objB2.setName(name); 76 ObjC objC2 = new ObjC(); 77 objC2.setName(name); 78 79 List refs = new ArrayList (); 80 refs.add(objA2); 81 refs.add(objB2); 82 83 objA.setRef(objB); 84 objC2.setReferences(refs); 85 objB.setRef(objC); 86 objC2.setRef(objA); 87 88 broker.beginTransaction(); 89 broker.store(objA); 90 broker.store(objC2); 91 broker.commitTransaction(); 92 93 Criteria crit = new Criteria(); 94 crit.addLike("name", name); 95 Query q = QueryFactory.newQuery(RefObject.class, crit); 96 Collection result = broker.getCollectionByQuery(q); 97 assertEquals(6, result.size()); 98 } 99 finally 100 { 101 cldA.setAlwaysRefresh(oldRefreshA); 102 cldB.setAlwaysRefresh(oldRefreshB); 103 } 104 } 105 106 110 public void testInterfaceAsCollectionRef_1() 111 { 112 String name = "testQueryWithCollectionRef_" + System.currentTimeMillis(); 114 RefObject a = new ObjA(); 115 RefObject a2 = new ObjA(); 116 RefObject b = new ObjB(); 117 RefObject b2 = new ObjB(); 118 ObjC c1 = new ObjC(); 120 RefObject d1 = new ObjC(); 122 RefObject d2 = new ObjC(); 123 ObjC c2 = new ObjC(); 124 125 c1.setName(name+"_third"); 126 b.setName(name+"_second_1"); 127 b2.setName(name+"_second_2"); 128 a.setName(name+"_first_1"); 129 a2.setName(name+"_first_2"); 130 d1.setName(name+"_d1"); 131 d2.setName(name+"_d2"); 132 c2.setName(name + "_c2"); 133 134 c1.setNameC(name + "_1"); 135 c2.setNameC(name + "_2"); 136 137 a.setRef(b); 138 b.setRef(c1); 139 a2.setRef(b2); 140 141 List refList = new ArrayList (); 142 refList.add(a); 143 refList.add(b2); 144 refList.add(d1); 145 c1.setReferences(refList); 146 List refList2 = new ArrayList (); 147 refList2.add(d2); 148 c2.setReferences(refList2); 149 150 broker.beginTransaction(); 151 broker.store(a); 152 broker.store(a2); 153 broker.store(c2); 154 broker.commitTransaction(); 155 156 Criteria crit = new Criteria(); 158 crit.addLike("name", name + "%"); 159 Query q = QueryFactory.newQuery(RefObject.class, crit); 160 Collection result = broker.getCollectionByQuery(q); 161 assertEquals(8, result.size()); 162 163 crit = new Criteria(); 166 crit.addEqualTo("references.name", name+"_d1"); 167 q = QueryFactory.newQuery(ObjC.class, crit); 168 result = broker.getCollectionByQuery(q); 169 assertEquals(1, result.size()); 170 ObjC newC = (ObjC) result.iterator().next(); 171 assertEquals(name + "_1", newC.getNameC()); 172 173 crit = new Criteria(); 176 crit.addLike("nameC", name+"_%"); 177 q = QueryFactory.newQuery(ObjC.class, crit); 178 result = broker.getCollectionByQuery(q); 179 assertEquals(2, result.size()); 180 181 crit = new Criteria(); 185 crit.addEqualTo("ref.references.name", name+"_d1"); 186 crit.addPathClass("ref", ObjC.class); 188 q = QueryFactory.newQuery(ObjB.class, crit); 189 result = broker.getCollectionByQuery(q); 190 assertEquals(1, result.size()); 191 ObjB newB = (ObjB) result.iterator().next(); 192 assertNotNull(newB.getRef()); 193 assertTrue(newB.getRef() instanceof ObjC); 194 newC = (ObjC) newB.getRef(); 195 assertEquals(3, newC.getReferences().size()); 196 197 crit = new Criteria(); 201 crit.addLike("ref.nameC", name+"_%"); 202 crit.addPathClass("ref", ObjC.class); 204 q = QueryFactory.newQuery(ObjB.class, crit); 205 result = broker.getCollectionByQuery(q); 206 assertEquals(1, result.size()); 207 newB = (ObjB) result.iterator().next(); 208 assertNotNull(newB.getRef()); 209 assertTrue(newB.getRef() instanceof ObjC); 210 newC = (ObjC) newB.getRef(); 211 assertEquals(3, newC.getReferences().size()); 212 213 crit = new Criteria(); 215 crit.addLike("name", name+"_%"); 216 crit.addEqualTo("ref.name", name+"_second_1"); 217 crit.addPathClass("ref", ObjB.class); 218 q = QueryFactory.newQuery(ObjA.class, crit); 219 result = broker.getCollectionByQuery(q); 220 assertEquals(1, result.size()); 221 222 crit = new Criteria(); 225 crit.addLike("name", name+"_%"); 226 crit.addEqualTo("ref.name", name+"_second_1"); 227 crit.addEqualTo("ref.ref.name", name+"_third"); 228 crit.addPathClass("ref", ObjB.class); 229 crit.addPathClass("ref.ref", ObjC.class); 230 q = QueryFactory.newQuery(ObjA.class, crit); 231 result = broker.getCollectionByQuery(q); 232 assertEquals(1, result.size()); 233 234 crit = new Criteria(); 238 crit.addLike("name", name+"_%"); 239 crit.addEqualTo("ref.ref.references.name", name+"_d1"); 240 crit.addPathClass("ref", ObjB.class); 241 crit.addPathClass("ref.ref", ObjC.class); 242 q = QueryFactory.newQuery(ObjA.class, crit); 243 result = broker.getCollectionByQuery(q); 244 assertEquals(1, result.size()); 245 for(Iterator iterator = result.iterator(); iterator.hasNext();) 246 { 247 RefObject ref = (RefObject) iterator.next(); 248 assertTrue(ref instanceof ObjA); 249 String refName = ref.getName(); 250 assertTrue(!(refName.indexOf(name)<0)); 251 } 252 253 crit = new Criteria(); 258 crit.addLike("name", name+"_%"); 259 crit.addLike("ref.name", name+"_second%"); 260 crit.addLike("ref.ref.references.name", name+"_second%"); 261 crit.addPathClass("ref", ObjB.class); 262 crit.addPathClass("ref.ref", ObjC.class); 263 q = QueryFactory.newQuery(ObjA.class, crit); 264 result = broker.getCollectionByQuery(q); 265 assertEquals(1, result.size()); 266 for(Iterator iterator = result.iterator(); iterator.hasNext();) 267 { 268 RefObject ref = (RefObject) iterator.next(); 269 assertTrue(ref instanceof ObjA); 270 String refName = ref.getName(); 271 assertTrue(!(refName.indexOf(name)<0)); 272 } 273 } 274 275 279 public void testInterfaceAsCollectionRef_2() 280 { 281 String name = "testQueryWithCollectionRef_" + System.currentTimeMillis(); 283 RefObject a = new ObjA(); 284 RefObject a2 = new ObjA(); 285 RefObject b = new ObjB(); 286 RefObject b2 = new ObjB(); 287 ObjC c = new ObjC(); 289 RefObject d = new ObjC(); 291 292 c.setName(name+"_third"); 293 b.setName(name+"_second_1"); 294 b2.setName(name+"_second_2"); 295 a.setName(name+"_first_1"); 296 a2.setName(name+"_first_2"); 297 d.setName(name+"_none"); 298 299 a.setRef(b); 300 b.setRef(c); 301 a2.setRef(b2); 302 303 List refList = new ArrayList (); 304 refList.add(a); 305 refList.add(b2); 306 refList.add(d); 307 c.setReferences(refList); 308 309 broker.beginTransaction(); 310 broker.store(a); 311 broker.store(a2); 312 broker.commitTransaction(); 313 314 Criteria crit = new Criteria(); 316 crit.addEqualTo("name", name+"_third"); 317 Query q = QueryFactory.newQuery(RefObject.class, crit); 318 Collection result = broker.getCollectionByQuery(q); 319 assertEquals(1, result.size()); 320 ObjC newC = (ObjC) result.iterator().next(); 321 assertNotNull(newC.getReferences()); 322 assertEquals(3, newC.getReferences().size()); 323 324 crit = new Criteria(); 327 crit.addEqualTo("ref.ref.name", name+"_third"); 328 q = QueryFactory.newQuery(ObjA.class, crit); 329 result = broker.getCollectionByQuery(q); 330 assertEquals(1, result.size()); 331 333 crit = new Criteria(); 334 crit.addLike("references.name", name+"_first%"); 335 q = QueryFactory.newQuery(ObjC.class, crit); 336 result = broker.getCollectionByQuery(q); 337 assertEquals(1, result.size()); 338 339 crit = new Criteria(); 342 crit.addEqualTo("name", name+"_first_2"); 343 Criteria critOr = new Criteria(); 344 critOr.addEqualTo("ref.ref.name", name+"_third"); 345 crit.addOrCriteria(critOr); 346 q = QueryFactory.newQuery(ObjA.class, crit); 347 result = broker.getCollectionByQuery(q); 348 assertEquals(2, result.size()); 349 for(Iterator iterator = result.iterator(); iterator.hasNext();) 350 { 351 RefObject ref = (RefObject) iterator.next(); 352 assertTrue(ref instanceof ObjA); 353 String refName = ref.getName(); 354 assertTrue(!(refName.indexOf(name)<0)); 355 } 356 357 crit = new Criteria(); 360 crit.addLike("name", name+"_%"); 361 Criteria critAnd = new Criteria(); 362 critAnd.addEqualTo("ref.ref.name", name+"_third"); 363 crit.addAndCriteria(critAnd); 364 q = QueryFactory.newQuery(ObjA.class, crit); 365 result = broker.getCollectionByQuery(q); 366 assertEquals(1, result.size()); 367 for(Iterator iterator = result.iterator(); iterator.hasNext();) 368 { 369 RefObject ref = (RefObject) iterator.next(); 370 assertTrue(ref instanceof ObjA); 371 String refName = ref.getName(); 372 assertTrue(!(refName.indexOf(name)<0)); 373 } 374 375 crit = new Criteria(); 378 crit.addLike("ref.name", name+"_second%"); 379 critAnd = new Criteria(); 380 critAnd.addLike("name", name+"%"); 381 crit.addAndCriteria(critAnd); 382 q = QueryFactory.newQuery(ObjA.class, crit); 383 result = broker.getCollectionByQuery(q); 384 assertEquals(2, result.size()); 385 for(Iterator iterator = result.iterator(); iterator.hasNext();) 386 { 387 RefObject ref = (RefObject) iterator.next(); 388 assertTrue(ref instanceof ObjA); 389 String refName = ref.getName(); 390 assertTrue(!(refName.indexOf(name)<0)); 391 } 392 } 393 394 public void testDeepPathQuery() 395 { 396 String name = "testDeepPathQuery_" + System.currentTimeMillis(); 398 RefObject a = new ObjA(); 399 RefObject a2 = new ObjA(); 400 RefObject b = new ObjB(); 401 RefObject b2 = new ObjB(); 402 ObjC c = new ObjC(); 403 404 c.setName(name+"_third"); 405 b.setName(name+"_second_1"); 406 b2.setName(name+"_second_2"); 407 a.setName(name+"_first_1"); 408 a2.setName(name+"_first_2"); 409 410 a.setRef(b); 411 b.setRef(c); 412 a2.setRef(b2); 413 414 List refList = new ArrayList (); 415 refList.add(a); 416 refList.add(b2); 417 c.setReferences(refList); 418 419 broker.beginTransaction(); 420 broker.store(a); 421 broker.store(a2); 422 broker.commitTransaction(); 423 424 Criteria crit = new Criteria(); 426 crit.addLike("name", name+"%"); 427 Query q = QueryFactory.newQuery(ObjA.class, crit); 428 Collection result = broker.getCollectionByQuery(q); 429 assertEquals(2, result.size()); 430 431 crit = new Criteria(); 433 crit.addLike("name", name+"_third%"); 434 q = QueryFactory.newQuery(ObjC.class, crit); 435 result = broker.getCollectionByQuery(q); 436 assertEquals(1, result.size()); 437 438 crit = new Criteria(); 440 crit.addLike("name", name+"%"); 441 q = QueryFactory.newQuery(ObjC.class, crit); 442 result = broker.getCollectionByQuery(q); 443 assertEquals(1, result.size()); 444 445 crit = new Criteria(); 447 crit.addLike("ref.name", name+"_second%"); 448 q = QueryFactory.newQuery(ObjA.class, crit); 449 result = broker.getCollectionByQuery(q); 450 assertEquals(2, result.size()); 451 452 crit = new Criteria(); 454 crit.addLike("name", name+"%"); 455 q = QueryFactory.newQuery(RefObject.class, crit); 456 result = broker.getCollectionByQuery(q); 457 assertEquals(5, result.size()); 458 459 crit = new Criteria(); 462 crit.addEqualTo("ref.ref.name", name+"_third"); 463 q = QueryFactory.newQuery(ObjA.class, crit); 464 result = broker.getCollectionByQuery(q); 465 assertEquals(1, result.size()); 466 468 crit = new Criteria(); 470 crit.addEqualTo("name", name+"_first_2"); 471 Criteria critOr = new Criteria(); 472 critOr.addEqualTo("ref.ref.name", name+"_third"); 473 crit.addOrCriteria(critOr); 474 q = QueryFactory.newQuery(ObjA.class, crit); 475 result = broker.getCollectionByQuery(q); 476 assertEquals(2, result.size()); 477 for(Iterator iterator = result.iterator(); iterator.hasNext();) 478 { 479 RefObject ref = (RefObject) iterator.next(); 480 assertTrue(ref instanceof ObjA); 481 String refName = ref.getName(); 482 assertTrue(!(refName.indexOf(name)<0)); 483 } 484 } 485 486 public void testAutoUpdateDeleteSettings() 487 { 488 changeRepositoryAutoSetting("ref", true, false, false); 489 ObjectReferenceDescriptor ord = broker.getClassDescriptor(Repository.class) 490 .getObjectReferenceDescriptorByName("ref"); 491 assertEquals(ObjectReferenceDescriptor.CASCADE_LINK, ord.getCascadingStore()); 492 assertEquals(ObjectReferenceDescriptor.CASCADE_NONE, ord.getCascadingDelete()); 493 assertEquals(false, ord.getCascadeStore()); 494 assertEquals(false, ord.getCascadeDelete()); 495 496 changeRepositoryAutoSetting("ref", true, true, true); 497 ord = broker.getClassDescriptor(Repository.class).getObjectReferenceDescriptorByName("ref"); 498 assertEquals(ObjectReferenceDescriptor.CASCADE_OBJECT, ord.getCascadingStore()); 499 assertEquals(ObjectReferenceDescriptor.CASCADE_OBJECT, ord.getCascadingDelete()); 500 assertEquals(true, ord.getCascadeStore()); 501 assertEquals(true, ord.getCascadeDelete()); 502 } 503 504 509 public void testHandlingOfMultiplePKFields() throws Exception 510 { 511 String timestamp = "testLookupWithMultiplePK_" + System.currentTimeMillis(); 512 String regionName = "baden_" + timestamp; 513 String countryName = "germany_" + timestamp; 514 519 Region region = new Region(regionName, countryName, "original"); 520 521 broker.beginTransaction(); 522 broker.store(region); 523 broker.commitTransaction(); 524 525 Identity oid = new Identity(region, broker); 526 broker.clearCache(); 527 Region loadedRegion = (Region) broker.getObjectByIdentity(oid); 528 529 assertNotNull(loadedRegion); 530 assertEquals(region.getName(), loadedRegion.getName()); 531 532 loadedRegion.setDescription("update_1"); 533 broker.beginTransaction(); 534 broker.store(loadedRegion); 535 broker.commitTransaction(); 536 broker.clearCache(); 537 loadedRegion = (Region) broker.getObjectByIdentity(oid); 538 assertNotNull(loadedRegion); 539 assertEquals("update_1", loadedRegion.getDescription()); 540 541 loadedRegion.setDescription("update_2"); 542 broker.beginTransaction(); 543 broker.store(loadedRegion); 544 broker.commitTransaction(); 545 broker.clearCache(); 546 loadedRegion = (Region) broker.getObjectByIdentity(oid); 547 assertNotNull(loadedRegion); 548 assertEquals("update_2", loadedRegion.getDescription()); 549 550 Criteria crit = new Criteria(); 551 crit.addLike("name", regionName); 552 Query q = QueryFactory.newQuery(Region.class, crit); 553 Collection result = broker.getCollectionByQuery(q); 554 assertEquals(1, result.size()); 555 } 556 557 public void testStoreWithMultiplePK_1() throws Exception 558 { 559 String timestamp = "testStoreWithMultiplePK_1_" + System.currentTimeMillis(); 560 String regionName = "baden_1" + timestamp; 561 String countryName = "germany_1" + timestamp; 562 Region region = new Region(regionName, countryName, "brrr"); 563 Wine wine = new Wine(timestamp, "silvaner", "2003", regionName, countryName); 564 565 broker.beginTransaction(); 566 broker.store(region); 567 broker.commitTransaction(); 568 569 574 broker.beginTransaction(); 575 broker.retrieveAllReferences(wine); 576 broker.store(wine); 577 broker.commitTransaction(); 578 579 Identity oid = new Identity(wine, broker); 580 broker.clearCache(); 581 Wine loadedWine = (Wine) broker.getObjectByIdentity(oid); 582 assertNotNull(loadedWine); 583 assertEquals(wine.getGrape(), loadedWine.getGrape()); 584 assertNotNull(loadedWine.getRegion()); 585 assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry()); 586 } 587 588 public void testStoreWithMultiplePK_2() throws Exception 589 { 590 String timestamp = "testStoreWithMultiplePK_2_" + System.currentTimeMillis(); 591 String regionName = "baden_2" + timestamp; 592 String countryName = "germany_2" + timestamp; 593 598 Region region = new Region(regionName, countryName, "brrr"); 599 Wine wine = new Wine(timestamp, "silvaner", "2003", null, null); 600 wine.setRegion(region); 601 602 broker.beginTransaction(); 603 broker.store(region); 604 broker.commitTransaction(); 605 606 broker.beginTransaction(); 607 broker.store(wine); 608 broker.commitTransaction(); 609 610 Identity oid = new Identity(wine, broker); 611 broker.clearCache(); 612 Wine loadedWine = (Wine) broker.getObjectByIdentity(oid); 613 assertNotNull(loadedWine); 614 assertEquals(wine.getGrape(), loadedWine.getGrape()); 615 assertNotNull(loadedWine.getRegion()); 616 assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry()); 617 } 618 619 public void testDeleteWithMultiplePK() 620 { 621 String timestamp = "testDeleteWithMultiplePK_" + System.currentTimeMillis(); 622 String regionName = "baden_2" + timestamp; 623 String countryName = "germany_2" + timestamp; 624 625 630 Region region = new Region(regionName, countryName, "brrr"); 631 Wine wine = new Wine(timestamp, "silvaner", "2003", null, null); 632 wine.setRegion(region); 633 634 broker.beginTransaction(); 635 broker.store(region); 636 broker.commitTransaction(); 637 638 broker.beginTransaction(); 639 broker.store(wine); 640 broker.commitTransaction(); 641 642 Identity oid = new Identity(wine, broker); 643 Identity oidRegion = new Identity(region, broker); 644 broker.clearCache(); 645 Wine loadedWine = (Wine) broker.getObjectByIdentity(oid); 646 assertNotNull(loadedWine); 647 assertEquals(wine.getGrape(), loadedWine.getGrape()); 648 assertNotNull(loadedWine.getRegion()); 649 assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry()); 650 651 broker.beginTransaction(); 652 broker.delete(wine); 653 broker.commitTransaction(); 654 655 loadedWine = (Wine) broker.getObjectByIdentity(oid); 656 assertNull(loadedWine); 657 Region loadedregion = (Region) broker.getObjectByIdentity(oidRegion); 658 assertNotNull(loadedregion); 659 660 broker.clearCache(); 661 loadedWine = (Wine) broker.getObjectByIdentity(oid); 662 assertNull(loadedWine); 663 loadedregion = (Region) broker.getObjectByIdentity(oidRegion); 664 assertNotNull(loadedregion); 665 } 666 667 public void testStoreWithMultiplePK_3() throws Exception 668 { 669 String timestamp = "testStoreWithMultiplePK_3_" + System.currentTimeMillis(); 670 String regionName = "baden_3" + timestamp; 671 String countryName = "germany_3" + timestamp; 672 677 Region region = new Region(regionName, countryName, "brrr"); 678 Wine wine = new Wine(timestamp, "silvaner", "2003", regionName, countryName); 679 wine.setRegion(region); 680 681 broker.beginTransaction(); 682 broker.store(region); 683 broker.commitTransaction(); 684 685 broker.beginTransaction(); 686 broker.store(wine); 687 broker.commitTransaction(); 688 689 Identity oid = new Identity(wine, broker); 690 broker.clearCache(); 691 Wine loadedWine = (Wine) broker.getObjectByIdentity(oid); 692 assertNotNull(loadedWine); 693 assertEquals(wine.getGrape(), loadedWine.getGrape()); 694 assertNotNull(loadedWine.getRegion()); 695 assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry()); 696 } 697 698 public void testStoreReferencesMappedToSameTable() 699 { 700 String referenceNamePrefix = "testStoreReferencesMappedToSameTable" + System.currentTimeMillis(); 701 Repository[] repository = prepareRepository(referenceNamePrefix); 702 703 broker.beginTransaction(); 704 broker.store(repository[0]); 705 broker.store(repository[1]); 706 broker.store(repository[2]); 707 broker.commitTransaction(); 708 709 broker.clearCache(); 710 Identity oid = new Identity(repository[0], broker); 711 712 Repository rep = (Repository) broker.getObjectByIdentity(oid); 713 assertNotNull(rep.getRef()); 714 assertNotNull(rep.getRefA()); 715 assertNotNull(rep.getRefB()); 716 assertEquals(rep.getRefB().getRefNameB(), REF_TEST_STRING); 718 } 719 720 public void testGetReferencesByIdentityMappedToSameTable() 721 { 722 String referenceNamePrefix = "testGetReferencesByIdentityMappedToSameTable" + System.currentTimeMillis(); 723 Repository[] repository = prepareRepository(referenceNamePrefix); 724 725 broker.beginTransaction(); 726 broker.store(repository[0]); 727 broker.store(repository[1]); 728 broker.store(repository[2]); 729 broker.commitTransaction(); 730 731 assertNotNull(repository[0].getRef()); 732 assertNotNull(repository[0].getRefA()); 733 assertNotNull(repository[0].getRefB()); 734 735 Identity oid_ref = new Identity(repository[0].getRef(), broker); 736 Identity oid_refA = new Identity(repository[0].getRefA(), broker); 737 Identity oid_refB = new Identity(repository[0].getRefB(), broker); 738 739 broker.clearCache(); 740 Object result; 741 result = broker.getObjectByIdentity(oid_ref); 742 assertTrue(result instanceof Reference); 743 result = broker.getObjectByIdentity(oid_refA); 744 assertTrue(result instanceof ReferenceA); 745 result = broker.getObjectByIdentity(oid_refB); 746 assertTrue(result instanceof ReferenceB); 747 748 broker.clearCache(); 749 Identity repOID = new Identity(repository[0], broker); 750 Repository repositoryObj = (Repository) broker.getObjectByIdentity(repOID); 751 assertNotNull(repositoryObj); 752 ReferenceBIF refB = repositoryObj.getRefB(); 753 assertNotNull(refB); 754 assertEquals(refB.getRefNameB(), REF_TEST_STRING); 755 } 756 757 public void testQueryReferencesMappedToSameTable() 758 { 759 String referenceNamePrefix = "testQueryReferencesMappedToSameTable" + System.currentTimeMillis(); 760 Repository[] repository = prepareRepository(referenceNamePrefix); 761 762 broker.beginTransaction(); 763 broker.store(repository[0]); 764 broker.store(repository[1]); 765 broker.store(repository[2]); 766 broker.commitTransaction(); 767 768 broker.clearCache(); 769 Criteria criteria = new Criteria(); 770 criteria.addLike("name", referenceNamePrefix + "%"); 771 Query query = QueryFactory.newQuery(ReferenceIF.class, criteria); 772 Collection result = broker.getCollectionByQuery(query); 773 774 assertEquals("Wrong number of References", 9, result.size()); 775 int ref_count = 0; 776 int refA_count = 0; 777 int refB_count = 0; 778 Iterator it = result.iterator(); 779 Object obj; 780 while(it.hasNext()) 781 { 782 obj = it.next(); 783 if(obj instanceof ReferenceA) 784 refA_count++; 785 else if(obj instanceof ReferenceB) 786 refB_count++; 787 else if(obj instanceof Reference) ref_count++; 788 } 789 assertEquals("Wrong number of RefernceA", 3, refA_count); 790 assertEquals("Wrong number of RefernceB", 3, refB_count); 791 assertEquals("Wrong number of Refernce", 3, ref_count); 792 793 result = broker.getCollectionByQuery(query); 794 it = result.iterator(); 795 while(it.hasNext()) 796 { 797 obj = it.next(); 798 if(obj instanceof ReferenceA) 799 { 800 assertNotNull(((ReferenceA) obj).getRefNameA()); 801 assertNotNull(((ReferenceA) obj).getName()); 802 } 803 else if(obj instanceof ReferenceB) 804 { 805 assertNotNull(((ReferenceB) obj).getRefNameB()); 806 assertNotNull(((ReferenceB) obj).getName()); 807 } 808 else if(obj instanceof Reference) 809 { 810 assertNotNull(((Reference) obj).getName()); 811 } 812 } 813 } 814 815 public void testDeleteReferencesMappedToSameTable() 816 { 817 String referenceNamePrefix = "testDeleteReferencesMappedToSameTable" + System.currentTimeMillis(); 818 Repository[] repository = prepareRepository(referenceNamePrefix); 819 820 broker.beginTransaction(); 821 broker.store(repository[0]); 822 broker.store(repository[1]); 823 broker.store(repository[2]); 824 broker.commitTransaction(); 825 826 Criteria criteria = new Criteria(); 827 criteria.addLike("name", referenceNamePrefix + "%"); 828 Query query = QueryFactory.newQuery(ReferenceIF.class, criteria); 829 Collection result = broker.getCollectionByQuery(query); 830 831 assertEquals("Wrong number of References", 9, result.size()); 832 833 broker.beginTransaction(); 834 broker.delete(repository[0]); 835 broker.delete(repository[1]); 836 broker.delete(repository[2]); 837 broker.commitTransaction(); 838 839 result = broker.getCollectionByQuery(query); 840 assertEquals("Wrong number of References", 0, result.size()); 841 } 842 843 public void testDeleteReferencesMappedToSameTable_2() 844 { 845 String referenceNamePrefix = "testDeleteReferencesMappedToSameTable_2" + System.currentTimeMillis(); 846 changeRepositoryAutoSetting("ref", true, true, false); 847 changeRepositoryAutoSetting("refA", true, true, false); 848 changeRepositoryAutoSetting("refB", true, true, false); 849 850 Repository[] repository = prepareRepository(referenceNamePrefix); 851 852 broker.beginTransaction(); 853 broker.store(repository[0]); 854 broker.store(repository[1]); 855 broker.store(repository[2]); 856 broker.commitTransaction(); 857 858 Criteria criteria = new Criteria(); 859 criteria.addLike("name", referenceNamePrefix + "%"); 860 Query query = QueryFactory.newQuery(ReferenceIF.class, criteria); 861 Collection result = broker.getCollectionByQuery(query); 862 863 assertEquals("Wrong number of References", 9, result.size()); 864 865 broker.beginTransaction(); 866 broker.delete(repository[0]); 867 broker.delete(repository[1]); 868 broker.delete(repository[2]); 869 broker.commitTransaction(); 870 871 result = broker.getCollectionByQuery(query); 872 assertEquals("Wrong number of References", 9, result.size()); 873 } 874 875 public void testDeleteReferencesMappedToSameTable_3() 876 { 877 String referenceNamePrefix = "testDeleteReferencesMappedToSameTable_3" + System.currentTimeMillis(); 878 changeRepositoryAutoSetting("ref", true, true, false); 879 changeRepositoryAutoSetting("refA", true, true, true); 880 changeRepositoryAutoSetting("refB", true, true, false); 881 882 Repository[] repository = prepareRepository(referenceNamePrefix); 883 884 broker.beginTransaction(); 885 broker.store(repository[0]); 886 broker.store(repository[1]); 887 broker.store(repository[2]); 888 broker.commitTransaction(); 889 890 Criteria criteria = new Criteria(); 891 criteria.addLike("name", referenceNamePrefix + "%"); 892 Query query = QueryFactory.newQuery(ReferenceIF.class, criteria); 893 Collection result = broker.getCollectionByQuery(query); 894 895 assertEquals("Wrong number of References", 9, result.size()); 896 897 broker.beginTransaction(); 898 broker.delete(repository[0]); 899 broker.delete(repository[1]); 900 broker.delete(repository[2]); 901 broker.commitTransaction(); 902 903 result = broker.getCollectionByQuery(query); 904 assertEquals("Wrong number of References", 6, result.size()); 905 } 906 907 private void changeRepositoryAutoSetting(String attributeName, boolean retrieve, int update, int delete) 908 { 909 ClassDescriptor cld = broker.getClassDescriptor(Repository.class); 910 ObjectReferenceDescriptor ord = cld.getObjectReferenceDescriptorByName(attributeName); 911 ord.setCascadeRetrieve(retrieve); 912 ord.setCascadingStore(update); 913 ord.setCascadingDelete(delete); 914 } 915 916 private void changeRepositoryAutoSetting(String attributeName, boolean retrieve, boolean update, boolean delete) 917 { 918 ClassDescriptor cld = broker.getClassDescriptor(Repository.class); 919 ObjectReferenceDescriptor ord = cld.getObjectReferenceDescriptorByName(attributeName); 920 ord.setCascadeRetrieve(retrieve); 921 ord.setCascadeStore(update); 922 ord.setCascadeDelete(delete); 923 } 924 925 962 public void testRepositoryFKStore() 963 { 964 String referenceNamePrefix = "testReferenceStore" + System.currentTimeMillis(); 965 RepositoryFK[] repository = prepareRepositoryFK(referenceNamePrefix); 966 967 broker.beginTransaction(); 968 broker.store(repository[0]); 969 broker.store(repository[1]); 970 broker.store(repository[2]); 971 broker.commitTransaction(); 972 973 Identity oid = new Identity(repository[0], broker); 974 RepositoryFK repFK = (RepositoryFK) broker.getObjectByIdentity(oid); 975 976 assertNotNull("We should found a RepositoryFK object, but doesn't.", repFK); 977 assertNotNull(repFK.getRef()); 978 assertNotNull(repFK.getRefA()); 979 assertNotNull(repFK.getRefB()); 980 } 981 982 986 public void testAbstractReferenceStore() throws Exception 987 { 988 String name = "testAbstractReferenceStore_" + System.currentTimeMillis(); 989 992 Bird bird_1 = new Bird(); 993 bird_1.setName(name); 994 bird_1.setWingspan(new Double (2.33)); 995 Bird bird_2 = new Bird(); 996 bird_2.setName(name); 997 bird_2.setWingspan(new Double (0.99)); 998 999 Mammal mammal_1 = new Mammal(); 1000 mammal_1.setName(name); 1001 mammal_1.setHeight(new Double (1.88)); 1002 Mammal mammal_2 = new Mammal(); 1003 mammal_2.setName(name); 1004 mammal_2.setHeight(new Double (19.13)); 1005 1006 Fish fish_1 = new Fish(); 1007 fish_1.setName(name); 1008 fish_1.setLength(new Double (0.033)); 1009 Fish fish_2 = new Fish(); 1010 fish_2.setName(name); 1011 fish_2.setLength(new Double (37.89)); 1012 1013 Repository rep_1 = new Repository(); 1014 rep_1.setAnimal(mammal_1); 1015 Repository rep_2 = new Repository(); 1016 rep_2.setAnimal(bird_1); 1017 Repository rep_3 = new Repository(); 1018 rep_3.setAnimal(fish_1); 1019 1020 1023 broker.beginTransaction(); 1024 broker.store(bird_2); 1026 broker.store(mammal_2); 1027 broker.store(fish_2); 1028 broker.store(rep_1); 1030 broker.store(rep_2); 1031 broker.store(rep_3); 1032 broker.commitTransaction(); 1033 1034 Identity oid_mammal = new Identity(mammal_1, broker); 1035 Identity oid_bird = new Identity(bird_1, broker); 1036 Identity oid_fish = new Identity(fish_1, broker); 1037 Identity oid_rep_1 = new Identity(rep_1, broker); 1038 Identity oid_rep_2 = new Identity(rep_2, broker); 1039 Identity oid_rep_3 = new Identity(rep_3, broker); 1040 1041 broker.clearCache(); 1042 Mammal lookup_mammal = (Mammal) broker.getObjectByIdentity(oid_mammal); 1044 Bird lookup_bird = (Bird) broker.getObjectByIdentity(oid_bird); 1045 Fish lookup_fish = (Fish) broker.getObjectByIdentity(oid_fish); 1046 assertEquals(mammal_1, lookup_mammal); 1047 assertEquals(bird_1, lookup_bird); 1048 assertEquals(fish_1, lookup_fish); 1049 1050 broker.clearCache(); 1051 Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1); 1053 Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2); 1054 Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3); 1055 1056 assertNotNull(lookup_rep_1.getAnimal()); 1057 assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(), 1058 lookup_rep_1.getAnimal() instanceof Mammal); 1059 assertEquals(mammal_1, lookup_rep_1.getAnimal()); 1060 1061 assertNotNull(lookup_rep_2.getAnimal()); 1062 assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(), 1063 lookup_rep_2.getAnimal() instanceof Bird); 1064 assertEquals(bird_1, lookup_rep_2.getAnimal()); 1065 1066 assertNotNull(lookup_rep_3.getAnimal()); 1067 assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(), 1068 lookup_rep_3.getAnimal() instanceof Fish); 1069 assertEquals(fish_1, lookup_rep_3.getAnimal()); 1070 } 1071 1072 public void testAbstractReferenceQuery() throws Exception 1073 { 1074 String name = "testAbstractReferenceQuery_" + System.currentTimeMillis(); 1075 1078 Bird bird_1 = new Bird(); 1079 bird_1.setName(name); 1080 bird_1.setWingspan(new Double (2.33)); 1081 Bird bird_2 = new Bird(); 1082 bird_2.setName(name); 1083 bird_2.setWingspan(new Double (0.99)); 1084 1085 Mammal mammal_1 = new Mammal(); 1086 mammal_1.setName(name); 1087 mammal_1.setHeight(new Double (1.88)); 1088 Mammal mammal_2 = new Mammal(); 1089 mammal_2.setName(name); 1090 mammal_2.setHeight(new Double (19.13)); 1091 1092 Fish fish_1 = new Fish(); 1093 fish_1.setName(name); 1094 fish_1.setLength(new Double (0.033)); 1095 Fish fish_2 = new Fish(); 1096 fish_2.setName(name); 1097 fish_2.setLength(new Double (37.89)); 1098 1099 Repository rep_1 = new Repository(); 1100 rep_1.setAnimal(mammal_1); 1101 Repository rep_2 = new Repository(); 1102 rep_2.setAnimal(bird_1); 1103 Repository rep_3 = new Repository(); 1104 rep_3.setAnimal(fish_1); 1105 1106 1109 broker.beginTransaction(); 1110 broker.store(bird_2); 1112 broker.store(mammal_2); 1113 broker.store(fish_2); 1114 broker.store(rep_1); 1116 broker.store(rep_2); 1117 broker.store(rep_3); 1118 broker.commitTransaction(); 1119 1120 Identity oid_rep_1 = new Identity(rep_1, broker); 1121 Identity oid_rep_2 = new Identity(rep_2, broker); 1122 Identity oid_rep_3 = new Identity(rep_3, broker); 1123 1124 broker.clearCache(); 1125 Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1); 1127 Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2); 1128 Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3); 1129 1130 assertNotNull(lookup_rep_1.getAnimal()); 1131 assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(), 1132 lookup_rep_1.getAnimal() instanceof Mammal); 1133 assertEquals(mammal_1, lookup_rep_1.getAnimal()); 1134 1135 assertNotNull(lookup_rep_2.getAnimal()); 1136 assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(), 1137 lookup_rep_2.getAnimal() instanceof Bird); 1138 assertEquals(bird_1, lookup_rep_2.getAnimal()); 1139 1140 assertNotNull(lookup_rep_3.getAnimal()); 1141 assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(), 1142 lookup_rep_3.getAnimal() instanceof Fish); 1143 assertEquals(fish_1, lookup_rep_3.getAnimal()); 1144 1145 broker.clearCache(); 1146 Criteria crit = new Criteria(); 1148 crit.addEqualTo("name", name); 1149 Query query = QueryFactory.newQuery(Animal.class, crit); 1150 Collection result = broker.getCollectionByQuery(query); 1151 assertNotNull(result); 1152 int[] mammalBirdFish = new int[3]; 1153 for(Iterator iterator = result.iterator(); iterator.hasNext();) 1154 { 1155 Object o = iterator.next(); 1156 if(o instanceof Mammal) ++mammalBirdFish[0]; 1157 if(o instanceof Bird) ++mammalBirdFish[1]; 1158 if(o instanceof Fish) ++mammalBirdFish[2]; 1159 } 1160 assertEquals(2, mammalBirdFish[0]); 1161 assertEquals(2, mammalBirdFish[1]); 1162 assertEquals(2, mammalBirdFish[2]); 1163 } 1164 1165 1169 public void testAbstractReferenceDelete() throws Exception 1170 { 1171 String name = "testAbstractReferenceDelete_" + System.currentTimeMillis(); 1172 1175 Bird bird_1 = new Bird(); 1176 bird_1.setName(name); 1177 bird_1.setWingspan(new Double (2.33)); 1178 Bird bird_2 = new Bird(); 1179 bird_2.setName(name); 1180 bird_2.setWingspan(new Double (0.99)); 1181 1182 Mammal mammal_1 = new Mammal(); 1183 mammal_1.setName(name); 1184 mammal_1.setHeight(new Double (1.88)); 1185 Mammal mammal_2 = new Mammal(); 1186 mammal_2.setName(name); 1187 mammal_2.setHeight(new Double (19.13)); 1188 1189 Fish fish_1 = new Fish(); 1190 fish_1.setName(name); 1191 fish_1.setLength(new Double (0.033)); 1192 Fish fish_2 = new Fish(); 1193 fish_2.setName(name); 1194 fish_2.setLength(new Double (37.89)); 1195 1196 Repository rep_1 = new Repository(); 1197 rep_1.setAnimal(mammal_1); 1198 Repository rep_2 = new Repository(); 1199 rep_2.setAnimal(bird_1); 1200 Repository rep_3 = new Repository(); 1201 rep_3.setAnimal(fish_1); 1202 1203 1206 broker.beginTransaction(); 1207 broker.store(bird_2); 1209 broker.store(mammal_2); 1210 broker.store(fish_2); 1211 broker.store(rep_1); 1213 broker.store(rep_2); 1214 broker.store(rep_3); 1215 broker.commitTransaction(); 1216 1217 Identity oid_rep_1 = new Identity(rep_1, broker); 1218 Identity oid_rep_2 = new Identity(rep_2, broker); 1219 Identity oid_rep_3 = new Identity(rep_3, broker); 1220 1221 broker.clearCache(); 1222 Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1); 1224 Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2); 1225 Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3); 1226 1227 assertNotNull(lookup_rep_1.getAnimal()); 1228 assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(), 1229 lookup_rep_1.getAnimal() instanceof Mammal); 1230 assertEquals(mammal_1, lookup_rep_1.getAnimal()); 1231 1232 assertNotNull(lookup_rep_2.getAnimal()); 1233 assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(), 1234 lookup_rep_2.getAnimal() instanceof Bird); 1235 assertEquals(bird_1, lookup_rep_2.getAnimal()); 1236 1237 assertNotNull(lookup_rep_3.getAnimal()); 1238 assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(), 1239 lookup_rep_3.getAnimal() instanceof Fish); 1240 assertEquals(fish_1, lookup_rep_3.getAnimal()); 1241 1242 broker.clearCache(); 1243 1244 broker.beginTransaction(); 1245 broker.delete(rep_1); 1246 broker.delete(rep_2); 1247 broker.delete(rep_3); 1248 broker.commitTransaction(); 1249 1250 lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1); 1251 lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2); 1252 lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3); 1253 assertNull(lookup_rep_1); 1254 assertNull(lookup_rep_2); 1255 assertNull(lookup_rep_3); 1256 1257 } 1258 1259 private Repository[] prepareRepository(String referenceNamePrefix) 1260 { 1261 Reference[] ref = new Reference[]{ 1262 new Reference(referenceNamePrefix + "ref_1"), 1263 new Reference(referenceNamePrefix + "ref_2"), 1264 new Reference(referenceNamePrefix + "ref_3")}; 1265 ReferenceA[] refA = new ReferenceA[]{ 1266 new ReferenceA(referenceNamePrefix + "refA_1", "a1"), 1267 new ReferenceA(referenceNamePrefix + "refA_2", "a2"), 1268 new ReferenceA(referenceNamePrefix + "refA_3", "a3")}; 1269 ReferenceB[] refB = new ReferenceB[]{ 1270 new ReferenceB(referenceNamePrefix + "refB_1", REF_TEST_STRING), 1271 new ReferenceB(referenceNamePrefix + "refB_2", "b2"), 1272 new ReferenceB(referenceNamePrefix + "refB_3", "b3")}; 1273 1274 Repository repository = new Repository(); 1275 repository.setRef(ref[0]); 1276 repository.setRefA(refA[0]); 1277 repository.setRefB(refB[0]); 1278 1279 Repository repository2 = new Repository(); 1280 repository2.setRef(ref[1]); 1281 repository2.setRefA(refA[1]); 1282 repository2.setRefB(refB[1]); 1283 1284 Repository repository3 = new Repository(); 1285 repository3.setRef(ref[2]); 1286 repository3.setRefA(refA[2]); 1287 repository3.setRefB(refB[2]); 1288 1289 return new Repository[]{repository, repository2, repository3}; 1290 } 1291 1292 private RepositoryFK[] prepareRepositoryFK(String referenceNamePrefix) 1293 { 1294 Reference[] ref = new Reference[]{ 1295 new Reference(referenceNamePrefix + "ref_1"), 1296 new Reference(referenceNamePrefix + "ref_2"), 1297 new Reference(referenceNamePrefix + "ref_3")}; 1298 ReferenceA[] refA = new ReferenceA[]{ 1299 new ReferenceA(referenceNamePrefix + "refA_1", "a1"), 1300 new ReferenceA(referenceNamePrefix + "refA_2", "a2"), 1301 new ReferenceA(referenceNamePrefix + "refA_3", "a3")}; 1302 ReferenceB[] refB = new ReferenceB[]{ 1303 new ReferenceB(referenceNamePrefix + "refB_1", REF_TEST_STRING), 1304 new ReferenceB(referenceNamePrefix + "refB_2", "b2"), 1305 new ReferenceB(referenceNamePrefix + "refB_3", "b3")}; 1306 1307 RepositoryFK repository = new RepositoryFK(); 1308 repository.setRef(ref[0]); 1309 repository.setRefA(refA[0]); 1310 repository.setRefB(refB[0]); 1311 1312 RepositoryFK repository2 = new RepositoryFK(); 1313 repository2.setRef(ref[1]); 1314 repository2.setRefA(refA[1]); 1315 repository2.setRefB(refB[1]); 1316 1317 RepositoryFK repository3 = new RepositoryFK(); 1318 repository3.setRef(ref[2]); 1319 repository3.setRefA(refA[2]); 1320 repository3.setRefB(refB[2]); 1321 1322 return new RepositoryFK[]{repository, repository2, repository3}; 1323 } 1324 1325 public void testMassOperations() 1326 { 1327 broker.beginTransaction(); 1328 for (int i = 1; i < 100; i++) 1329 { 1330 1331 ProductGroup pg = new ProductGroup(); 1332 pg.setGroupName("1-1 test productgroup_" + i); 1333 broker.store(pg); 1334 1335 Article article = Article.createInstance(); 1336 article.setArticleName("1-1 test article_" + i); 1337 article.setProductGroupId(pg.getGroupId()); 1338 1339 broker.retrieveReference(article, "productGroup"); 1340 broker.store(article); 1341 } 1342 broker.commitTransaction(); 1343 } 1344 1345 1346 1347 1348 1352 public static class Repository implements Serializable 1353 { 1354 private Integer repId; 1355 1356 private Integer refId; 1357 private Integer refAId; 1358 private Integer refBId; 1359 1360 private ReferenceIF ref; 1361 private ReferenceAIF refA; 1362 private ReferenceBIF refB; 1363 1364 private Animal animal; 1365 private Integer animalId; 1366 1367 public Repository() 1368 { 1369 } 1370 1371 public Integer getRefId() 1372 { 1373 return refId; 1374 } 1375 1376 public void setRefId(Integer refId) 1377 { 1378 this.refId = refId; 1379 } 1380 1381 public Integer getRefAId() 1382 { 1383 return refAId; 1384 } 1385 1386 public void setRefAId(Integer refAId) 1387 { 1388 this.refAId = refAId; 1389 } 1390 1391 public Integer getRefBId() 1392 { 1393 return refBId; 1394 } 1395 1396 public void setRefBId(Integer refBId) 1397 { 1398 this.refBId = refBId; 1399 } 1400 1401 public Animal getAnimal() 1402 { 1403 return animal; 1404 } 1405 1406 public void setAnimal(Animal animal) 1407 { 1408 this.animal = animal; 1409 } 1410 1411 public Integer getAnimalId() 1412 { 1413 return animalId; 1414 } 1415 1416 public void setAnimalId(Integer animalId) 1417 { 1418 this.animalId = animalId; 1419 } 1420 1421 public ReferenceIF getRef() 1422 { 1423 return ref; 1424 } 1425 1426 public void setRef(ReferenceIF ref) 1427 { 1428 this.ref = ref; 1429 } 1430 1431 public ReferenceAIF getRefA() 1432 { 1433 return refA; 1434 } 1435 1436 public void setRefA(ReferenceAIF refA) 1437 { 1438 this.refA = refA; 1439 } 1440 1441 public ReferenceBIF getRefB() 1442 { 1443 return refB; 1444 } 1445 1446 public void setRefB(ReferenceBIF refB) 1447 { 1448 this.refB = refB; 1449 } 1450 1451 public Integer getRepId() 1452 { 1453 return repId; 1454 } 1455 1456 public void setRepId(Integer repId) 1457 { 1458 this.repId = repId; 1459 } 1460 } 1461 1462 1466 public static class RepositoryFK extends Repository 1467 { 1468 } 1469 1470 public static interface ReferenceIF extends Serializable 1471 { 1472 Integer getRefId(); 1473 1474 void setRefId(Integer refId); 1475 1476 String getName(); 1477 1478 void setName(String name); 1479 } 1480 1481 public static interface ReferenceAIF extends Serializable 1482 { 1483 String getRefNameA(); 1484 1485 void setRefNameA(String name); 1486 } 1487 1488 public static interface ReferenceBIF extends Serializable 1489 { 1490 String getRefNameB(); 1491 1492 void setRefNameB(String name); 1493 } 1494 1495 public static class Reference implements ReferenceIF 1496 { 1497 protected String ojbConcreteClass; 1498 private Integer refId; 1499 private String name; 1500 1501 public Reference() 1502 { 1503 this(null); 1504 } 1505 1506 public Reference(String name) 1507 { 1508 this.name = name; 1509 ojbConcreteClass = this.getClass().getName(); 1510 } 1511 1512 public String getOjbConcreteClass() 1513 { 1514 return ojbConcreteClass; 1515 } 1516 1517 public void setOjbConcreteClass(String ojbConcreteClass) 1518 { 1519 this.ojbConcreteClass = ojbConcreteClass; 1520 } 1521 1522 public Integer getRefId() 1523 { 1524 return refId; 1525 } 1526 1527 public void setRefId(Integer refId) 1528 { 1529 this.refId = refId; 1530 } 1531 1532 public String getName() 1533 { 1534 return name; 1535 } 1536 1537 public void setName(String name) 1538 { 1539 this.name = name; 1540 } 1541 } 1542 1543 public static class ReferenceA extends Reference implements ReferenceAIF 1544 { 1545 private String refNameA; 1546 1547 public ReferenceA() 1548 { 1549 super(); 1550 } 1551 1552 public ReferenceA(String name, String refNameA) 1553 { 1554 super(name); 1555 this.refNameA = refNameA; 1556 } 1557 1558 public String getRefNameA() 1559 { 1560 return refNameA; 1561 } 1562 1563 public void setRefNameA(String refName) 1564 { 1565 this.refNameA = refName; 1566 } 1567 } 1568 1569 public static class ReferenceB extends Reference implements ReferenceBIF 1570 { 1571 private String refNameB; 1572 1573 public ReferenceB() 1574 { 1575 super(); 1576 } 1577 1578 public ReferenceB(String name, String refNameB) 1579 { 1580 super(name); 1581 this.refNameB = refNameB; 1582 } 1583 1584 public String getRefNameB() 1585 { 1586 return refNameB; 1587 } 1588 1589 public void setRefNameB(String refName) 1590 { 1591 this.refNameB = refName; 1592 } 1593 } 1594 1595 1599 public static abstract class Animal 1600 { 1601 private Integer id; 1602 private String name; 1603 1604 public Integer getId() 1605 { 1606 return id; 1607 } 1608 1609 public void setId(Integer id) 1610 { 1611 this.id = id; 1612 } 1613 1614 public String getName() 1615 { 1616 return name; 1617 } 1618 1619 public void setName(String name) 1620 { 1621 this.name = name; 1622 } 1623 1624 public boolean equals(Object obj) 1625 { 1626 if(!(obj instanceof Animal)) return false; 1627 Animal animal = (Animal) obj; 1628 boolean result; 1629 result = name == null ? (animal.getName() == null) : name.equals(animal.getName()); 1630 result = result && (id == null ? animal.getId() == null : id.equals(animal.getId())); 1631 return result; 1632 } 1633 } 1634 1635 public static class Mammal extends Animal 1636 { 1637 private Double height; 1638 private String ojbConcreteClass; 1639 1640 public Mammal() 1641 { 1642 ojbConcreteClass = Mammal.class.getName(); 1643 } 1644 1645 public Double getHeight() 1646 { 1647 return height; 1648 } 1649 1650 public void setHeight(Double height) 1651 { 1652 this.height = height; 1653 } 1654 1655 public String getOjbConcreteClass() 1656 { 1657 return ojbConcreteClass; 1658 } 1659 1660 public void setOjbConcreteClass(String ojbConcreteClass) 1661 { 1662 this.ojbConcreteClass = ojbConcreteClass; 1663 } 1664 1665 public boolean equals(Object obj) 1666 { 1667 if(!(obj instanceof Mammal)) return false; 1668 Mammal m = (Mammal) obj; 1669 boolean result = super.equals(obj); 1670 result = result && (height == null ? m.getHeight() == null : height.equals(m.getHeight())); 1671 return result; 1672 } 1673 } 1674 1675 public static class Bird extends Animal 1676 { 1677 private Double wingspan; 1678 private String ojbConcreteClass; 1679 1680 public Bird() 1681 { 1682 ojbConcreteClass = Bird.class.getName(); 1683 } 1684 1685 public boolean equals(Object obj) 1686 { 1687 if(!(obj instanceof Bird)) return false; 1688 Bird m = (Bird) obj; 1689 boolean result = super.equals(obj); 1690 result = result && (wingspan == null ? m.getWingspan() == null : wingspan.equals(m.getWingspan())); 1691 return result; 1692 } 1693 1694 public Double getWingspan() 1695 { 1696 return wingspan; 1697 } 1698 1699 public void setWingspan(Double wingspan) 1700 { 1701 this.wingspan = wingspan; 1702 } 1703 1704 public String getOjbConcreteClass() 1705 { 1706 return ojbConcreteClass; 1707 } 1708 1709 public void setOjbConcreteClass(String ojbConcreteClass) 1710 { 1711 this.ojbConcreteClass = ojbConcreteClass; 1712 } 1713 } 1714 1715 public static class Fish extends Animal 1716 { 1717 private Double length; 1718 private String ojbConcreteClass; 1719 1720 public Fish() 1721 { 1722 ojbConcreteClass = Fish.class.getName(); 1723 } 1724 1725 public boolean equals(Object obj) 1726 { 1727 if(!(obj instanceof Fish)) return false; 1728 Fish m = (Fish) obj; 1729 boolean result = super.equals(obj); 1730 result = result && (length == null ? m.getLength() == null : length.equals(m.getLength())); 1731 return result; 1732 } 1733 1734 public String getOjbConcreteClass() 1735 { 1736 return ojbConcreteClass; 1737 } 1738 1739 public void setOjbConcreteClass(String ojbConcreteClass) 1740 { 1741 this.ojbConcreteClass = ojbConcreteClass; 1742 } 1743 1744 public Double getLength() 1745 { 1746 return length; 1747 } 1748 1749 public void setLength(Double length) 1750 { 1751 this.length = length; 1752 } 1753 } 1754 1755 1756 public static class Wine 1760 { 1761 private String id; 1762 private String grape; 1763 private String year; 1764 private String regionName; 1765 private String regionCountry; 1766 private Region region; 1767 1768 public Wine() 1769 { 1770 } 1771 1772 public Wine(String id, String grape, String year, String regionName, String regionCountry) 1773 { 1774 this.id = id; 1775 this.grape = grape; 1776 this.year = year; 1777 this.regionName = regionName; 1778 this.regionCountry = regionCountry; 1779 } 1780 1781 public Region getRegion() 1782 { 1783 return region; 1784 } 1785 1786 public void setRegion(Region region) 1787 { 1788 this.region = region; 1789 } 1790 1791 public String getId() 1792 { 1793 return id; 1794 } 1795 1796 public void setId(String id) 1797 { 1798 this.id = id; 1799 } 1800 1801 public String getGrape() 1802 { 1803 return grape; 1804 } 1805 1806 public void setGrape(String grape) 1807 { 1808 this.grape = grape; 1809 } 1810 1811 public String getYear() 1812 { 1813 return year; 1814 } 1815 1816 public void setYear(String year) 1817 { 1818 this.year = year; 1819 } 1820 1821 public String getRegionName() 1822 { 1823 return regionName; 1824 } 1825 1826 public void setRegionName(String regionName) 1827 { 1828 this.regionName = regionName; 1829 } 1830 1831 public String getRegionCountry() 1832 { 1833 return regionCountry; 1834 } 1835 1836 public void setRegionCountry(String regionCountry) 1837 { 1838 this.regionCountry = regionCountry; 1839 } 1840 1841 public String toString() 1842 { 1843 return new ToStringBuilder(this) 1844 .append("id", id) 1845 .append("grape", grape) 1846 .append("regionCountry", regionCountry) 1847 .append("regionName", regionName) 1848 .append("year", year) 1849 .append("region", region) 1850 .toString(); 1851 } 1852 } 1853 1854 public static class Region 1855 { 1856 private String name; 1857 private String country; 1858 private String description; 1859 1860 public Region() 1861 { 1862 } 1863 1864 public Region(String name, String country, String description) 1865 { 1866 this.name = name; 1867 this.country = country; 1868 this.description = description; 1869 } 1870 1871 public String getName() 1872 { 1873 return name; 1874 } 1875 1876 public void setName(String name) 1877 { 1878 this.name = name; 1879 } 1880 1881 public String getCountry() 1882 { 1883 return country; 1884 } 1885 1886 public void setCountry(String country) 1887 { 1888 this.country = country; 1889 } 1890 1891 public String getDescription() 1892 { 1893 return description; 1894 } 1895 1896 public void setDescription(String description) 1897 { 1898 this.description = description; 1899 } 1900 1901 public String toString() 1902 { 1903 return new ToStringBuilder(this) 1904 .append("country", country) 1905 .append("name", name) 1906 .append("description", description) 1907 .toString(); 1908 } 1909 } 1910 1911 public static interface RefObject 1912 { 1913 Integer getId(); 1914 void setId(Integer id); 1915 String getName(); 1916 void setName(String name); 1917 RefObject getRef(); 1918 void setRef(RefObject ref); 1919 Integer getFkColRef(); 1920 void setFkColRef(Integer id); 1921 } 1922 1923 public static class ObjA implements RefObject 1924 { 1925 Integer id; 1926 String name; 1927 RefObject ref; 1928 Integer fkColRef; 1929 1930 public Integer getId() 1931 { 1932 return id; 1933 } 1934 1935 public void setId(Integer id) 1936 { 1937 this.id = id; 1938 } 1939 1940 public String getName() 1941 { 1942 return name; 1943 } 1944 1945 public void setName(String name) 1946 { 1947 this.name = name; 1948 } 1949 1950 public Integer getFkColRef() 1951 { 1952 return fkColRef; 1953 } 1954 1955 public void setFkColRef(Integer fkColRef) 1956 { 1957 this.fkColRef = fkColRef; 1958 } 1959 1960 public RefObject getRef() 1961 { 1962 return ref; 1963 } 1964 1965 public void setRef(RefObject ref) 1966 { 1967 this.ref = ref; 1968 } 1969 } 1970 1971 public static class ObjB extends ObjA 1972 { 1973 1974 } 1975 1976 public static class ObjC extends ObjA 1977 { 1978 String nameC; 1979 List references; 1980 1981 public String getNameC() 1982 { 1983 return nameC; 1984 } 1985 1986 public void setNameC(String nameC) 1987 { 1988 this.nameC = nameC; 1989 } 1990 1991 public List getReferences() 1992 { 1993 return references; 1994 } 1995 1996 public void setReferences(List references) 1997 { 1998 this.references = references; 1999 } 2000 } 2001} 2002 | Popular Tags |