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
*
* $obj = $c->findPk(12, $con);
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con an optional connection object
*
* @return CcFiles|array|mixed the result, formatted by the current formatter
*/
public function findPk($key, $con = null)
{
if ((null !== ($obj = CcFilesPeer::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
*
* $objs = $c->findPks(array(12, 56, 832), $con);
*
* @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 CcFilesQuery The current query, for fluid interface
*/
public function filterByPrimaryKey($key)
{
return $this->addUsingAlias(CcFilesPeer::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 CcFilesQuery The current query, for fluid interface
*/
public function filterByPrimaryKeys($keys)
{
return $this->addUsingAlias(CcFilesPeer::ID, $keys, Criteria::IN);
}
/**
* Filter the query on the id column
*
* @param int|array $dbId 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbId($dbId = null, $comparison = null)
{
if (is_array($dbId) && null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CcFilesPeer::ID, $dbId, $comparison);
}
/**
* Filter the query on the name column
*
* @param string $dbName 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbName($dbName = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbName)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbName)) {
$dbName = str_replace('*', '%', $dbName);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::NAME, $dbName, $comparison);
}
/**
* Filter the query on the mime column
*
* @param string $dbMime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbMime($dbMime = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbMime)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbMime)) {
$dbMime = str_replace('*', '%', $dbMime);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::MIME, $dbMime, $comparison);
}
/**
* Filter the query on the ftype column
*
* @param string $dbFtype 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbFtype($dbFtype = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbFtype)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbFtype)) {
$dbFtype = str_replace('*', '%', $dbFtype);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::FTYPE, $dbFtype, $comparison);
}
/**
* Filter the query on the directory column
*
* @param int|array $dbDirectory 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbDirectory($dbDirectory = null, $comparison = null)
{
if (is_array($dbDirectory)) {
$useMinMax = false;
if (isset($dbDirectory['min'])) {
$this->addUsingAlias(CcFilesPeer::DIRECTORY, $dbDirectory['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbDirectory['max'])) {
$this->addUsingAlias(CcFilesPeer::DIRECTORY, $dbDirectory['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::DIRECTORY, $dbDirectory, $comparison);
}
/**
* Filter the query on the filepath column
*
* @param string $dbFilepath 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbFilepath($dbFilepath = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbFilepath)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbFilepath)) {
$dbFilepath = str_replace('*', '%', $dbFilepath);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::FILEPATH, $dbFilepath, $comparison);
}
/**
* Filter the query on the state column
*
* @param string $dbState 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbState($dbState = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbState)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbState)) {
$dbState = str_replace('*', '%', $dbState);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::STATE, $dbState, $comparison);
}
/**
* Filter the query on the currentlyaccessing column
*
* @param int|array $dbCurrentlyaccessing 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbCurrentlyaccessing($dbCurrentlyaccessing = null, $comparison = null)
{
if (is_array($dbCurrentlyaccessing)) {
$useMinMax = false;
if (isset($dbCurrentlyaccessing['min'])) {
$this->addUsingAlias(CcFilesPeer::CURRENTLYACCESSING, $dbCurrentlyaccessing['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbCurrentlyaccessing['max'])) {
$this->addUsingAlias(CcFilesPeer::CURRENTLYACCESSING, $dbCurrentlyaccessing['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::CURRENTLYACCESSING, $dbCurrentlyaccessing, $comparison);
}
/**
* Filter the query on the editedby column
*
* @param int|array $dbEditedby 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbEditedby($dbEditedby = null, $comparison = null)
{
if (is_array($dbEditedby)) {
$useMinMax = false;
if (isset($dbEditedby['min'])) {
$this->addUsingAlias(CcFilesPeer::EDITEDBY, $dbEditedby['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbEditedby['max'])) {
$this->addUsingAlias(CcFilesPeer::EDITEDBY, $dbEditedby['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::EDITEDBY, $dbEditedby, $comparison);
}
/**
* Filter the query on the mtime column
*
* @param string|array $dbMtime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbMtime($dbMtime = null, $comparison = null)
{
if (is_array($dbMtime)) {
$useMinMax = false;
if (isset($dbMtime['min'])) {
$this->addUsingAlias(CcFilesPeer::MTIME, $dbMtime['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbMtime['max'])) {
$this->addUsingAlias(CcFilesPeer::MTIME, $dbMtime['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::MTIME, $dbMtime, $comparison);
}
/**
* Filter the query on the utime column
*
* @param string|array $dbUtime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbUtime($dbUtime = null, $comparison = null)
{
if (is_array($dbUtime)) {
$useMinMax = false;
if (isset($dbUtime['min'])) {
$this->addUsingAlias(CcFilesPeer::UTIME, $dbUtime['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbUtime['max'])) {
$this->addUsingAlias(CcFilesPeer::UTIME, $dbUtime['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::UTIME, $dbUtime, $comparison);
}
/**
* Filter the query on the lptime column
*
* @param string|array $dbLPtime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLPtime($dbLPtime = null, $comparison = null)
{
if (is_array($dbLPtime)) {
$useMinMax = false;
if (isset($dbLPtime['min'])) {
$this->addUsingAlias(CcFilesPeer::LPTIME, $dbLPtime['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbLPtime['max'])) {
$this->addUsingAlias(CcFilesPeer::LPTIME, $dbLPtime['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::LPTIME, $dbLPtime, $comparison);
}
/**
* Filter the query on the md5 column
*
* @param string $dbMd5 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbMd5($dbMd5 = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbMd5)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbMd5)) {
$dbMd5 = str_replace('*', '%', $dbMd5);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::MD5, $dbMd5, $comparison);
}
/**
* Filter the query on the track_title column
*
* @param string $dbTrackTitle 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbTrackTitle($dbTrackTitle = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbTrackTitle)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbTrackTitle)) {
$dbTrackTitle = str_replace('*', '%', $dbTrackTitle);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::TRACK_TITLE, $dbTrackTitle, $comparison);
}
/**
* Filter the query on the artist_name column
*
* @param string $dbArtistName 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbArtistName($dbArtistName = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbArtistName)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbArtistName)) {
$dbArtistName = str_replace('*', '%', $dbArtistName);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ARTIST_NAME, $dbArtistName, $comparison);
}
/**
* Filter the query on the bit_rate column
*
* @param int|array $dbBitRate 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbBitRate($dbBitRate = null, $comparison = null)
{
if (is_array($dbBitRate)) {
$useMinMax = false;
if (isset($dbBitRate['min'])) {
$this->addUsingAlias(CcFilesPeer::BIT_RATE, $dbBitRate['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbBitRate['max'])) {
$this->addUsingAlias(CcFilesPeer::BIT_RATE, $dbBitRate['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::BIT_RATE, $dbBitRate, $comparison);
}
/**
* Filter the query on the sample_rate column
*
* @param int|array $dbSampleRate 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSampleRate($dbSampleRate = null, $comparison = null)
{
if (is_array($dbSampleRate)) {
$useMinMax = false;
if (isset($dbSampleRate['min'])) {
$this->addUsingAlias(CcFilesPeer::SAMPLE_RATE, $dbSampleRate['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbSampleRate['max'])) {
$this->addUsingAlias(CcFilesPeer::SAMPLE_RATE, $dbSampleRate['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::SAMPLE_RATE, $dbSampleRate, $comparison);
}
/**
* Filter the query on the format column
*
* @param string $dbFormat 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbFormat($dbFormat = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbFormat)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbFormat)) {
$dbFormat = str_replace('*', '%', $dbFormat);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::FORMAT, $dbFormat, $comparison);
}
/**
* Filter the query on the length column
*
* @param string $dbLength 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLength($dbLength = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbLength)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbLength)) {
$dbLength = str_replace('*', '%', $dbLength);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::LENGTH, $dbLength, $comparison);
}
/**
* Filter the query on the album_title column
*
* @param string $dbAlbumTitle 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbAlbumTitle($dbAlbumTitle = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbAlbumTitle)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbAlbumTitle)) {
$dbAlbumTitle = str_replace('*', '%', $dbAlbumTitle);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ALBUM_TITLE, $dbAlbumTitle, $comparison);
}
/**
* Filter the query on the genre column
*
* @param string $dbGenre 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbGenre($dbGenre = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbGenre)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbGenre)) {
$dbGenre = str_replace('*', '%', $dbGenre);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::GENRE, $dbGenre, $comparison);
}
/**
* Filter the query on the comments column
*
* @param string $dbComments 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbComments($dbComments = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbComments)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbComments)) {
$dbComments = str_replace('*', '%', $dbComments);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::COMMENTS, $dbComments, $comparison);
}
/**
* Filter the query on the year column
*
* @param string $dbYear 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbYear($dbYear = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbYear)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbYear)) {
$dbYear = str_replace('*', '%', $dbYear);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::YEAR, $dbYear, $comparison);
}
/**
* Filter the query on the track_number column
*
* @param int|array $dbTrackNumber 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbTrackNumber($dbTrackNumber = null, $comparison = null)
{
if (is_array($dbTrackNumber)) {
$useMinMax = false;
if (isset($dbTrackNumber['min'])) {
$this->addUsingAlias(CcFilesPeer::TRACK_NUMBER, $dbTrackNumber['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbTrackNumber['max'])) {
$this->addUsingAlias(CcFilesPeer::TRACK_NUMBER, $dbTrackNumber['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::TRACK_NUMBER, $dbTrackNumber, $comparison);
}
/**
* Filter the query on the channels column
*
* @param int|array $dbChannels 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbChannels($dbChannels = null, $comparison = null)
{
if (is_array($dbChannels)) {
$useMinMax = false;
if (isset($dbChannels['min'])) {
$this->addUsingAlias(CcFilesPeer::CHANNELS, $dbChannels['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbChannels['max'])) {
$this->addUsingAlias(CcFilesPeer::CHANNELS, $dbChannels['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::CHANNELS, $dbChannels, $comparison);
}
/**
* Filter the query on the url column
*
* @param string $dbUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbUrl($dbUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbUrl)) {
$dbUrl = str_replace('*', '%', $dbUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::URL, $dbUrl, $comparison);
}
/**
* Filter the query on the bpm column
*
* @param int|array $dbBpm 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbBpm($dbBpm = null, $comparison = null)
{
if (is_array($dbBpm)) {
$useMinMax = false;
if (isset($dbBpm['min'])) {
$this->addUsingAlias(CcFilesPeer::BPM, $dbBpm['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbBpm['max'])) {
$this->addUsingAlias(CcFilesPeer::BPM, $dbBpm['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::BPM, $dbBpm, $comparison);
}
/**
* Filter the query on the rating column
*
* @param string $dbRating 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbRating($dbRating = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbRating)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbRating)) {
$dbRating = str_replace('*', '%', $dbRating);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::RATING, $dbRating, $comparison);
}
/**
* Filter the query on the encoded_by column
*
* @param string $dbEncodedBy 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbEncodedBy($dbEncodedBy = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbEncodedBy)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbEncodedBy)) {
$dbEncodedBy = str_replace('*', '%', $dbEncodedBy);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ENCODED_BY, $dbEncodedBy, $comparison);
}
/**
* Filter the query on the disc_number column
*
* @param string $dbDiscNumber 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbDiscNumber($dbDiscNumber = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbDiscNumber)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbDiscNumber)) {
$dbDiscNumber = str_replace('*', '%', $dbDiscNumber);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::DISC_NUMBER, $dbDiscNumber, $comparison);
}
/**
* Filter the query on the mood column
*
* @param string $dbMood 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbMood($dbMood = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbMood)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbMood)) {
$dbMood = str_replace('*', '%', $dbMood);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::MOOD, $dbMood, $comparison);
}
/**
* Filter the query on the label column
*
* @param string $dbLabel 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLabel($dbLabel = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbLabel)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbLabel)) {
$dbLabel = str_replace('*', '%', $dbLabel);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::LABEL, $dbLabel, $comparison);
}
/**
* Filter the query on the composer column
*
* @param string $dbComposer 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbComposer($dbComposer = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbComposer)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbComposer)) {
$dbComposer = str_replace('*', '%', $dbComposer);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::COMPOSER, $dbComposer, $comparison);
}
/**
* Filter the query on the encoder column
*
* @param string $dbEncoder 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbEncoder($dbEncoder = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbEncoder)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbEncoder)) {
$dbEncoder = str_replace('*', '%', $dbEncoder);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ENCODER, $dbEncoder, $comparison);
}
/**
* Filter the query on the checksum column
*
* @param string $dbChecksum 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbChecksum($dbChecksum = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbChecksum)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbChecksum)) {
$dbChecksum = str_replace('*', '%', $dbChecksum);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::CHECKSUM, $dbChecksum, $comparison);
}
/**
* Filter the query on the lyrics column
*
* @param string $dbLyrics 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLyrics($dbLyrics = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbLyrics)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbLyrics)) {
$dbLyrics = str_replace('*', '%', $dbLyrics);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::LYRICS, $dbLyrics, $comparison);
}
/**
* Filter the query on the orchestra column
*
* @param string $dbOrchestra 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbOrchestra($dbOrchestra = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbOrchestra)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbOrchestra)) {
$dbOrchestra = str_replace('*', '%', $dbOrchestra);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ORCHESTRA, $dbOrchestra, $comparison);
}
/**
* Filter the query on the conductor column
*
* @param string $dbConductor 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbConductor($dbConductor = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbConductor)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbConductor)) {
$dbConductor = str_replace('*', '%', $dbConductor);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::CONDUCTOR, $dbConductor, $comparison);
}
/**
* Filter the query on the lyricist column
*
* @param string $dbLyricist 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLyricist($dbLyricist = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbLyricist)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbLyricist)) {
$dbLyricist = str_replace('*', '%', $dbLyricist);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::LYRICIST, $dbLyricist, $comparison);
}
/**
* Filter the query on the original_lyricist column
*
* @param string $dbOriginalLyricist 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbOriginalLyricist($dbOriginalLyricist = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbOriginalLyricist)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbOriginalLyricist)) {
$dbOriginalLyricist = str_replace('*', '%', $dbOriginalLyricist);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ORIGINAL_LYRICIST, $dbOriginalLyricist, $comparison);
}
/**
* Filter the query on the radio_station_name column
*
* @param string $dbRadioStationName 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbRadioStationName($dbRadioStationName = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbRadioStationName)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbRadioStationName)) {
$dbRadioStationName = str_replace('*', '%', $dbRadioStationName);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::RADIO_STATION_NAME, $dbRadioStationName, $comparison);
}
/**
* Filter the query on the info_url column
*
* @param string $dbInfoUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbInfoUrl($dbInfoUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbInfoUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbInfoUrl)) {
$dbInfoUrl = str_replace('*', '%', $dbInfoUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::INFO_URL, $dbInfoUrl, $comparison);
}
/**
* Filter the query on the artist_url column
*
* @param string $dbArtistUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbArtistUrl($dbArtistUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbArtistUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbArtistUrl)) {
$dbArtistUrl = str_replace('*', '%', $dbArtistUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ARTIST_URL, $dbArtistUrl, $comparison);
}
/**
* Filter the query on the audio_source_url column
*
* @param string $dbAudioSourceUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbAudioSourceUrl($dbAudioSourceUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbAudioSourceUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbAudioSourceUrl)) {
$dbAudioSourceUrl = str_replace('*', '%', $dbAudioSourceUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::AUDIO_SOURCE_URL, $dbAudioSourceUrl, $comparison);
}
/**
* Filter the query on the radio_station_url column
*
* @param string $dbRadioStationUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbRadioStationUrl($dbRadioStationUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbRadioStationUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbRadioStationUrl)) {
$dbRadioStationUrl = str_replace('*', '%', $dbRadioStationUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::RADIO_STATION_URL, $dbRadioStationUrl, $comparison);
}
/**
* Filter the query on the buy_this_url column
*
* @param string $dbBuyThisUrl 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbBuyThisUrl($dbBuyThisUrl = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbBuyThisUrl)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbBuyThisUrl)) {
$dbBuyThisUrl = str_replace('*', '%', $dbBuyThisUrl);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::BUY_THIS_URL, $dbBuyThisUrl, $comparison);
}
/**
* Filter the query on the isrc_number column
*
* @param string $dbIsrcNumber 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbIsrcNumber($dbIsrcNumber = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbIsrcNumber)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbIsrcNumber)) {
$dbIsrcNumber = str_replace('*', '%', $dbIsrcNumber);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ISRC_NUMBER, $dbIsrcNumber, $comparison);
}
/**
* Filter the query on the catalog_number column
*
* @param string $dbCatalogNumber 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbCatalogNumber($dbCatalogNumber = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbCatalogNumber)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbCatalogNumber)) {
$dbCatalogNumber = str_replace('*', '%', $dbCatalogNumber);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::CATALOG_NUMBER, $dbCatalogNumber, $comparison);
}
/**
* Filter the query on the original_artist column
*
* @param string $dbOriginalArtist 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbOriginalArtist($dbOriginalArtist = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbOriginalArtist)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbOriginalArtist)) {
$dbOriginalArtist = str_replace('*', '%', $dbOriginalArtist);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::ORIGINAL_ARTIST, $dbOriginalArtist, $comparison);
}
/**
* Filter the query on the copyright column
*
* @param string $dbCopyright 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbCopyright($dbCopyright = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbCopyright)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbCopyright)) {
$dbCopyright = str_replace('*', '%', $dbCopyright);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::COPYRIGHT, $dbCopyright, $comparison);
}
/**
* Filter the query on the report_datetime column
*
* @param string $dbReportDatetime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbReportDatetime($dbReportDatetime = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbReportDatetime)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbReportDatetime)) {
$dbReportDatetime = str_replace('*', '%', $dbReportDatetime);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::REPORT_DATETIME, $dbReportDatetime, $comparison);
}
/**
* Filter the query on the report_location column
*
* @param string $dbReportLocation 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbReportLocation($dbReportLocation = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbReportLocation)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbReportLocation)) {
$dbReportLocation = str_replace('*', '%', $dbReportLocation);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::REPORT_LOCATION, $dbReportLocation, $comparison);
}
/**
* Filter the query on the report_organization column
*
* @param string $dbReportOrganization 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbReportOrganization($dbReportOrganization = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbReportOrganization)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbReportOrganization)) {
$dbReportOrganization = str_replace('*', '%', $dbReportOrganization);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::REPORT_ORGANIZATION, $dbReportOrganization, $comparison);
}
/**
* Filter the query on the subject column
*
* @param string $dbSubject 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSubject($dbSubject = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbSubject)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbSubject)) {
$dbSubject = str_replace('*', '%', $dbSubject);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::SUBJECT, $dbSubject, $comparison);
}
/**
* Filter the query on the contributor column
*
* @param string $dbContributor 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbContributor($dbContributor = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbContributor)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbContributor)) {
$dbContributor = str_replace('*', '%', $dbContributor);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::CONTRIBUTOR, $dbContributor, $comparison);
}
/**
* Filter the query on the language column
*
* @param string $dbLanguage 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbLanguage($dbLanguage = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbLanguage)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbLanguage)) {
$dbLanguage = str_replace('*', '%', $dbLanguage);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::LANGUAGE, $dbLanguage, $comparison);
}
/**
* Filter the query on the file_exists column
*
* @param boolean|string $dbFileExists The value to use as filter.
* Accepts strings ('false', 'off', '-', 'no', 'n', and '0' are false, the rest is true)
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByDbFileExists($dbFileExists = null, $comparison = null)
{
if (is_string($dbFileExists)) {
$file_exists = in_array(strtolower($dbFileExists), array('false', 'off', '-', 'no', 'n', '0')) ? false : true;
}
return $this->addUsingAlias(CcFilesPeer::FILE_EXISTS, $dbFileExists, $comparison);
}
/**
* Filter the query on the soundcloud_id column
*
* @param int|array $dbSoundcloudId 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSoundcloudId($dbSoundcloudId = null, $comparison = null)
{
if (is_array($dbSoundcloudId)) {
$useMinMax = false;
if (isset($dbSoundcloudId['min'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ID, $dbSoundcloudId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbSoundcloudId['max'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ID, $dbSoundcloudId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ID, $dbSoundcloudId, $comparison);
}
/**
* Filter the query on the soundcloud_error_code column
*
* @param int|array $dbSoundcloudErrorCode 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSoundcloudErrorCode($dbSoundcloudErrorCode = null, $comparison = null)
{
if (is_array($dbSoundcloudErrorCode)) {
$useMinMax = false;
if (isset($dbSoundcloudErrorCode['min'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ERROR_CODE, $dbSoundcloudErrorCode['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbSoundcloudErrorCode['max'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ERROR_CODE, $dbSoundcloudErrorCode['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ERROR_CODE, $dbSoundcloudErrorCode, $comparison);
}
/**
* Filter the query on the soundcloud_error_msg column
*
* @param string $dbSoundcloudErrorMsg 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSoundcloudErrorMsg($dbSoundcloudErrorMsg = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbSoundcloudErrorMsg)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbSoundcloudErrorMsg)) {
$dbSoundcloudErrorMsg = str_replace('*', '%', $dbSoundcloudErrorMsg);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_ERROR_MSG, $dbSoundcloudErrorMsg, $comparison);
}
/**
* Filter the query on the soundcloud_link_to_file column
*
* @param string $dbSoundcloudLinkToFile 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSoundcloudLinkToFile($dbSoundcloudLinkToFile = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbSoundcloudLinkToFile)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbSoundcloudLinkToFile)) {
$dbSoundcloudLinkToFile = str_replace('*', '%', $dbSoundcloudLinkToFile);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_LINK_TO_FILE, $dbSoundcloudLinkToFile, $comparison);
}
/**
* Filter the query on the soundcloud_upload_time column
*
* @param string|array $dbSoundCloundUploadTime 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbSoundCloundUploadTime($dbSoundCloundUploadTime = null, $comparison = null)
{
if (is_array($dbSoundCloundUploadTime)) {
$useMinMax = false;
if (isset($dbSoundCloundUploadTime['min'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_UPLOAD_TIME, $dbSoundCloundUploadTime['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbSoundCloundUploadTime['max'])) {
$this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_UPLOAD_TIME, $dbSoundCloundUploadTime['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::SOUNDCLOUD_UPLOAD_TIME, $dbSoundCloundUploadTime, $comparison);
}
/**
* Filter the query on the replay_gain column
*
* @param string $dbReplayGain 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbReplayGain($dbReplayGain = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($dbReplayGain)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $dbReplayGain)) {
$dbReplayGain = str_replace('*', '%', $dbReplayGain);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(CcFilesPeer::REPLAY_GAIN, $dbReplayGain, $comparison);
}
/**
* Filter the query on the owner_id column
*
* @param int|array $dbOwnerId 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 CcFilesQuery The current query, for fluid interface
*/
public function filterByDbOwnerId($dbOwnerId = null, $comparison = null)
{
if (is_array($dbOwnerId)) {
$useMinMax = false;
if (isset($dbOwnerId['min'])) {
$this->addUsingAlias(CcFilesPeer::OWNER_ID, $dbOwnerId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($dbOwnerId['max'])) {
$this->addUsingAlias(CcFilesPeer::OWNER_ID, $dbOwnerId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(CcFilesPeer::OWNER_ID, $dbOwnerId, $comparison);
}
/**
* Filter the query by a related CcSubjs object
*
* @param CcSubjs $ccSubjs the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByOwner($ccSubjs, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::OWNER_ID, $ccSubjs->getDbId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the Owner relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinOwner($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Owner');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'Owner');
}
return $this;
}
/**
* Use the Owner relation CcSubjs object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcSubjsQuery A secondary query class using the current class as primary query
*/
public function useOwnerQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinOwner($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Owner', 'CcSubjsQuery');
}
/**
* Filter the query by a related CcSubjs object
*
* @param CcSubjs $ccSubjs the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcSubjsRelatedByDbEditedby($ccSubjs, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::EDITEDBY, $ccSubjs->getDbId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcSubjsRelatedByDbEditedby relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcSubjsRelatedByDbEditedby($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcSubjsRelatedByDbEditedby');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcSubjsRelatedByDbEditedby');
}
return $this;
}
/**
* Use the CcSubjsRelatedByDbEditedby relation CcSubjs object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcSubjsQuery A secondary query class using the current class as primary query
*/
public function useCcSubjsRelatedByDbEditedbyQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcSubjsRelatedByDbEditedby($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcSubjsRelatedByDbEditedby', 'CcSubjsQuery');
}
/**
* Filter the query by a related CcMusicDirs object
*
* @param CcMusicDirs $ccMusicDirs the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcMusicDirs($ccMusicDirs, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::DIRECTORY, $ccMusicDirs->getId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcMusicDirs relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcMusicDirs($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcMusicDirs');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcMusicDirs');
}
return $this;
}
/**
* Use the CcMusicDirs relation CcMusicDirs object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcMusicDirsQuery A secondary query class using the current class as primary query
*/
public function useCcMusicDirsQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcMusicDirs($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcMusicDirs', 'CcMusicDirsQuery');
}
/**
* Filter the query by a related CcShowInstances object
*
* @param CcShowInstances $ccShowInstances the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcShowInstances($ccShowInstances, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::ID, $ccShowInstances->getDbRecordedFile(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcShowInstances relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcShowInstances($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcShowInstances');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcShowInstances');
}
return $this;
}
/**
* Use the CcShowInstances relation CcShowInstances object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcShowInstancesQuery A secondary query class using the current class as primary query
*/
public function useCcShowInstancesQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcShowInstances($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcShowInstances', 'CcShowInstancesQuery');
}
/**
* Filter the query by a related CcPlaylistcontents object
*
* @param CcPlaylistcontents $ccPlaylistcontents the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcPlaylistcontents($ccPlaylistcontents, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::ID, $ccPlaylistcontents->getDbFileId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcPlaylistcontents relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcPlaylistcontents($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcPlaylistcontents');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcPlaylistcontents');
}
return $this;
}
/**
* Use the CcPlaylistcontents relation CcPlaylistcontents object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcPlaylistcontentsQuery A secondary query class using the current class as primary query
*/
public function useCcPlaylistcontentsQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcPlaylistcontents($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcPlaylistcontents', 'CcPlaylistcontentsQuery');
}
/**
* Filter the query by a related CcBlockcontents object
*
* @param CcBlockcontents $ccBlockcontents the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcBlockcontents($ccBlockcontents, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::ID, $ccBlockcontents->getDbFileId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcBlockcontents relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcBlockcontents($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcBlockcontents');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcBlockcontents');
}
return $this;
}
/**
* Use the CcBlockcontents relation CcBlockcontents object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcBlockcontentsQuery A secondary query class using the current class as primary query
*/
public function useCcBlockcontentsQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcBlockcontents($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcBlockcontents', 'CcBlockcontentsQuery');
}
/**
* Filter the query by a related CcSchedule object
*
* @param CcSchedule $ccSchedule the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function filterByCcSchedule($ccSchedule, $comparison = null)
{
return $this
->addUsingAlias(CcFilesPeer::ID, $ccSchedule->getDbFileId(), $comparison);
}
/**
* Adds a JOIN clause to the query using the CcSchedule relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function joinCcSchedule($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('CcSchedule');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'CcSchedule');
}
return $this;
}
/**
* Use the CcSchedule relation CcSchedule object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return CcScheduleQuery A secondary query class using the current class as primary query
*/
public function useCcScheduleQuery($relationAlias = '', $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinCcSchedule($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'CcSchedule', 'CcScheduleQuery');
}
/**
* Exclude object from result
*
* @param CcFiles $ccFiles Object to remove from the list of results
*
* @return CcFilesQuery The current query, for fluid interface
*/
public function prune($ccFiles = null)
{
if ($ccFiles) {
$this->addUsingAlias(CcFilesPeer::ID, $ccFiles->getDbId(), Criteria::NOT_EQUAL);
}
return $this;
}
} // BaseCcFilesQuery