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