1 package org.apache.turbine.services.security.torque.om;
2
3 import java.math.BigDecimal;
4 import java.sql.Connection;
5 import java.sql.SQLException;
6 import java.util.ArrayList;
7 import java.util.Date;
8 import java.util.Iterator;
9 import java.util.LinkedList;
10 import java.util.List;
11
12 import org.apache.torque.NoRowsException;
13 import org.apache.torque.TooManyRowsException;
14 import org.apache.torque.Torque;
15 import org.apache.torque.TorqueException;
16 import org.apache.torque.TorqueRuntimeException;
17 import org.apache.torque.map.MapBuilder;
18 import org.apache.torque.map.TableMap;
19 import org.apache.torque.om.DateKey;
20 import org.apache.torque.om.NumberKey;
21 import org.apache.torque.om.StringKey;
22 import org.apache.torque.om.ObjectKey;
23 import org.apache.torque.om.SimpleKey;
24 import org.apache.torque.util.BasePeer;
25 import org.apache.torque.util.Criteria;
26
27 import com.workingdogs.village.DataSetException;
28 import com.workingdogs.village.QueryDataSet;
29 import com.workingdogs.village.Record;
30
31
32 import org.apache.turbine.services.security.torque.om.map.*;
33
34
35
36
37
38
39
40
41
42
43 public abstract class BaseTurbineRolePermissionPeer
44 extends BasePeer
45 {
46
47 private static final long serialVersionUID = 1308842746584L;
48
49
50
51 public static final String DATABASE_NAME;
52
53
54 public static final String TABLE_NAME;
55
56
57
58
59
60
61
62 public static MapBuilder getMapBuilder()
63 throws TorqueException
64 {
65 return Torque.getMapBuilder(TurbineRolePermissionMapBuilder.CLASS_NAME);
66 }
67
68
69 public static final String ROLE_ID;
70
71 public static final String PERMISSION_ID;
72
73 static
74 {
75 DATABASE_NAME = "default";
76 TABLE_NAME = "TURBINE_ROLE_PERMISSION";
77
78 ROLE_ID = "TURBINE_ROLE_PERMISSION.ROLE_ID";
79 PERMISSION_ID = "TURBINE_ROLE_PERMISSION.PERMISSION_ID";
80 if (Torque.isInit())
81 {
82 try
83 {
84 Torque.getMapBuilder(TurbineRolePermissionMapBuilder.CLASS_NAME);
85 }
86 catch (TorqueException e)
87 {
88 log.error("Could not initialize Peer", e);
89 throw new TorqueRuntimeException(e);
90 }
91 }
92 else
93 {
94 Torque.registerMapBuilder(TurbineRolePermissionMapBuilder.CLASS_NAME);
95 }
96 }
97
98
99 public static final int numColumns = 2;
100
101
102 protected static final String CLASSNAME_DEFAULT =
103 "org.apache.turbine.services.security.torque.om.TurbineRolePermission";
104
105
106 protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
107
108
109
110
111
112
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
130 if (t instanceof Error)
131 {
132 throw (Error) t.fillInStackTrace();
133 }
134 }
135 return c;
136 }
137
138
139
140
141
142
143
144
145
146
147
148 public static List<TurbineRolePermission> 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
184
185
186
187
188
189 public static ObjectKey doInsert(Criteria criteria)
190 throws TorqueException
191 {
192 return BaseTurbineRolePermissionPeer
193 .doInsert(criteria, (Connection) null);
194 }
195
196
197
198
199
200
201
202
203
204
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
225
226
227
228
229
230 public static void addSelectColumns(Criteria criteria)
231 throws TorqueException
232 {
233 criteria.addSelectColumn(ROLE_ID);
234 criteria.addSelectColumn(PERMISSION_ID);
235 }
236
237
238
239
240
241
242
243
244
245
246 public static void correctBooleans(Criteria criteria) throws TorqueException
247 {
248 correctBooleans(criteria, getTableMap());
249 }
250
251
252
253
254
255
256
257
258
259
260 public static TurbineRolePermission row2Object(Record row,
261 int offset,
262 Class cls)
263 throws TorqueException
264 {
265 try
266 {
267 TurbineRolePermission obj = (TurbineRolePermission) cls.newInstance();
268 TurbineRolePermissionPeer.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
286
287
288
289
290
291
292
293 public static void populateObject(Record row,
294 int offset,
295 TurbineRolePermission obj)
296 throws TorqueException
297 {
298 try
299 {
300 obj.setRoleId(row.getValue(offset + 0).asInt());
301 obj.setPermissionId(row.getValue(offset + 1).asInt());
302 }
303 catch (DataSetException e)
304 {
305 throw new TorqueException(e);
306 }
307 }
308
309
310
311
312
313
314
315
316
317 public static List<TurbineRolePermission> doSelect(Criteria criteria) throws TorqueException
318 {
319 return populateObjects(doSelectVillageRecords(criteria));
320 }
321
322
323
324
325
326
327
328
329
330
331 public static List<TurbineRolePermission> doSelect(Criteria criteria, Connection con)
332 throws TorqueException
333 {
334 return populateObjects(doSelectVillageRecords(criteria, con));
335 }
336
337
338
339
340
341
342
343
344
345
346
347 public static List<Record> doSelectVillageRecords(Criteria criteria)
348 throws TorqueException
349 {
350 return BaseTurbineRolePermissionPeer
351 .doSelectVillageRecords(criteria, (Connection) null);
352 }
353
354
355
356
357
358
359
360
361
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
375
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
388
389
390
391
392
393 public static List<TurbineRolePermission> populateObjects(List<Record> records)
394 throws TorqueException
395 {
396 List<TurbineRolePermission> results = new ArrayList<TurbineRolePermission>(records.size());
397
398
399 for (int i = 0; i < records.size(); i++)
400 {
401 Record row = records.get(i);
402 results.add(TurbineRolePermissionPeer.row2Object(row, 1,
403 TurbineRolePermissionPeer.getOMClass()));
404 }
405 return results;
406 }
407
408
409
410
411
412
413
414
415
416
417 public static Class getOMClass()
418 throws TorqueException
419 {
420 return CLASS_DEFAULT;
421 }
422
423
424
425
426
427
428
429
430
431 public static void doUpdate(Criteria criteria) throws TorqueException
432 {
433 BaseTurbineRolePermissionPeer
434 .doUpdate(criteria, (Connection) null);
435 }
436
437
438
439
440
441
442
443
444
445
446
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(ROLE_ID, criteria.remove(ROLE_ID));
456
457 selectCriteria.put(PERMISSION_ID, criteria.remove(PERMISSION_ID));
458
459 setDbName(criteria);
460
461 if (con == null)
462 {
463 BasePeer.doUpdate(selectCriteria, criteria);
464 }
465 else
466 {
467 BasePeer.doUpdate(selectCriteria, criteria, con);
468 }
469 }
470
471
472
473
474
475
476
477
478 public static void doDelete(Criteria criteria) throws TorqueException
479 {
480 TurbineRolePermissionPeer
481 .doDelete(criteria, (Connection) null);
482 }
483
484
485
486
487
488
489
490
491
492
493
494 public static void doDelete(Criteria criteria, Connection con)
495 throws TorqueException
496 {
497 correctBooleans(criteria);
498
499 setDbName(criteria);
500
501 if (con == null)
502 {
503 BasePeer.doDelete(criteria, TABLE_NAME);
504 }
505 else
506 {
507 BasePeer.doDelete(criteria, TABLE_NAME, con);
508 }
509 }
510
511
512
513
514
515
516
517 public static List<TurbineRolePermission> doSelect(TurbineRolePermission obj) throws TorqueException
518 {
519 return doSelect(buildSelectCriteria(obj));
520 }
521
522
523
524
525
526
527
528 public static void doInsert(TurbineRolePermission obj) throws TorqueException
529 {
530 doInsert(buildCriteria(obj));
531 obj.setNew(false);
532 obj.setModified(false);
533 }
534
535
536
537
538
539
540 public static void doUpdate(TurbineRolePermission obj) throws TorqueException
541 {
542 doUpdate(buildCriteria(obj));
543 obj.setModified(false);
544 }
545
546
547
548
549
550
551 public static void doDelete(TurbineRolePermission obj) throws TorqueException
552 {
553 doDelete(buildSelectCriteria(obj));
554 }
555
556
557
558
559
560
561
562
563
564
565
566 public static void doInsert(TurbineRolePermission obj, Connection con)
567 throws TorqueException
568 {
569 doInsert(buildCriteria(obj), con);
570 obj.setNew(false);
571 obj.setModified(false);
572 }
573
574
575
576
577
578
579
580
581
582
583
584 public static void doUpdate(TurbineRolePermission obj, Connection con)
585 throws TorqueException
586 {
587 doUpdate(buildCriteria(obj), con);
588 obj.setModified(false);
589 }
590
591
592
593
594
595
596
597
598
599
600
601 public static void doDelete(TurbineRolePermission obj, Connection con)
602 throws TorqueException
603 {
604 doDelete(buildSelectCriteria(obj), con);
605 }
606
607
608
609
610
611
612
613
614 public static void doDelete(ObjectKey pk) throws TorqueException
615 {
616 BaseTurbineRolePermissionPeer
617 .doDelete(pk, (Connection) null);
618 }
619
620
621
622
623
624
625
626
627
628
629
630 public static void doDelete(ObjectKey pk, Connection con)
631 throws TorqueException
632 {
633 doDelete(buildCriteria(pk), con);
634 }
635
636
637 public static Criteria buildCriteria( ObjectKey pk )
638 {
639 Criteria criteria = new Criteria();
640 SimpleKey[] keys = (SimpleKey[])pk.getValue();
641 criteria.add(ROLE_ID, keys[0]);
642 criteria.add(PERMISSION_ID, keys[1]);
643 return criteria;
644 }
645
646
647 public static Criteria buildCriteria( TurbineRolePermission obj )
648 {
649 Criteria criteria = new Criteria(DATABASE_NAME);
650 criteria.add(ROLE_ID, obj.getRoleId());
651 criteria.add(PERMISSION_ID, obj.getPermissionId());
652 return criteria;
653 }
654
655
656 public static Criteria buildSelectCriteria( TurbineRolePermission obj )
657 {
658 Criteria criteria = new Criteria(DATABASE_NAME);
659 criteria.add(ROLE_ID, obj.getRoleId());
660 criteria.add(PERMISSION_ID, obj.getPermissionId());
661 return criteria;
662 }
663
664
665
666
667
668
669
670
671
672
673
674
675 public static TurbineRolePermission retrieveByPK(ObjectKey pk)
676 throws TorqueException, NoRowsException, TooManyRowsException
677 {
678 Connection db = null;
679 TurbineRolePermission retVal = null;
680 try
681 {
682 db = Torque.getConnection(DATABASE_NAME);
683 retVal = retrieveByPK(pk, db);
684 }
685 finally
686 {
687 Torque.closeConnection(db);
688 }
689 return retVal;
690 }
691
692
693
694
695
696
697
698
699
700
701
702 public static TurbineRolePermission retrieveByPK(ObjectKey pk, Connection con)
703 throws TorqueException, NoRowsException, TooManyRowsException
704 {
705 Criteria criteria = buildCriteria(pk);
706 List<TurbineRolePermission> v = doSelect(criteria, con);
707 if (v.size() == 0)
708 {
709 throw new NoRowsException("Failed to select a row.");
710 }
711 else if (v.size() > 1)
712 {
713 throw new TooManyRowsException("Failed to select only one row.");
714 }
715 else
716 {
717 return (TurbineRolePermission)v.get(0);
718 }
719 }
720
721
722
723
724
725
726
727
728 public static List<TurbineRolePermission> retrieveByPKs(List<ObjectKey> pks)
729 throws TorqueException
730 {
731 Connection db = null;
732 List<TurbineRolePermission> retVal = null;
733 try
734 {
735 db = Torque.getConnection(DATABASE_NAME);
736 retVal = retrieveByPKs(pks, db);
737 }
738 finally
739 {
740 Torque.closeConnection(db);
741 }
742 return retVal;
743 }
744
745
746
747
748
749
750
751
752
753 public static List<TurbineRolePermission> retrieveByPKs( List<ObjectKey> pks, Connection dbcon )
754 throws TorqueException
755 {
756 List<TurbineRolePermission> objs = null;
757 if (pks == null || pks.size() == 0)
758 {
759 objs = new LinkedList<TurbineRolePermission>();
760 }
761 else
762 {
763 Criteria criteria = new Criteria();
764 Iterator<ObjectKey> iter = pks.iterator();
765 while (iter.hasNext())
766 {
767 ObjectKey pk = iter.next();
768 SimpleKey[] keys = (SimpleKey[])pk.getValue();
769 Criteria.Criterion c0 = criteria.getNewCriterion(
770 ROLE_ID, keys[0], Criteria.EQUAL);
771 Criteria.Criterion c1 = criteria.getNewCriterion(
772 PERMISSION_ID, keys[1], Criteria.EQUAL);
773 c0.and(c1);
774 criteria.or(c0);
775 }
776 objs = doSelect(criteria, dbcon);
777 }
778 return objs;
779 }
780
781
782
783
784
785
786
787
788 public static TurbineRolePermission retrieveByPK(
789 int roleId
790 , int permissionId
791 ) throws TorqueException
792 {
793 Connection db = null;
794 TurbineRolePermission retVal = null;
795 try
796 {
797 db = Torque.getConnection(DATABASE_NAME);
798 retVal = retrieveByPK(
799 roleId
800 , permissionId
801 , db);
802 }
803 finally
804 {
805 Torque.closeConnection(db);
806 }
807 return retVal;
808 }
809
810
811
812
813
814
815
816
817 public static TurbineRolePermission retrieveByPK(
818 int roleId
819 , int permissionId
820 ,Connection con) throws TorqueException
821 {
822
823 Criteria criteria = new Criteria(5);
824 criteria.add(ROLE_ID, roleId);
825 criteria.add(PERMISSION_ID, permissionId);
826 List<TurbineRolePermission> v = doSelect(criteria, con);
827 if (v.size() == 1)
828 {
829 return v.get(0);
830 }
831 else
832 {
833 throw new TorqueException("Failed to select one and only one row.");
834 }
835 }
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855 protected static List<TurbineRolePermission> doSelectJoinTurbineRole(Criteria criteria)
856 throws TorqueException
857 {
858 return doSelectJoinTurbineRole(criteria, null);
859 }
860
861
862
863
864
865
866
867
868
869
870
871
872 protected static List<TurbineRolePermission> doSelectJoinTurbineRole(Criteria criteria, Connection conn)
873 throws TorqueException
874 {
875 setDbName(criteria);
876
877 TurbineRolePermissionPeer.addSelectColumns(criteria);
878 int offset = numColumns + 1;
879 TurbineRolePeer.addSelectColumns(criteria);
880
881 criteria.addJoin(TurbineRolePermissionPeer.ROLE_ID,
882 TurbineRolePeer.ROLE_ID);
883
884 correctBooleans(criteria);
885
886 List<Record> rows;
887 if (conn == null)
888 {
889 rows = BasePeer.doSelect(criteria);
890 }
891 else
892 {
893 rows = BasePeer.doSelect(criteria,conn);
894 }
895
896 List<TurbineRolePermission> results = new ArrayList<TurbineRolePermission>();
897
898 for (int i = 0; i < rows.size(); i++)
899 {
900 Record row = rows.get(i);
901
902 Class omClass = TurbineRolePermissionPeer.getOMClass();
903 TurbineRolePermission obj1 = (TurbineRolePermission) TurbineRolePermissionPeer
904 .row2Object(row, 1, omClass);
905 omClass = TurbineRolePeer.getOMClass();
906 TurbineRole obj2 = (TurbineRole) TurbineRolePeer
907 .row2Object(row, offset, omClass);
908
909 boolean newObject = true;
910 for (int j = 0; j < results.size(); j++)
911 {
912 TurbineRolePermission temp_obj1 = results.get(j);
913 TurbineRole temp_obj2 = (TurbineRole) temp_obj1.getTurbineRole();
914 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
915 {
916 newObject = false;
917 temp_obj2.addTurbineRolePermission(obj1);
918 break;
919 }
920 }
921 if (newObject)
922 {
923 obj2.initTurbineRolePermissions();
924 obj2.addTurbineRolePermission(obj1);
925 }
926 results.add(obj1);
927 }
928 return results;
929 }
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945 protected static List<TurbineRolePermission> doSelectJoinTurbinePermission(Criteria criteria)
946 throws TorqueException
947 {
948 return doSelectJoinTurbinePermission(criteria, null);
949 }
950
951
952
953
954
955
956
957
958
959
960
961
962 protected static List<TurbineRolePermission> doSelectJoinTurbinePermission(Criteria criteria, Connection conn)
963 throws TorqueException
964 {
965 setDbName(criteria);
966
967 TurbineRolePermissionPeer.addSelectColumns(criteria);
968 int offset = numColumns + 1;
969 TurbinePermissionPeer.addSelectColumns(criteria);
970
971 criteria.addJoin(TurbineRolePermissionPeer.PERMISSION_ID,
972 TurbinePermissionPeer.PERMISSION_ID);
973
974 correctBooleans(criteria);
975
976 List<Record> rows;
977 if (conn == null)
978 {
979 rows = BasePeer.doSelect(criteria);
980 }
981 else
982 {
983 rows = BasePeer.doSelect(criteria,conn);
984 }
985
986 List<TurbineRolePermission> results = new ArrayList<TurbineRolePermission>();
987
988 for (int i = 0; i < rows.size(); i++)
989 {
990 Record row = rows.get(i);
991
992 Class omClass = TurbineRolePermissionPeer.getOMClass();
993 TurbineRolePermission obj1 = (TurbineRolePermission) TurbineRolePermissionPeer
994 .row2Object(row, 1, omClass);
995 omClass = TurbinePermissionPeer.getOMClass();
996 TurbinePermission obj2 = (TurbinePermission) TurbinePermissionPeer
997 .row2Object(row, offset, omClass);
998
999 boolean newObject = true;
1000 for (int j = 0; j < results.size(); j++)
1001 {
1002 TurbineRolePermission temp_obj1 = results.get(j);
1003 TurbinePermission temp_obj2 = (TurbinePermission) temp_obj1.getTurbinePermission();
1004 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1005 {
1006 newObject = false;
1007 temp_obj2.addTurbineRolePermission(obj1);
1008 break;
1009 }
1010 }
1011 if (newObject)
1012 {
1013 obj2.initTurbineRolePermissions();
1014 obj2.addTurbineRolePermission(obj1);
1015 }
1016 results.add(obj1);
1017 }
1018 return results;
1019 }
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030 public static TableMap getTableMap()
1031 throws TorqueException
1032 {
1033 return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
1034 }
1035
1036 private static void setDbName(Criteria crit)
1037 {
1038
1039
1040
1041 if (crit.getDbName() == Torque.getDefaultDB())
1042 {
1043 crit.setDbName(DATABASE_NAME);
1044 }
1045 }
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062 public static List<Record> executeQuery(String queryString) throws TorqueException
1063 {
1064 return BasePeer.executeQuery(queryString);
1065 }
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079 public static List<Record> executeQuery(String queryString, String dbName)
1080 throws TorqueException
1081 {
1082 return BasePeer.executeQuery(queryString,dbName);
1083 }
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098 public static List<Record> executeQuery(
1099 String queryString,
1100 String dbName,
1101 boolean singleRecord)
1102 throws TorqueException
1103 {
1104 return BasePeer.executeQuery(queryString,dbName,singleRecord);
1105 }
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119 public static List<Record> executeQuery(
1120 String queryString,
1121 boolean singleRecord,
1122 Connection con)
1123 throws TorqueException
1124 {
1125 return BasePeer.executeQuery(queryString,singleRecord,con);
1126 }
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142 public static List<Record> executeQuery(
1143 String queryString,
1144 int start,
1145 int numberOfResults,
1146 String dbName,
1147 boolean singleRecord)
1148 throws TorqueException
1149 {
1150 return BasePeer.executeQuery(queryString,start,numberOfResults,dbName,singleRecord);
1151 }
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167 public static List<Record> executeQuery(
1168 String queryString,
1169 int start,
1170 int numberOfResults,
1171 boolean singleRecord,
1172 Connection con)
1173 throws TorqueException
1174 {
1175 return BasePeer.executeQuery(queryString,start,numberOfResults,singleRecord,con);
1176 }
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189 public static List<Record> getSelectResults(QueryDataSet qds)
1190 throws TorqueException
1191 {
1192 return BasePeer.getSelectResults(qds);
1193 }
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207 public static List<Record> getSelectResults(QueryDataSet qds, boolean singleRecord)
1208 throws TorqueException
1209 {
1210 return BasePeer.getSelectResults(qds,singleRecord);
1211 }
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227 public static List<Record> getSelectResults(
1228 QueryDataSet qds,
1229 int numberOfResults,
1230 boolean singleRecord)
1231 throws TorqueException
1232 {
1233 return BasePeer.getSelectResults(qds,numberOfResults,singleRecord);
1234 }
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253 public static List getSelectResults(
1254 QueryDataSet qds,
1255 int start,
1256 int numberOfResults,
1257 boolean singleRecord)
1258 throws TorqueException
1259 {
1260 return BasePeer.getSelectResults(qds,start,numberOfResults,singleRecord);
1261 }
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273 public static List<Record> doPSSelect(Criteria criteria, Connection con)
1274 throws TorqueException
1275 {
1276 return BasePeer.doPSSelect(criteria,con);
1277 }
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288 public static List<Record> doPSSelect(Criteria criteria) throws TorqueException
1289 {
1290 return BasePeer.doPSSelect(criteria);
1291 }
1292 }