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 BaseTurbinePermissionPeer 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(TurbinePermissionMapBuilder.CLASS_NAME) instead 061 */ 062 public static MapBuilder getMapBuilder() 063 throws TorqueException 064 { 065 return Torque.getMapBuilder(TurbinePermissionMapBuilder.CLASS_NAME); 066 } 067 068 /** the column name for the PERMISSION_ID field */ 069 public static final String PERMISSION_ID; 070 /** the column name for the PERMISSION_NAME field */ 071 public static final String PERMISSION_NAME; 072 073 static 074 { 075 DATABASE_NAME = "default"; 076 TABLE_NAME = "TURBINE_PERMISSION"; 077 078 PERMISSION_ID = "TURBINE_PERMISSION.PERMISSION_ID"; 079 PERMISSION_NAME = "TURBINE_PERMISSION.PERMISSION_NAME"; 080 if (Torque.isInit()) 081 { 082 try 083 { 084 Torque.getMapBuilder(TurbinePermissionMapBuilder.CLASS_NAME); 085 } 086 catch (TorqueException e) 087 { 088 log.error("Could not initialize Peer", e); 089 throw new TorqueRuntimeException(e); 090 } 091 } 092 else 093 { 094 Torque.registerMapBuilder(TurbinePermissionMapBuilder.CLASS_NAME); 095 } 096 } 097 098 /** number of columns for this peer */ 099 public static final int numColumns = 2; 100 101 /** A class that can be returned by this peer. */ 102 protected static final String CLASSNAME_DEFAULT = 103 "org.apache.turbine.services.security.torque.om.TurbinePermission"; 104 105 /** A class that can be returned by this peer. */ 106 protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT); 107 108 /** 109 * Class object initialization method. 110 * 111 * @param className name of the class to initialize 112 * @return the initialized class 113 */ 114 private static Class initClass(String className) 115 { 116 Class c = null; 117 try 118 { 119 c = Class.forName(className); 120 } 121 catch (Throwable t) 122 { 123 log.error("A FATAL ERROR has occurred which should not " 124 + "have happened under any circumstance. Please notify " 125 + "the Torque developers <torque-dev@db.apache.org> " 126 + "and give as many details as possible (including the error " 127 + "stack trace).", t); 128 129 // Error objects should always be propagated. 130 if (t instanceof Error) 131 { 132 throw (Error) t.fillInStackTrace(); 133 } 134 } 135 return c; 136 } 137 138 /** 139 * Get the list of objects for a ResultSet. Please not that your 140 * resultset MUST return columns in the right order. You can use 141 * getFieldNames() in BaseObject to get the correct sequence. 142 * 143 * @param results the ResultSet 144 * @return the list of objects 145 * @throws TorqueException Any exceptions caught during processing will be 146 * rethrown wrapped into a TorqueException. 147 */ 148 public static List<TurbinePermission> resultSet2Objects(java.sql.ResultSet results) 149 throws TorqueException 150 { 151 try 152 { 153 QueryDataSet qds = null; 154 List<Record> rows = null; 155 try 156 { 157 qds = new QueryDataSet(results); 158 rows = getSelectResults(qds); 159 } 160 finally 161 { 162 if (qds != null) 163 { 164 qds.close(); 165 } 166 } 167 168 return populateObjects(rows); 169 } 170 catch (SQLException e) 171 { 172 throw new TorqueException(e); 173 } 174 catch (DataSetException e) 175 { 176 throw new TorqueException(e); 177 } 178 } 179 180 181 182 /** 183 * Method to do inserts. 184 * 185 * @param criteria object used to create the INSERT statement. 186 * @throws TorqueException Any exceptions caught during processing will be 187 * rethrown wrapped into a TorqueException. 188 */ 189 public static ObjectKey doInsert(Criteria criteria) 190 throws TorqueException 191 { 192 return BaseTurbinePermissionPeer 193 .doInsert(criteria, (Connection) null); 194 } 195 196 /** 197 * Method to do inserts. This method is to be used during a transaction, 198 * otherwise use the doInsert(Criteria) method. It will take care of 199 * the connection details internally. 200 * 201 * @param criteria object used to create the INSERT statement. 202 * @param con the connection to use 203 * @throws TorqueException Any exceptions caught during processing will be 204 * rethrown wrapped into a TorqueException. 205 */ 206 public static ObjectKey doInsert(Criteria criteria, Connection con) 207 throws TorqueException 208 { 209 correctBooleans(criteria); 210 211 setDbName(criteria); 212 213 if (con == null) 214 { 215 return BasePeer.doInsert(criteria); 216 } 217 else 218 { 219 return BasePeer.doInsert(criteria, con); 220 } 221 } 222 223 /** 224 * Add all the columns needed to create a new object. 225 * 226 * @param criteria object containing the columns to add. 227 * @throws TorqueException Any exceptions caught during processing will be 228 * rethrown wrapped into a TorqueException. 229 */ 230 public static void addSelectColumns(Criteria criteria) 231 throws TorqueException 232 { 233 criteria.addSelectColumn(PERMISSION_ID); 234 criteria.addSelectColumn(PERMISSION_NAME); 235 } 236 237 /** 238 * changes the boolean values in the criteria to the appropriate type, 239 * whenever a booleanchar or booleanint column is involved. 240 * This enables the user to create criteria using Boolean values 241 * for booleanchar or booleanint columns 242 * @param criteria the criteria in which the boolean values should be corrected 243 * @throws TorqueException if the database map for the criteria cannot be 244 obtained. 245 */ 246 public static void correctBooleans(Criteria criteria) throws TorqueException 247 { 248 correctBooleans(criteria, getTableMap()); 249 } 250 251 /** 252 * Create a new object of type cls from a resultset row starting 253 * from a specified offset. This is done so that you can select 254 * other rows than just those needed for this object. You may 255 * for example want to create two objects from the same row. 256 * 257 * @throws TorqueException Any exceptions caught during processing will be 258 * rethrown wrapped into a TorqueException. 259 */ 260 public static TurbinePermission row2Object(Record row, 261 int offset, 262 Class cls) 263 throws TorqueException 264 { 265 try 266 { 267 TurbinePermission obj = (TurbinePermission) cls.newInstance(); 268 TurbinePermissionPeer.populateObject(row, offset, obj); 269 obj.setModified(false); 270 obj.setNew(false); 271 272 return obj; 273 } 274 catch (InstantiationException e) 275 { 276 throw new TorqueException(e); 277 } 278 catch (IllegalAccessException e) 279 { 280 throw new TorqueException(e); 281 } 282 } 283 284 /** 285 * Populates an object from a resultset row starting 286 * from a specified offset. This is done so that you can select 287 * other rows than just those needed for this object. You may 288 * for example want to create two objects from the same row. 289 * 290 * @throws TorqueException Any exceptions caught during processing will be 291 * rethrown wrapped into a TorqueException. 292 */ 293 public static void populateObject(Record row, 294 int offset, 295 TurbinePermission obj) 296 throws TorqueException 297 { 298 try 299 { 300 obj.setPermissionId(row.getValue(offset + 0).asInt()); 301 obj.setName(row.getValue(offset + 1).asString()); 302 } 303 catch (DataSetException e) 304 { 305 throw new TorqueException(e); 306 } 307 } 308 309 /** 310 * Method to do selects. 311 * 312 * @param criteria object used to create the SELECT statement. 313 * @return List of selected Objects 314 * @throws TorqueException Any exceptions caught during processing will be 315 * rethrown wrapped into a TorqueException. 316 */ 317 public static List<TurbinePermission> doSelect(Criteria criteria) throws TorqueException 318 { 319 return populateObjects(doSelectVillageRecords(criteria)); 320 } 321 322 /** 323 * Method to do selects within a transaction. 324 * 325 * @param criteria object used to create the SELECT statement. 326 * @param con the connection to use 327 * @return List of selected Objects 328 * @throws TorqueException Any exceptions caught during processing will be 329 * rethrown wrapped into a TorqueException. 330 */ 331 public static List<TurbinePermission> doSelect(Criteria criteria, Connection con) 332 throws TorqueException 333 { 334 return populateObjects(doSelectVillageRecords(criteria, con)); 335 } 336 337 /** 338 * Grabs the raw Village records to be formed into objects. 339 * This method handles connections internally. The Record objects 340 * returned by this method should be considered readonly. Do not 341 * alter the data and call save(), your results may vary, but are 342 * certainly likely to result in hard to track MT bugs. 343 * 344 * @throws TorqueException Any exceptions caught during processing will be 345 * rethrown wrapped into a TorqueException. 346 */ 347 public static List<Record> doSelectVillageRecords(Criteria criteria) 348 throws TorqueException 349 { 350 return BaseTurbinePermissionPeer 351 .doSelectVillageRecords(criteria, (Connection) null); 352 } 353 354 /** 355 * Grabs the raw Village records to be formed into objects. 356 * This method should be used for transactions 357 * 358 * @param criteria object used to create the SELECT statement. 359 * @param con the connection to use 360 * @throws TorqueException Any exceptions caught during processing will be 361 * rethrown wrapped into a TorqueException. 362 */ 363 public static List<Record> doSelectVillageRecords(Criteria criteria, Connection con) 364 throws TorqueException 365 { 366 if (criteria.getSelectColumns().size() == 0) 367 { 368 addSelectColumns(criteria); 369 } 370 correctBooleans(criteria); 371 372 setDbName(criteria); 373 374 // BasePeer returns a List of Value (Village) arrays. The array 375 // order follows the order columns were placed in the Select clause. 376 if (con == null) 377 { 378 return BasePeer.doSelect(criteria); 379 } 380 else 381 { 382 return BasePeer.doSelect(criteria, con); 383 } 384 } 385 386 /** 387 * The returned List will contain objects of the default type or 388 * objects that inherit from the default. 389 * 390 * @throws TorqueException Any exceptions caught during processing will be 391 * rethrown wrapped into a TorqueException. 392 */ 393 public static List<TurbinePermission> populateObjects(List<Record> records) 394 throws TorqueException 395 { 396 List<TurbinePermission> results = new ArrayList<TurbinePermission>(records.size()); 397 398 // populate the object(s) 399 for (int i = 0; i < records.size(); i++) 400 { 401 Record row = records.get(i); 402 results.add(TurbinePermissionPeer.row2Object(row, 1, 403 TurbinePermissionPeer.getOMClass())); 404 } 405 return results; 406 } 407 408 409 /** 410 * The class that the Peer will make instances of. 411 * If the BO is abstract then you must implement this method 412 * in the BO. 413 * 414 * @throws TorqueException Any exceptions caught during processing will be 415 * rethrown wrapped into a TorqueException. 416 */ 417 public static Class getOMClass() 418 throws TorqueException 419 { 420 return CLASS_DEFAULT; 421 } 422 423 /** 424 * Method to do updates. 425 * 426 * @param criteria object containing data that is used to create the UPDATE 427 * statement. 428 * @throws TorqueException Any exceptions caught during processing will be 429 * rethrown wrapped into a TorqueException. 430 */ 431 public static void doUpdate(Criteria criteria) throws TorqueException 432 { 433 BaseTurbinePermissionPeer 434 .doUpdate(criteria, (Connection) null); 435 } 436 437 /** 438 * Method to do updates. This method is to be used during a transaction, 439 * otherwise use the doUpdate(Criteria) method. It will take care of 440 * the connection details internally. 441 * 442 * @param criteria object containing data that is used to create the UPDATE 443 * statement. 444 * @param con the connection to use 445 * @throws TorqueException Any exceptions caught during processing will be 446 * rethrown wrapped into a TorqueException. 447 */ 448 public static void doUpdate(Criteria criteria, Connection con) 449 throws TorqueException 450 { 451 Criteria selectCriteria = new Criteria(DATABASE_NAME, 2); 452 correctBooleans(criteria); 453 454 455 selectCriteria.put(PERMISSION_ID, criteria.remove(PERMISSION_ID)); 456 457 458 setDbName(criteria); 459 460 if (con == null) 461 { 462 BasePeer.doUpdate(selectCriteria, criteria); 463 } 464 else 465 { 466 BasePeer.doUpdate(selectCriteria, criteria, con); 467 } 468 } 469 470 /** 471 * Method to do deletes. 472 * 473 * @param criteria object containing data that is used DELETE from database. 474 * @throws TorqueException Any exceptions caught during processing will be 475 * rethrown wrapped into a TorqueException. 476 */ 477 public static void doDelete(Criteria criteria) throws TorqueException 478 { 479 TurbinePermissionPeer 480 .doDelete(criteria, (Connection) null); 481 } 482 483 /** 484 * Method to do deletes. This method is to be used during a transaction, 485 * otherwise use the doDelete(Criteria) method. It will take care of 486 * the connection details internally. 487 * 488 * @param criteria object containing data that is used DELETE from database. 489 * @param con the connection to use 490 * @throws TorqueException Any exceptions caught during processing will be 491 * rethrown wrapped into a TorqueException. 492 */ 493 public static void doDelete(Criteria criteria, Connection con) 494 throws TorqueException 495 { 496 correctBooleans(criteria); 497 498 setDbName(criteria); 499 500 if (con == null) 501 { 502 BasePeer.doDelete(criteria, TABLE_NAME); 503 } 504 else 505 { 506 BasePeer.doDelete(criteria, TABLE_NAME, con); 507 } 508 } 509 510 /** 511 * Method to do selects 512 * 513 * @throws TorqueException Any exceptions caught during processing will be 514 * rethrown wrapped into a TorqueException. 515 */ 516 public static List<TurbinePermission> doSelect(TurbinePermission obj) throws TorqueException 517 { 518 return doSelect(buildSelectCriteria(obj)); 519 } 520 521 /** 522 * Method to do inserts 523 * 524 * @throws TorqueException Any exceptions caught during processing will be 525 * rethrown wrapped into a TorqueException. 526 */ 527 public static void doInsert(TurbinePermission obj) throws TorqueException 528 { 529 obj.setPrimaryKey(doInsert(buildCriteria(obj))); 530 obj.setNew(false); 531 obj.setModified(false); 532 } 533 534 /** 535 * @param obj the data object to update in the database. 536 * @throws TorqueException Any exceptions caught during processing will be 537 * rethrown wrapped into a TorqueException. 538 */ 539 public static void doUpdate(TurbinePermission obj) throws TorqueException 540 { 541 doUpdate(buildCriteria(obj)); 542 obj.setModified(false); 543 } 544 545 /** 546 * @param obj the data object to delete in the database. 547 * @throws TorqueException Any exceptions caught during processing will be 548 * rethrown wrapped into a TorqueException. 549 */ 550 public static void doDelete(TurbinePermission obj) throws TorqueException 551 { 552 doDelete(buildSelectCriteria(obj)); 553 } 554 555 /** 556 * Method to do inserts. This method is to be used during a transaction, 557 * otherwise use the doInsert(TurbinePermission) method. It will take 558 * care of the connection details internally. 559 * 560 * @param obj the data object to insert into the database. 561 * @param con the connection to use 562 * @throws TorqueException Any exceptions caught during processing will be 563 * rethrown wrapped into a TorqueException. 564 */ 565 public static void doInsert(TurbinePermission obj, Connection con) 566 throws TorqueException 567 { 568 obj.setPrimaryKey(doInsert(buildCriteria(obj), con)); 569 obj.setNew(false); 570 obj.setModified(false); 571 } 572 573 /** 574 * Method to do update. This method is to be used during a transaction, 575 * otherwise use the doUpdate(TurbinePermission) method. It will take 576 * care of the connection details internally. 577 * 578 * @param obj the data object to update in the database. 579 * @param con the connection to use 580 * @throws TorqueException Any exceptions caught during processing will be 581 * rethrown wrapped into a TorqueException. 582 */ 583 public static void doUpdate(TurbinePermission obj, Connection con) 584 throws TorqueException 585 { 586 doUpdate(buildCriteria(obj), con); 587 obj.setModified(false); 588 } 589 590 /** 591 * Method to delete. This method is to be used during a transaction, 592 * otherwise use the doDelete(TurbinePermission) method. It will take 593 * care of the connection details internally. 594 * 595 * @param obj the data object to delete in the database. 596 * @param con the connection to use 597 * @throws TorqueException Any exceptions caught during processing will be 598 * rethrown wrapped into a TorqueException. 599 */ 600 public static void doDelete(TurbinePermission obj, Connection con) 601 throws TorqueException 602 { 603 doDelete(buildSelectCriteria(obj), con); 604 } 605 606 /** 607 * Method to do deletes. 608 * 609 * @param pk ObjectKey that is used DELETE from database. 610 * @throws TorqueException Any exceptions caught during processing will be 611 * rethrown wrapped into a TorqueException. 612 */ 613 public static void doDelete(ObjectKey pk) throws TorqueException 614 { 615 BaseTurbinePermissionPeer 616 .doDelete(pk, (Connection) null); 617 } 618 619 /** 620 * Method to delete. This method is to be used during a transaction, 621 * otherwise use the doDelete(ObjectKey) method. It will take 622 * care of the connection details internally. 623 * 624 * @param pk the primary key for the object to delete in the database. 625 * @param con the connection to use 626 * @throws TorqueException Any exceptions caught during processing will be 627 * rethrown wrapped into a TorqueException. 628 */ 629 public static void doDelete(ObjectKey pk, Connection con) 630 throws TorqueException 631 { 632 doDelete(buildCriteria(pk), con); 633 } 634 635 /** Build a Criteria object from an ObjectKey */ 636 public static Criteria buildCriteria( ObjectKey pk ) 637 { 638 Criteria criteria = new Criteria(); 639 criteria.add(PERMISSION_ID, pk); 640 return criteria; 641 } 642 643 /** Build a Criteria object from the data object for this peer */ 644 public static Criteria buildCriteria( TurbinePermission obj ) 645 { 646 Criteria criteria = new Criteria(DATABASE_NAME); 647 if (!obj.isNew()) 648 criteria.add(PERMISSION_ID, obj.getPermissionId()); 649 criteria.add(PERMISSION_NAME, obj.getName()); 650 return criteria; 651 } 652 653 /** Build a Criteria object from the data object for this peer, skipping all binary columns */ 654 public static Criteria buildSelectCriteria( TurbinePermission obj ) 655 { 656 Criteria criteria = new Criteria(DATABASE_NAME); 657 if (!obj.isNew()) 658 { 659 criteria.add(PERMISSION_ID, obj.getPermissionId()); 660 } 661 criteria.add(PERMISSION_NAME, obj.getName()); 662 return criteria; 663 } 664 665 666 /** 667 * Retrieve a single object by pk 668 * 669 * @param pk the primary key 670 * @throws TorqueException Any exceptions caught during processing will be 671 * rethrown wrapped into a TorqueException. 672 * @throws NoRowsException Primary key was not found in database. 673 * @throws TooManyRowsException Primary key was not found in database. 674 */ 675 public static TurbinePermission retrieveByPK(int pk) 676 throws TorqueException, NoRowsException, TooManyRowsException 677 { 678 return retrieveByPK(SimpleKey.keyFor(pk)); 679 } 680 681 /** 682 * Retrieve a single object by pk 683 * 684 * @param pk the primary key 685 * @param con the connection to use 686 * @throws TorqueException Any exceptions caught during processing will be 687 * rethrown wrapped into a TorqueException. 688 * @throws NoRowsException Primary key was not found in database. 689 * @throws TooManyRowsException Primary key was not found in database. 690 */ 691 public static TurbinePermission retrieveByPK(int pk, Connection con) 692 throws TorqueException, NoRowsException, TooManyRowsException 693 { 694 return retrieveByPK(SimpleKey.keyFor(pk), con); 695 } 696 697 /** 698 * Retrieve a single object by pk 699 * 700 * @param pk the primary key 701 * @throws TorqueException Any exceptions caught during processing will be 702 * rethrown wrapped into a TorqueException. 703 * @throws NoRowsException Primary key was not found in database. 704 * @throws TooManyRowsException Primary key was not found in database. 705 */ 706 public static TurbinePermission retrieveByPK(ObjectKey pk) 707 throws TorqueException, NoRowsException, TooManyRowsException 708 { 709 Connection db = null; 710 TurbinePermission retVal = null; 711 try 712 { 713 db = Torque.getConnection(DATABASE_NAME); 714 retVal = retrieveByPK(pk, db); 715 } 716 finally 717 { 718 Torque.closeConnection(db); 719 } 720 return retVal; 721 } 722 723 /** 724 * Retrieve a single object by pk 725 * 726 * @param pk the primary key 727 * @param con the connection to use 728 * @throws TorqueException Any exceptions caught during processing will be 729 * rethrown wrapped into a TorqueException. 730 * @throws NoRowsException Primary key was not found in database. 731 * @throws TooManyRowsException Primary key was not found in database. 732 */ 733 public static TurbinePermission retrieveByPK(ObjectKey pk, Connection con) 734 throws TorqueException, NoRowsException, TooManyRowsException 735 { 736 Criteria criteria = buildCriteria(pk); 737 List<TurbinePermission> v = doSelect(criteria, con); 738 if (v.size() == 0) 739 { 740 throw new NoRowsException("Failed to select a row."); 741 } 742 else if (v.size() > 1) 743 { 744 throw new TooManyRowsException("Failed to select only one row."); 745 } 746 else 747 { 748 return (TurbinePermission)v.get(0); 749 } 750 } 751 752 /** 753 * Retrieve a multiple objects by pk 754 * 755 * @param pks List of primary keys 756 * @throws TorqueException Any exceptions caught during processing will be 757 * rethrown wrapped into a TorqueException. 758 */ 759 public static List<TurbinePermission> retrieveByPKs(List<ObjectKey> pks) 760 throws TorqueException 761 { 762 Connection db = null; 763 List<TurbinePermission> retVal = null; 764 try 765 { 766 db = Torque.getConnection(DATABASE_NAME); 767 retVal = retrieveByPKs(pks, db); 768 } 769 finally 770 { 771 Torque.closeConnection(db); 772 } 773 return retVal; 774 } 775 776 /** 777 * Retrieve a multiple objects by pk 778 * 779 * @param pks List of primary keys 780 * @param dbcon the connection to use 781 * @throws TorqueException Any exceptions caught during processing will be 782 * rethrown wrapped into a TorqueException. 783 */ 784 public static List<TurbinePermission> retrieveByPKs( List<ObjectKey> pks, Connection dbcon ) 785 throws TorqueException 786 { 787 List<TurbinePermission> objs = null; 788 if (pks == null || pks.size() == 0) 789 { 790 objs = new LinkedList<TurbinePermission>(); 791 } 792 else 793 { 794 Criteria criteria = new Criteria(); 795 criteria.addIn( PERMISSION_ID, pks ); 796 objs = doSelect(criteria, dbcon); 797 } 798 return objs; 799 } 800 801 802 803 804 805 806 807 808 809 810 /** 811 * Returns the TableMap related to this peer. 812 * 813 * @throws TorqueException Any exceptions caught during processing will be 814 * rethrown wrapped into a TorqueException. 815 */ 816 public static TableMap getTableMap() 817 throws TorqueException 818 { 819 return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME); 820 } 821 822 private static void setDbName(Criteria crit) 823 { 824 // Set the correct dbName if it has not been overridden 825 // crit.getDbName will return the same object if not set to 826 // another value so == check is okay and faster 827 if (crit.getDbName() == Torque.getDefaultDB()) 828 { 829 crit.setDbName(DATABASE_NAME); 830 } 831 } 832 833 834 // The following methods wrap some methods in BasePeer 835 // to have more support for Java5 generic types in the Peer 836 837 /** 838 * Utility method which executes a given sql statement. This 839 * method should be used for select statements only. Use 840 * executeStatement for update, insert, and delete operations. 841 * 842 * @param queryString A String with the sql statement to execute. 843 * @return List of Record objects. 844 * @throws TorqueException Any exceptions caught during processing will be 845 * rethrown wrapped into a TorqueException. 846 * @see org.apache.torque.util.BasePeer#executeQuery(String) 847 */ 848 public static List<Record> executeQuery(String queryString) throws TorqueException 849 { 850 return BasePeer.executeQuery(queryString); 851 } 852 853 /** 854 * Utility method which executes a given sql statement. This 855 * method should be used for select statements only. Use 856 * executeStatement for update, insert, and delete operations. 857 * 858 * @param queryString A String with the sql statement to execute. 859 * @param dbName The database to connect to. 860 * @return List of Record objects. 861 * @throws TorqueException Any exceptions caught during processing will be 862 * rethrown wrapped into a TorqueException. 863 * @see org.apache.torque.util.BasePeer#executeQuery(String,String) 864 */ 865 public static List<Record> executeQuery(String queryString, String dbName) 866 throws TorqueException 867 { 868 return BasePeer.executeQuery(queryString,dbName); 869 } 870 871 872 /** 873 * Method for performing a SELECT. Returns all results. 874 * 875 * @param queryString A String with the sql statement to execute. 876 * @param dbName The database to connect to. 877 * @param singleRecord Whether or not we want to select only a 878 * single record. 879 * @return List of Record objects. 880 * @throws TorqueException Any exceptions caught during processing will be 881 * rethrown wrapped into a TorqueException. 882 * @see org.apache.torque.util.BasePeer#executeQuery(String,String,boolean) 883 */ 884 public static List<Record> executeQuery( 885 String queryString, 886 String dbName, 887 boolean singleRecord) 888 throws TorqueException 889 { 890 return BasePeer.executeQuery(queryString,dbName,singleRecord); 891 } 892 893 /** 894 * Method for performing a SELECT. Returns all results. 895 * 896 * @param queryString A String with the sql statement to execute. 897 * @param singleRecord Whether or not we want to select only a 898 * single record. 899 * @param con A Connection. 900 * @return List of Record objects. 901 * @throws TorqueException Any exceptions caught during processing will be 902 * rethrown wrapped into a TorqueException. 903 * @see org.apache.torque.util.BasePeer#executeQuery(String,boolean,Connection) 904 */ 905 public static List<Record> executeQuery( 906 String queryString, 907 boolean singleRecord, 908 Connection con) 909 throws TorqueException 910 { 911 return BasePeer.executeQuery(queryString,singleRecord,con); 912 } 913 914 /** 915 * Method for performing a SELECT. 916 * 917 * @param queryString A String with the sql statement to execute. 918 * @param start The first row to return. 919 * @param numberOfResults The number of rows to return. 920 * @param dbName The database to connect to. 921 * @param singleRecord Whether or not we want to select only a 922 * single record. 923 * @return List of Record objects. 924 * @throws TorqueException Any exceptions caught during processing will be 925 * rethrown wrapped into a TorqueException. 926 * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean) 927 */ 928 public static List<Record> executeQuery( 929 String queryString, 930 int start, 931 int numberOfResults, 932 String dbName, 933 boolean singleRecord) 934 throws TorqueException 935 { 936 return BasePeer.executeQuery(queryString,start,numberOfResults,dbName,singleRecord); 937 } 938 939 /** 940 * Method for performing a SELECT. Returns all results. 941 * 942 * @param queryString A String with the sql statement to execute. 943 * @param start The first row to return. 944 * @param numberOfResults The number of rows to return. 945 * @param singleRecord Whether or not we want to select only a 946 * single record. 947 * @param con A Connection. 948 * @return List of Record objects. 949 * @throws TorqueException Any exceptions caught during processing will be 950 * rethrown wrapped into a TorqueException. 951 * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean,Connection) 952 */ 953 public static List<Record> executeQuery( 954 String queryString, 955 int start, 956 int numberOfResults, 957 boolean singleRecord, 958 Connection con) 959 throws TorqueException 960 { 961 return BasePeer.executeQuery(queryString,start,numberOfResults,singleRecord,con); 962 } 963 964 /** 965 * Returns all records in a QueryDataSet as a List of Record 966 * objects. Used for functionality like util.LargeSelect. 967 * 968 * @see #getSelectResults(QueryDataSet, int, int, boolean) 969 * @param qds the QueryDataSet 970 * @return a List of Record objects 971 * @throws TorqueException Any exceptions caught during processing will be 972 * rethrown wrapped into a TorqueException. 973 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet) 974 */ 975 public static List<Record> getSelectResults(QueryDataSet qds) 976 throws TorqueException 977 { 978 return BasePeer.getSelectResults(qds); 979 } 980 981 /** 982 * Returns all records in a QueryDataSet as a List of Record 983 * objects. Used for functionality like util.LargeSelect. 984 * 985 * @see #getSelectResults(QueryDataSet, int, int, boolean) 986 * @param qds the QueryDataSet 987 * @param singleRecord 988 * @return a List of Record objects 989 * @throws TorqueException Any exceptions caught during processing will be 990 * rethrown wrapped into a TorqueException. 991 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,boolean) 992 */ 993 public static List<Record> getSelectResults(QueryDataSet qds, boolean singleRecord) 994 throws TorqueException 995 { 996 return BasePeer.getSelectResults(qds,singleRecord); 997 } 998 999 /** 1000 * Returns numberOfResults records in a QueryDataSet as a List 1001 * of Record objects. Starting at record 0. Used for 1002 * functionality like util.LargeSelect. 1003 * 1004 * @see #getSelectResults(QueryDataSet, int, int, boolean) 1005 * @param qds the QueryDataSet 1006 * @param numberOfResults 1007 * @param singleRecord 1008 * @return a List of Record objects 1009 * @throws TorqueException Any exceptions caught during processing will be 1010 * rethrown wrapped into a TorqueException. 1011 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,boolean) 1012 */ 1013 public static List<Record> getSelectResults( 1014 QueryDataSet qds, 1015 int numberOfResults, 1016 boolean singleRecord) 1017 throws TorqueException 1018 { 1019 return BasePeer.getSelectResults(qds,numberOfResults,singleRecord); 1020 } 1021 1022 /** 1023 * Returns numberOfResults records in a QueryDataSet as a List 1024 * of Record objects. Starting at record start. Used for 1025 * functionality like util.LargeSelect. 1026 * 1027 * @param qds The <code>QueryDataSet</code> to extract results 1028 * from. 1029 * @param start The index from which to start retrieving 1030 * <code>Record</code> objects from the data set. 1031 * @param numberOfResults The number of results to return (or 1032 * <code> -1</code> for all results). 1033 * @param singleRecord Whether or not we want to select only a 1034 * single record. 1035 * @return A <code>List</code> of <code>Record</code> objects. 1036 * @exception TorqueException If any <code>Exception</code> occurs. 1037 * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,int,boolean) 1038 */ 1039 public static List getSelectResults( 1040 QueryDataSet qds, 1041 int start, 1042 int numberOfResults, 1043 boolean singleRecord) 1044 throws TorqueException 1045 { 1046 return BasePeer.getSelectResults(qds,start,numberOfResults,singleRecord); 1047 } 1048 1049 /** 1050 * Performs a SQL <code>select</code> using a PreparedStatement. 1051 * Note: this method does not handle null criteria values. 1052 * 1053 * @param criteria 1054 * @param con 1055 * @return a List of Record objects. 1056 * @throws TorqueException Error performing database query. 1057 * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria,Connection) 1058 */ 1059 public static List<Record> doPSSelect(Criteria criteria, Connection con) 1060 throws TorqueException 1061 { 1062 return BasePeer.doPSSelect(criteria,con); 1063 } 1064 1065 /** 1066 * Do a Prepared Statement select according to the given criteria 1067 * 1068 * @param criteria 1069 * @return a List of Record objects. 1070 * @throws TorqueException Any exceptions caught during processing will be 1071 * rethrown wrapped into a TorqueException. 1072 * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria) 1073 */ 1074 public static List<Record> doPSSelect(Criteria criteria) throws TorqueException 1075 { 1076 return BasePeer.doPSSelect(criteria); 1077 } 1078 }