airtime_nginx_php7/airtime_mvc/application/models/airtime/om/BaseCcTransQuery.php

<?php


/**
 * Base class that represents a query for the 'cc_trans' table.
 *
 * 
 *
 * @method     CcTransQuery orderById($order = Criteria::ASC) Order by the id column
 * @method     CcTransQuery orderByTrtok($order = Criteria::ASC) Order by the trtok column
 * @method     CcTransQuery orderByDirection($order = Criteria::ASC) Order by the direction column
 * @method     CcTransQuery orderByState($order = Criteria::ASC) Order by the state column
 * @method     CcTransQuery orderByTrtype($order = Criteria::ASC) Order by the trtype column
 * @method     CcTransQuery orderByLock($order = Criteria::ASC) Order by the lock column
 * @method     CcTransQuery orderByTarget($order = Criteria::ASC) Order by the target column
 * @method     CcTransQuery orderByRtrtok($order = Criteria::ASC) Order by the rtrtok column
 * @method     CcTransQuery orderByMdtrtok($order = Criteria::ASC) Order by the mdtrtok column
 * @method     CcTransQuery orderByGunid($order = Criteria::ASC) Order by the gunid column
 * @method     CcTransQuery orderByPdtoken($order = Criteria::ASC) Order by the pdtoken column
 * @method     CcTransQuery orderByUrl($order = Criteria::ASC) Order by the url column
 * @method     CcTransQuery orderByLocalfile($order = Criteria::ASC) Order by the localfile column
 * @method     CcTransQuery orderByFname($order = Criteria::ASC) Order by the fname column
 * @method     CcTransQuery orderByTitle($order = Criteria::ASC) Order by the title column
 * @method     CcTransQuery orderByExpectedsum($order = Criteria::ASC) Order by the expectedsum column
 * @method     CcTransQuery orderByRealsum($order = Criteria::ASC) Order by the realsum column
 * @method     CcTransQuery orderByExpectedsize($order = Criteria::ASC) Order by the expectedsize column
 * @method     CcTransQuery orderByRealsize($order = Criteria::ASC) Order by the realsize column
 * @method     CcTransQuery orderByUid($order = Criteria::ASC) Order by the uid column
 * @method     CcTransQuery orderByErrmsg($order = Criteria::ASC) Order by the errmsg column
 * @method     CcTransQuery orderByJobpid($order = Criteria::ASC) Order by the jobpid column
 * @method     CcTransQuery orderByStart($order = Criteria::ASC) Order by the start column
 * @method     CcTransQuery orderByTs($order = Criteria::ASC) Order by the ts column
 *
 * @method     CcTransQuery groupById() Group by the id column
 * @method     CcTransQuery groupByTrtok() Group by the trtok column
 * @method     CcTransQuery groupByDirection() Group by the direction column
 * @method     CcTransQuery groupByState() Group by the state column
 * @method     CcTransQuery groupByTrtype() Group by the trtype column
 * @method     CcTransQuery groupByLock() Group by the lock column
 * @method     CcTransQuery groupByTarget() Group by the target column
 * @method     CcTransQuery groupByRtrtok() Group by the rtrtok column
 * @method     CcTransQuery groupByMdtrtok() Group by the mdtrtok column
 * @method     CcTransQuery groupByGunid() Group by the gunid column
 * @method     CcTransQuery groupByPdtoken() Group by the pdtoken column
 * @method     CcTransQuery groupByUrl() Group by the url column
 * @method     CcTransQuery groupByLocalfile() Group by the localfile column
 * @method     CcTransQuery groupByFname() Group by the fname column
 * @method     CcTransQuery groupByTitle() Group by the title column
 * @method     CcTransQuery groupByExpectedsum() Group by the expectedsum column
 * @method     CcTransQuery groupByRealsum() Group by the realsum column
 * @method     CcTransQuery groupByExpectedsize() Group by the expectedsize column
 * @method     CcTransQuery groupByRealsize() Group by the realsize column
 * @method     CcTransQuery groupByUid() Group by the uid column
 * @method     CcTransQuery groupByErrmsg() Group by the errmsg column
 * @method     CcTransQuery groupByJobpid() Group by the jobpid column
 * @method     CcTransQuery groupByStart() Group by the start column
 * @method     CcTransQuery groupByTs() Group by the ts column
 *
 * @method     CcTransQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
 * @method     CcTransQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
 * @method     CcTransQuery innerJoin($relation) Adds a INNER JOIN clause to the query
 *
 * @method     CcTrans findOne(PropelPDO $con = null) Return the first CcTrans matching the query
 * @method     CcTrans findOneOrCreate(PropelPDO $con = null) Return the first CcTrans matching the query, or a new CcTrans object populated from the query conditions when no match is found
 *
 * @method     CcTrans findOneById(int $id) Return the first CcTrans filtered by the id column
 * @method     CcTrans findOneByTrtok(string $trtok) Return the first CcTrans filtered by the trtok column
 * @method     CcTrans findOneByDirection(string $direction) Return the first CcTrans filtered by the direction column
 * @method     CcTrans findOneByState(string $state) Return the first CcTrans filtered by the state column
 * @method     CcTrans findOneByTrtype(string $trtype) Return the first CcTrans filtered by the trtype column
 * @method     CcTrans findOneByLock(string $lock) Return the first CcTrans filtered by the lock column
 * @method     CcTrans findOneByTarget(string $target) Return the first CcTrans filtered by the target column
 * @method     CcTrans findOneByRtrtok(string $rtrtok) Return the first CcTrans filtered by the rtrtok column
 * @method     CcTrans findOneByMdtrtok(string $mdtrtok) Return the first CcTrans filtered by the mdtrtok column
 * @method     CcTrans findOneByGunid(string $gunid) Return the first CcTrans filtered by the gunid column
 * @method     CcTrans findOneByPdtoken(string $pdtoken) Return the first CcTrans filtered by the pdtoken column
 * @method     CcTrans findOneByUrl(string $url) Return the first CcTrans filtered by the url column
 * @method     CcTrans findOneByLocalfile(string $localfile) Return the first CcTrans filtered by the localfile column
 * @method     CcTrans findOneByFname(string $fname) Return the first CcTrans filtered by the fname column
 * @method     CcTrans findOneByTitle(string $title) Return the first CcTrans filtered by the title column
 * @method     CcTrans findOneByExpectedsum(string $expectedsum) Return the first CcTrans filtered by the expectedsum column
 * @method     CcTrans findOneByRealsum(string $realsum) Return the first CcTrans filtered by the realsum column
 * @method     CcTrans findOneByExpectedsize(int $expectedsize) Return the first CcTrans filtered by the expectedsize column
 * @method     CcTrans findOneByRealsize(int $realsize) Return the first CcTrans filtered by the realsize column
 * @method     CcTrans findOneByUid(int $uid) Return the first CcTrans filtered by the uid column
 * @method     CcTrans findOneByErrmsg(string $errmsg) Return the first CcTrans filtered by the errmsg column
 * @method     CcTrans findOneByJobpid(int $jobpid) Return the first CcTrans filtered by the jobpid column
 * @method     CcTrans findOneByStart(string $start) Return the first CcTrans filtered by the start column
 * @method     CcTrans findOneByTs(string $ts) Return the first CcTrans filtered by the ts column
 *
 * @method     array findById(int $id) Return CcTrans objects filtered by the id column
 * @method     array findByTrtok(string $trtok) Return CcTrans objects filtered by the trtok column
 * @method     array findByDirection(string $direction) Return CcTrans objects filtered by the direction column
 * @method     array findByState(string $state) Return CcTrans objects filtered by the state column
 * @method     array findByTrtype(string $trtype) Return CcTrans objects filtered by the trtype column
 * @method     array findByLock(string $lock) Return CcTrans objects filtered by the lock column
 * @method     array findByTarget(string $target) Return CcTrans objects filtered by the target column
 * @method     array findByRtrtok(string $rtrtok) Return CcTrans objects filtered by the rtrtok column
 * @method     array findByMdtrtok(string $mdtrtok) Return CcTrans objects filtered by the mdtrtok column
 * @method     array findByGunid(string $gunid) Return CcTrans objects filtered by the gunid column
 * @method     array findByPdtoken(string $pdtoken) Return CcTrans objects filtered by the pdtoken column
 * @method     array findByUrl(string $url) Return CcTrans objects filtered by the url column
 * @method     array findByLocalfile(string $localfile) Return CcTrans objects filtered by the localfile column
 * @method     array findByFname(string $fname) Return CcTrans objects filtered by the fname column
 * @method     array findByTitle(string $title) Return CcTrans objects filtered by the title column
 * @method     array findByExpectedsum(string $expectedsum) Return CcTrans objects filtered by the expectedsum column
 * @method     array findByRealsum(string $realsum) Return CcTrans objects filtered by the realsum column
 * @method     array findByExpectedsize(int $expectedsize) Return CcTrans objects filtered by the expectedsize column
 * @method     array findByRealsize(int $realsize) Return CcTrans objects filtered by the realsize column
 * @method     array findByUid(int $uid) Return CcTrans objects filtered by the uid column
 * @method     array findByErrmsg(string $errmsg) Return CcTrans objects filtered by the errmsg column
 * @method     array findByJobpid(int $jobpid) Return CcTrans objects filtered by the jobpid column
 * @method     array findByStart(string $start) Return CcTrans objects filtered by the start column
 * @method     array findByTs(string $ts) Return CcTrans objects filtered by the ts column
 *
 * @package    propel.generator.airtime.om
 */
abstract class BaseCcTransQuery extends ModelCriteria
{

	/**
	 * Initializes internal state of BaseCcTransQuery object.
	 *
	 * @param     string $dbName The dabase name
	 * @param     string $modelName The phpName of a model, e.g. 'Book'
	 * @param     string $modelAlias The alias for the model in this query, e.g. 'b'
	 */
	public function __construct($dbName = 'airtime', $modelName = 'CcTrans', $modelAlias = null)
	{
		parent::__construct($dbName, $modelName, $modelAlias);
	}

	/**
	 * Returns a new CcTransQuery object.
	 *
	 * @param     string $modelAlias The alias of a model in the query
	 * @param     Criteria $criteria Optional Criteria to build the query from
	 *
	 * @return    CcTransQuery
	 */
	public static function create($modelAlias = null, $criteria = null)
	{
		if ($criteria instanceof CcTransQuery) {
			return $criteria;
		}
		$query = new CcTransQuery();
		if (null !== $modelAlias) {
			$query->setModelAlias($modelAlias);
		}
		if ($criteria instanceof Criteria) {
			$query->mergeWith($criteria);
		}
		return $query;
	}

	/**
	 * Find object by primary key
	 * Use instance pooling to avoid a database query if the object exists
	 * <code>
	 * $obj  = $c->findPk(12, $con);
	 * </code>
	 * @param     mixed $key Primary key to use for the query
	 * @param     PropelPDO $con an optional connection object
	 *
	 * @return    CcTrans|array|mixed the result, formatted by the current formatter
	 */
	public function findPk($key, $con = null)
	{
		if ((null !== ($obj = CcTransPeer::getInstanceFromPool((string) $key))) && $this->getFormatter()->isObjectFormatter()) {
			// the object is alredy in the instance pool
			return $obj;
		} else {
			// the object has not been requested yet, or the formatter is not an object formatter
			$criteria = $this->isKeepQuery() ? clone $this : $this;
			$stmt = $criteria
				->filterByPrimaryKey($key)
				->getSelectStatement($con);
			return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
		}
	}

	/**
	 * Find objects by primary key
	 * <code>
	 * $objs = $c->findPks(array(12, 56, 832), $con);
	 * </code>
	 * @param     array $keys Primary keys to use for the query
	 * @param     PropelPDO $con an optional connection object
	 *
	 * @return    PropelObjectCollection|array|mixed the list of results, formatted by the current formatter
	 */
	public function findPks($keys, $con = null)
	{	
		$criteria = $this->isKeepQuery() ? clone $this : $this;
		return $this
			->filterByPrimaryKeys($keys)
			->find($con);
	}

	/**
	 * Filter the query by primary key
	 *
	 * @param     mixed $key Primary key to use for the query
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByPrimaryKey($key)
	{
		return $this->addUsingAlias(CcTransPeer::ID, $key, Criteria::EQUAL);
	}

	/**
	 * Filter the query by a list of primary keys
	 *
	 * @param     array $keys The list of primary key to use for the query
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByPrimaryKeys($keys)
	{
		return $this->addUsingAlias(CcTransPeer::ID, $keys, Criteria::IN);
	}

	/**
	 * Filter the query on the id column
	 * 
	 * @param     int|array $id The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterById($id = null, $comparison = null)
	{
		if (is_array($id) && null === $comparison) {
			$comparison = Criteria::IN;
		}
		return $this->addUsingAlias(CcTransPeer::ID, $id, $comparison);
	}

	/**
	 * Filter the query on the trtok column
	 * 
	 * @param     string $trtok The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByTrtok($trtok = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($trtok)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $trtok)) {
				$trtok = str_replace('*', '%', $trtok);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::TRTOK, $trtok, $comparison);
	}

	/**
	 * Filter the query on the direction column
	 * 
	 * @param     string $direction The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByDirection($direction = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($direction)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $direction)) {
				$direction = str_replace('*', '%', $direction);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::DIRECTION, $direction, $comparison);
	}

	/**
	 * Filter the query on the state column
	 * 
	 * @param     string $state The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByState($state = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($state)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $state)) {
				$state = str_replace('*', '%', $state);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::STATE, $state, $comparison);
	}

	/**
	 * Filter the query on the trtype column
	 * 
	 * @param     string $trtype The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByTrtype($trtype = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($trtype)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $trtype)) {
				$trtype = str_replace('*', '%', $trtype);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::TRTYPE, $trtype, $comparison);
	}

	/**
	 * Filter the query on the lock column
	 * 
	 * @param     string $lock The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByLock($lock = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($lock)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $lock)) {
				$lock = str_replace('*', '%', $lock);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::LOCK, $lock, $comparison);
	}

	/**
	 * Filter the query on the target column
	 * 
	 * @param     string $target The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByTarget($target = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($target)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $target)) {
				$target = str_replace('*', '%', $target);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::TARGET, $target, $comparison);
	}

	/**
	 * Filter the query on the rtrtok column
	 * 
	 * @param     string $rtrtok The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByRtrtok($rtrtok = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($rtrtok)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $rtrtok)) {
				$rtrtok = str_replace('*', '%', $rtrtok);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::RTRTOK, $rtrtok, $comparison);
	}

	/**
	 * Filter the query on the mdtrtok column
	 * 
	 * @param     string $mdtrtok The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByMdtrtok($mdtrtok = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($mdtrtok)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $mdtrtok)) {
				$mdtrtok = str_replace('*', '%', $mdtrtok);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::MDTRTOK, $mdtrtok, $comparison);
	}

	/**
	 * Filter the query on the gunid column
	 * 
	 * @param     string $gunid The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByGunid($gunid = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($gunid)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $gunid)) {
				$gunid = str_replace('*', '%', $gunid);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::GUNID, $gunid, $comparison);
	}

	/**
	 * Filter the query on the pdtoken column
	 * 
	 * @param     string|array $pdtoken The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByPdtoken($pdtoken = null, $comparison = null)
	{
		if (is_array($pdtoken)) {
			$useMinMax = false;
			if (isset($pdtoken['min'])) {
				$this->addUsingAlias(CcTransPeer::PDTOKEN, $pdtoken['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($pdtoken['max'])) {
				$this->addUsingAlias(CcTransPeer::PDTOKEN, $pdtoken['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::PDTOKEN, $pdtoken, $comparison);
	}

	/**
	 * Filter the query on the url column
	 * 
	 * @param     string $url The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByUrl($url = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($url)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $url)) {
				$url = str_replace('*', '%', $url);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::URL, $url, $comparison);
	}

	/**
	 * Filter the query on the localfile column
	 * 
	 * @param     string $localfile The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByLocalfile($localfile = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($localfile)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $localfile)) {
				$localfile = str_replace('*', '%', $localfile);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::LOCALFILE, $localfile, $comparison);
	}

	/**
	 * Filter the query on the fname column
	 * 
	 * @param     string $fname The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByFname($fname = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($fname)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $fname)) {
				$fname = str_replace('*', '%', $fname);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::FNAME, $fname, $comparison);
	}

	/**
	 * Filter the query on the title column
	 * 
	 * @param     string $title The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByTitle($title = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($title)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $title)) {
				$title = str_replace('*', '%', $title);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::TITLE, $title, $comparison);
	}

	/**
	 * Filter the query on the expectedsum column
	 * 
	 * @param     string $expectedsum The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByExpectedsum($expectedsum = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($expectedsum)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $expectedsum)) {
				$expectedsum = str_replace('*', '%', $expectedsum);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::EXPECTEDSUM, $expectedsum, $comparison);
	}

	/**
	 * Filter the query on the realsum column
	 * 
	 * @param     string $realsum The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByRealsum($realsum = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($realsum)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $realsum)) {
				$realsum = str_replace('*', '%', $realsum);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::REALSUM, $realsum, $comparison);
	}

	/**
	 * Filter the query on the expectedsize column
	 * 
	 * @param     int|array $expectedsize The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByExpectedsize($expectedsize = null, $comparison = null)
	{
		if (is_array($expectedsize)) {
			$useMinMax = false;
			if (isset($expectedsize['min'])) {
				$this->addUsingAlias(CcTransPeer::EXPECTEDSIZE, $expectedsize['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($expectedsize['max'])) {
				$this->addUsingAlias(CcTransPeer::EXPECTEDSIZE, $expectedsize['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::EXPECTEDSIZE, $expectedsize, $comparison);
	}

	/**
	 * Filter the query on the realsize column
	 * 
	 * @param     int|array $realsize The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByRealsize($realsize = null, $comparison = null)
	{
		if (is_array($realsize)) {
			$useMinMax = false;
			if (isset($realsize['min'])) {
				$this->addUsingAlias(CcTransPeer::REALSIZE, $realsize['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($realsize['max'])) {
				$this->addUsingAlias(CcTransPeer::REALSIZE, $realsize['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::REALSIZE, $realsize, $comparison);
	}

	/**
	 * Filter the query on the uid column
	 * 
	 * @param     int|array $uid The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByUid($uid = null, $comparison = null)
	{
		if (is_array($uid)) {
			$useMinMax = false;
			if (isset($uid['min'])) {
				$this->addUsingAlias(CcTransPeer::UID, $uid['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($uid['max'])) {
				$this->addUsingAlias(CcTransPeer::UID, $uid['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::UID, $uid, $comparison);
	}

	/**
	 * Filter the query on the errmsg column
	 * 
	 * @param     string $errmsg The value to use as filter.
	 *            Accepts wildcards (* and % trigger a LIKE)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByErrmsg($errmsg = null, $comparison = null)
	{
		if (null === $comparison) {
			if (is_array($errmsg)) {
				$comparison = Criteria::IN;
			} elseif (preg_match('/[\%\*]/', $errmsg)) {
				$errmsg = str_replace('*', '%', $errmsg);
				$comparison = Criteria::LIKE;
			}
		}
		return $this->addUsingAlias(CcTransPeer::ERRMSG, $errmsg, $comparison);
	}

	/**
	 * Filter the query on the jobpid column
	 * 
	 * @param     int|array $jobpid The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByJobpid($jobpid = null, $comparison = null)
	{
		if (is_array($jobpid)) {
			$useMinMax = false;
			if (isset($jobpid['min'])) {
				$this->addUsingAlias(CcTransPeer::JOBPID, $jobpid['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($jobpid['max'])) {
				$this->addUsingAlias(CcTransPeer::JOBPID, $jobpid['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::JOBPID, $jobpid, $comparison);
	}

	/**
	 * Filter the query on the start column
	 * 
	 * @param     string|array $start The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByStart($start = null, $comparison = null)
	{
		if (is_array($start)) {
			$useMinMax = false;
			if (isset($start['min'])) {
				$this->addUsingAlias(CcTransPeer::START, $start['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($start['max'])) {
				$this->addUsingAlias(CcTransPeer::START, $start['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::START, $start, $comparison);
	}

	/**
	 * Filter the query on the ts column
	 * 
	 * @param     string|array $ts The value to use as filter.
	 *            Accepts an associative array('min' => $minValue, 'max' => $maxValue)
	 * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function filterByTs($ts = null, $comparison = null)
	{
		if (is_array($ts)) {
			$useMinMax = false;
			if (isset($ts['min'])) {
				$this->addUsingAlias(CcTransPeer::TS, $ts['min'], Criteria::GREATER_EQUAL);
				$useMinMax = true;
			}
			if (isset($ts['max'])) {
				$this->addUsingAlias(CcTransPeer::TS, $ts['max'], Criteria::LESS_EQUAL);
				$useMinMax = true;
			}
			if ($useMinMax) {
				return $this;
			}
			if (null === $comparison) {
				$comparison = Criteria::IN;
			}
		}
		return $this->addUsingAlias(CcTransPeer::TS, $ts, $comparison);
	}

	/**
	 * Exclude object from result
	 *
	 * @param     CcTrans $ccTrans Object to remove from the list of results
	 *
	 * @return    CcTransQuery The current query, for fluid interface
	 */
	public function prune($ccTrans = null)
	{
		if ($ccTrans) {
			$this->addUsingAlias(CcTransPeer::ID, $ccTrans->getId(), Criteria::NOT_EQUAL);
	  }
	  
		return $this;
	}

} // BaseCcTransQuery