1: <?php
2:
3: namespace cli_db\propel\om;
4:
5: use \BasePeer;
6: use \Criteria;
7: use \PDO;
8: use \PDOStatement;
9: use \Propel;
10: use \PropelException;
11: use \PropelPDO;
12: use cli_db\propel\CvtermPeer;
13: use cli_db\propel\FeatureCvterm;
14: use cli_db\propel\FeatureCvtermDbxrefPeer;
15: use cli_db\propel\FeatureCvtermPeer;
16: use cli_db\propel\FeatureCvtermPubPeer;
17: use cli_db\propel\FeatureCvtermpropPeer;
18: use cli_db\propel\FeaturePeer;
19: use cli_db\propel\PubPeer;
20: use cli_db\propel\map\FeatureCvtermTableMap;
21:
22: 23: 24: 25: 26: 27: 28:
29: abstract class BaseFeatureCvtermPeer
30: {
31:
32:
33: const DATABASE_NAME = 'cli_db';
34:
35:
36: const TABLE_NAME = 'feature_cvterm';
37:
38:
39: const OM_CLASS = 'cli_db\\propel\\FeatureCvterm';
40:
41:
42: const TM_CLASS = 'FeatureCvtermTableMap';
43:
44:
45: const NUM_COLUMNS = 6;
46:
47:
48: const NUM_LAZY_LOAD_COLUMNS = 0;
49:
50:
51: const NUM_HYDRATE_COLUMNS = 6;
52:
53:
54: const FEATURE_CVTERM_ID = 'feature_cvterm.feature_cvterm_id';
55:
56:
57: const FEATURE_ID = 'feature_cvterm.feature_id';
58:
59:
60: const CVTERM_ID = 'feature_cvterm.cvterm_id';
61:
62:
63: const PUB_ID = 'feature_cvterm.pub_id';
64:
65:
66: const IS_NOT = 'feature_cvterm.is_not';
67:
68:
69: const RANK = 'feature_cvterm.rank';
70:
71:
72: const DEFAULT_STRING_FORMAT = 'YAML';
73:
74: 75: 76: 77: 78: 79:
80: public static $instances = array();
81:
82:
83: 84: 85: 86: 87: 88:
89: protected static $fieldNames = array (
90: BasePeer::TYPE_PHPNAME => array ('FeatureCvtermId', 'FeatureId', 'CvtermId', 'PubId', 'IsNot', 'Rank', ),
91: BasePeer::TYPE_STUDLYPHPNAME => array ('featureCvtermId', 'featureId', 'cvtermId', 'pubId', 'isNot', 'rank', ),
92: BasePeer::TYPE_COLNAME => array (FeatureCvtermPeer::FEATURE_CVTERM_ID, FeatureCvtermPeer::FEATURE_ID, FeatureCvtermPeer::CVTERM_ID, FeatureCvtermPeer::PUB_ID, FeatureCvtermPeer::IS_NOT, FeatureCvtermPeer::RANK, ),
93: BasePeer::TYPE_RAW_COLNAME => array ('FEATURE_CVTERM_ID', 'FEATURE_ID', 'CVTERM_ID', 'PUB_ID', 'IS_NOT', 'RANK', ),
94: BasePeer::TYPE_FIELDNAME => array ('feature_cvterm_id', 'feature_id', 'cvterm_id', 'pub_id', 'is_not', 'rank', ),
95: BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, )
96: );
97:
98: 99: 100: 101: 102: 103:
104: protected static $fieldKeys = array (
105: BasePeer::TYPE_PHPNAME => array ('FeatureCvtermId' => 0, 'FeatureId' => 1, 'CvtermId' => 2, 'PubId' => 3, 'IsNot' => 4, 'Rank' => 5, ),
106: BasePeer::TYPE_STUDLYPHPNAME => array ('featureCvtermId' => 0, 'featureId' => 1, 'cvtermId' => 2, 'pubId' => 3, 'isNot' => 4, 'rank' => 5, ),
107: BasePeer::TYPE_COLNAME => array (FeatureCvtermPeer::FEATURE_CVTERM_ID => 0, FeatureCvtermPeer::FEATURE_ID => 1, FeatureCvtermPeer::CVTERM_ID => 2, FeatureCvtermPeer::PUB_ID => 3, FeatureCvtermPeer::IS_NOT => 4, FeatureCvtermPeer::RANK => 5, ),
108: BasePeer::TYPE_RAW_COLNAME => array ('FEATURE_CVTERM_ID' => 0, 'FEATURE_ID' => 1, 'CVTERM_ID' => 2, 'PUB_ID' => 3, 'IS_NOT' => 4, 'RANK' => 5, ),
109: BasePeer::TYPE_FIELDNAME => array ('feature_cvterm_id' => 0, 'feature_id' => 1, 'cvterm_id' => 2, 'pub_id' => 3, 'is_not' => 4, 'rank' => 5, ),
110: BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, )
111: );
112:
113: 114: 115: 116: 117: 118: 119: 120: 121: 122:
123: public static function translateFieldName($name, $fromType, $toType)
124: {
125: $toNames = FeatureCvtermPeer::getFieldNames($toType);
126: $key = isset(FeatureCvtermPeer::$fieldKeys[$fromType][$name]) ? FeatureCvtermPeer::$fieldKeys[$fromType][$name] : null;
127: if ($key === null) {
128: throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(FeatureCvtermPeer::$fieldKeys[$fromType], true));
129: }
130:
131: return $toNames[$key];
132: }
133:
134: 135: 136: 137: 138: 139: 140: 141: 142:
143: public static function getFieldNames($type = BasePeer::TYPE_PHPNAME)
144: {
145: if (!array_key_exists($type, FeatureCvtermPeer::$fieldNames)) {
146: throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME, BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. ' . $type . ' was given.');
147: }
148:
149: return FeatureCvtermPeer::$fieldNames[$type];
150: }
151:
152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163:
164: public static function alias($alias, $column)
165: {
166: return str_replace(FeatureCvtermPeer::TABLE_NAME.'.', $alias.'.', $column);
167: }
168:
169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180:
181: public static function addSelectColumns(Criteria $criteria, $alias = null)
182: {
183: if (null === $alias) {
184: $criteria->addSelectColumn(FeatureCvtermPeer::FEATURE_CVTERM_ID);
185: $criteria->addSelectColumn(FeatureCvtermPeer::FEATURE_ID);
186: $criteria->addSelectColumn(FeatureCvtermPeer::CVTERM_ID);
187: $criteria->addSelectColumn(FeatureCvtermPeer::PUB_ID);
188: $criteria->addSelectColumn(FeatureCvtermPeer::IS_NOT);
189: $criteria->addSelectColumn(FeatureCvtermPeer::RANK);
190: } else {
191: $criteria->addSelectColumn($alias . '.feature_cvterm_id');
192: $criteria->addSelectColumn($alias . '.feature_id');
193: $criteria->addSelectColumn($alias . '.cvterm_id');
194: $criteria->addSelectColumn($alias . '.pub_id');
195: $criteria->addSelectColumn($alias . '.is_not');
196: $criteria->addSelectColumn($alias . '.rank');
197: }
198: }
199:
200: 201: 202: 203: 204: 205: 206: 207:
208: public static function doCount(Criteria $criteria, $distinct = false, PropelPDO $con = null)
209: {
210:
211: $criteria = clone $criteria;
212:
213:
214:
215:
216: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
217:
218: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
219: $criteria->setDistinct();
220: }
221:
222: if (!$criteria->hasSelectClause()) {
223: FeatureCvtermPeer::addSelectColumns($criteria);
224: }
225:
226: $criteria->clearOrderByColumns();
227: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
228:
229: if ($con === null) {
230: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
231: }
232:
233: $stmt = BasePeer::doCount($criteria, $con);
234:
235: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
236: $count = (int) $row[0];
237: } else {
238: $count = 0;
239: }
240: $stmt->closeCursor();
241:
242: return $count;
243: }
244: 245: 246: 247: 248: 249: 250: 251: 252:
253: public static function doSelectOne(Criteria $criteria, PropelPDO $con = null)
254: {
255: $critcopy = clone $criteria;
256: $critcopy->setLimit(1);
257: $objects = FeatureCvtermPeer::doSelect($critcopy, $con);
258: if ($objects) {
259: return $objects[0];
260: }
261:
262: return null;
263: }
264: 265: 266: 267: 268: 269: 270: 271: 272:
273: public static function doSelect(Criteria $criteria, PropelPDO $con = null)
274: {
275: return FeatureCvtermPeer::populateObjects(FeatureCvtermPeer::doSelectStmt($criteria, $con));
276: }
277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289:
290: public static function doSelectStmt(Criteria $criteria, PropelPDO $con = null)
291: {
292: if ($con === null) {
293: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
294: }
295:
296: if (!$criteria->hasSelectClause()) {
297: $criteria = clone $criteria;
298: FeatureCvtermPeer::addSelectColumns($criteria);
299: }
300:
301:
302: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
303:
304:
305: return BasePeer::doSelect($criteria, $con);
306: }
307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318:
319: public static function addInstanceToPool($obj, $key = null)
320: {
321: if (Propel::isInstancePoolingEnabled()) {
322: if ($key === null) {
323: $key = (string) $obj->getFeatureCvtermId();
324: }
325: FeatureCvtermPeer::$instances[$key] = $obj;
326: }
327: }
328:
329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341:
342: public static function removeInstanceFromPool($value)
343: {
344: if (Propel::isInstancePoolingEnabled() && $value !== null) {
345: if (is_object($value) && $value instanceof FeatureCvterm) {
346: $key = (string) $value->getFeatureCvtermId();
347: } elseif (is_scalar($value)) {
348:
349: $key = (string) $value;
350: } else {
351: $e = new PropelException("Invalid value passed to removeInstanceFromPool(). Expected primary key or FeatureCvterm object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value,true)));
352: throw $e;
353: }
354:
355: unset(FeatureCvtermPeer::$instances[$key]);
356: }
357: }
358:
359: 360: 361: 362: 363: 364: 365: 366: 367: 368:
369: public static function getInstanceFromPool($key)
370: {
371: if (Propel::isInstancePoolingEnabled()) {
372: if (isset(FeatureCvtermPeer::$instances[$key])) {
373: return FeatureCvtermPeer::$instances[$key];
374: }
375: }
376:
377: return null;
378: }
379:
380: 381: 382: 383: 384:
385: public static function clearInstancePool($and_clear_all_references = false)
386: {
387: if ($and_clear_all_references)
388: {
389: foreach (FeatureCvtermPeer::$instances as $instance)
390: {
391: $instance->clearAllReferences(true);
392: }
393: }
394: FeatureCvtermPeer::$instances = array();
395: }
396:
397: 398: 399: 400:
401: public static function clearRelatedInstancePool()
402: {
403:
404:
405: FeatureCvtermDbxrefPeer::clearInstancePool();
406:
407:
408: FeatureCvtermPubPeer::clearInstancePool();
409:
410:
411: FeatureCvtermpropPeer::clearInstancePool();
412: }
413:
414: 415: 416: 417: 418: 419: 420: 421: 422: 423:
424: public static function getPrimaryKeyHashFromRow($row, $startcol = 0)
425: {
426:
427: if ($row[$startcol] === null) {
428: return null;
429: }
430:
431: return (string) $row[$startcol];
432: }
433:
434: 435: 436: 437: 438: 439: 440: 441: 442:
443: public static function getPrimaryKeyFromRow($row, $startcol = 0)
444: {
445:
446: return (int) $row[$startcol];
447: }
448:
449: 450: 451: 452: 453: 454: 455:
456: public static function populateObjects(PDOStatement $stmt)
457: {
458: $results = array();
459:
460:
461: $cls = FeatureCvtermPeer::getOMClass();
462:
463: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
464: $key = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
465: if (null !== ($obj = FeatureCvtermPeer::getInstanceFromPool($key))) {
466:
467:
468:
469: $results[] = $obj;
470: } else {
471: $obj = new $cls();
472: $obj->hydrate($row);
473: $results[] = $obj;
474: FeatureCvtermPeer::addInstanceToPool($obj, $key);
475: }
476: }
477: $stmt->closeCursor();
478:
479: return $results;
480: }
481: 482: 483: 484: 485: 486: 487: 488: 489:
490: public static function populateObject($row, $startcol = 0)
491: {
492: $key = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, $startcol);
493: if (null !== ($obj = FeatureCvtermPeer::getInstanceFromPool($key))) {
494:
495:
496:
497: $col = $startcol + FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
498: } else {
499: $cls = FeatureCvtermPeer::OM_CLASS;
500: $obj = new $cls();
501: $col = $obj->hydrate($row, $startcol);
502: FeatureCvtermPeer::addInstanceToPool($obj, $key);
503: }
504:
505: return array($obj, $col);
506: }
507:
508:
509: 510: 511: 512: 513: 514: 515: 516: 517:
518: public static function doCountJoinCvterm(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
519: {
520:
521: $criteria = clone $criteria;
522:
523:
524:
525:
526: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
527:
528: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
529: $criteria->setDistinct();
530: }
531:
532: if (!$criteria->hasSelectClause()) {
533: FeatureCvtermPeer::addSelectColumns($criteria);
534: }
535:
536: $criteria->clearOrderByColumns();
537:
538:
539: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
540:
541: if ($con === null) {
542: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
543: }
544:
545: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
546:
547: $stmt = BasePeer::doCount($criteria, $con);
548:
549: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
550: $count = (int) $row[0];
551: } else {
552: $count = 0;
553: }
554: $stmt->closeCursor();
555:
556: return $count;
557: }
558:
559:
560: 561: 562: 563: 564: 565: 566: 567: 568:
569: public static function doCountJoinFeature(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
570: {
571:
572: $criteria = clone $criteria;
573:
574:
575:
576:
577: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
578:
579: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
580: $criteria->setDistinct();
581: }
582:
583: if (!$criteria->hasSelectClause()) {
584: FeatureCvtermPeer::addSelectColumns($criteria);
585: }
586:
587: $criteria->clearOrderByColumns();
588:
589:
590: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
591:
592: if ($con === null) {
593: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
594: }
595:
596: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
597:
598: $stmt = BasePeer::doCount($criteria, $con);
599:
600: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
601: $count = (int) $row[0];
602: } else {
603: $count = 0;
604: }
605: $stmt->closeCursor();
606:
607: return $count;
608: }
609:
610:
611: 612: 613: 614: 615: 616: 617: 618: 619:
620: public static function doCountJoinPub(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
621: {
622:
623: $criteria = clone $criteria;
624:
625:
626:
627:
628: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
629:
630: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
631: $criteria->setDistinct();
632: }
633:
634: if (!$criteria->hasSelectClause()) {
635: FeatureCvtermPeer::addSelectColumns($criteria);
636: }
637:
638: $criteria->clearOrderByColumns();
639:
640:
641: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
642:
643: if ($con === null) {
644: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
645: }
646:
647: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
648:
649: $stmt = BasePeer::doCount($criteria, $con);
650:
651: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
652: $count = (int) $row[0];
653: } else {
654: $count = 0;
655: }
656: $stmt->closeCursor();
657:
658: return $count;
659: }
660:
661:
662: 663: 664: 665: 666: 667: 668: 669: 670:
671: public static function doSelectJoinCvterm(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
672: {
673: $criteria = clone $criteria;
674:
675:
676: if ($criteria->getDbName() == Propel::getDefaultDB()) {
677: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
678: }
679:
680: FeatureCvtermPeer::addSelectColumns($criteria);
681: $startcol = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
682: CvtermPeer::addSelectColumns($criteria);
683:
684: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
685:
686: $stmt = BasePeer::doSelect($criteria, $con);
687: $results = array();
688:
689: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
690: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
691: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
692:
693:
694:
695: } else {
696:
697: $cls = FeatureCvtermPeer::getOMClass();
698:
699: $obj1 = new $cls();
700: $obj1->hydrate($row);
701: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
702: }
703:
704: $key2 = CvtermPeer::getPrimaryKeyHashFromRow($row, $startcol);
705: if ($key2 !== null) {
706: $obj2 = CvtermPeer::getInstanceFromPool($key2);
707: if (!$obj2) {
708:
709: $cls = CvtermPeer::getOMClass();
710:
711: $obj2 = new $cls();
712: $obj2->hydrate($row, $startcol);
713: CvtermPeer::addInstanceToPool($obj2, $key2);
714: }
715:
716:
717: $obj2->addFeatureCvterm($obj1);
718:
719: }
720:
721: $results[] = $obj1;
722: }
723: $stmt->closeCursor();
724:
725: return $results;
726: }
727:
728:
729: 730: 731: 732: 733: 734: 735: 736: 737:
738: public static function doSelectJoinFeature(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
739: {
740: $criteria = clone $criteria;
741:
742:
743: if ($criteria->getDbName() == Propel::getDefaultDB()) {
744: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
745: }
746:
747: FeatureCvtermPeer::addSelectColumns($criteria);
748: $startcol = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
749: FeaturePeer::addSelectColumns($criteria);
750:
751: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
752:
753: $stmt = BasePeer::doSelect($criteria, $con);
754: $results = array();
755:
756: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
757: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
758: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
759:
760:
761:
762: } else {
763:
764: $cls = FeatureCvtermPeer::getOMClass();
765:
766: $obj1 = new $cls();
767: $obj1->hydrate($row);
768: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
769: }
770:
771: $key2 = FeaturePeer::getPrimaryKeyHashFromRow($row, $startcol);
772: if ($key2 !== null) {
773: $obj2 = FeaturePeer::getInstanceFromPool($key2);
774: if (!$obj2) {
775:
776: $cls = FeaturePeer::getOMClass();
777:
778: $obj2 = new $cls();
779: $obj2->hydrate($row, $startcol);
780: FeaturePeer::addInstanceToPool($obj2, $key2);
781: }
782:
783:
784: $obj2->addFeatureCvterm($obj1);
785:
786: }
787:
788: $results[] = $obj1;
789: }
790: $stmt->closeCursor();
791:
792: return $results;
793: }
794:
795:
796: 797: 798: 799: 800: 801: 802: 803: 804:
805: public static function doSelectJoinPub(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
806: {
807: $criteria = clone $criteria;
808:
809:
810: if ($criteria->getDbName() == Propel::getDefaultDB()) {
811: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
812: }
813:
814: FeatureCvtermPeer::addSelectColumns($criteria);
815: $startcol = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
816: PubPeer::addSelectColumns($criteria);
817:
818: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
819:
820: $stmt = BasePeer::doSelect($criteria, $con);
821: $results = array();
822:
823: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
824: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
825: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
826:
827:
828:
829: } else {
830:
831: $cls = FeatureCvtermPeer::getOMClass();
832:
833: $obj1 = new $cls();
834: $obj1->hydrate($row);
835: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
836: }
837:
838: $key2 = PubPeer::getPrimaryKeyHashFromRow($row, $startcol);
839: if ($key2 !== null) {
840: $obj2 = PubPeer::getInstanceFromPool($key2);
841: if (!$obj2) {
842:
843: $cls = PubPeer::getOMClass();
844:
845: $obj2 = new $cls();
846: $obj2->hydrate($row, $startcol);
847: PubPeer::addInstanceToPool($obj2, $key2);
848: }
849:
850:
851: $obj2->addFeatureCvterm($obj1);
852:
853: }
854:
855: $results[] = $obj1;
856: }
857: $stmt->closeCursor();
858:
859: return $results;
860: }
861:
862:
863: 864: 865: 866: 867: 868: 869: 870: 871:
872: public static function doCountJoinAll(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
873: {
874:
875: $criteria = clone $criteria;
876:
877:
878:
879:
880: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
881:
882: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
883: $criteria->setDistinct();
884: }
885:
886: if (!$criteria->hasSelectClause()) {
887: FeatureCvtermPeer::addSelectColumns($criteria);
888: }
889:
890: $criteria->clearOrderByColumns();
891:
892:
893: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
894:
895: if ($con === null) {
896: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
897: }
898:
899: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
900:
901: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
902:
903: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
904:
905: $stmt = BasePeer::doCount($criteria, $con);
906:
907: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
908: $count = (int) $row[0];
909: } else {
910: $count = 0;
911: }
912: $stmt->closeCursor();
913:
914: return $count;
915: }
916:
917: 918: 919: 920: 921: 922: 923: 924: 925: 926:
927: public static function doSelectJoinAll(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
928: {
929: $criteria = clone $criteria;
930:
931:
932: if ($criteria->getDbName() == Propel::getDefaultDB()) {
933: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
934: }
935:
936: FeatureCvtermPeer::addSelectColumns($criteria);
937: $startcol2 = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
938:
939: CvtermPeer::addSelectColumns($criteria);
940: $startcol3 = $startcol2 + CvtermPeer::NUM_HYDRATE_COLUMNS;
941:
942: FeaturePeer::addSelectColumns($criteria);
943: $startcol4 = $startcol3 + FeaturePeer::NUM_HYDRATE_COLUMNS;
944:
945: PubPeer::addSelectColumns($criteria);
946: $startcol5 = $startcol4 + PubPeer::NUM_HYDRATE_COLUMNS;
947:
948: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
949:
950: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
951:
952: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
953:
954: $stmt = BasePeer::doSelect($criteria, $con);
955: $results = array();
956:
957: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
958: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
959: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
960:
961:
962:
963: } else {
964: $cls = FeatureCvtermPeer::getOMClass();
965:
966: $obj1 = new $cls();
967: $obj1->hydrate($row);
968: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
969: }
970:
971:
972:
973: $key2 = CvtermPeer::getPrimaryKeyHashFromRow($row, $startcol2);
974: if ($key2 !== null) {
975: $obj2 = CvtermPeer::getInstanceFromPool($key2);
976: if (!$obj2) {
977:
978: $cls = CvtermPeer::getOMClass();
979:
980: $obj2 = new $cls();
981: $obj2->hydrate($row, $startcol2);
982: CvtermPeer::addInstanceToPool($obj2, $key2);
983: }
984:
985:
986: $obj2->addFeatureCvterm($obj1);
987: }
988:
989:
990:
991: $key3 = FeaturePeer::getPrimaryKeyHashFromRow($row, $startcol3);
992: if ($key3 !== null) {
993: $obj3 = FeaturePeer::getInstanceFromPool($key3);
994: if (!$obj3) {
995:
996: $cls = FeaturePeer::getOMClass();
997:
998: $obj3 = new $cls();
999: $obj3->hydrate($row, $startcol3);
1000: FeaturePeer::addInstanceToPool($obj3, $key3);
1001: }
1002:
1003:
1004: $obj3->addFeatureCvterm($obj1);
1005: }
1006:
1007:
1008:
1009: $key4 = PubPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1010: if ($key4 !== null) {
1011: $obj4 = PubPeer::getInstanceFromPool($key4);
1012: if (!$obj4) {
1013:
1014: $cls = PubPeer::getOMClass();
1015:
1016: $obj4 = new $cls();
1017: $obj4->hydrate($row, $startcol4);
1018: PubPeer::addInstanceToPool($obj4, $key4);
1019: }
1020:
1021:
1022: $obj4->addFeatureCvterm($obj1);
1023: }
1024:
1025: $results[] = $obj1;
1026: }
1027: $stmt->closeCursor();
1028:
1029: return $results;
1030: }
1031:
1032:
1033: 1034: 1035: 1036: 1037: 1038: 1039: 1040: 1041:
1042: public static function doCountJoinAllExceptCvterm(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1043: {
1044:
1045: $criteria = clone $criteria;
1046:
1047:
1048:
1049:
1050: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
1051:
1052: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1053: $criteria->setDistinct();
1054: }
1055:
1056: if (!$criteria->hasSelectClause()) {
1057: FeatureCvtermPeer::addSelectColumns($criteria);
1058: }
1059:
1060: $criteria->clearOrderByColumns();
1061:
1062:
1063: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1064:
1065: if ($con === null) {
1066: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1067: }
1068:
1069: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
1070:
1071: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
1072:
1073: $stmt = BasePeer::doCount($criteria, $con);
1074:
1075: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1076: $count = (int) $row[0];
1077: } else {
1078: $count = 0;
1079: }
1080: $stmt->closeCursor();
1081:
1082: return $count;
1083: }
1084:
1085:
1086: 1087: 1088: 1089: 1090: 1091: 1092: 1093: 1094:
1095: public static function doCountJoinAllExceptFeature(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1096: {
1097:
1098: $criteria = clone $criteria;
1099:
1100:
1101:
1102:
1103: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
1104:
1105: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1106: $criteria->setDistinct();
1107: }
1108:
1109: if (!$criteria->hasSelectClause()) {
1110: FeatureCvtermPeer::addSelectColumns($criteria);
1111: }
1112:
1113: $criteria->clearOrderByColumns();
1114:
1115:
1116: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1117:
1118: if ($con === null) {
1119: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1120: }
1121:
1122: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
1123:
1124: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
1125:
1126: $stmt = BasePeer::doCount($criteria, $con);
1127:
1128: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1129: $count = (int) $row[0];
1130: } else {
1131: $count = 0;
1132: }
1133: $stmt->closeCursor();
1134:
1135: return $count;
1136: }
1137:
1138:
1139: 1140: 1141: 1142: 1143: 1144: 1145: 1146: 1147:
1148: public static function doCountJoinAllExceptPub(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1149: {
1150:
1151: $criteria = clone $criteria;
1152:
1153:
1154:
1155:
1156: $criteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
1157:
1158: if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1159: $criteria->setDistinct();
1160: }
1161:
1162: if (!$criteria->hasSelectClause()) {
1163: FeatureCvtermPeer::addSelectColumns($criteria);
1164: }
1165:
1166: $criteria->clearOrderByColumns();
1167:
1168:
1169: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1170:
1171: if ($con === null) {
1172: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1173: }
1174:
1175: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
1176:
1177: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
1178:
1179: $stmt = BasePeer::doCount($criteria, $con);
1180:
1181: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1182: $count = (int) $row[0];
1183: } else {
1184: $count = 0;
1185: }
1186: $stmt->closeCursor();
1187:
1188: return $count;
1189: }
1190:
1191:
1192: 1193: 1194: 1195: 1196: 1197: 1198: 1199: 1200: 1201:
1202: public static function doSelectJoinAllExceptCvterm(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1203: {
1204: $criteria = clone $criteria;
1205:
1206:
1207:
1208:
1209: if ($criteria->getDbName() == Propel::getDefaultDB()) {
1210: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1211: }
1212:
1213: FeatureCvtermPeer::addSelectColumns($criteria);
1214: $startcol2 = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
1215:
1216: FeaturePeer::addSelectColumns($criteria);
1217: $startcol3 = $startcol2 + FeaturePeer::NUM_HYDRATE_COLUMNS;
1218:
1219: PubPeer::addSelectColumns($criteria);
1220: $startcol4 = $startcol3 + PubPeer::NUM_HYDRATE_COLUMNS;
1221:
1222: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
1223:
1224: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
1225:
1226:
1227: $stmt = BasePeer::doSelect($criteria, $con);
1228: $results = array();
1229:
1230: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1231: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
1232: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
1233:
1234:
1235:
1236: } else {
1237: $cls = FeatureCvtermPeer::getOMClass();
1238:
1239: $obj1 = new $cls();
1240: $obj1->hydrate($row);
1241: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
1242: }
1243:
1244:
1245:
1246: $key2 = FeaturePeer::getPrimaryKeyHashFromRow($row, $startcol2);
1247: if ($key2 !== null) {
1248: $obj2 = FeaturePeer::getInstanceFromPool($key2);
1249: if (!$obj2) {
1250:
1251: $cls = FeaturePeer::getOMClass();
1252:
1253: $obj2 = new $cls();
1254: $obj2->hydrate($row, $startcol2);
1255: FeaturePeer::addInstanceToPool($obj2, $key2);
1256: }
1257:
1258:
1259: $obj2->addFeatureCvterm($obj1);
1260:
1261: }
1262:
1263:
1264:
1265: $key3 = PubPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1266: if ($key3 !== null) {
1267: $obj3 = PubPeer::getInstanceFromPool($key3);
1268: if (!$obj3) {
1269:
1270: $cls = PubPeer::getOMClass();
1271:
1272: $obj3 = new $cls();
1273: $obj3->hydrate($row, $startcol3);
1274: PubPeer::addInstanceToPool($obj3, $key3);
1275: }
1276:
1277:
1278: $obj3->addFeatureCvterm($obj1);
1279:
1280: }
1281:
1282: $results[] = $obj1;
1283: }
1284: $stmt->closeCursor();
1285:
1286: return $results;
1287: }
1288:
1289:
1290: 1291: 1292: 1293: 1294: 1295: 1296: 1297: 1298: 1299:
1300: public static function doSelectJoinAllExceptFeature(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1301: {
1302: $criteria = clone $criteria;
1303:
1304:
1305:
1306:
1307: if ($criteria->getDbName() == Propel::getDefaultDB()) {
1308: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1309: }
1310:
1311: FeatureCvtermPeer::addSelectColumns($criteria);
1312: $startcol2 = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
1313:
1314: CvtermPeer::addSelectColumns($criteria);
1315: $startcol3 = $startcol2 + CvtermPeer::NUM_HYDRATE_COLUMNS;
1316:
1317: PubPeer::addSelectColumns($criteria);
1318: $startcol4 = $startcol3 + PubPeer::NUM_HYDRATE_COLUMNS;
1319:
1320: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
1321:
1322: $criteria->addJoin(FeatureCvtermPeer::PUB_ID, PubPeer::PUB_ID, $join_behavior);
1323:
1324:
1325: $stmt = BasePeer::doSelect($criteria, $con);
1326: $results = array();
1327:
1328: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1329: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
1330: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
1331:
1332:
1333:
1334: } else {
1335: $cls = FeatureCvtermPeer::getOMClass();
1336:
1337: $obj1 = new $cls();
1338: $obj1->hydrate($row);
1339: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
1340: }
1341:
1342:
1343:
1344: $key2 = CvtermPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1345: if ($key2 !== null) {
1346: $obj2 = CvtermPeer::getInstanceFromPool($key2);
1347: if (!$obj2) {
1348:
1349: $cls = CvtermPeer::getOMClass();
1350:
1351: $obj2 = new $cls();
1352: $obj2->hydrate($row, $startcol2);
1353: CvtermPeer::addInstanceToPool($obj2, $key2);
1354: }
1355:
1356:
1357: $obj2->addFeatureCvterm($obj1);
1358:
1359: }
1360:
1361:
1362:
1363: $key3 = PubPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1364: if ($key3 !== null) {
1365: $obj3 = PubPeer::getInstanceFromPool($key3);
1366: if (!$obj3) {
1367:
1368: $cls = PubPeer::getOMClass();
1369:
1370: $obj3 = new $cls();
1371: $obj3->hydrate($row, $startcol3);
1372: PubPeer::addInstanceToPool($obj3, $key3);
1373: }
1374:
1375:
1376: $obj3->addFeatureCvterm($obj1);
1377:
1378: }
1379:
1380: $results[] = $obj1;
1381: }
1382: $stmt->closeCursor();
1383:
1384: return $results;
1385: }
1386:
1387:
1388: 1389: 1390: 1391: 1392: 1393: 1394: 1395: 1396: 1397:
1398: public static function doSelectJoinAllExceptPub(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1399: {
1400: $criteria = clone $criteria;
1401:
1402:
1403:
1404:
1405: if ($criteria->getDbName() == Propel::getDefaultDB()) {
1406: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1407: }
1408:
1409: FeatureCvtermPeer::addSelectColumns($criteria);
1410: $startcol2 = FeatureCvtermPeer::NUM_HYDRATE_COLUMNS;
1411:
1412: CvtermPeer::addSelectColumns($criteria);
1413: $startcol3 = $startcol2 + CvtermPeer::NUM_HYDRATE_COLUMNS;
1414:
1415: FeaturePeer::addSelectColumns($criteria);
1416: $startcol4 = $startcol3 + FeaturePeer::NUM_HYDRATE_COLUMNS;
1417:
1418: $criteria->addJoin(FeatureCvtermPeer::CVTERM_ID, CvtermPeer::CVTERM_ID, $join_behavior);
1419:
1420: $criteria->addJoin(FeatureCvtermPeer::FEATURE_ID, FeaturePeer::FEATURE_ID, $join_behavior);
1421:
1422:
1423: $stmt = BasePeer::doSelect($criteria, $con);
1424: $results = array();
1425:
1426: while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1427: $key1 = FeatureCvtermPeer::getPrimaryKeyHashFromRow($row, 0);
1428: if (null !== ($obj1 = FeatureCvtermPeer::getInstanceFromPool($key1))) {
1429:
1430:
1431:
1432: } else {
1433: $cls = FeatureCvtermPeer::getOMClass();
1434:
1435: $obj1 = new $cls();
1436: $obj1->hydrate($row);
1437: FeatureCvtermPeer::addInstanceToPool($obj1, $key1);
1438: }
1439:
1440:
1441:
1442: $key2 = CvtermPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1443: if ($key2 !== null) {
1444: $obj2 = CvtermPeer::getInstanceFromPool($key2);
1445: if (!$obj2) {
1446:
1447: $cls = CvtermPeer::getOMClass();
1448:
1449: $obj2 = new $cls();
1450: $obj2->hydrate($row, $startcol2);
1451: CvtermPeer::addInstanceToPool($obj2, $key2);
1452: }
1453:
1454:
1455: $obj2->addFeatureCvterm($obj1);
1456:
1457: }
1458:
1459:
1460:
1461: $key3 = FeaturePeer::getPrimaryKeyHashFromRow($row, $startcol3);
1462: if ($key3 !== null) {
1463: $obj3 = FeaturePeer::getInstanceFromPool($key3);
1464: if (!$obj3) {
1465:
1466: $cls = FeaturePeer::getOMClass();
1467:
1468: $obj3 = new $cls();
1469: $obj3->hydrate($row, $startcol3);
1470: FeaturePeer::addInstanceToPool($obj3, $key3);
1471: }
1472:
1473:
1474: $obj3->addFeatureCvterm($obj1);
1475:
1476: }
1477:
1478: $results[] = $obj1;
1479: }
1480: $stmt->closeCursor();
1481:
1482: return $results;
1483: }
1484:
1485: 1486: 1487: 1488: 1489: 1490: 1491:
1492: public static function getTableMap()
1493: {
1494: return Propel::getDatabaseMap(FeatureCvtermPeer::DATABASE_NAME)->getTable(FeatureCvtermPeer::TABLE_NAME);
1495: }
1496:
1497: 1498: 1499:
1500: public static function buildTableMap()
1501: {
1502: $dbMap = Propel::getDatabaseMap(BaseFeatureCvtermPeer::DATABASE_NAME);
1503: if (!$dbMap->hasTable(BaseFeatureCvtermPeer::TABLE_NAME)) {
1504: $dbMap->addTableObject(new FeatureCvtermTableMap());
1505: }
1506: }
1507:
1508: 1509: 1510: 1511: 1512: 1513:
1514: public static function getOMClass($row = 0, $colnum = 0)
1515: {
1516: return FeatureCvtermPeer::OM_CLASS;
1517: }
1518:
1519: 1520: 1521: 1522: 1523: 1524: 1525: 1526: 1527:
1528: public static function doInsert($values, PropelPDO $con = null)
1529: {
1530: if ($con === null) {
1531: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1532: }
1533:
1534: if ($values instanceof Criteria) {
1535: $criteria = clone $values;
1536: } else {
1537: $criteria = $values->buildCriteria();
1538: }
1539:
1540: if ($criteria->containsKey(FeatureCvtermPeer::FEATURE_CVTERM_ID) && $criteria->keyContainsValue(FeatureCvtermPeer::FEATURE_CVTERM_ID) ) {
1541: throw new PropelException('Cannot insert a value for auto-increment primary key ('.FeatureCvtermPeer::FEATURE_CVTERM_ID.')');
1542: }
1543:
1544:
1545:
1546: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1547:
1548: try {
1549:
1550:
1551: $con->beginTransaction();
1552: $pk = BasePeer::doInsert($criteria, $con);
1553: $con->commit();
1554: } catch (PropelException $e) {
1555: $con->rollBack();
1556: throw $e;
1557: }
1558:
1559: return $pk;
1560: }
1561:
1562: 1563: 1564: 1565: 1566: 1567: 1568: 1569: 1570:
1571: public static function doUpdate($values, PropelPDO $con = null)
1572: {
1573: if ($con === null) {
1574: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1575: }
1576:
1577: $selectCriteria = new Criteria(FeatureCvtermPeer::DATABASE_NAME);
1578:
1579: if ($values instanceof Criteria) {
1580: $criteria = clone $values;
1581:
1582: $comparison = $criteria->getComparison(FeatureCvtermPeer::FEATURE_CVTERM_ID);
1583: $value = $criteria->remove(FeatureCvtermPeer::FEATURE_CVTERM_ID);
1584: if ($value) {
1585: $selectCriteria->add(FeatureCvtermPeer::FEATURE_CVTERM_ID, $value, $comparison);
1586: } else {
1587: $selectCriteria->setPrimaryTableName(FeatureCvtermPeer::TABLE_NAME);
1588: }
1589:
1590: } else {
1591: $criteria = $values->buildCriteria();
1592: $selectCriteria = $values->buildPkeyCriteria();
1593: }
1594:
1595:
1596: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1597:
1598: return BasePeer::doUpdate($selectCriteria, $criteria, $con);
1599: }
1600:
1601: 1602: 1603: 1604: 1605: 1606: 1607:
1608: public static function doDeleteAll(PropelPDO $con = null)
1609: {
1610: if ($con === null) {
1611: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1612: }
1613: $affectedRows = 0;
1614: try {
1615:
1616:
1617: $con->beginTransaction();
1618: $affectedRows += BasePeer::doDeleteAll(FeatureCvtermPeer::TABLE_NAME, $con, FeatureCvtermPeer::DATABASE_NAME);
1619:
1620:
1621:
1622: FeatureCvtermPeer::clearInstancePool();
1623: FeatureCvtermPeer::clearRelatedInstancePool();
1624: $con->commit();
1625:
1626: return $affectedRows;
1627: } catch (PropelException $e) {
1628: $con->rollBack();
1629: throw $e;
1630: }
1631: }
1632:
1633: 1634: 1635: 1636: 1637: 1638: 1639: 1640: 1641: 1642: 1643:
1644: public static function doDelete($values, PropelPDO $con = null)
1645: {
1646: if ($con === null) {
1647: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1648: }
1649:
1650: if ($values instanceof Criteria) {
1651:
1652:
1653:
1654: FeatureCvtermPeer::clearInstancePool();
1655:
1656: $criteria = clone $values;
1657: } elseif ($values instanceof FeatureCvterm) {
1658:
1659: FeatureCvtermPeer::removeInstanceFromPool($values);
1660:
1661: $criteria = $values->buildPkeyCriteria();
1662: } else {
1663: $criteria = new Criteria(FeatureCvtermPeer::DATABASE_NAME);
1664: $criteria->add(FeatureCvtermPeer::FEATURE_CVTERM_ID, (array) $values, Criteria::IN);
1665:
1666: foreach ((array) $values as $singleval) {
1667: FeatureCvtermPeer::removeInstanceFromPool($singleval);
1668: }
1669: }
1670:
1671:
1672: $criteria->setDbName(FeatureCvtermPeer::DATABASE_NAME);
1673:
1674: $affectedRows = 0;
1675:
1676: try {
1677:
1678:
1679: $con->beginTransaction();
1680:
1681: $affectedRows += BasePeer::doDelete($criteria, $con);
1682: FeatureCvtermPeer::clearRelatedInstancePool();
1683: $con->commit();
1684:
1685: return $affectedRows;
1686: } catch (PropelException $e) {
1687: $con->rollBack();
1688: throw $e;
1689: }
1690: }
1691:
1692: 1693: 1694: 1695: 1696: 1697: 1698: 1699: 1700: 1701: 1702: 1703:
1704: public static function doValidate($obj, $cols = null)
1705: {
1706: $columns = array();
1707:
1708: if ($cols) {
1709: $dbMap = Propel::getDatabaseMap(FeatureCvtermPeer::DATABASE_NAME);
1710: $tableMap = $dbMap->getTable(FeatureCvtermPeer::TABLE_NAME);
1711:
1712: if (! is_array($cols)) {
1713: $cols = array($cols);
1714: }
1715:
1716: foreach ($cols as $colName) {
1717: if ($tableMap->hasColumn($colName)) {
1718: $get = 'get' . $tableMap->getColumn($colName)->getPhpName();
1719: $columns[$colName] = $obj->$get();
1720: }
1721: }
1722: } else {
1723:
1724: }
1725:
1726: return BasePeer::doValidate(FeatureCvtermPeer::DATABASE_NAME, FeatureCvtermPeer::TABLE_NAME, $columns);
1727: }
1728:
1729: 1730: 1731: 1732: 1733: 1734: 1735:
1736: public static function retrieveByPK($pk, PropelPDO $con = null)
1737: {
1738:
1739: if (null !== ($obj = FeatureCvtermPeer::getInstanceFromPool((string) $pk))) {
1740: return $obj;
1741: }
1742:
1743: if ($con === null) {
1744: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1745: }
1746:
1747: $criteria = new Criteria(FeatureCvtermPeer::DATABASE_NAME);
1748: $criteria->add(FeatureCvtermPeer::FEATURE_CVTERM_ID, $pk);
1749:
1750: $v = FeatureCvtermPeer::doSelect($criteria, $con);
1751:
1752: return !empty($v) > 0 ? $v[0] : null;
1753: }
1754:
1755: 1756: 1757: 1758: 1759: 1760: 1761: 1762: 1763:
1764: public static function retrieveByPKs($pks, PropelPDO $con = null)
1765: {
1766: if ($con === null) {
1767: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1768: }
1769:
1770: $objs = null;
1771: if (empty($pks)) {
1772: $objs = array();
1773: } else {
1774: $criteria = new Criteria(FeatureCvtermPeer::DATABASE_NAME);
1775: $criteria->add(FeatureCvtermPeer::FEATURE_CVTERM_ID, $pks, Criteria::IN);
1776: $objs = FeatureCvtermPeer::doSelect($criteria, $con);
1777: }
1778:
1779: return $objs;
1780: }
1781:
1782: }
1783:
1784:
1785:
1786: BaseFeatureCvtermPeer::buildTableMap();
1787:
1788: