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