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\Cvterm;
16: use cli_db\propel\Feature;
17: use cli_db\propel\FeatureCvterm;
18: use cli_db\propel\FeatureCvtermDbxref;
19: use cli_db\propel\FeatureCvtermPeer;
20: use cli_db\propel\FeatureCvtermPub;
21: use cli_db\propel\FeatureCvtermQuery;
22: use cli_db\propel\FeatureCvtermprop;
23: use cli_db\propel\Pub;
24:
25: /**
26: * Base class that represents a query for the 'feature_cvterm' table.
27: *
28: *
29: *
30: * @method FeatureCvtermQuery orderByFeatureCvtermId($order = Criteria::ASC) Order by the feature_cvterm_id column
31: * @method FeatureCvtermQuery orderByFeatureId($order = Criteria::ASC) Order by the feature_id column
32: * @method FeatureCvtermQuery orderByCvtermId($order = Criteria::ASC) Order by the cvterm_id column
33: * @method FeatureCvtermQuery orderByPubId($order = Criteria::ASC) Order by the pub_id column
34: * @method FeatureCvtermQuery orderByIsNot($order = Criteria::ASC) Order by the is_not column
35: * @method FeatureCvtermQuery orderByRank($order = Criteria::ASC) Order by the rank column
36: *
37: * @method FeatureCvtermQuery groupByFeatureCvtermId() Group by the feature_cvterm_id column
38: * @method FeatureCvtermQuery groupByFeatureId() Group by the feature_id column
39: * @method FeatureCvtermQuery groupByCvtermId() Group by the cvterm_id column
40: * @method FeatureCvtermQuery groupByPubId() Group by the pub_id column
41: * @method FeatureCvtermQuery groupByIsNot() Group by the is_not column
42: * @method FeatureCvtermQuery groupByRank() Group by the rank column
43: *
44: * @method FeatureCvtermQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
45: * @method FeatureCvtermQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
46: * @method FeatureCvtermQuery innerJoin($relation) Adds a INNER JOIN clause to the query
47: *
48: * @method FeatureCvtermQuery leftJoinCvterm($relationAlias = null) Adds a LEFT JOIN clause to the query using the Cvterm relation
49: * @method FeatureCvtermQuery rightJoinCvterm($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Cvterm relation
50: * @method FeatureCvtermQuery innerJoinCvterm($relationAlias = null) Adds a INNER JOIN clause to the query using the Cvterm relation
51: *
52: * @method FeatureCvtermQuery leftJoinFeature($relationAlias = null) Adds a LEFT JOIN clause to the query using the Feature relation
53: * @method FeatureCvtermQuery rightJoinFeature($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Feature relation
54: * @method FeatureCvtermQuery innerJoinFeature($relationAlias = null) Adds a INNER JOIN clause to the query using the Feature relation
55: *
56: * @method FeatureCvtermQuery leftJoinPub($relationAlias = null) Adds a LEFT JOIN clause to the query using the Pub relation
57: * @method FeatureCvtermQuery rightJoinPub($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Pub relation
58: * @method FeatureCvtermQuery innerJoinPub($relationAlias = null) Adds a INNER JOIN clause to the query using the Pub relation
59: *
60: * @method FeatureCvtermQuery leftJoinFeatureCvtermDbxref($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureCvtermDbxref relation
61: * @method FeatureCvtermQuery rightJoinFeatureCvtermDbxref($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureCvtermDbxref relation
62: * @method FeatureCvtermQuery innerJoinFeatureCvtermDbxref($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureCvtermDbxref relation
63: *
64: * @method FeatureCvtermQuery leftJoinFeatureCvtermPub($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureCvtermPub relation
65: * @method FeatureCvtermQuery rightJoinFeatureCvtermPub($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureCvtermPub relation
66: * @method FeatureCvtermQuery innerJoinFeatureCvtermPub($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureCvtermPub relation
67: *
68: * @method FeatureCvtermQuery leftJoinFeatureCvtermprop($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureCvtermprop relation
69: * @method FeatureCvtermQuery rightJoinFeatureCvtermprop($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureCvtermprop relation
70: * @method FeatureCvtermQuery innerJoinFeatureCvtermprop($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureCvtermprop relation
71: *
72: * @method FeatureCvterm findOne(PropelPDO $con = null) Return the first FeatureCvterm matching the query
73: * @method FeatureCvterm findOneOrCreate(PropelPDO $con = null) Return the first FeatureCvterm matching the query, or a new FeatureCvterm object populated from the query conditions when no match is found
74: *
75: * @method FeatureCvterm findOneByFeatureId(int $feature_id) Return the first FeatureCvterm filtered by the feature_id column
76: * @method FeatureCvterm findOneByCvtermId(int $cvterm_id) Return the first FeatureCvterm filtered by the cvterm_id column
77: * @method FeatureCvterm findOneByPubId(int $pub_id) Return the first FeatureCvterm filtered by the pub_id column
78: * @method FeatureCvterm findOneByIsNot(boolean $is_not) Return the first FeatureCvterm filtered by the is_not column
79: * @method FeatureCvterm findOneByRank(int $rank) Return the first FeatureCvterm filtered by the rank column
80: *
81: * @method array findByFeatureCvtermId(int $feature_cvterm_id) Return FeatureCvterm objects filtered by the feature_cvterm_id column
82: * @method array findByFeatureId(int $feature_id) Return FeatureCvterm objects filtered by the feature_id column
83: * @method array findByCvtermId(int $cvterm_id) Return FeatureCvterm objects filtered by the cvterm_id column
84: * @method array findByPubId(int $pub_id) Return FeatureCvterm objects filtered by the pub_id column
85: * @method array findByIsNot(boolean $is_not) Return FeatureCvterm objects filtered by the is_not column
86: * @method array findByRank(int $rank) Return FeatureCvterm objects filtered by the rank column
87: *
88: * @package propel.generator.cli_db.om
89: */
90: abstract class BaseFeatureCvtermQuery extends ModelCriteria
91: {
92: /**
93: * Initializes internal state of BaseFeatureCvtermQuery object.
94: *
95: * @param string $dbName The dabase name
96: * @param string $modelName The phpName of a model, e.g. 'Book'
97: * @param string $modelAlias The alias for the model in this query, e.g. 'b'
98: */
99: public function __construct($dbName = 'cli_db', $modelName = 'cli_db\\propel\\FeatureCvterm', $modelAlias = null)
100: {
101: parent::__construct($dbName, $modelName, $modelAlias);
102: }
103:
104: /**
105: * Returns a new FeatureCvtermQuery object.
106: *
107: * @param string $modelAlias The alias of a model in the query
108: * @param FeatureCvtermQuery|Criteria $criteria Optional Criteria to build the query from
109: *
110: * @return FeatureCvtermQuery
111: */
112: public static function create($modelAlias = null, $criteria = null)
113: {
114: if ($criteria instanceof FeatureCvtermQuery) {
115: return $criteria;
116: }
117: $query = new FeatureCvtermQuery();
118: if (null !== $modelAlias) {
119: $query->setModelAlias($modelAlias);
120: }
121: if ($criteria instanceof Criteria) {
122: $query->mergeWith($criteria);
123: }
124:
125: return $query;
126: }
127:
128: /**
129: * Find object by primary key.
130: * Propel uses the instance pool to skip the database if the object exists.
131: * Go fast if the query is untouched.
132: *
133: * <code>
134: * $obj = $c->findPk(12, $con);
135: * </code>
136: *
137: * @param mixed $key Primary key to use for the query
138: * @param PropelPDO $con an optional connection object
139: *
140: * @return FeatureCvterm|FeatureCvterm[]|mixed the result, formatted by the current formatter
141: */
142: public function findPk($key, $con = null)
143: {
144: if ($key === null) {
145: return null;
146: }
147: if ((null !== ($obj = FeatureCvtermPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
148: // the object is alredy in the instance pool
149: return $obj;
150: }
151: if ($con === null) {
152: $con = Propel::getConnection(FeatureCvtermPeer::DATABASE_NAME, Propel::CONNECTION_READ);
153: }
154: $this->basePreSelect($con);
155: if ($this->formatter || $this->modelAlias || $this->with || $this->select
156: || $this->selectColumns || $this->asColumns || $this->selectModifiers
157: || $this->map || $this->having || $this->joins) {
158: return $this->findPkComplex($key, $con);
159: } else {
160: return $this->findPkSimple($key, $con);
161: }
162: }
163:
164: /**
165: * Alias of findPk to use instance pooling
166: *
167: * @param mixed $key Primary key to use for the query
168: * @param PropelPDO $con A connection object
169: *
170: * @return FeatureCvterm A model object, or null if the key is not found
171: * @throws PropelException
172: */
173: public function findOneByFeatureCvtermId($key, $con = null)
174: {
175: return $this->findPk($key, $con);
176: }
177:
178: /**
179: * Find object by primary key using raw SQL to go fast.
180: * Bypass doSelect() and the object formatter by using generated code.
181: *
182: * @param mixed $key Primary key to use for the query
183: * @param PropelPDO $con A connection object
184: *
185: * @return FeatureCvterm A model object, or null if the key is not found
186: * @throws PropelException
187: */
188: protected function findPkSimple($key, $con)
189: {
190: $sql = 'SELECT "feature_cvterm_id", "feature_id", "cvterm_id", "pub_id", "is_not", "rank" FROM "feature_cvterm" WHERE "feature_cvterm_id" = :p0';
191: try {
192: $stmt = $con->prepare($sql);
193: $stmt->bindValue(':p0', $key, PDO::PARAM_INT);
194: $stmt->execute();
195: } catch (Exception $e) {
196: Propel::log($e->getMessage(), Propel::LOG_ERR);
197: throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
198: }
199: $obj = null;
200: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
201: $obj = new FeatureCvterm();
202: $obj->hydrate($row);
203: FeatureCvtermPeer::addInstanceToPool($obj, (string) $key);
204: }
205: $stmt->closeCursor();
206:
207: return $obj;
208: }
209:
210: /**
211: * Find object by primary key.
212: *
213: * @param mixed $key Primary key to use for the query
214: * @param PropelPDO $con A connection object
215: *
216: * @return FeatureCvterm|FeatureCvterm[]|mixed the result, formatted by the current formatter
217: */
218: protected function findPkComplex($key, $con)
219: {
220: // As the query uses a PK condition, no limit(1) is necessary.
221: $criteria = $this->isKeepQuery() ? clone $this : $this;
222: $stmt = $criteria
223: ->filterByPrimaryKey($key)
224: ->doSelect($con);
225:
226: return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
227: }
228:
229: /**
230: * Find objects by primary key
231: * <code>
232: * $objs = $c->findPks(array(12, 56, 832), $con);
233: * </code>
234: * @param array $keys Primary keys to use for the query
235: * @param PropelPDO $con an optional connection object
236: *
237: * @return PropelObjectCollection|FeatureCvterm[]|mixed the list of results, formatted by the current formatter
238: */
239: public function findPks($keys, $con = null)
240: {
241: if ($con === null) {
242: $con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
243: }
244: $this->basePreSelect($con);
245: $criteria = $this->isKeepQuery() ? clone $this : $this;
246: $stmt = $criteria
247: ->filterByPrimaryKeys($keys)
248: ->doSelect($con);
249:
250: return $criteria->getFormatter()->init($criteria)->format($stmt);
251: }
252:
253: /**
254: * Filter the query by primary key
255: *
256: * @param mixed $key Primary key to use for the query
257: *
258: * @return FeatureCvtermQuery The current query, for fluid interface
259: */
260: public function filterByPrimaryKey($key)
261: {
262:
263: return $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $key, Criteria::EQUAL);
264: }
265:
266: /**
267: * Filter the query by a list of primary keys
268: *
269: * @param array $keys The list of primary key to use for the query
270: *
271: * @return FeatureCvtermQuery The current query, for fluid interface
272: */
273: public function filterByPrimaryKeys($keys)
274: {
275:
276: return $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $keys, Criteria::IN);
277: }
278:
279: /**
280: * Filter the query on the feature_cvterm_id column
281: *
282: * Example usage:
283: * <code>
284: * $query->filterByFeatureCvtermId(1234); // WHERE feature_cvterm_id = 1234
285: * $query->filterByFeatureCvtermId(array(12, 34)); // WHERE feature_cvterm_id IN (12, 34)
286: * $query->filterByFeatureCvtermId(array('min' => 12)); // WHERE feature_cvterm_id >= 12
287: * $query->filterByFeatureCvtermId(array('max' => 12)); // WHERE feature_cvterm_id <= 12
288: * </code>
289: *
290: * @param mixed $featureCvtermId The value to use as filter.
291: * Use scalar values for equality.
292: * Use array values for in_array() equivalent.
293: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
294: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
295: *
296: * @return FeatureCvtermQuery The current query, for fluid interface
297: */
298: public function filterByFeatureCvtermId($featureCvtermId = null, $comparison = null)
299: {
300: if (is_array($featureCvtermId)) {
301: $useMinMax = false;
302: if (isset($featureCvtermId['min'])) {
303: $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermId['min'], Criteria::GREATER_EQUAL);
304: $useMinMax = true;
305: }
306: if (isset($featureCvtermId['max'])) {
307: $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermId['max'], Criteria::LESS_EQUAL);
308: $useMinMax = true;
309: }
310: if ($useMinMax) {
311: return $this;
312: }
313: if (null === $comparison) {
314: $comparison = Criteria::IN;
315: }
316: }
317:
318: return $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermId, $comparison);
319: }
320:
321: /**
322: * Filter the query on the feature_id column
323: *
324: * Example usage:
325: * <code>
326: * $query->filterByFeatureId(1234); // WHERE feature_id = 1234
327: * $query->filterByFeatureId(array(12, 34)); // WHERE feature_id IN (12, 34)
328: * $query->filterByFeatureId(array('min' => 12)); // WHERE feature_id >= 12
329: * $query->filterByFeatureId(array('max' => 12)); // WHERE feature_id <= 12
330: * </code>
331: *
332: * @see filterByFeature()
333: *
334: * @param mixed $featureId The value to use as filter.
335: * Use scalar values for equality.
336: * Use array values for in_array() equivalent.
337: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
338: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
339: *
340: * @return FeatureCvtermQuery The current query, for fluid interface
341: */
342: public function filterByFeatureId($featureId = null, $comparison = null)
343: {
344: if (is_array($featureId)) {
345: $useMinMax = false;
346: if (isset($featureId['min'])) {
347: $this->addUsingAlias(FeatureCvtermPeer::FEATURE_ID, $featureId['min'], Criteria::GREATER_EQUAL);
348: $useMinMax = true;
349: }
350: if (isset($featureId['max'])) {
351: $this->addUsingAlias(FeatureCvtermPeer::FEATURE_ID, $featureId['max'], Criteria::LESS_EQUAL);
352: $useMinMax = true;
353: }
354: if ($useMinMax) {
355: return $this;
356: }
357: if (null === $comparison) {
358: $comparison = Criteria::IN;
359: }
360: }
361:
362: return $this->addUsingAlias(FeatureCvtermPeer::FEATURE_ID, $featureId, $comparison);
363: }
364:
365: /**
366: * Filter the query on the cvterm_id column
367: *
368: * Example usage:
369: * <code>
370: * $query->filterByCvtermId(1234); // WHERE cvterm_id = 1234
371: * $query->filterByCvtermId(array(12, 34)); // WHERE cvterm_id IN (12, 34)
372: * $query->filterByCvtermId(array('min' => 12)); // WHERE cvterm_id >= 12
373: * $query->filterByCvtermId(array('max' => 12)); // WHERE cvterm_id <= 12
374: * </code>
375: *
376: * @see filterByCvterm()
377: *
378: * @param mixed $cvtermId The value to use as filter.
379: * Use scalar values for equality.
380: * Use array values for in_array() equivalent.
381: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
382: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
383: *
384: * @return FeatureCvtermQuery The current query, for fluid interface
385: */
386: public function filterByCvtermId($cvtermId = null, $comparison = null)
387: {
388: if (is_array($cvtermId)) {
389: $useMinMax = false;
390: if (isset($cvtermId['min'])) {
391: $this->addUsingAlias(FeatureCvtermPeer::CVTERM_ID, $cvtermId['min'], Criteria::GREATER_EQUAL);
392: $useMinMax = true;
393: }
394: if (isset($cvtermId['max'])) {
395: $this->addUsingAlias(FeatureCvtermPeer::CVTERM_ID, $cvtermId['max'], Criteria::LESS_EQUAL);
396: $useMinMax = true;
397: }
398: if ($useMinMax) {
399: return $this;
400: }
401: if (null === $comparison) {
402: $comparison = Criteria::IN;
403: }
404: }
405:
406: return $this->addUsingAlias(FeatureCvtermPeer::CVTERM_ID, $cvtermId, $comparison);
407: }
408:
409: /**
410: * Filter the query on the pub_id column
411: *
412: * Example usage:
413: * <code>
414: * $query->filterByPubId(1234); // WHERE pub_id = 1234
415: * $query->filterByPubId(array(12, 34)); // WHERE pub_id IN (12, 34)
416: * $query->filterByPubId(array('min' => 12)); // WHERE pub_id >= 12
417: * $query->filterByPubId(array('max' => 12)); // WHERE pub_id <= 12
418: * </code>
419: *
420: * @see filterByPub()
421: *
422: * @param mixed $pubId The value to use as filter.
423: * Use scalar values for equality.
424: * Use array values for in_array() equivalent.
425: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
426: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
427: *
428: * @return FeatureCvtermQuery The current query, for fluid interface
429: */
430: public function filterByPubId($pubId = null, $comparison = null)
431: {
432: if (is_array($pubId)) {
433: $useMinMax = false;
434: if (isset($pubId['min'])) {
435: $this->addUsingAlias(FeatureCvtermPeer::PUB_ID, $pubId['min'], Criteria::GREATER_EQUAL);
436: $useMinMax = true;
437: }
438: if (isset($pubId['max'])) {
439: $this->addUsingAlias(FeatureCvtermPeer::PUB_ID, $pubId['max'], Criteria::LESS_EQUAL);
440: $useMinMax = true;
441: }
442: if ($useMinMax) {
443: return $this;
444: }
445: if (null === $comparison) {
446: $comparison = Criteria::IN;
447: }
448: }
449:
450: return $this->addUsingAlias(FeatureCvtermPeer::PUB_ID, $pubId, $comparison);
451: }
452:
453: /**
454: * Filter the query on the is_not column
455: *
456: * Example usage:
457: * <code>
458: * $query->filterByIsNot(true); // WHERE is_not = true
459: * $query->filterByIsNot('yes'); // WHERE is_not = true
460: * </code>
461: *
462: * @param boolean|string $isNot The value to use as filter.
463: * Non-boolean arguments are converted using the following rules:
464: * * 1, '1', 'true', 'on', and 'yes' are converted to boolean true
465: * * 0, '0', 'false', 'off', and 'no' are converted to boolean false
466: * Check on string values is case insensitive (so 'FaLsE' is seen as 'false').
467: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
468: *
469: * @return FeatureCvtermQuery The current query, for fluid interface
470: */
471: public function filterByIsNot($isNot = null, $comparison = null)
472: {
473: if (is_string($isNot)) {
474: $isNot = in_array(strtolower($isNot), array('false', 'off', '-', 'no', 'n', '0', '')) ? false : true;
475: }
476:
477: return $this->addUsingAlias(FeatureCvtermPeer::IS_NOT, $isNot, $comparison);
478: }
479:
480: /**
481: * Filter the query on the rank column
482: *
483: * Example usage:
484: * <code>
485: * $query->filterByRank(1234); // WHERE rank = 1234
486: * $query->filterByRank(array(12, 34)); // WHERE rank IN (12, 34)
487: * $query->filterByRank(array('min' => 12)); // WHERE rank >= 12
488: * $query->filterByRank(array('max' => 12)); // WHERE rank <= 12
489: * </code>
490: *
491: * @param mixed $rank The value to use as filter.
492: * Use scalar values for equality.
493: * Use array values for in_array() equivalent.
494: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
495: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
496: *
497: * @return FeatureCvtermQuery The current query, for fluid interface
498: */
499: public function filterByRank($rank = null, $comparison = null)
500: {
501: if (is_array($rank)) {
502: $useMinMax = false;
503: if (isset($rank['min'])) {
504: $this->addUsingAlias(FeatureCvtermPeer::RANK, $rank['min'], Criteria::GREATER_EQUAL);
505: $useMinMax = true;
506: }
507: if (isset($rank['max'])) {
508: $this->addUsingAlias(FeatureCvtermPeer::RANK, $rank['max'], Criteria::LESS_EQUAL);
509: $useMinMax = true;
510: }
511: if ($useMinMax) {
512: return $this;
513: }
514: if (null === $comparison) {
515: $comparison = Criteria::IN;
516: }
517: }
518:
519: return $this->addUsingAlias(FeatureCvtermPeer::RANK, $rank, $comparison);
520: }
521:
522: /**
523: * Filter the query by a related Cvterm object
524: *
525: * @param Cvterm|PropelObjectCollection $cvterm The related object(s) to use as filter
526: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
527: *
528: * @return FeatureCvtermQuery The current query, for fluid interface
529: * @throws PropelException - if the provided filter is invalid.
530: */
531: public function filterByCvterm($cvterm, $comparison = null)
532: {
533: if ($cvterm instanceof Cvterm) {
534: return $this
535: ->addUsingAlias(FeatureCvtermPeer::CVTERM_ID, $cvterm->getCvtermId(), $comparison);
536: } elseif ($cvterm instanceof PropelObjectCollection) {
537: if (null === $comparison) {
538: $comparison = Criteria::IN;
539: }
540:
541: return $this
542: ->addUsingAlias(FeatureCvtermPeer::CVTERM_ID, $cvterm->toKeyValue('PrimaryKey', 'CvtermId'), $comparison);
543: } else {
544: throw new PropelException('filterByCvterm() only accepts arguments of type Cvterm or PropelCollection');
545: }
546: }
547:
548: /**
549: * Adds a JOIN clause to the query using the Cvterm relation
550: *
551: * @param string $relationAlias optional alias for the relation
552: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
553: *
554: * @return FeatureCvtermQuery The current query, for fluid interface
555: */
556: public function joinCvterm($relationAlias = null, $joinType = Criteria::INNER_JOIN)
557: {
558: $tableMap = $this->getTableMap();
559: $relationMap = $tableMap->getRelation('Cvterm');
560:
561: // create a ModelJoin object for this join
562: $join = new ModelJoin();
563: $join->setJoinType($joinType);
564: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
565: if ($previousJoin = $this->getPreviousJoin()) {
566: $join->setPreviousJoin($previousJoin);
567: }
568:
569: // add the ModelJoin to the current object
570: if ($relationAlias) {
571: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
572: $this->addJoinObject($join, $relationAlias);
573: } else {
574: $this->addJoinObject($join, 'Cvterm');
575: }
576:
577: return $this;
578: }
579:
580: /**
581: * Use the Cvterm relation Cvterm object
582: *
583: * @see useQuery()
584: *
585: * @param string $relationAlias optional alias for the relation,
586: * to be used as main alias in the secondary query
587: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
588: *
589: * @return \cli_db\propel\CvtermQuery A secondary query class using the current class as primary query
590: */
591: public function useCvtermQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
592: {
593: return $this
594: ->joinCvterm($relationAlias, $joinType)
595: ->useQuery($relationAlias ? $relationAlias : 'Cvterm', '\cli_db\propel\CvtermQuery');
596: }
597:
598: /**
599: * Filter the query by a related Feature object
600: *
601: * @param Feature|PropelObjectCollection $feature The related object(s) to use as filter
602: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
603: *
604: * @return FeatureCvtermQuery The current query, for fluid interface
605: * @throws PropelException - if the provided filter is invalid.
606: */
607: public function filterByFeature($feature, $comparison = null)
608: {
609: if ($feature instanceof Feature) {
610: return $this
611: ->addUsingAlias(FeatureCvtermPeer::FEATURE_ID, $feature->getFeatureId(), $comparison);
612: } elseif ($feature instanceof PropelObjectCollection) {
613: if (null === $comparison) {
614: $comparison = Criteria::IN;
615: }
616:
617: return $this
618: ->addUsingAlias(FeatureCvtermPeer::FEATURE_ID, $feature->toKeyValue('PrimaryKey', 'FeatureId'), $comparison);
619: } else {
620: throw new PropelException('filterByFeature() only accepts arguments of type Feature or PropelCollection');
621: }
622: }
623:
624: /**
625: * Adds a JOIN clause to the query using the Feature relation
626: *
627: * @param string $relationAlias optional alias for the relation
628: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
629: *
630: * @return FeatureCvtermQuery The current query, for fluid interface
631: */
632: public function joinFeature($relationAlias = null, $joinType = Criteria::INNER_JOIN)
633: {
634: $tableMap = $this->getTableMap();
635: $relationMap = $tableMap->getRelation('Feature');
636:
637: // create a ModelJoin object for this join
638: $join = new ModelJoin();
639: $join->setJoinType($joinType);
640: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
641: if ($previousJoin = $this->getPreviousJoin()) {
642: $join->setPreviousJoin($previousJoin);
643: }
644:
645: // add the ModelJoin to the current object
646: if ($relationAlias) {
647: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
648: $this->addJoinObject($join, $relationAlias);
649: } else {
650: $this->addJoinObject($join, 'Feature');
651: }
652:
653: return $this;
654: }
655:
656: /**
657: * Use the Feature relation Feature object
658: *
659: * @see useQuery()
660: *
661: * @param string $relationAlias optional alias for the relation,
662: * to be used as main alias in the secondary query
663: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
664: *
665: * @return \cli_db\propel\FeatureQuery A secondary query class using the current class as primary query
666: */
667: public function useFeatureQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
668: {
669: return $this
670: ->joinFeature($relationAlias, $joinType)
671: ->useQuery($relationAlias ? $relationAlias : 'Feature', '\cli_db\propel\FeatureQuery');
672: }
673:
674: /**
675: * Filter the query by a related Pub object
676: *
677: * @param Pub|PropelObjectCollection $pub The related object(s) to use as filter
678: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
679: *
680: * @return FeatureCvtermQuery The current query, for fluid interface
681: * @throws PropelException - if the provided filter is invalid.
682: */
683: public function filterByPub($pub, $comparison = null)
684: {
685: if ($pub instanceof Pub) {
686: return $this
687: ->addUsingAlias(FeatureCvtermPeer::PUB_ID, $pub->getPubId(), $comparison);
688: } elseif ($pub instanceof PropelObjectCollection) {
689: if (null === $comparison) {
690: $comparison = Criteria::IN;
691: }
692:
693: return $this
694: ->addUsingAlias(FeatureCvtermPeer::PUB_ID, $pub->toKeyValue('PrimaryKey', 'PubId'), $comparison);
695: } else {
696: throw new PropelException('filterByPub() only accepts arguments of type Pub or PropelCollection');
697: }
698: }
699:
700: /**
701: * Adds a JOIN clause to the query using the Pub relation
702: *
703: * @param string $relationAlias optional alias for the relation
704: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
705: *
706: * @return FeatureCvtermQuery The current query, for fluid interface
707: */
708: public function joinPub($relationAlias = null, $joinType = Criteria::INNER_JOIN)
709: {
710: $tableMap = $this->getTableMap();
711: $relationMap = $tableMap->getRelation('Pub');
712:
713: // create a ModelJoin object for this join
714: $join = new ModelJoin();
715: $join->setJoinType($joinType);
716: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
717: if ($previousJoin = $this->getPreviousJoin()) {
718: $join->setPreviousJoin($previousJoin);
719: }
720:
721: // add the ModelJoin to the current object
722: if ($relationAlias) {
723: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
724: $this->addJoinObject($join, $relationAlias);
725: } else {
726: $this->addJoinObject($join, 'Pub');
727: }
728:
729: return $this;
730: }
731:
732: /**
733: * Use the Pub relation Pub object
734: *
735: * @see useQuery()
736: *
737: * @param string $relationAlias optional alias for the relation,
738: * to be used as main alias in the secondary query
739: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
740: *
741: * @return \cli_db\propel\PubQuery A secondary query class using the current class as primary query
742: */
743: public function usePubQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
744: {
745: return $this
746: ->joinPub($relationAlias, $joinType)
747: ->useQuery($relationAlias ? $relationAlias : 'Pub', '\cli_db\propel\PubQuery');
748: }
749:
750: /**
751: * Filter the query by a related FeatureCvtermDbxref object
752: *
753: * @param FeatureCvtermDbxref|PropelObjectCollection $featureCvtermDbxref the related object to use as filter
754: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
755: *
756: * @return FeatureCvtermQuery The current query, for fluid interface
757: * @throws PropelException - if the provided filter is invalid.
758: */
759: public function filterByFeatureCvtermDbxref($featureCvtermDbxref, $comparison = null)
760: {
761: if ($featureCvtermDbxref instanceof FeatureCvtermDbxref) {
762: return $this
763: ->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermDbxref->getFeatureCvtermId(), $comparison);
764: } elseif ($featureCvtermDbxref instanceof PropelObjectCollection) {
765: return $this
766: ->useFeatureCvtermDbxrefQuery()
767: ->filterByPrimaryKeys($featureCvtermDbxref->getPrimaryKeys())
768: ->endUse();
769: } else {
770: throw new PropelException('filterByFeatureCvtermDbxref() only accepts arguments of type FeatureCvtermDbxref or PropelCollection');
771: }
772: }
773:
774: /**
775: * Adds a JOIN clause to the query using the FeatureCvtermDbxref relation
776: *
777: * @param string $relationAlias optional alias for the relation
778: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
779: *
780: * @return FeatureCvtermQuery The current query, for fluid interface
781: */
782: public function joinFeatureCvtermDbxref($relationAlias = null, $joinType = Criteria::INNER_JOIN)
783: {
784: $tableMap = $this->getTableMap();
785: $relationMap = $tableMap->getRelation('FeatureCvtermDbxref');
786:
787: // create a ModelJoin object for this join
788: $join = new ModelJoin();
789: $join->setJoinType($joinType);
790: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
791: if ($previousJoin = $this->getPreviousJoin()) {
792: $join->setPreviousJoin($previousJoin);
793: }
794:
795: // add the ModelJoin to the current object
796: if ($relationAlias) {
797: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
798: $this->addJoinObject($join, $relationAlias);
799: } else {
800: $this->addJoinObject($join, 'FeatureCvtermDbxref');
801: }
802:
803: return $this;
804: }
805:
806: /**
807: * Use the FeatureCvtermDbxref relation FeatureCvtermDbxref object
808: *
809: * @see useQuery()
810: *
811: * @param string $relationAlias optional alias for the relation,
812: * to be used as main alias in the secondary query
813: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
814: *
815: * @return \cli_db\propel\FeatureCvtermDbxrefQuery A secondary query class using the current class as primary query
816: */
817: public function useFeatureCvtermDbxrefQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
818: {
819: return $this
820: ->joinFeatureCvtermDbxref($relationAlias, $joinType)
821: ->useQuery($relationAlias ? $relationAlias : 'FeatureCvtermDbxref', '\cli_db\propel\FeatureCvtermDbxrefQuery');
822: }
823:
824: /**
825: * Filter the query by a related FeatureCvtermPub object
826: *
827: * @param FeatureCvtermPub|PropelObjectCollection $featureCvtermPub the related object to use as filter
828: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
829: *
830: * @return FeatureCvtermQuery The current query, for fluid interface
831: * @throws PropelException - if the provided filter is invalid.
832: */
833: public function filterByFeatureCvtermPub($featureCvtermPub, $comparison = null)
834: {
835: if ($featureCvtermPub instanceof FeatureCvtermPub) {
836: return $this
837: ->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermPub->getFeatureCvtermId(), $comparison);
838: } elseif ($featureCvtermPub instanceof PropelObjectCollection) {
839: return $this
840: ->useFeatureCvtermPubQuery()
841: ->filterByPrimaryKeys($featureCvtermPub->getPrimaryKeys())
842: ->endUse();
843: } else {
844: throw new PropelException('filterByFeatureCvtermPub() only accepts arguments of type FeatureCvtermPub or PropelCollection');
845: }
846: }
847:
848: /**
849: * Adds a JOIN clause to the query using the FeatureCvtermPub relation
850: *
851: * @param string $relationAlias optional alias for the relation
852: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
853: *
854: * @return FeatureCvtermQuery The current query, for fluid interface
855: */
856: public function joinFeatureCvtermPub($relationAlias = null, $joinType = Criteria::INNER_JOIN)
857: {
858: $tableMap = $this->getTableMap();
859: $relationMap = $tableMap->getRelation('FeatureCvtermPub');
860:
861: // create a ModelJoin object for this join
862: $join = new ModelJoin();
863: $join->setJoinType($joinType);
864: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
865: if ($previousJoin = $this->getPreviousJoin()) {
866: $join->setPreviousJoin($previousJoin);
867: }
868:
869: // add the ModelJoin to the current object
870: if ($relationAlias) {
871: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
872: $this->addJoinObject($join, $relationAlias);
873: } else {
874: $this->addJoinObject($join, 'FeatureCvtermPub');
875: }
876:
877: return $this;
878: }
879:
880: /**
881: * Use the FeatureCvtermPub relation FeatureCvtermPub object
882: *
883: * @see useQuery()
884: *
885: * @param string $relationAlias optional alias for the relation,
886: * to be used as main alias in the secondary query
887: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
888: *
889: * @return \cli_db\propel\FeatureCvtermPubQuery A secondary query class using the current class as primary query
890: */
891: public function useFeatureCvtermPubQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
892: {
893: return $this
894: ->joinFeatureCvtermPub($relationAlias, $joinType)
895: ->useQuery($relationAlias ? $relationAlias : 'FeatureCvtermPub', '\cli_db\propel\FeatureCvtermPubQuery');
896: }
897:
898: /**
899: * Filter the query by a related FeatureCvtermprop object
900: *
901: * @param FeatureCvtermprop|PropelObjectCollection $featureCvtermprop the related object to use as filter
902: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
903: *
904: * @return FeatureCvtermQuery The current query, for fluid interface
905: * @throws PropelException - if the provided filter is invalid.
906: */
907: public function filterByFeatureCvtermprop($featureCvtermprop, $comparison = null)
908: {
909: if ($featureCvtermprop instanceof FeatureCvtermprop) {
910: return $this
911: ->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvtermprop->getFeatureCvtermId(), $comparison);
912: } elseif ($featureCvtermprop instanceof PropelObjectCollection) {
913: return $this
914: ->useFeatureCvtermpropQuery()
915: ->filterByPrimaryKeys($featureCvtermprop->getPrimaryKeys())
916: ->endUse();
917: } else {
918: throw new PropelException('filterByFeatureCvtermprop() only accepts arguments of type FeatureCvtermprop or PropelCollection');
919: }
920: }
921:
922: /**
923: * Adds a JOIN clause to the query using the FeatureCvtermprop relation
924: *
925: * @param string $relationAlias optional alias for the relation
926: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
927: *
928: * @return FeatureCvtermQuery The current query, for fluid interface
929: */
930: public function joinFeatureCvtermprop($relationAlias = null, $joinType = Criteria::INNER_JOIN)
931: {
932: $tableMap = $this->getTableMap();
933: $relationMap = $tableMap->getRelation('FeatureCvtermprop');
934:
935: // create a ModelJoin object for this join
936: $join = new ModelJoin();
937: $join->setJoinType($joinType);
938: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
939: if ($previousJoin = $this->getPreviousJoin()) {
940: $join->setPreviousJoin($previousJoin);
941: }
942:
943: // add the ModelJoin to the current object
944: if ($relationAlias) {
945: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
946: $this->addJoinObject($join, $relationAlias);
947: } else {
948: $this->addJoinObject($join, 'FeatureCvtermprop');
949: }
950:
951: return $this;
952: }
953:
954: /**
955: * Use the FeatureCvtermprop relation FeatureCvtermprop object
956: *
957: * @see useQuery()
958: *
959: * @param string $relationAlias optional alias for the relation,
960: * to be used as main alias in the secondary query
961: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
962: *
963: * @return \cli_db\propel\FeatureCvtermpropQuery A secondary query class using the current class as primary query
964: */
965: public function useFeatureCvtermpropQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
966: {
967: return $this
968: ->joinFeatureCvtermprop($relationAlias, $joinType)
969: ->useQuery($relationAlias ? $relationAlias : 'FeatureCvtermprop', '\cli_db\propel\FeatureCvtermpropQuery');
970: }
971:
972: /**
973: * Exclude object from result
974: *
975: * @param FeatureCvterm $featureCvterm Object to remove from the list of results
976: *
977: * @return FeatureCvtermQuery The current query, for fluid interface
978: */
979: public function prune($featureCvterm = null)
980: {
981: if ($featureCvterm) {
982: $this->addUsingAlias(FeatureCvtermPeer::FEATURE_CVTERM_ID, $featureCvterm->getFeatureCvtermId(), Criteria::NOT_EQUAL);
983: }
984:
985: return $this;
986: }
987:
988: }
989: