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