1: <?php
2:
3: namespace cli_db\propel\om;
4:
5: use \Criteria;
6: use \Exception;
7: use \ModelCriteria;
8: use \ModelJoin;
9: use \PDO;
10: use \Propel;
11: use \PropelCollection;
12: use \PropelException;
13: use \PropelObjectCollection;
14: use \PropelPDO;
15: use cli_db\propel\Db;
16: use cli_db\propel\Dbxref;
17: use cli_db\propel\DbxrefPeer;
18: use cli_db\propel\DbxrefQuery;
19: use cli_db\propel\Feature;
20: use cli_db\propel\FeatureCvtermDbxref;
21: use cli_db\propel\FeatureDbxref;
22: use cli_db\propel\PubDbxref;
23:
24: /**
25: * Base class that represents a query for the 'dbxref' table.
26: *
27: *
28: *
29: * @method DbxrefQuery orderByDbxrefId($order = Criteria::ASC) Order by the dbxref_id column
30: * @method DbxrefQuery orderByDbId($order = Criteria::ASC) Order by the db_id column
31: * @method DbxrefQuery orderByAccession($order = Criteria::ASC) Order by the accession column
32: * @method DbxrefQuery orderByVersion($order = Criteria::ASC) Order by the version column
33: * @method DbxrefQuery orderByDescription($order = Criteria::ASC) Order by the description column
34: *
35: * @method DbxrefQuery groupByDbxrefId() Group by the dbxref_id column
36: * @method DbxrefQuery groupByDbId() Group by the db_id column
37: * @method DbxrefQuery groupByAccession() Group by the accession column
38: * @method DbxrefQuery groupByVersion() Group by the version column
39: * @method DbxrefQuery groupByDescription() Group by the description column
40: *
41: * @method DbxrefQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
42: * @method DbxrefQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
43: * @method DbxrefQuery innerJoin($relation) Adds a INNER JOIN clause to the query
44: *
45: * @method DbxrefQuery leftJoinDb($relationAlias = null) Adds a LEFT JOIN clause to the query using the Db relation
46: * @method DbxrefQuery rightJoinDb($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Db relation
47: * @method DbxrefQuery innerJoinDb($relationAlias = null) Adds a INNER JOIN clause to the query using the Db relation
48: *
49: * @method DbxrefQuery leftJoinFeature($relationAlias = null) Adds a LEFT JOIN clause to the query using the Feature relation
50: * @method DbxrefQuery rightJoinFeature($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Feature relation
51: * @method DbxrefQuery innerJoinFeature($relationAlias = null) Adds a INNER JOIN clause to the query using the Feature relation
52: *
53: * @method DbxrefQuery leftJoinFeatureCvtermDbxref($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureCvtermDbxref relation
54: * @method DbxrefQuery rightJoinFeatureCvtermDbxref($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureCvtermDbxref relation
55: * @method DbxrefQuery innerJoinFeatureCvtermDbxref($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureCvtermDbxref relation
56: *
57: * @method DbxrefQuery leftJoinFeatureDbxref($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureDbxref relation
58: * @method DbxrefQuery rightJoinFeatureDbxref($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureDbxref relation
59: * @method DbxrefQuery innerJoinFeatureDbxref($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureDbxref relation
60: *
61: * @method DbxrefQuery leftJoinPubDbxref($relationAlias = null) Adds a LEFT JOIN clause to the query using the PubDbxref relation
62: * @method DbxrefQuery rightJoinPubDbxref($relationAlias = null) Adds a RIGHT JOIN clause to the query using the PubDbxref relation
63: * @method DbxrefQuery innerJoinPubDbxref($relationAlias = null) Adds a INNER JOIN clause to the query using the PubDbxref relation
64: *
65: * @method Dbxref findOne(PropelPDO $con = null) Return the first Dbxref matching the query
66: * @method Dbxref findOneOrCreate(PropelPDO $con = null) Return the first Dbxref matching the query, or a new Dbxref object populated from the query conditions when no match is found
67: *
68: * @method Dbxref findOneByDbId(int $db_id) Return the first Dbxref filtered by the db_id column
69: * @method Dbxref findOneByAccession(string $accession) Return the first Dbxref filtered by the accession column
70: * @method Dbxref findOneByVersion(string $version) Return the first Dbxref filtered by the version column
71: * @method Dbxref findOneByDescription(string $description) Return the first Dbxref filtered by the description column
72: *
73: * @method array findByDbxrefId(int $dbxref_id) Return Dbxref objects filtered by the dbxref_id column
74: * @method array findByDbId(int $db_id) Return Dbxref objects filtered by the db_id column
75: * @method array findByAccession(string $accession) Return Dbxref objects filtered by the accession column
76: * @method array findByVersion(string $version) Return Dbxref objects filtered by the version column
77: * @method array findByDescription(string $description) Return Dbxref objects filtered by the description column
78: *
79: * @package propel.generator.cli_db.om
80: */
81: abstract class BaseDbxrefQuery extends ModelCriteria
82: {
83: /**
84: * Initializes internal state of BaseDbxrefQuery object.
85: *
86: * @param string $dbName The dabase name
87: * @param string $modelName The phpName of a model, e.g. 'Book'
88: * @param string $modelAlias The alias for the model in this query, e.g. 'b'
89: */
90: public function __construct($dbName = 'cli_db', $modelName = 'cli_db\\propel\\Dbxref', $modelAlias = null)
91: {
92: parent::__construct($dbName, $modelName, $modelAlias);
93: }
94:
95: /**
96: * Returns a new DbxrefQuery object.
97: *
98: * @param string $modelAlias The alias of a model in the query
99: * @param DbxrefQuery|Criteria $criteria Optional Criteria to build the query from
100: *
101: * @return DbxrefQuery
102: */
103: public static function create($modelAlias = null, $criteria = null)
104: {
105: if ($criteria instanceof DbxrefQuery) {
106: return $criteria;
107: }
108: $query = new DbxrefQuery();
109: if (null !== $modelAlias) {
110: $query->setModelAlias($modelAlias);
111: }
112: if ($criteria instanceof Criteria) {
113: $query->mergeWith($criteria);
114: }
115:
116: return $query;
117: }
118:
119: /**
120: * Find object by primary key.
121: * Propel uses the instance pool to skip the database if the object exists.
122: * Go fast if the query is untouched.
123: *
124: * <code>
125: * $obj = $c->findPk(12, $con);
126: * </code>
127: *
128: * @param mixed $key Primary key to use for the query
129: * @param PropelPDO $con an optional connection object
130: *
131: * @return Dbxref|Dbxref[]|mixed the result, formatted by the current formatter
132: */
133: public function findPk($key, $con = null)
134: {
135: if ($key === null) {
136: return null;
137: }
138: if ((null !== ($obj = DbxrefPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
139: // the object is alredy in the instance pool
140: return $obj;
141: }
142: if ($con === null) {
143: $con = Propel::getConnection(DbxrefPeer::DATABASE_NAME, Propel::CONNECTION_READ);
144: }
145: $this->basePreSelect($con);
146: if ($this->formatter || $this->modelAlias || $this->with || $this->select
147: || $this->selectColumns || $this->asColumns || $this->selectModifiers
148: || $this->map || $this->having || $this->joins) {
149: return $this->findPkComplex($key, $con);
150: } else {
151: return $this->findPkSimple($key, $con);
152: }
153: }
154:
155: /**
156: * Alias of findPk to use instance pooling
157: *
158: * @param mixed $key Primary key to use for the query
159: * @param PropelPDO $con A connection object
160: *
161: * @return Dbxref A model object, or null if the key is not found
162: * @throws PropelException
163: */
164: public function findOneByDbxrefId($key, $con = null)
165: {
166: return $this->findPk($key, $con);
167: }
168:
169: /**
170: * Find object by primary key using raw SQL to go fast.
171: * Bypass doSelect() and the object formatter by using generated code.
172: *
173: * @param mixed $key Primary key to use for the query
174: * @param PropelPDO $con A connection object
175: *
176: * @return Dbxref A model object, or null if the key is not found
177: * @throws PropelException
178: */
179: protected function findPkSimple($key, $con)
180: {
181: $sql = 'SELECT "dbxref_id", "db_id", "accession", "version", "description" FROM "dbxref" WHERE "dbxref_id" = :p0';
182: try {
183: $stmt = $con->prepare($sql);
184: $stmt->bindValue(':p0', $key, PDO::PARAM_INT);
185: $stmt->execute();
186: } catch (Exception $e) {
187: Propel::log($e->getMessage(), Propel::LOG_ERR);
188: throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
189: }
190: $obj = null;
191: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
192: $obj = new Dbxref();
193: $obj->hydrate($row);
194: DbxrefPeer::addInstanceToPool($obj, (string) $key);
195: }
196: $stmt->closeCursor();
197:
198: return $obj;
199: }
200:
201: /**
202: * Find object by primary key.
203: *
204: * @param mixed $key Primary key to use for the query
205: * @param PropelPDO $con A connection object
206: *
207: * @return Dbxref|Dbxref[]|mixed the result, formatted by the current formatter
208: */
209: protected function findPkComplex($key, $con)
210: {
211: // As the query uses a PK condition, no limit(1) is necessary.
212: $criteria = $this->isKeepQuery() ? clone $this : $this;
213: $stmt = $criteria
214: ->filterByPrimaryKey($key)
215: ->doSelect($con);
216:
217: return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
218: }
219:
220: /**
221: * Find objects by primary key
222: * <code>
223: * $objs = $c->findPks(array(12, 56, 832), $con);
224: * </code>
225: * @param array $keys Primary keys to use for the query
226: * @param PropelPDO $con an optional connection object
227: *
228: * @return PropelObjectCollection|Dbxref[]|mixed the list of results, formatted by the current formatter
229: */
230: public function findPks($keys, $con = null)
231: {
232: if ($con === null) {
233: $con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
234: }
235: $this->basePreSelect($con);
236: $criteria = $this->isKeepQuery() ? clone $this : $this;
237: $stmt = $criteria
238: ->filterByPrimaryKeys($keys)
239: ->doSelect($con);
240:
241: return $criteria->getFormatter()->init($criteria)->format($stmt);
242: }
243:
244: /**
245: * Filter the query by primary key
246: *
247: * @param mixed $key Primary key to use for the query
248: *
249: * @return DbxrefQuery The current query, for fluid interface
250: */
251: public function filterByPrimaryKey($key)
252: {
253:
254: return $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $key, Criteria::EQUAL);
255: }
256:
257: /**
258: * Filter the query by a list of primary keys
259: *
260: * @param array $keys The list of primary key to use for the query
261: *
262: * @return DbxrefQuery The current query, for fluid interface
263: */
264: public function filterByPrimaryKeys($keys)
265: {
266:
267: return $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $keys, Criteria::IN);
268: }
269:
270: /**
271: * Filter the query on the dbxref_id column
272: *
273: * Example usage:
274: * <code>
275: * $query->filterByDbxrefId(1234); // WHERE dbxref_id = 1234
276: * $query->filterByDbxrefId(array(12, 34)); // WHERE dbxref_id IN (12, 34)
277: * $query->filterByDbxrefId(array('min' => 12)); // WHERE dbxref_id >= 12
278: * $query->filterByDbxrefId(array('max' => 12)); // WHERE dbxref_id <= 12
279: * </code>
280: *
281: * @param mixed $dbxrefId The value to use as filter.
282: * Use scalar values for equality.
283: * Use array values for in_array() equivalent.
284: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
285: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
286: *
287: * @return DbxrefQuery The current query, for fluid interface
288: */
289: public function filterByDbxrefId($dbxrefId = null, $comparison = null)
290: {
291: if (is_array($dbxrefId)) {
292: $useMinMax = false;
293: if (isset($dbxrefId['min'])) {
294: $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $dbxrefId['min'], Criteria::GREATER_EQUAL);
295: $useMinMax = true;
296: }
297: if (isset($dbxrefId['max'])) {
298: $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $dbxrefId['max'], Criteria::LESS_EQUAL);
299: $useMinMax = true;
300: }
301: if ($useMinMax) {
302: return $this;
303: }
304: if (null === $comparison) {
305: $comparison = Criteria::IN;
306: }
307: }
308:
309: return $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $dbxrefId, $comparison);
310: }
311:
312: /**
313: * Filter the query on the db_id column
314: *
315: * Example usage:
316: * <code>
317: * $query->filterByDbId(1234); // WHERE db_id = 1234
318: * $query->filterByDbId(array(12, 34)); // WHERE db_id IN (12, 34)
319: * $query->filterByDbId(array('min' => 12)); // WHERE db_id >= 12
320: * $query->filterByDbId(array('max' => 12)); // WHERE db_id <= 12
321: * </code>
322: *
323: * @see filterByDb()
324: *
325: * @param mixed $dbId The value to use as filter.
326: * Use scalar values for equality.
327: * Use array values for in_array() equivalent.
328: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
329: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
330: *
331: * @return DbxrefQuery The current query, for fluid interface
332: */
333: public function filterByDbId($dbId = null, $comparison = null)
334: {
335: if (is_array($dbId)) {
336: $useMinMax = false;
337: if (isset($dbId['min'])) {
338: $this->addUsingAlias(DbxrefPeer::DB_ID, $dbId['min'], Criteria::GREATER_EQUAL);
339: $useMinMax = true;
340: }
341: if (isset($dbId['max'])) {
342: $this->addUsingAlias(DbxrefPeer::DB_ID, $dbId['max'], Criteria::LESS_EQUAL);
343: $useMinMax = true;
344: }
345: if ($useMinMax) {
346: return $this;
347: }
348: if (null === $comparison) {
349: $comparison = Criteria::IN;
350: }
351: }
352:
353: return $this->addUsingAlias(DbxrefPeer::DB_ID, $dbId, $comparison);
354: }
355:
356: /**
357: * Filter the query on the accession column
358: *
359: * Example usage:
360: * <code>
361: * $query->filterByAccession('fooValue'); // WHERE accession = 'fooValue'
362: * $query->filterByAccession('%fooValue%'); // WHERE accession LIKE '%fooValue%'
363: * </code>
364: *
365: * @param string $accession The value to use as filter.
366: * Accepts wildcards (* and % trigger a LIKE)
367: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
368: *
369: * @return DbxrefQuery The current query, for fluid interface
370: */
371: public function filterByAccession($accession = null, $comparison = null)
372: {
373: if (null === $comparison) {
374: if (is_array($accession)) {
375: $comparison = Criteria::IN;
376: } elseif (preg_match('/[\%\*]/', $accession)) {
377: $accession = str_replace('*', '%', $accession);
378: $comparison = Criteria::LIKE;
379: }
380: }
381:
382: return $this->addUsingAlias(DbxrefPeer::ACCESSION, $accession, $comparison);
383: }
384:
385: /**
386: * Filter the query on the version column
387: *
388: * Example usage:
389: * <code>
390: * $query->filterByVersion('fooValue'); // WHERE version = 'fooValue'
391: * $query->filterByVersion('%fooValue%'); // WHERE version LIKE '%fooValue%'
392: * </code>
393: *
394: * @param string $version The value to use as filter.
395: * Accepts wildcards (* and % trigger a LIKE)
396: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
397: *
398: * @return DbxrefQuery The current query, for fluid interface
399: */
400: public function filterByVersion($version = null, $comparison = null)
401: {
402: if (null === $comparison) {
403: if (is_array($version)) {
404: $comparison = Criteria::IN;
405: } elseif (preg_match('/[\%\*]/', $version)) {
406: $version = str_replace('*', '%', $version);
407: $comparison = Criteria::LIKE;
408: }
409: }
410:
411: return $this->addUsingAlias(DbxrefPeer::VERSION, $version, $comparison);
412: }
413:
414: /**
415: * Filter the query on the description column
416: *
417: * Example usage:
418: * <code>
419: * $query->filterByDescription('fooValue'); // WHERE description = 'fooValue'
420: * $query->filterByDescription('%fooValue%'); // WHERE description LIKE '%fooValue%'
421: * </code>
422: *
423: * @param string $description The value to use as filter.
424: * Accepts wildcards (* and % trigger a LIKE)
425: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
426: *
427: * @return DbxrefQuery The current query, for fluid interface
428: */
429: public function filterByDescription($description = null, $comparison = null)
430: {
431: if (null === $comparison) {
432: if (is_array($description)) {
433: $comparison = Criteria::IN;
434: } elseif (preg_match('/[\%\*]/', $description)) {
435: $description = str_replace('*', '%', $description);
436: $comparison = Criteria::LIKE;
437: }
438: }
439:
440: return $this->addUsingAlias(DbxrefPeer::DESCRIPTION, $description, $comparison);
441: }
442:
443: /**
444: * Filter the query by a related Db object
445: *
446: * @param Db|PropelObjectCollection $db The related object(s) to use as filter
447: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
448: *
449: * @return DbxrefQuery The current query, for fluid interface
450: * @throws PropelException - if the provided filter is invalid.
451: */
452: public function filterByDb($db, $comparison = null)
453: {
454: if ($db instanceof Db) {
455: return $this
456: ->addUsingAlias(DbxrefPeer::DB_ID, $db->getDbId(), $comparison);
457: } elseif ($db instanceof PropelObjectCollection) {
458: if (null === $comparison) {
459: $comparison = Criteria::IN;
460: }
461:
462: return $this
463: ->addUsingAlias(DbxrefPeer::DB_ID, $db->toKeyValue('PrimaryKey', 'DbId'), $comparison);
464: } else {
465: throw new PropelException('filterByDb() only accepts arguments of type Db or PropelCollection');
466: }
467: }
468:
469: /**
470: * Adds a JOIN clause to the query using the Db relation
471: *
472: * @param string $relationAlias optional alias for the relation
473: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
474: *
475: * @return DbxrefQuery The current query, for fluid interface
476: */
477: public function joinDb($relationAlias = null, $joinType = Criteria::INNER_JOIN)
478: {
479: $tableMap = $this->getTableMap();
480: $relationMap = $tableMap->getRelation('Db');
481:
482: // create a ModelJoin object for this join
483: $join = new ModelJoin();
484: $join->setJoinType($joinType);
485: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
486: if ($previousJoin = $this->getPreviousJoin()) {
487: $join->setPreviousJoin($previousJoin);
488: }
489:
490: // add the ModelJoin to the current object
491: if ($relationAlias) {
492: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
493: $this->addJoinObject($join, $relationAlias);
494: } else {
495: $this->addJoinObject($join, 'Db');
496: }
497:
498: return $this;
499: }
500:
501: /**
502: * Use the Db relation Db object
503: *
504: * @see useQuery()
505: *
506: * @param string $relationAlias optional alias for the relation,
507: * to be used as main alias in the secondary query
508: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
509: *
510: * @return \cli_db\propel\DbQuery A secondary query class using the current class as primary query
511: */
512: public function useDbQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
513: {
514: return $this
515: ->joinDb($relationAlias, $joinType)
516: ->useQuery($relationAlias ? $relationAlias : 'Db', '\cli_db\propel\DbQuery');
517: }
518:
519: /**
520: * Filter the query by a related Feature object
521: *
522: * @param Feature|PropelObjectCollection $feature the related object to use as filter
523: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
524: *
525: * @return DbxrefQuery The current query, for fluid interface
526: * @throws PropelException - if the provided filter is invalid.
527: */
528: public function filterByFeature($feature, $comparison = null)
529: {
530: if ($feature instanceof Feature) {
531: return $this
532: ->addUsingAlias(DbxrefPeer::DBXREF_ID, $feature->getDbxrefId(), $comparison);
533: } elseif ($feature instanceof PropelObjectCollection) {
534: return $this
535: ->useFeatureQuery()
536: ->filterByPrimaryKeys($feature->getPrimaryKeys())
537: ->endUse();
538: } else {
539: throw new PropelException('filterByFeature() only accepts arguments of type Feature or PropelCollection');
540: }
541: }
542:
543: /**
544: * Adds a JOIN clause to the query using the Feature relation
545: *
546: * @param string $relationAlias optional alias for the relation
547: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
548: *
549: * @return DbxrefQuery The current query, for fluid interface
550: */
551: public function joinFeature($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
552: {
553: $tableMap = $this->getTableMap();
554: $relationMap = $tableMap->getRelation('Feature');
555:
556: // create a ModelJoin object for this join
557: $join = new ModelJoin();
558: $join->setJoinType($joinType);
559: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
560: if ($previousJoin = $this->getPreviousJoin()) {
561: $join->setPreviousJoin($previousJoin);
562: }
563:
564: // add the ModelJoin to the current object
565: if ($relationAlias) {
566: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
567: $this->addJoinObject($join, $relationAlias);
568: } else {
569: $this->addJoinObject($join, 'Feature');
570: }
571:
572: return $this;
573: }
574:
575: /**
576: * Use the Feature relation Feature object
577: *
578: * @see useQuery()
579: *
580: * @param string $relationAlias optional alias for the relation,
581: * to be used as main alias in the secondary query
582: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
583: *
584: * @return \cli_db\propel\FeatureQuery A secondary query class using the current class as primary query
585: */
586: public function useFeatureQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
587: {
588: return $this
589: ->joinFeature($relationAlias, $joinType)
590: ->useQuery($relationAlias ? $relationAlias : 'Feature', '\cli_db\propel\FeatureQuery');
591: }
592:
593: /**
594: * Filter the query by a related FeatureCvtermDbxref object
595: *
596: * @param FeatureCvtermDbxref|PropelObjectCollection $featureCvtermDbxref the related object to use as filter
597: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
598: *
599: * @return DbxrefQuery The current query, for fluid interface
600: * @throws PropelException - if the provided filter is invalid.
601: */
602: public function filterByFeatureCvtermDbxref($featureCvtermDbxref, $comparison = null)
603: {
604: if ($featureCvtermDbxref instanceof FeatureCvtermDbxref) {
605: return $this
606: ->addUsingAlias(DbxrefPeer::DBXREF_ID, $featureCvtermDbxref->getDbxrefId(), $comparison);
607: } elseif ($featureCvtermDbxref instanceof PropelObjectCollection) {
608: return $this
609: ->useFeatureCvtermDbxrefQuery()
610: ->filterByPrimaryKeys($featureCvtermDbxref->getPrimaryKeys())
611: ->endUse();
612: } else {
613: throw new PropelException('filterByFeatureCvtermDbxref() only accepts arguments of type FeatureCvtermDbxref or PropelCollection');
614: }
615: }
616:
617: /**
618: * Adds a JOIN clause to the query using the FeatureCvtermDbxref relation
619: *
620: * @param string $relationAlias optional alias for the relation
621: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
622: *
623: * @return DbxrefQuery The current query, for fluid interface
624: */
625: public function joinFeatureCvtermDbxref($relationAlias = null, $joinType = Criteria::INNER_JOIN)
626: {
627: $tableMap = $this->getTableMap();
628: $relationMap = $tableMap->getRelation('FeatureCvtermDbxref');
629:
630: // create a ModelJoin object for this join
631: $join = new ModelJoin();
632: $join->setJoinType($joinType);
633: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
634: if ($previousJoin = $this->getPreviousJoin()) {
635: $join->setPreviousJoin($previousJoin);
636: }
637:
638: // add the ModelJoin to the current object
639: if ($relationAlias) {
640: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
641: $this->addJoinObject($join, $relationAlias);
642: } else {
643: $this->addJoinObject($join, 'FeatureCvtermDbxref');
644: }
645:
646: return $this;
647: }
648:
649: /**
650: * Use the FeatureCvtermDbxref relation FeatureCvtermDbxref object
651: *
652: * @see useQuery()
653: *
654: * @param string $relationAlias optional alias for the relation,
655: * to be used as main alias in the secondary query
656: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
657: *
658: * @return \cli_db\propel\FeatureCvtermDbxrefQuery A secondary query class using the current class as primary query
659: */
660: public function useFeatureCvtermDbxrefQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
661: {
662: return $this
663: ->joinFeatureCvtermDbxref($relationAlias, $joinType)
664: ->useQuery($relationAlias ? $relationAlias : 'FeatureCvtermDbxref', '\cli_db\propel\FeatureCvtermDbxrefQuery');
665: }
666:
667: /**
668: * Filter the query by a related FeatureDbxref object
669: *
670: * @param FeatureDbxref|PropelObjectCollection $featureDbxref the related object to use as filter
671: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
672: *
673: * @return DbxrefQuery The current query, for fluid interface
674: * @throws PropelException - if the provided filter is invalid.
675: */
676: public function filterByFeatureDbxref($featureDbxref, $comparison = null)
677: {
678: if ($featureDbxref instanceof FeatureDbxref) {
679: return $this
680: ->addUsingAlias(DbxrefPeer::DBXREF_ID, $featureDbxref->getDbxrefId(), $comparison);
681: } elseif ($featureDbxref instanceof PropelObjectCollection) {
682: return $this
683: ->useFeatureDbxrefQuery()
684: ->filterByPrimaryKeys($featureDbxref->getPrimaryKeys())
685: ->endUse();
686: } else {
687: throw new PropelException('filterByFeatureDbxref() only accepts arguments of type FeatureDbxref or PropelCollection');
688: }
689: }
690:
691: /**
692: * Adds a JOIN clause to the query using the FeatureDbxref relation
693: *
694: * @param string $relationAlias optional alias for the relation
695: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
696: *
697: * @return DbxrefQuery The current query, for fluid interface
698: */
699: public function joinFeatureDbxref($relationAlias = null, $joinType = Criteria::INNER_JOIN)
700: {
701: $tableMap = $this->getTableMap();
702: $relationMap = $tableMap->getRelation('FeatureDbxref');
703:
704: // create a ModelJoin object for this join
705: $join = new ModelJoin();
706: $join->setJoinType($joinType);
707: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
708: if ($previousJoin = $this->getPreviousJoin()) {
709: $join->setPreviousJoin($previousJoin);
710: }
711:
712: // add the ModelJoin to the current object
713: if ($relationAlias) {
714: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
715: $this->addJoinObject($join, $relationAlias);
716: } else {
717: $this->addJoinObject($join, 'FeatureDbxref');
718: }
719:
720: return $this;
721: }
722:
723: /**
724: * Use the FeatureDbxref relation FeatureDbxref object
725: *
726: * @see useQuery()
727: *
728: * @param string $relationAlias optional alias for the relation,
729: * to be used as main alias in the secondary query
730: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
731: *
732: * @return \cli_db\propel\FeatureDbxrefQuery A secondary query class using the current class as primary query
733: */
734: public function useFeatureDbxrefQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
735: {
736: return $this
737: ->joinFeatureDbxref($relationAlias, $joinType)
738: ->useQuery($relationAlias ? $relationAlias : 'FeatureDbxref', '\cli_db\propel\FeatureDbxrefQuery');
739: }
740:
741: /**
742: * Filter the query by a related PubDbxref object
743: *
744: * @param PubDbxref|PropelObjectCollection $pubDbxref the related object to use as filter
745: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
746: *
747: * @return DbxrefQuery The current query, for fluid interface
748: * @throws PropelException - if the provided filter is invalid.
749: */
750: public function filterByPubDbxref($pubDbxref, $comparison = null)
751: {
752: if ($pubDbxref instanceof PubDbxref) {
753: return $this
754: ->addUsingAlias(DbxrefPeer::DBXREF_ID, $pubDbxref->getDbxrefId(), $comparison);
755: } elseif ($pubDbxref instanceof PropelObjectCollection) {
756: return $this
757: ->usePubDbxrefQuery()
758: ->filterByPrimaryKeys($pubDbxref->getPrimaryKeys())
759: ->endUse();
760: } else {
761: throw new PropelException('filterByPubDbxref() only accepts arguments of type PubDbxref or PropelCollection');
762: }
763: }
764:
765: /**
766: * Adds a JOIN clause to the query using the PubDbxref relation
767: *
768: * @param string $relationAlias optional alias for the relation
769: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
770: *
771: * @return DbxrefQuery The current query, for fluid interface
772: */
773: public function joinPubDbxref($relationAlias = null, $joinType = Criteria::INNER_JOIN)
774: {
775: $tableMap = $this->getTableMap();
776: $relationMap = $tableMap->getRelation('PubDbxref');
777:
778: // create a ModelJoin object for this join
779: $join = new ModelJoin();
780: $join->setJoinType($joinType);
781: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
782: if ($previousJoin = $this->getPreviousJoin()) {
783: $join->setPreviousJoin($previousJoin);
784: }
785:
786: // add the ModelJoin to the current object
787: if ($relationAlias) {
788: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
789: $this->addJoinObject($join, $relationAlias);
790: } else {
791: $this->addJoinObject($join, 'PubDbxref');
792: }
793:
794: return $this;
795: }
796:
797: /**
798: * Use the PubDbxref relation PubDbxref object
799: *
800: * @see useQuery()
801: *
802: * @param string $relationAlias optional alias for the relation,
803: * to be used as main alias in the secondary query
804: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
805: *
806: * @return \cli_db\propel\PubDbxrefQuery A secondary query class using the current class as primary query
807: */
808: public function usePubDbxrefQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
809: {
810: return $this
811: ->joinPubDbxref($relationAlias, $joinType)
812: ->useQuery($relationAlias ? $relationAlias : 'PubDbxref', '\cli_db\propel\PubDbxrefQuery');
813: }
814:
815: /**
816: * Exclude object from result
817: *
818: * @param Dbxref $dbxref Object to remove from the list of results
819: *
820: * @return DbxrefQuery The current query, for fluid interface
821: */
822: public function prune($dbxref = null)
823: {
824: if ($dbxref) {
825: $this->addUsingAlias(DbxrefPeer::DBXREF_ID, $dbxref->getDbxrefId(), Criteria::NOT_EQUAL);
826: }
827:
828: return $this;
829: }
830:
831: }
832: