001 package org.apache.turbine.services.security.torque.om; 002 003 import java.math.BigDecimal; 004 import java.sql.Connection; 005 import java.sql.SQLException; 006 import java.util.ArrayList; 007 import java.util.Date; 008 import java.util.Iterator; 009 import java.util.LinkedList; 010 import java.util.List; 011 012 import org.apache.torque.NoRowsException; 013 import org.apache.torque.TooManyRowsException; 014 import org.apache.torque.Torque; 015 import org.apache.torque.TorqueException; 016 import org.apache.torque.TorqueRuntimeException; 017 import org.apache.torque.map.MapBuilder; 018 import org.apache.torque.map.TableMap; 019 import org.apache.torque.om.DateKey; 020 import org.apache.torque.om.NumberKey; 021 import org.apache.torque.om.StringKey; 022 import org.apache.torque.om.ObjectKey; 023 import org.apache.torque.om.SimpleKey; 024 import org.apache.torque.util.BasePeer; 025 import org.apache.torque.util.Criteria; 026 027 import com.workingdogs.village.DataSetException; 028 import com.workingdogs.village.QueryDataSet; 029 import com.workingdogs.village.Record; 030 031 // Local classes 032 import org.apache.turbine.services.security.torque.om.map.*; 033 034 035 036 037 /** 038 * This class was autogenerated by Torque on: 039 * 040 * [Thu Jun 23 17:25:46 CEST 2011] 041 * 042 */ 043 public abstract class BaseTurbineUserGroupRolePeer 044 extends BasePeer 045 { 046 /** Serial version */ 047 private static final long serialVersionUID = 1308842746584L; 048 049 050 /** the default database name for this class */ 051 public static final String DATABASE_NAME; 052 053 /** the table name for this class */ 054 public static final String TABLE_NAME; 055 056 /** 057 * @return the map builder for this peer 058 * @throws TorqueException Any exceptions caught during processing will be 059 * rethrown wrapped into a TorqueException. 060 * @deprecated Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME) instead 061 */ 062 public static MapBuilder getMapBuilder() 063 throws TorqueException 064 { 065 return Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME); 066 } 067 068 /** the column name for the USER_ID field */ 069 public static final String USER_ID; 070 /** the column name for the GROUP_ID field */ 071 public static final String GROUP_ID; 072 /** the column name for the ROLE_ID field */ 073 public static final String ROLE_ID; 074 075 static 076 { 077 DATABASE_NAME = "default"; 078 TABLE_NAME = "TURBINE_USER_GROUP_ROLE"; 079 080 USER_ID = "TURBINE_USER_GROUP_ROLE.USER_ID"; 081 GROUP_ID = "TURBINE_USER_GROUP_ROLE.GROUP_ID"; 082 ROLE_ID = "TURBINE_USER_GROUP_ROLE.ROLE_ID"; 083 if (Torque.isInit()) 084 { 085 try 086 { 087 Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME); 088 } 089 catch (TorqueException e) 090 { 091 log.error("Could not initialize Peer", e); 092 throw new TorqueRuntimeException(e); 093 } 094 } 095 else 096 { 097 Torque.registerMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME); 098 } 099 } 100 101 /** number of columns for this peer */ 102 public static final int numColumns = 3; 103 104 /** A class that can be returned by this peer. */ 105 protected static final String CLASSNAME_DEFAULT = 106 "org.apache.turbine.services.security.torque.om.TurbineUserGroupRole"; 107 108 /** A class that can be returned by this peer. */ 109 protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT); 110 111 /** 112 * Class object initialization method. 113 * 114 * @param className name of the class to initialize 115 * @return the initialized class 116 */ 117 private static Class initClass(String className) 118 { 119 Class c = null; 120 try 121 { 122 c = Class.forName(className); 123 } 124 catch (Throwable t) 125 { 126 log.error("A FATAL ERROR has occurred which should not " 127 + "have happened under any circumstance. Please notify " 128 + "the Torque developers <torque-dev@db.apache.org> " 129 + "and give as many details as possible (including the error " 130 + "stack trace).", t); 131 132 // Error objects should always be propagated. 133 if (t instanceof Error) 134 { 135 throw (Error) t.fillInStackTrace(); 136 } 137 } 138 return c; 139 } 140 141 /** 142 * Get the list of objects for a ResultSet. Please not that your 143 * resultset MUST return columns in the right order. You can use 144 * getFieldNames() in BaseObject to get the correct sequence. 145 * 146 * @param results the ResultSet 147 * @return the list of objects 148 * @throws TorqueException Any exceptions caught during processing will be 149 * rethrown wrapped into a TorqueException. 150 */ 151 public static List<TurbineUserGroupRole> resultSet2Objects(java.sql.ResultSet results) 152 throws TorqueException 153 { 154 try 155 { 156 QueryDataSet qds = null; 157 List<Record> rows = null; 158 try 159 { 160 qds = new QueryDataSet(results); 161 rows = getSelectResults(qds); 162 } 163 finally 164 { 165 if (qds != null) 166 { 167 qds.close(); 168 } 169 } 170 171 return populateObjects(rows); 172 } 173 catch (SQLException e) 174 { 175 throw new TorqueException(e); 176 } 177 catch (DataSetException e) 178 { 179 throw new TorqueException(e); 180 } 181 } 182 183 184 185 /** 186 * Method to do inserts. 187 * 188 * @param criteria object used to create the INSERT statement. 189 * @throws TorqueException Any exceptions caught during processing will be 190 * rethrown wrapped into a TorqueException. 191 */ 192 public static ObjectKey doInsert(Criteria criteria) 193 throws TorqueException 194 { 195 return BaseTurbineUserGroupRolePeer 196 .doInsert(criteria, (Connection) null); 197 } 198 199 /** 200 * Method to do inserts. This method is to be used during a transaction, 201 * otherwise use the doInsert(Criteria) method. It will take care of 202 * the connection details internally. 203 * 204 * @param criteria object used to create the INSERT statement. 205 * @param con the connection to use 206 * @throws TorqueException Any exceptions caught during processing will be 207 * rethrown wrapped into a TorqueException. 208 */ 209 public static ObjectKey doInsert(Criteria criteria, Connection con) 210 throws TorqueException 211 { 212 correctBooleans(criteria); 213 214 setDbName(criteria); 215 216 if (con == null) 217 { 218 return BasePeer.doInsert(criteria); 219 } 220 else 221 { 222 return BasePeer.doInsert(criteria, con); 223 } 224 } 225 226 /** 227 * Add all the columns needed to create a new object. 228 * 229 * @param criteria object containing the columns to add. 230 * @throws TorqueException Any exceptions caught during processing will be 231 * rethrown wrapped into a TorqueException. 232 */ 233 public static void addSelectColumns(Criteria criteria) 234 throws TorqueException 235 { 236 criteria.addSelectColumn(USER_ID); 237 criteria.addSelectColumn(GROUP_ID); 238 criteria.addSelectColumn(ROLE_ID); 239 } 240 241 /** 242 * changes the boolean values in the criteria to the appropriate type, 243 * whenever a booleanchar or booleanint column is involved. 244 * This enables the user to create criteria using Boolean values 245 * for booleanchar or booleanint columns 246 * @param criteria the criteria in which the boolean values should be corrected 247 * @throws TorqueException if the database map for the criteria cannot be 248 obtained. 249 */ 250 public static void correctBooleans(Criteria criteria) throws TorqueException 251 { 252 correctBooleans(criteria, getTableMap()); 253 } 254 255 /** 256 * Create a new object of type cls from a resultset row starting 257 * from a specified offset. This is done so that you can select 258 * other rows than just those needed for this object. You may 259 * for example want to create two objects from the same row. 260 * 261 * @throws TorqueException Any exceptions caught during processing will be 262 * rethrown wrapped into a TorqueException. 263 */ 264 public static TurbineUserGroupRole row2Object(Record row, 265 int offset, 266 Class cls) 267 throws TorqueException 268 { 269 try 270 { 271 TurbineUserGroupRole obj = (TurbineUserGroupRole) cls.newInstance(); 272 TurbineUserGroupRolePeer.populateObject(row, offset, obj); 273 obj.setModified(false); 274 obj.setNew(false); 275 276 return obj; 277 } 278 catch (InstantiationException e) 279 { 280 throw new TorqueException(e); 281 } 282 catch (IllegalAccessException e) 283 { 284 throw new TorqueException(e); 285 } 286 } 287 288 /** 289 * Populates an object from a resultset row starting 290 * from a specified offset. This is done so that you can select 291 * other rows than just those needed for this object. You may 292 * for example want to create two objects from the same row. 293 * 294 * @throws TorqueException Any exceptions caught during processing will be 295 * rethrown wrapped into a TorqueException. 296 */ 297 public static void populateObject(Record row, 298 int offset, 299 TurbineUserGroupRole obj) 300 throws TorqueException 301 { 302 try 303 { 304 obj.setUserId(row.getValue(offset + 0).asInt()); 305 obj.setGroupId(row.getValue(offset + 1).asInt()); 306 obj.setRoleId(row.getValue(offset + 2).asInt()); 307 } 308 catch (DataSetException e) 309 { 310 throw new TorqueException(e); 311 } 312 } 313 314 /** 315 * Method to do selects. 316 * 317 * @param criteria object used to create the SELECT statement. 318 * @return List of selected Objects 319 * @throws TorqueException Any exceptions caught during processing will be 320 * rethrown wrapped into a TorqueException. 321 */ 322 public static List<TurbineUserGroupRole> doSelect(Criteria criteria) throws TorqueException 323 { 324 return populateObjects(doSelectVillageRecords(criteria)); 325 } 326 327 /** 328 * Method to do selects within a transaction. 329 * 330 * @param criteria object used to create the SELECT statement. 331 * @param con the connection to use 332 * @return List of selected Objects 333 * @throws TorqueException Any exceptions caught during processing will be 334 * rethrown wrapped into a TorqueException. 335 */ 336 public static List<TurbineUserGroupRole> doSelect(Criteria criteria, Connection con) 337 throws TorqueException 338 { 339 return populateObjects(doSelectVillageRecords(criteria, con)); 340 } 341 342 /** 343 * Grabs the raw Village records to be formed into objects. 344 * This method handles connections internally. The Record objects 345 * returned by this method should be considered readonly. Do not 346 * alter the data and call save(), your results may vary, but are 347 * certainly likely to result in hard to track MT bugs. 348 * 349 * @throws TorqueException Any exceptions caught during processing will be 350 * rethrown wrapped into a TorqueException. 351 */ 352 public static List<Record> doSelectVillageRecords(Criteria criteria) 353 throws TorqueException 354 { 355 return BaseTurbineUserGroupRolePeer 356 .doSelectVillageRecords(criteria, (Connection) null); 357 } 358 359 /** 360 * Grabs the raw Village records to be formed into objects. 361 * This method should be used for transactions 362 * 363 * @param criteria object used to create the SELECT statement. 364 * @param con the connection to use 365 * @throws TorqueException Any exceptions caught during processing will be 366 * rethrown wrapped into a TorqueException. 367 */ 368 public static List<Record> doSelectVillageRecords(Criteria criteria, Connection con) 369 throws TorqueException 370 { 371 if (criteria.getSelectColumns().size() == 0) 372 { 373 addSelectColumns(criteria); 374 } 375 correctBooleans(criteria); 376 377 setDbName(criteria); 378 379 // BasePeer returns a List of Value (Village) arrays. The array 380 // order follows the order columns were placed in the Select clause. 381 if (con == null) 382 { 383 return BasePeer.doSelect(criteria); 384 } 385 else 386 { 387 return BasePeer.doSelect(criteria, con); 388 } 389 } 390 391 /** 392 * The returned List will contain objects of the default type or 393 * objects that inherit from the default. 394 * 395 * @throws TorqueException Any exceptions caught during processing will be 396 * rethrown wrapped into a TorqueException. 397 */ 398 public static List<TurbineUserGroupRole> populateObjects(List<Record> records) 399 throws TorqueException 400 { 401 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(records.size()); 402 403 // populate the object(s) 404 for (int i = 0; i < records.size(); i++) 405 { 406 Record row = records.get(i); 407 results.add(TurbineUserGroupRolePeer.row2Object(row, 1, 408 TurbineUserGroupRolePeer.getOMClass())); 409 } 410 return results; 411 } 412 413 414 /** 415 * The class that the Peer will make instances of. 416 * If the BO is abstract then you must implement this method 417 * in the BO. 418 * 419 * @throws TorqueException Any exceptions caught during processing will be 420 * rethrown wrapped into a TorqueException. 421 */ 422 public static Class getOMClass() 423 throws TorqueException 424 { 425 return CLASS_DEFAULT; 426 } 427 428 /** 429 * Method to do updates. 430 * 431 * @param criteria object containing data that is used to create the UPDATE 432 * statement. 433 * @throws TorqueException Any exceptions caught during processing will be 434 * rethrown wrapped into a TorqueException. 435 */ 436 public static void doUpdate(Criteria criteria) throws TorqueException 437 { 438 BaseTurbineUserGroupRolePeer 439 .doUpdate(criteria, (Connection) null); 440 } 441 442 /** 443 * Method to do updates. This method is to be used during a transaction, 444 * otherwise use the doUpdate(Criteria) method. It will take care of 445 * the connection details internally. 446 * 447 * @param criteria object containing data that is used to create the UPDATE 448 * statement. 449 * @param con the connection to use 450 * @throws TorqueException Any exceptions caught during processing will be 451 * rethrown wrapped into a TorqueException. 452 */ 453 public static void doUpdate(Criteria criteria, Connection con) 454 throws TorqueException 455 { 456 Criteria selectCriteria = new Criteria(DATABASE_NAME, 2); 457 correctBooleans(criteria); 458 459 460 selectCriteria.put(USER_ID, criteria.remove(USER_ID)); 461 462 selectCriteria.put(GROUP_ID, criteria.remove(GROUP_ID)); 463 464 selectCriteria.put(ROLE_ID, criteria.remove(ROLE_ID)); 465 466 setDbName(criteria); 467 468 if (con == null) 469 { 470 BasePeer.doUpdate(selectCriteria, criteria); 471 } 472 else 473 { 474 BasePeer.doUpdate(selectCriteria, criteria, con); 475 } 476 } 477 478 /** 479 * Method to do deletes. 480 * 481 * @param criteria object containing data that is used DELETE from database. 482 * @throws TorqueException Any exceptions caught during processing will be 483 * rethrown wrapped into a TorqueException. 484 */ 485 public static void doDelete(Criteria criteria) throws TorqueException 486 { 487 TurbineUserGroupRolePeer 488 .doDelete(criteria, (Connection) null); 489 } 490 491 /** 492 * Method to do deletes. This method is to be used during a transaction, 493 * otherwise use the doDelete(Criteria) method. It will take care of 494 * the connection details internally. 495 * 496 * @param criteria object containing data that is used DELETE from database. 497 * @param con the connection to use 498 * @throws TorqueException Any exceptions caught during processing will be 499 * rethrown wrapped into a TorqueException. 500 */ 501 public static void doDelete(Criteria criteria, Connection con) 502 throws TorqueException 503 { 504 correctBooleans(criteria); 505 506 setDbName(criteria); 507 508 if (con == null) 509 { 510 BasePeer.doDelete(criteria, TABLE_NAME); 511 } 512 else 513 { 514 BasePeer.doDelete(criteria, TABLE_NAME, con); 515 } 516 } 517 518 /** 519 * Method to do selects 520 * 521 * @throws TorqueException Any exceptions caught during processing will be 522 * rethrown wrapped into a TorqueException. 523 */ 524 public static List<TurbineUserGroupRole> doSelect(TurbineUserGroupRole obj) throws TorqueException 525 { 526 return doSelect(buildSelectCriteria(obj)); 527 } 528 529 /** 530 * Method to do inserts 531 * 532 * @throws TorqueException Any exceptions caught during processing will be 533 * rethrown wrapped into a TorqueException. 534 */ 535 public static void doInsert(TurbineUserGroupRole obj) throws TorqueException 536 { 537 doInsert(buildCriteria(obj)); 538 obj.setNew(false); 539 obj.setModified(false); 540 } 541 542 /** 543 * @param obj the data object to update in the database. 544 * @throws TorqueException Any exceptions caught during processing will be 545 * rethrown wrapped into a TorqueException. 546 */ 547 public static void doUpdate(TurbineUserGroupRole obj) throws TorqueException 548 { 549 doUpdate(buildCriteria(obj)); 550 obj.setModified(false); 551 } 552 553 /** 554 * @param obj the data object to delete in the database. 555 * @throws TorqueException Any exceptions caught during processing will be 556 * rethrown wrapped into a TorqueException. 557 */ 558 public static void doDelete(TurbineUserGroupRole obj) throws TorqueException 559 { 560 doDelete(buildSelectCriteria(obj)); 561 } 562 563 /** 564 * Method to do inserts. This method is to be used during a transaction, 565 * otherwise use the doInsert(TurbineUserGroupRole) method. It will take 566 * care of the connection details internally. 567 * 568 * @param obj the data object to insert into the database. 569 * @param con the connection to use 570 * @throws TorqueException Any exceptions caught during processing will be 571 * rethrown wrapped into a TorqueException. 572 */ 573 public static void doInsert(TurbineUserGroupRole obj, Connection con) 574 throws TorqueException 575 { 576 doInsert(buildCriteria(obj), con); 577 obj.setNew(false); 578 obj.setModified(false); 579 } 580 581 /** 582 * Method to do update. This method is to be used during a transaction, 583 * otherwise use the doUpdate(TurbineUserGroupRole) method. It will take 584 * care of the connection details internally. 585 * 586 * @param obj the data object to update in the database. 587 * @param con the connection to use 588 * @throws TorqueException Any exceptions caught during processing will be 589 * rethrown wrapped into a TorqueException. 590 */ 591 public static void doUpdate(TurbineUserGroupRole obj, Connection con) 592 throws TorqueException 593 { 594 doUpdate(buildCriteria(obj), con); 595 obj.setModified(false); 596 } 597 598 /** 599 * Method to delete. This method is to be used during a transaction, 600 * otherwise use the doDelete(TurbineUserGroupRole) method. It will take 601 * care of the connection details internally. 602 * 603 * @param obj the data object to delete in the database. 604 * @param con the connection to use 605 * @throws TorqueException Any exceptions caught during processing will be 606 * rethrown wrapped into a TorqueException. 607 */ 608 public static void doDelete(TurbineUserGroupRole obj, Connection con) 609 throws TorqueException 610 { 611 doDelete(buildSelectCriteria(obj), con); 612 } 613 614 /** 615 * Method to do deletes. 616 * 617 * @param pk ObjectKey that is used DELETE from database. 618 * @throws TorqueException Any exceptions caught during processing will be 619 * rethrown wrapped into a TorqueException. 620 */ 621 public static void doDelete(ObjectKey pk) throws TorqueException 622 { 623 BaseTurbineUserGroupRolePeer 624 .doDelete(pk, (Connection) null); 625 } 626 627 /** 628 * Method to delete. This method is to be used during a transaction, 629 * otherwise use the doDelete(ObjectKey) method. It will take 630 * care of the connection details internally. 631 * 632 * @param pk the primary key for the object to delete in the database. 633 * @param con the connection to use 634 * @throws TorqueException Any exceptions caught during processing will be 635 * rethrown wrapped into a TorqueException. 636 */ 637 public static void doDelete(ObjectKey pk, Connection con) 638 throws TorqueException 639 { 640 doDelete(buildCriteria(pk), con); 641 } 642 643 /** Build a Criteria object from an ObjectKey */ 644 public static Criteria buildCriteria( ObjectKey pk ) 645 { 646 Criteria criteria = new Criteria(); 647 SimpleKey[] keys = (SimpleKey[])pk.getValue(); 648 criteria.add(USER_ID, keys[0]); 649 criteria.add(GROUP_ID, keys[1]); 650 criteria.add(ROLE_ID, keys[2]); 651 return criteria; 652 } 653 654 /** Build a Criteria object from the data object for this peer */ 655 public static Criteria buildCriteria( TurbineUserGroupRole obj ) 656 { 657 Criteria criteria = new Criteria(DATABASE_NAME); 658 criteria.add(USER_ID, obj.getUserId()); 659 criteria.add(GROUP_ID, obj.getGroupId()); 660 criteria.add(ROLE_ID, obj.getRoleId()); 661 return criteria; 662 } 663 664 /** Build a Criteria object from the data object for this peer, skipping all binary columns */ 665 public static Criteria buildSelectCriteria( TurbineUserGroupRole obj ) 666 { 667 Criteria criteria = new Criteria(DATABASE_NAME); 668 criteria.add(USER_ID, obj.getUserId()); 669 criteria.add(GROUP_ID, obj.getGroupId()); 670 criteria.add(ROLE_ID, obj.getRoleId()); 671 return criteria; 672 } 673 674 675 676 /** 677 * Retrieve a single object by pk 678 * 679 * @param pk the primary key 680 * @throws TorqueException Any exceptions caught during processing will be 681 * rethrown wrapped into a TorqueException. 682 * @throws NoRowsException Primary key was not found in database. 683 * @throws TooManyRowsException Primary key was not found in database. 684 */ 685 public static TurbineUserGroupRole retrieveByPK(ObjectKey pk) 686 throws TorqueException, NoRowsException, TooManyRowsException 687 { 688 Connection db = null; 689 TurbineUserGroupRole retVal = null; 690 try 691 { 692 db = Torque.getConnection(DATABASE_NAME); 693 retVal = retrieveByPK(pk, db); 694 } 695 finally 696 { 697 Torque.closeConnection(db); 698 } 699 return retVal; 700 } 701 702 /** 703 * Retrieve a single object by pk 704 * 705 * @param pk the primary key 706 * @param con the connection to use 707 * @throws TorqueException Any exceptions caught during processing will be 708 * rethrown wrapped into a TorqueException. 709 * @throws NoRowsException Primary key was not found in database. 710 * @throws TooManyRowsException Primary key was not found in database. 711 */ 712 public static TurbineUserGroupRole retrieveByPK(ObjectKey pk, Connection con) 713 throws TorqueException, NoRowsException, TooManyRowsException 714 { 715 Criteria criteria = buildCriteria(pk); 716 List<TurbineUserGroupRole> v = doSelect(criteria, con); 717 if (v.size() == 0) 718 { 719 throw new NoRowsException("Failed to select a row."); 720 } 721 else if (v.size() > 1) 722 { 723 throw new TooManyRowsException("Failed to select only one row."); 724 } 725 else 726 { 727 return (TurbineUserGroupRole)v.get(0); 728 } 729 } 730 731 /** 732 * Retrieve a multiple objects by pk 733 * 734 * @param pks List of primary keys 735 * @throws TorqueException Any exceptions caught during processing will be 736 * rethrown wrapped into a TorqueException. 737 */ 738 public static List<TurbineUserGroupRole> retrieveByPKs(List<ObjectKey> pks) 739 throws TorqueException 740 { 741 Connection db = null; 742 List<TurbineUserGroupRole> retVal = null; 743 try 744 { 745 db = Torque.getConnection(DATABASE_NAME); 746 retVal = retrieveByPKs(pks, db); 747 } 748 finally 749 { 750 Torque.closeConnection(db); 751 } 752 return retVal; 753 } 754 755 /** 756 * Retrieve a multiple objects by pk 757 * 758 * @param pks List of primary keys 759 * @param dbcon the connection to use 760 * @throws TorqueException Any exceptions caught during processing will be 761 * rethrown wrapped into a TorqueException. 762 */ 763 public static List<TurbineUserGroupRole> retrieveByPKs( List<ObjectKey> pks, Connection dbcon ) 764 throws TorqueException 765 { 766 List<TurbineUserGroupRole> objs = null; 767 if (pks == null || pks.size() == 0) 768 { 769 objs = new LinkedList<TurbineUserGroupRole>(); 770 } 771 else 772 { 773 Criteria criteria = new Criteria(); 774 Iterator<ObjectKey> iter = pks.iterator(); 775 while (iter.hasNext()) 776 { 777 ObjectKey pk = iter.next(); 778 SimpleKey[] keys = (SimpleKey[])pk.getValue(); 779 Criteria.Criterion c0 = criteria.getNewCriterion( 780 USER_ID, keys[0], Criteria.EQUAL); 781 Criteria.Criterion c1 = criteria.getNewCriterion( 782 GROUP_ID, keys[1], Criteria.EQUAL); 783 c0.and(c1); 784 Criteria.Criterion c2 = criteria.getNewCriterion( 785 ROLE_ID, keys[2], Criteria.EQUAL); 786 c1.and(c2); 787 criteria.or(c0); 788 } 789 objs = doSelect(criteria, dbcon); 790 } 791 return objs; 792 } 793 794 795 /** 796 * retrieve object using using pk values. 797 * 798 * @param userId int 799 * @param groupId int 800 * @param roleId int 801 */ 802 public static TurbineUserGroupRole retrieveByPK( 803 int userId 804 , int groupId 805 , int roleId 806 ) throws TorqueException 807 { 808 Connection db = null; 809 TurbineUserGroupRole retVal = null; 810 try 811 { 812 db = Torque.getConnection(DATABASE_NAME); 813 retVal = retrieveByPK( 814 userId 815 , groupId 816 , roleId 817 , db); 818 } 819 finally 820 { 821 Torque.closeConnection(db); 822 } 823 return retVal; 824 } 825 826 /** 827 * retrieve object using using pk values. 828 * 829 * @param userId int 830 * @param groupId int 831 * @param roleId int 832 * @param con Connection 833 */ 834 public static TurbineUserGroupRole retrieveByPK( 835 int userId 836 , int groupId 837 , int roleId 838 ,Connection con) throws TorqueException 839 { 840 841 Criteria criteria = new Criteria(5); 842 criteria.add(USER_ID, userId); 843 criteria.add(GROUP_ID, groupId); 844 criteria.add(ROLE_ID, roleId); 845 List<TurbineUserGroupRole> v = doSelect(criteria, con); 846 if (v.size() == 1) 847 { 848 return v.get(0); 849 } 850 else 851 { 852 throw new TorqueException("Failed to select one and only one row."); 853 } 854 } 855 856 857 858 859 860 861 862 863 /** 864 * selects a collection of TurbineUserGroupRole objects pre-filled with their 865 * TurbineUser objects. 866 * 867 * This method is protected by default in order to keep the public 868 * api reasonable. You can provide public methods for those you 869 * actually need in TurbineUserGroupRolePeer. 870 * 871 * @throws TorqueException Any exceptions caught during processing will be 872 * rethrown wrapped into a TorqueException. 873 */ 874 protected static List<TurbineUserGroupRole> doSelectJoinTurbineUser(Criteria criteria) 875 throws TorqueException 876 { 877 return doSelectJoinTurbineUser(criteria, null); 878 } 879 880 /** 881 * selects a collection of TurbineUserGroupRole objects pre-filled with their 882 * TurbineUser objects. 883 * 884 * This method is protected by default in order to keep the public 885 * api reasonable. You can provide public methods for those you 886 * actually need in TurbineUserGroupRolePeer. 887 * 888 * @throws TorqueException Any exceptions caught during processing will be 889 * rethrown wrapped into a TorqueException. 890 */ 891 protected static List<TurbineUserGroupRole> doSelectJoinTurbineUser(Criteria criteria, Connection conn) 892 throws TorqueException 893 { 894 setDbName(criteria); 895 896 TurbineUserGroupRolePeer.addSelectColumns(criteria); 897 int offset = numColumns + 1; 898 TurbineUserPeer.addSelectColumns(criteria); 899 900 criteria.addJoin(TurbineUserGroupRolePeer.USER_ID, 901 TurbineUserPeer.USER_ID); 902 903 correctBooleans(criteria); 904 905 List<Record> rows; 906 if (conn == null) 907 { 908 rows = BasePeer.doSelect(criteria); 909 } 910 else 911 { 912 rows = BasePeer.doSelect(criteria,conn); 913 } 914 915 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 916 917 for (int i = 0; i < rows.size(); i++) 918 { 919 Record row = rows.get(i); 920 921 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 922 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 923 .row2Object(row, 1, omClass); 924 omClass = TurbineUserPeer.getOMClass(); 925 TurbineUser obj2 = (TurbineUser) TurbineUserPeer 926 .row2Object(row, offset, omClass); 927 928 boolean newObject = true; 929 for (int j = 0; j < results.size(); j++) 930 { 931 TurbineUserGroupRole temp_obj1 = results.get(j); 932 TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser(); 933 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 934 { 935 newObject = false; 936 temp_obj2.addTurbineUserGroupRole(obj1); 937 break; 938 } 939 } 940 if (newObject) 941 { 942 obj2.initTurbineUserGroupRoles(); 943 obj2.addTurbineUserGroupRole(obj1); 944 } 945 results.add(obj1); 946 } 947 return results; 948 } 949 950 951 952 953 /** 954 * selects a collection of TurbineUserGroupRole objects pre-filled with their 955 * TurbineGroup objects. 956 * 957 * This method is protected by default in order to keep the public 958 * api reasonable. You can provide public methods for those you 959 * actually need in TurbineUserGroupRolePeer. 960 * 961 * @throws TorqueException Any exceptions caught during processing will be 962 * rethrown wrapped into a TorqueException. 963 */ 964 protected static List<TurbineUserGroupRole> doSelectJoinTurbineGroup(Criteria criteria) 965 throws TorqueException 966 { 967 return doSelectJoinTurbineGroup(criteria, null); 968 } 969 970 /** 971 * selects a collection of TurbineUserGroupRole objects pre-filled with their 972 * TurbineGroup objects. 973 * 974 * This method is protected by default in order to keep the public 975 * api reasonable. You can provide public methods for those you 976 * actually need in TurbineUserGroupRolePeer. 977 * 978 * @throws TorqueException Any exceptions caught during processing will be 979 * rethrown wrapped into a TorqueException. 980 */ 981 protected static List<TurbineUserGroupRole> doSelectJoinTurbineGroup(Criteria criteria, Connection conn) 982 throws TorqueException 983 { 984 setDbName(criteria); 985 986 TurbineUserGroupRolePeer.addSelectColumns(criteria); 987 int offset = numColumns + 1; 988 TurbineGroupPeer.addSelectColumns(criteria); 989 990 criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID, 991 TurbineGroupPeer.GROUP_ID); 992 993 correctBooleans(criteria); 994 995 List<Record> rows; 996 if (conn == null) 997 { 998 rows = BasePeer.doSelect(criteria); 999 } 1000 else 1001 { 1002 rows = BasePeer.doSelect(criteria,conn); 1003 } 1004 1005 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 1006 1007 for (int i = 0; i < rows.size(); i++) 1008 { 1009 Record row = rows.get(i); 1010 1011 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 1012 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 1013 .row2Object(row, 1, omClass); 1014 omClass = TurbineGroupPeer.getOMClass(); 1015 TurbineGroup obj2 = (TurbineGroup) TurbineGroupPeer 1016 .row2Object(row, offset, omClass); 1017 1018 boolean newObject = true; 1019 for (int j = 0; j < results.size(); j++) 1020 { 1021 TurbineUserGroupRole temp_obj1 = results.get(j); 1022 TurbineGroup temp_obj2 = (TurbineGroup) temp_obj1.getTurbineGroup(); 1023 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 1024 { 1025 newObject = false; 1026 temp_obj2.addTurbineUserGroupRole(obj1); 1027 break; 1028 } 1029 } 1030 if (newObject) 1031 { 1032 obj2.initTurbineUserGroupRoles(); 1033 obj2.addTurbineUserGroupRole(obj1); 1034 } 1035 results.add(obj1); 1036 } 1037 return results; 1038 } 1039 1040 1041 1042 1043 /** 1044 * selects a collection of TurbineUserGroupRole objects pre-filled with their 1045 * TurbineRole objects. 1046 * 1047 * This method is protected by default in order to keep the public 1048 * api reasonable. You can provide public methods for those you 1049 * actually need in TurbineUserGroupRolePeer. 1050 * 1051 * @throws TorqueException Any exceptions caught during processing will be 1052 * rethrown wrapped into a TorqueException. 1053 */ 1054 protected static List<TurbineUserGroupRole> doSelectJoinTurbineRole(Criteria criteria) 1055 throws TorqueException 1056 { 1057 return doSelectJoinTurbineRole(criteria, null); 1058 } 1059 1060 /** 1061 * selects a collection of TurbineUserGroupRole objects pre-filled with their 1062 * TurbineRole objects. 1063 * 1064 * This method is protected by default in order to keep the public 1065 * api reasonable. You can provide public methods for those you 1066 * actually need in TurbineUserGroupRolePeer. 1067 * 1068 * @throws TorqueException Any exceptions caught during processing will be 1069 * rethrown wrapped into a TorqueException. 1070 */ 1071 protected static List<TurbineUserGroupRole> doSelectJoinTurbineRole(Criteria criteria, Connection conn) 1072 throws TorqueException 1073 { 1074 setDbName(criteria); 1075 1076 TurbineUserGroupRolePeer.addSelectColumns(criteria); 1077 int offset = numColumns + 1; 1078 TurbineRolePeer.addSelectColumns(criteria); 1079 1080 criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID, 1081 TurbineRolePeer.ROLE_ID); 1082 1083 correctBooleans(criteria); 1084 1085 List<Record> rows; 1086 if (conn == null) 1087 { 1088 rows = BasePeer.doSelect(criteria); 1089 } 1090 else 1091 { 1092 rows = BasePeer.doSelect(criteria,conn); 1093 } 1094 1095 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 1096 1097 for (int i = 0; i < rows.size(); i++) 1098 { 1099 Record row = rows.get(i); 1100 1101 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 1102 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 1103 .row2Object(row, 1, omClass); 1104 omClass = TurbineRolePeer.getOMClass(); 1105 TurbineRole obj2 = (TurbineRole) TurbineRolePeer 1106 .row2Object(row, offset, omClass); 1107 1108 boolean newObject = true; 1109 for (int j = 0; j < results.size(); j++) 1110 { 1111 TurbineUserGroupRole temp_obj1 = results.get(j); 1112 TurbineRole temp_obj2 = (TurbineRole) temp_obj1.getTurbineRole(); 1113 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 1114 { 1115 newObject = false; 1116 temp_obj2.addTurbineUserGroupRole(obj1); 1117 break; 1118 } 1119 } 1120 if (newObject) 1121 { 1122 obj2.initTurbineUserGroupRoles(); 1123 obj2.addTurbineUserGroupRole(obj1); 1124 } 1125 results.add(obj1); 1126 } 1127 return results; 1128 } 1129 1130 1131 1132 1133 1134 1135 1136 /** 1137 * selects a collection of TurbineUserGroupRole objects pre-filled with 1138 * all related objects. 1139 * 1140 * This method is protected by default in order to keep the public 1141 * api reasonable. You can provide public methods for those you 1142 * actually need in TurbineUserGroupRolePeer. 1143 * 1144 * @throws TorqueException Any exceptions caught during processing will be 1145 * rethrown wrapped into a TorqueException. 1146 */ 1147 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineUser(Criteria criteria) 1148 throws TorqueException 1149 { 1150 return doSelectJoinAllExceptTurbineUser(criteria, null); 1151 } 1152 1153 /** 1154 * selects a collection of TurbineUserGroupRole objects pre-filled with 1155 * all related objects. 1156 * 1157 * This method is protected by default in order to keep the public 1158 * api reasonable. You can provide public methods for those you 1159 * actually need in TurbineUserGroupRolePeer. 1160 * 1161 * @throws TorqueException Any exceptions caught during processing will be 1162 * rethrown wrapped into a TorqueException. 1163 */ 1164 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineUser(Criteria criteria, Connection conn) 1165 throws TorqueException 1166 { 1167 setDbName(criteria); 1168 1169 addSelectColumns(criteria); 1170 int offset2 = numColumns + 1; 1171 1172 1173 TurbineGroupPeer.addSelectColumns(criteria); 1174 criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID, TurbineGroupPeer.GROUP_ID); 1175 int offset3 = offset2 + TurbineGroupPeer.numColumns; 1176 1177 TurbineRolePeer.addSelectColumns(criteria); 1178 criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePeer.ROLE_ID); 1179 1180 correctBooleans(criteria); 1181 1182 List<Record> rows; 1183 if (conn == null) 1184 { 1185 rows = BasePeer.doSelect(criteria); 1186 } 1187 else 1188 { 1189 rows = BasePeer.doSelect(criteria,conn); 1190 } 1191 1192 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 1193 1194 for (int i = 0; i < rows.size(); i++) 1195 { 1196 Record row = rows.get(i); 1197 1198 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 1199 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 1200 .row2Object(row, 1, omClass); 1201 1202 1203 1204 1205 1206 omClass = TurbineGroupPeer.getOMClass(); 1207 TurbineGroup obj2 = (TurbineGroup) TurbineGroupPeer 1208 .row2Object( row, offset2, omClass); 1209 1210 boolean newObject = true; 1211 for (int j = 0; j < results.size(); j++) 1212 { 1213 TurbineUserGroupRole temp_obj1 = results.get(j); 1214 TurbineGroup temp_obj2 = (TurbineGroup) temp_obj1.getTurbineGroup(); 1215 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 1216 { 1217 newObject = false; 1218 temp_obj2.addTurbineUserGroupRole(obj1); 1219 break; 1220 } 1221 } 1222 if (newObject) 1223 { 1224 obj2.initTurbineUserGroupRoles(); 1225 obj2.addTurbineUserGroupRole(obj1); 1226 } 1227 1228 1229 1230 1231 omClass = TurbineRolePeer.getOMClass(); 1232 TurbineRole obj3 = (TurbineRole) TurbineRolePeer 1233 .row2Object( row, offset3, omClass); 1234 1235 newObject = true; 1236 for (int j = 0; j < results.size(); j++) 1237 { 1238 TurbineUserGroupRole temp_obj1 = results.get(j); 1239 TurbineRole temp_obj3 = (TurbineRole) temp_obj1.getTurbineRole(); 1240 if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey())) 1241 { 1242 newObject = false; 1243 temp_obj3.addTurbineUserGroupRole(obj1); 1244 break; 1245 } 1246 } 1247 if (newObject) 1248 { 1249 obj3.initTurbineUserGroupRoles(); 1250 obj3.addTurbineUserGroupRole(obj1); 1251 } 1252 results.add(obj1); 1253 } 1254 return results; 1255 } 1256 1257 1258 1259 1260 /** 1261 * selects a collection of TurbineUserGroupRole objects pre-filled with 1262 * all related objects. 1263 * 1264 * This method is protected by default in order to keep the public 1265 * api reasonable. You can provide public methods for those you 1266 * actually need in TurbineUserGroupRolePeer. 1267 * 1268 * @throws TorqueException Any exceptions caught during processing will be 1269 * rethrown wrapped into a TorqueException. 1270 */ 1271 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineGroup(Criteria criteria) 1272 throws TorqueException 1273 { 1274 return doSelectJoinAllExceptTurbineGroup(criteria, null); 1275 } 1276 1277 /** 1278 * selects a collection of TurbineUserGroupRole objects pre-filled with 1279 * all related objects. 1280 * 1281 * This method is protected by default in order to keep the public 1282 * api reasonable. You can provide public methods for those you 1283 * actually need in TurbineUserGroupRolePeer. 1284 * 1285 * @throws TorqueException Any exceptions caught during processing will be 1286 * rethrown wrapped into a TorqueException. 1287 */ 1288 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineGroup(Criteria criteria, Connection conn) 1289 throws TorqueException 1290 { 1291 setDbName(criteria); 1292 1293 addSelectColumns(criteria); 1294 int offset2 = numColumns + 1; 1295 1296 TurbineUserPeer.addSelectColumns(criteria); 1297 criteria.addJoin(TurbineUserGroupRolePeer.USER_ID, TurbineUserPeer.USER_ID); 1298 int offset3 = offset2 + TurbineUserPeer.numColumns; 1299 1300 1301 TurbineRolePeer.addSelectColumns(criteria); 1302 criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePeer.ROLE_ID); 1303 1304 correctBooleans(criteria); 1305 1306 List<Record> rows; 1307 if (conn == null) 1308 { 1309 rows = BasePeer.doSelect(criteria); 1310 } 1311 else 1312 { 1313 rows = BasePeer.doSelect(criteria,conn); 1314 } 1315 1316 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 1317 1318 for (int i = 0; i < rows.size(); i++) 1319 { 1320 Record row = rows.get(i); 1321 1322 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 1323 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 1324 .row2Object(row, 1, omClass); 1325 1326 1327 1328 1329 omClass = TurbineUserPeer.getOMClass(); 1330 TurbineUser obj2 = (TurbineUser) TurbineUserPeer 1331 .row2Object( row, offset2, omClass); 1332 1333 boolean newObject = true; 1334 for (int j = 0; j < results.size(); j++) 1335 { 1336 TurbineUserGroupRole temp_obj1 = results.get(j); 1337 TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser(); 1338 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 1339 { 1340 newObject = false; 1341 temp_obj2.addTurbineUserGroupRole(obj1); 1342 break; 1343 } 1344 } 1345 if (newObject) 1346 { 1347 obj2.initTurbineUserGroupRoles(); 1348 obj2.addTurbineUserGroupRole(obj1); 1349 } 1350 1351 1352 1353 1354 1355 omClass = TurbineRolePeer.getOMClass(); 1356 TurbineRole obj3 = (TurbineRole) TurbineRolePeer 1357 .row2Object( row, offset3, omClass); 1358 1359 newObject = true; 1360 for (int j = 0; j < results.size(); j++) 1361 { 1362 TurbineUserGroupRole temp_obj1 = results.get(j); 1363 TurbineRole temp_obj3 = (TurbineRole) temp_obj1.getTurbineRole(); 1364 if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey())) 1365 { 1366 newObject = false; 1367 temp_obj3.addTurbineUserGroupRole(obj1); 1368 break; 1369 } 1370 } 1371 if (newObject) 1372 { 1373 obj3.initTurbineUserGroupRoles(); 1374 obj3.addTurbineUserGroupRole(obj1); 1375 } 1376 results.add(obj1); 1377 } 1378 return results; 1379 } 1380 1381 1382 1383 1384 /** 1385 * selects a collection of TurbineUserGroupRole objects pre-filled with 1386 * all related objects. 1387 * 1388 * This method is protected by default in order to keep the public 1389 * api reasonable. You can provide public methods for those you 1390 * actually need in TurbineUserGroupRolePeer. 1391 * 1392 * @throws TorqueException Any exceptions caught during processing will be 1393 * rethrown wrapped into a TorqueException. 1394 */ 1395 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineRole(Criteria criteria) 1396 throws TorqueException 1397 { 1398 return doSelectJoinAllExceptTurbineRole(criteria, null); 1399 } 1400 1401 /** 1402 * selects a collection of TurbineUserGroupRole objects pre-filled with 1403 * all related objects. 1404 * 1405 * This method is protected by default in order to keep the public 1406 * api reasonable. You can provide public methods for those you 1407 * actually need in TurbineUserGroupRolePeer. 1408 * 1409 * @throws TorqueException Any exceptions caught during processing will be 1410 * rethrown wrapped into a TorqueException. 1411 */ 1412 protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineRole(Criteria criteria, Connection conn) 1413 throws TorqueException 1414 { 1415 setDbName(criteria); 1416 1417 addSelectColumns(criteria); 1418 int offset2 = numColumns + 1; 1419 1420 TurbineUserPeer.addSelectColumns(criteria); 1421 criteria.addJoin(TurbineUserGroupRolePeer.USER_ID, TurbineUserPeer.USER_ID); 1422 int offset3 = offset2 + TurbineUserPeer.numColumns; 1423 1424 TurbineGroupPeer.addSelectColumns(criteria); 1425 criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID, TurbineGroupPeer.GROUP_ID); 1426 1427 1428 correctBooleans(criteria); 1429 1430 List<Record> rows; 1431 if (conn == null) 1432 { 1433 rows = BasePeer.doSelect(criteria); 1434 } 1435 else 1436 { 1437 rows = BasePeer.doSelect(criteria,conn); 1438 } 1439 1440 List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(); 1441 1442 for (int i = 0; i < rows.size(); i++) 1443 { 1444 Record row = rows.get(i); 1445 1446 Class omClass = TurbineUserGroupRolePeer.getOMClass(); 1447 TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer 1448 .row2Object(row, 1, omClass); 1449 1450 1451 1452 1453 omClass = TurbineUserPeer.getOMClass(); 1454 TurbineUser obj2 = (TurbineUser) TurbineUserPeer 1455 .row2Object( row, offset2, omClass); 1456 1457 boolean newObject = true; 1458 for (int j = 0; j < results.size(); j++) 1459 { 1460 TurbineUserGroupRole temp_obj1 = results.get(j); 1461 TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser(); 1462 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey())) 1463 { 1464 newObject = false; 1465 temp_obj2.addTurbineUserGroupRole(obj1); 1466 break; 1467 } 1468 } 1469 if (newObject) 1470 { 1471 obj2.initTurbineUserGroupRoles(); 1472 obj2.addTurbineUserGroupRole(obj1); 1473 } 1474 1475 1476 1477 1478 omClass = TurbineGroupPeer.getOMClass(); 1479 TurbineGroup obj3 = (TurbineGroup) TurbineGroupPeer 1480 .row2Object( row, offset3, omClass); 1481 1482 newObject = true; 1483 for (int j = 0; j < results.size(); j++) 1484 { 1485 TurbineUserGroupRole temp_obj1 = results.get(j); 1486 TurbineGroup temp_obj3 = (TurbineGroup) temp_obj1.getTurbineGroup(); 1487 if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey())) 1488 { 1489 newObject = false; 1490 temp_obj3.addTurbineUserGroupRole(obj1); 1491 break; 1492 } 1493 } 1494 if (newObject) 1495 { 1496 obj3.initTurbineUserGroupRoles(); 1497 obj3.addTurbineUserGroupRole(obj1); 1498 } 1499 1500 results.add(obj1); 1501 } 1502 return results; 1503 } 1504 1505 1506 /** 1507 * Returns the TableMap related to this peer. 1508 * 1509 * @throws TorqueException Any exceptions caught during processing will be 1510 * rethrown wrapped into a TorqueException. 1511 */ 1512 public static TableMap getTableMap() 1513 throws TorqueException 1514 { 1515 return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME); 1516 } 1517 1518 private static void setDbName(Criteria crit) 1519 { 1520 // Set the correct dbName if it has not been overridden 1521 // crit.getDbName will return the same object if not set to 1522 // another value so == check is okay and faster 1523 if (crit.getDbName() == Torque.getDefaultDB()) 1524 { 1525 crit.setDbName(DATABASE_NAME); 1526 } 1527 } 1528 1529 1530 // The following methods wrap some methods in BasePeer 1531 // to have more support for Java5 generic types in the Peer 1532 1533 /** 1534 * Utility method which executes a given sql statement. This 1535 * method should be used for select statements only. Use 1536 * executeStatement for update, insert, and delete operations. 1537 * 1538 * @param queryString A String with the sql statement to execute. 1539 * @return List of Record objects. 1540 * @throws TorqueException Any exceptions caught during processing will be 1541 * rethrown wrapped into a TorqueException. 1542 * @see org.apache.torque.util.BasePeer#executeQuery(String) 1543 */ 1544 public static List<Record> executeQuery(String queryString) throws TorqueException 1545 { 1546 return BasePeer.executeQuery(queryString); 1547 } 1548 1549 /** 1550 * Utility method which executes a given sql statement. This 1551 * method should be used for select statements only. Use 1552 * executeStatement for update, insert, and delete operations. 1553 * 1554 * @param queryString A String with the sql statement to execute. 1555 * @param dbName The database to connect to. 1556 * @return List of Record objects. 1557 * @throws TorqueException Any exceptions caught during processing will be 1558 * rethrown wrapped into a TorqueException. 1559 * @see org.apache.torque.util.BasePeer#executeQuery(String,String) 1560 */ 1561 public static List<Record> executeQuery(String queryString, String dbName) 1562 throws TorqueException 1563 { 1564 return BasePeer.executeQuery(queryString,dbName); 1565 } 1566 1567 1568 /** 1569 * Method for performing a SELECT. Returns all results. 1570 * 1571 * @param queryString A String with the sql statement to execute. 1572 * @param dbName The database to connect to. 1573 * @param singleRecord Whether or not we want to select only a 1574 * single record. 1575 * @return List of Record objects. 1576 * @throws TorqueException Any exceptions caught during processing will be 1577 * rethrown wrapped into a TorqueException. 1578 * @see org.apache.torque.util.BasePeer#executeQuery(String,String,boolean) 1579 */ 1580 public static List<Record> executeQuery( 1581 String queryString, 1582 String dbName, 1583 boolean singleRecord) 1584 throws TorqueException 1585 { 1586 return BasePeer.executeQuery(queryString,dbName,singleRecord); 1587 } 1588 1589 /** 1590 * Method for performing a SELECT. Returns all results. 1591 * 1592 * @param queryString A String with the sql statement to execute. 1593 * @param singleRecord Whether or not we want to select only a 1594 * single record. 1595 * @param con A Connection. 1596 * @return List of Record objects. 1597 * @throws TorqueException Any exceptions caught during processing will be 1598 * rethrown wrapped into a TorqueException. 1599 * @see org.apache.torque.util.BasePeer#executeQuery(String,boolean,Connection) 1600 */ 1601 public static List<Record> executeQuery( 1602 String queryString, 1603 boolean singleRecord, 1604 Connection con) 1605 throws TorqueException 1606 { 1607 return BasePeer.executeQuery(queryString,singleRecord,con); 1608 } 1609 1610 /** 1611 * Method for performing a SELECT. 1612 * 1613 * @param queryString A String with the sql statement to execute. 1614 * @param start The first row to return. 1615 * @param numberOfResults The number of rows to return. 1616 * @param dbName The database to connect to. 1617 * @param singleRecord Whether or not we want to select only a 1618 * single record. 1619 * @return List of Record objects. 1620 * @throws TorqueException Any exceptions caught during processing will be 1621 * rethrown wrapped into a TorqueException. 1622 * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean) 1623 */ 1624 public static List<Record> executeQuery( 1625 String queryString, 1626 int start, 1627 int numberOfResults, 1628 String dbName, 1629 boolean singleRecord) 1630 throws TorqueException 1631 { 1632 return BasePeer.executeQuery(queryString,start,numberOfResults,dbName,singleRecord); 1633 } 1634 1635 /** 1636 * Method for performing a SELECT. Returns all results. 1637 * 1638 * @param queryString A String with the sql statement to execute. 1639 * @param start The first row to return. 1640 * @param numberOfResults The number of rows to return. 1641 * @param singleRecord Whether or not we want to select only a 1642 * single record. 1643 * @param con A Connection. 1644 * @return List of Record objects. 1645 * @throws TorqueException Any exceptions caught during processing will be 1646 * rethrown wrapped into a TorqueException. 1647 * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean,Connection) 1648 */ 1649 public static List<Record> executeQuery( 1650 String queryString, 1651 int start, 1652 int numberOfResults, 1653 boolean singleRecord, 1654 Connection con) 1655 throws TorqueException 1656 { 1657 return BasePeer.executeQuery(queryString,start,numberOfResults,singleRecord,con); 1658 } 1659 1660 /** 1661 * Returns all records in a QueryDataSet as a List of Record 1662 * objects. Used for functionality like util.LargeSelect. 1663 * 1664 * @see #getSelectResults(QueryDataSet, int, int, boolean) 1665 * @param qds the QueryDataSet 1666 * @return a List of Record objects 1667 * @throws TorqueException Any exceptions caught during processing will be 1668 * rethrown wrapped into a TorqueException. 1669 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet) 1670 */ 1671 public static List<Record> getSelectResults(QueryDataSet qds) 1672 throws TorqueException 1673 { 1674 return BasePeer.getSelectResults(qds); 1675 } 1676 1677 /** 1678 * Returns all records in a QueryDataSet as a List of Record 1679 * objects. Used for functionality like util.LargeSelect. 1680 * 1681 * @see #getSelectResults(QueryDataSet, int, int, boolean) 1682 * @param qds the QueryDataSet 1683 * @param singleRecord 1684 * @return a List of Record objects 1685 * @throws TorqueException Any exceptions caught during processing will be 1686 * rethrown wrapped into a TorqueException. 1687 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,boolean) 1688 */ 1689 public static List<Record> getSelectResults(QueryDataSet qds, boolean singleRecord) 1690 throws TorqueException 1691 { 1692 return BasePeer.getSelectResults(qds,singleRecord); 1693 } 1694 1695 /** 1696 * Returns numberOfResults records in a QueryDataSet as a List 1697 * of Record objects. Starting at record 0. Used for 1698 * functionality like util.LargeSelect. 1699 * 1700 * @see #getSelectResults(QueryDataSet, int, int, boolean) 1701 * @param qds the QueryDataSet 1702 * @param numberOfResults 1703 * @param singleRecord 1704 * @return a List of Record objects 1705 * @throws TorqueException Any exceptions caught during processing will be 1706 * rethrown wrapped into a TorqueException. 1707 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,boolean) 1708 */ 1709 public static List<Record> getSelectResults( 1710 QueryDataSet qds, 1711 int numberOfResults, 1712 boolean singleRecord) 1713 throws TorqueException 1714 { 1715 return BasePeer.getSelectResults(qds,numberOfResults,singleRecord); 1716 } 1717 1718 /** 1719 * Returns numberOfResults records in a QueryDataSet as a List 1720 * of Record objects. Starting at record start. Used for 1721 * functionality like util.LargeSelect. 1722 * 1723 * @param qds The <code>QueryDataSet</code> to extract results 1724 * from. 1725 * @param start The index from which to start retrieving 1726 * <code>Record</code> objects from the data set. 1727 * @param numberOfResults The number of results to return (or 1728 * <code> -1</code> for all results). 1729 * @param singleRecord Whether or not we want to select only a 1730 * single record. 1731 * @return A <code>List</code> of <code>Record</code> objects. 1732 * @exception TorqueException If any <code>Exception</code> occurs. 1733 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,int,boolean) 1734 */ 1735 public static List getSelectResults( 1736 QueryDataSet qds, 1737 int start, 1738 int numberOfResults, 1739 boolean singleRecord) 1740 throws TorqueException 1741 { 1742 return BasePeer.getSelectResults(qds,start,numberOfResults,singleRecord); 1743 } 1744 1745 /** 1746 * Performs a SQL <code>select</code> using a PreparedStatement. 1747 * Note: this method does not handle null criteria values. 1748 * 1749 * @param criteria 1750 * @param con 1751 * @return a List of Record objects. 1752 * @throws TorqueException Error performing database query. 1753 * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria,Connection) 1754 */ 1755 public static List<Record> doPSSelect(Criteria criteria, Connection con) 1756 throws TorqueException 1757 { 1758 return BasePeer.doPSSelect(criteria,con); 1759 } 1760 1761 /** 1762 * Do a Prepared Statement select according to the given criteria 1763 * 1764 * @param criteria 1765 * @return a List of Record objects. 1766 * @throws TorqueException Any exceptions caught during processing will be 1767 * rethrown wrapped into a TorqueException. 1768 * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria) 1769 */ 1770 public static List<Record> doPSSelect(Criteria criteria) throws TorqueException 1771 { 1772 return BasePeer.doPSSelect(criteria); 1773 } 1774 }