diff options
Diffstat (limited to 'generated-classes/Base/ProductQuery.php')
| -rw-r--r-- | generated-classes/Base/ProductQuery.php | 645 |
1 files changed, 645 insertions, 0 deletions
diff --git a/generated-classes/Base/ProductQuery.php b/generated-classes/Base/ProductQuery.php new file mode 100644 index 0000000..0665619 --- /dev/null +++ b/generated-classes/Base/ProductQuery.php @@ -0,0 +1,645 @@ +<?php + +namespace Base; + +use \Product as ChildProduct; +use \ProductQuery as ChildProductQuery; +use \Exception; +use \PDO; +use Map\ProductTableMap; +use Propel\Runtime\Propel; +use Propel\Runtime\ActiveQuery\Criteria; +use Propel\Runtime\ActiveQuery\ModelCriteria; +use Propel\Runtime\ActiveQuery\ModelJoin; +use Propel\Runtime\Collection\ObjectCollection; +use Propel\Runtime\Connection\ConnectionInterface; +use Propel\Runtime\Exception\PropelException; + +/** + * Base class that represents a query for the 'product' table. + * + * + * + * @method ChildProductQuery orderById($order = Criteria::ASC) Order by the id column + * @method ChildProductQuery orderByName($order = Criteria::ASC) Order by the name column + * @method ChildProductQuery orderByPrice($order = Criteria::ASC) Order by the price column + * @method ChildProductQuery orderByWidth($order = Criteria::ASC) Order by the width column + * @method ChildProductQuery orderByHeight($order = Criteria::ASC) Order by the height column + * @method ChildProductQuery orderByDescription($order = Criteria::ASC) Order by the description column + * + * @method ChildProductQuery groupById() Group by the id column + * @method ChildProductQuery groupByName() Group by the name column + * @method ChildProductQuery groupByPrice() Group by the price column + * @method ChildProductQuery groupByWidth() Group by the width column + * @method ChildProductQuery groupByHeight() Group by the height column + * @method ChildProductQuery groupByDescription() Group by the description column + * + * @method ChildProductQuery leftJoin($relation) Adds a LEFT JOIN clause to the query + * @method ChildProductQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query + * @method ChildProductQuery innerJoin($relation) Adds a INNER JOIN clause to the query + * + * @method ChildProductQuery leftJoinProductCategory($relationAlias = null) Adds a LEFT JOIN clause to the query using the ProductCategory relation + * @method ChildProductQuery rightJoinProductCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ProductCategory relation + * @method ChildProductQuery innerJoinProductCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the ProductCategory relation + * + * @method \ProductCategoryQuery endUse() Finalizes a secondary criteria and merges it with its primary Criteria + * + * @method ChildProduct findOne(ConnectionInterface $con = null) Return the first ChildProduct matching the query + * @method ChildProduct findOneOrCreate(ConnectionInterface $con = null) Return the first ChildProduct matching the query, or a new ChildProduct object populated from the query conditions when no match is found + * + * @method ChildProduct findOneById(int $id) Return the first ChildProduct filtered by the id column + * @method ChildProduct findOneByName(string $name) Return the first ChildProduct filtered by the name column + * @method ChildProduct findOneByPrice(string $price) Return the first ChildProduct filtered by the price column + * @method ChildProduct findOneByWidth(int $width) Return the first ChildProduct filtered by the width column + * @method ChildProduct findOneByHeight(int $height) Return the first ChildProduct filtered by the height column + * @method ChildProduct findOneByDescription(string $description) Return the first ChildProduct filtered by the description column * + + * @method ChildProduct requirePk($key, ConnectionInterface $con = null) Return the ChildProduct by primary key and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOne(ConnectionInterface $con = null) Return the first ChildProduct matching the query and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildProduct requireOneById(int $id) Return the first ChildProduct filtered by the id column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOneByName(string $name) Return the first ChildProduct filtered by the name column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOneByPrice(string $price) Return the first ChildProduct filtered by the price column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOneByWidth(int $width) Return the first ChildProduct filtered by the width column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOneByHeight(int $height) Return the first ChildProduct filtered by the height column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProduct requireOneByDescription(string $description) Return the first ChildProduct filtered by the description column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildProduct[]|ObjectCollection find(ConnectionInterface $con = null) Return ChildProduct objects based on current ModelCriteria + * @method ChildProduct[]|ObjectCollection findById(int $id) Return ChildProduct objects filtered by the id column + * @method ChildProduct[]|ObjectCollection findByName(string $name) Return ChildProduct objects filtered by the name column + * @method ChildProduct[]|ObjectCollection findByPrice(string $price) Return ChildProduct objects filtered by the price column + * @method ChildProduct[]|ObjectCollection findByWidth(int $width) Return ChildProduct objects filtered by the width column + * @method ChildProduct[]|ObjectCollection findByHeight(int $height) Return ChildProduct objects filtered by the height column + * @method ChildProduct[]|ObjectCollection findByDescription(string $description) Return ChildProduct objects filtered by the description column + * @method ChildProduct[]|\Propel\Runtime\Util\PropelModelPager paginate($page = 1, $maxPerPage = 10, ConnectionInterface $con = null) Issue a SELECT query based on the current ModelCriteria and uses a page and a maximum number of results per page to compute an offset and a limit + * + */ +abstract class ProductQuery extends ModelCriteria +{ + protected $entityNotFoundExceptionClass = '\\Propel\\Runtime\\Exception\\EntityNotFoundException'; + + /** + * Initializes internal state of \Base\ProductQuery object. + * + * @param string $dbName The database 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 = 'default', $modelName = '\\Product', $modelAlias = null) + { + parent::__construct($dbName, $modelName, $modelAlias); + } + + /** + * Returns a new ChildProductQuery object. + * + * @param string $modelAlias The alias of a model in the query + * @param Criteria $criteria Optional Criteria to build the query from + * + * @return ChildProductQuery + */ + public static function create($modelAlias = null, Criteria $criteria = null) + { + if ($criteria instanceof ChildProductQuery) { + return $criteria; + } + $query = new ChildProductQuery(); + if (null !== $modelAlias) { + $query->setModelAlias($modelAlias); + } + if ($criteria instanceof Criteria) { + $query->mergeWith($criteria); + } + + return $query; + } + + /** + * Find object by primary key. + * Propel uses the instance pool to skip the database if the object exists. + * Go fast if the query is untouched. + * + * <code> + * $obj = $c->findPk(12, $con); + * </code> + * + * @param mixed $key Primary key to use for the query + * @param ConnectionInterface $con an optional connection object + * + * @return ChildProduct|array|mixed the result, formatted by the current formatter + */ + public function findPk($key, ConnectionInterface $con = null) + { + if ($key === null) { + return null; + } + if ((null !== ($obj = ProductTableMap::getInstanceFromPool((string) $key))) && !$this->formatter) { + // the object is already in the instance pool + return $obj; + } + if ($con === null) { + $con = Propel::getServiceContainer()->getReadConnection(ProductTableMap::DATABASE_NAME); + } + $this->basePreSelect($con); + if ($this->formatter || $this->modelAlias || $this->with || $this->select + || $this->selectColumns || $this->asColumns || $this->selectModifiers + || $this->map || $this->having || $this->joins) { + return $this->findPkComplex($key, $con); + } else { + return $this->findPkSimple($key, $con); + } + } + + /** + * Find object by primary key using raw SQL to go fast. + * Bypass doSelect() and the object formatter by using generated code. + * + * @param mixed $key Primary key to use for the query + * @param ConnectionInterface $con A connection object + * + * @throws \Propel\Runtime\Exception\PropelException + * + * @return ChildProduct A model object, or null if the key is not found + */ + protected function findPkSimple($key, ConnectionInterface $con) + { + $sql = 'SELECT id, name, price, width, height, description FROM product WHERE id = :p0'; + try { + $stmt = $con->prepare($sql); + $stmt->bindValue(':p0', $key, PDO::PARAM_INT); + $stmt->execute(); + } catch (Exception $e) { + Propel::log($e->getMessage(), Propel::LOG_ERR); + throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), 0, $e); + } + $obj = null; + if ($row = $stmt->fetch(\PDO::FETCH_NUM)) { + /** @var ChildProduct $obj */ + $obj = new ChildProduct(); + $obj->hydrate($row); + ProductTableMap::addInstanceToPool($obj, (string) $key); + } + $stmt->closeCursor(); + + return $obj; + } + + /** + * Find object by primary key. + * + * @param mixed $key Primary key to use for the query + * @param ConnectionInterface $con A connection object + * + * @return ChildProduct|array|mixed the result, formatted by the current formatter + */ + protected function findPkComplex($key, ConnectionInterface $con) + { + // As the query uses a PK condition, no limit(1) is necessary. + $criteria = $this->isKeepQuery() ? clone $this : $this; + $dataFetcher = $criteria + ->filterByPrimaryKey($key) + ->doSelect($con); + + return $criteria->getFormatter()->init($criteria)->formatOne($dataFetcher); + } + + /** + * 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 ConnectionInterface $con an optional connection object + * + * @return ObjectCollection|array|mixed the list of results, formatted by the current formatter + */ + public function findPks($keys, ConnectionInterface $con = null) + { + if (null === $con) { + $con = Propel::getServiceContainer()->getReadConnection($this->getDbName()); + } + $this->basePreSelect($con); + $criteria = $this->isKeepQuery() ? clone $this : $this; + $dataFetcher = $criteria + ->filterByPrimaryKeys($keys) + ->doSelect($con); + + return $criteria->getFormatter()->init($criteria)->format($dataFetcher); + } + + /** + * Filter the query by primary key + * + * @param mixed $key Primary key to use for the query + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByPrimaryKey($key) + { + + return $this->addUsingAlias(ProductTableMap::COL_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 $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByPrimaryKeys($keys) + { + + return $this->addUsingAlias(ProductTableMap::COL_ID, $keys, Criteria::IN); + } + + /** + * Filter the query on the id column + * + * Example usage: + * <code> + * $query->filterById(1234); // WHERE id = 1234 + * $query->filterById(array(12, 34)); // WHERE id IN (12, 34) + * $query->filterById(array('min' => 12)); // WHERE id > 12 + * </code> + * + * @param mixed $id The value to use as filter. + * Use scalar values for equality. + * Use array values for in_array() equivalent. + * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals. + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function filterById($id = null, $comparison = null) + { + if (is_array($id)) { + $useMinMax = false; + if (isset($id['min'])) { + $this->addUsingAlias(ProductTableMap::COL_ID, $id['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($id['max'])) { + $this->addUsingAlias(ProductTableMap::COL_ID, $id['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_ID, $id, $comparison); + } + + /** + * Filter the query on the name column + * + * Example usage: + * <code> + * $query->filterByName('fooValue'); // WHERE name = 'fooValue' + * $query->filterByName('%fooValue%'); // WHERE name LIKE '%fooValue%' + * </code> + * + * @param string $name 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 $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByName($name = null, $comparison = null) + { + if (null === $comparison) { + if (is_array($name)) { + $comparison = Criteria::IN; + } elseif (preg_match('/[\%\*]/', $name)) { + $name = str_replace('*', '%', $name); + $comparison = Criteria::LIKE; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_NAME, $name, $comparison); + } + + /** + * Filter the query on the price column + * + * Example usage: + * <code> + * $query->filterByPrice(1234); // WHERE price = 1234 + * $query->filterByPrice(array(12, 34)); // WHERE price IN (12, 34) + * $query->filterByPrice(array('min' => 12)); // WHERE price > 12 + * </code> + * + * @param mixed $price The value to use as filter. + * Use scalar values for equality. + * Use array values for in_array() equivalent. + * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals. + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByPrice($price = null, $comparison = null) + { + if (is_array($price)) { + $useMinMax = false; + if (isset($price['min'])) { + $this->addUsingAlias(ProductTableMap::COL_PRICE, $price['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($price['max'])) { + $this->addUsingAlias(ProductTableMap::COL_PRICE, $price['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_PRICE, $price, $comparison); + } + + /** + * Filter the query on the width column + * + * Example usage: + * <code> + * $query->filterByWidth(1234); // WHERE width = 1234 + * $query->filterByWidth(array(12, 34)); // WHERE width IN (12, 34) + * $query->filterByWidth(array('min' => 12)); // WHERE width > 12 + * </code> + * + * @param mixed $width The value to use as filter. + * Use scalar values for equality. + * Use array values for in_array() equivalent. + * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals. + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByWidth($width = null, $comparison = null) + { + if (is_array($width)) { + $useMinMax = false; + if (isset($width['min'])) { + $this->addUsingAlias(ProductTableMap::COL_WIDTH, $width['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($width['max'])) { + $this->addUsingAlias(ProductTableMap::COL_WIDTH, $width['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_WIDTH, $width, $comparison); + } + + /** + * Filter the query on the height column + * + * Example usage: + * <code> + * $query->filterByHeight(1234); // WHERE height = 1234 + * $query->filterByHeight(array(12, 34)); // WHERE height IN (12, 34) + * $query->filterByHeight(array('min' => 12)); // WHERE height > 12 + * </code> + * + * @param mixed $height The value to use as filter. + * Use scalar values for equality. + * Use array values for in_array() equivalent. + * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals. + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByHeight($height = null, $comparison = null) + { + if (is_array($height)) { + $useMinMax = false; + if (isset($height['min'])) { + $this->addUsingAlias(ProductTableMap::COL_HEIGHT, $height['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($height['max'])) { + $this->addUsingAlias(ProductTableMap::COL_HEIGHT, $height['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_HEIGHT, $height, $comparison); + } + + /** + * Filter the query on the description column + * + * Example usage: + * <code> + * $query->filterByDescription('fooValue'); // WHERE description = 'fooValue' + * $query->filterByDescription('%fooValue%'); // WHERE description LIKE '%fooValue%' + * </code> + * + * @param string $description 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 $this|ChildProductQuery The current query, for fluid interface + */ + public function filterByDescription($description = null, $comparison = null) + { + if (null === $comparison) { + if (is_array($description)) { + $comparison = Criteria::IN; + } elseif (preg_match('/[\%\*]/', $description)) { + $description = str_replace('*', '%', $description); + $comparison = Criteria::LIKE; + } + } + + return $this->addUsingAlias(ProductTableMap::COL_DESCRIPTION, $description, $comparison); + } + + /** + * Filter the query by a related \ProductCategory object + * + * @param \ProductCategory|ObjectCollection $productCategory the related object to use as filter + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return ChildProductQuery The current query, for fluid interface + */ + public function filterByProductCategory($productCategory, $comparison = null) + { + if ($productCategory instanceof \ProductCategory) { + return $this + ->addUsingAlias(ProductTableMap::COL_ID, $productCategory->getProductId(), $comparison); + } elseif ($productCategory instanceof ObjectCollection) { + return $this + ->useProductCategoryQuery() + ->filterByPrimaryKeys($productCategory->getPrimaryKeys()) + ->endUse(); + } else { + throw new PropelException('filterByProductCategory() only accepts arguments of type \ProductCategory or Collection'); + } + } + + /** + * Adds a JOIN clause to the query using the ProductCategory relation + * + * @param string $relationAlias optional alias for the relation + * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join' + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function joinProductCategory($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + $tableMap = $this->getTableMap(); + $relationMap = $tableMap->getRelation('ProductCategory'); + + // 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, 'ProductCategory'); + } + + return $this; + } + + /** + * Use the ProductCategory relation ProductCategory 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 \ProductCategoryQuery A secondary query class using the current class as primary query + */ + public function useProductCategoryQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + return $this + ->joinProductCategory($relationAlias, $joinType) + ->useQuery($relationAlias ? $relationAlias : 'ProductCategory', '\ProductCategoryQuery'); + } + + /** + * Filter the query by a related Category object + * using the product_category table as cross reference + * + * @param Category $category the related object to use as filter + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @return ChildProductQuery The current query, for fluid interface + */ + public function filterByCategory($category, $comparison = Criteria::EQUAL) + { + return $this + ->useProductCategoryQuery() + ->filterByCategory($category, $comparison) + ->endUse(); + } + + /** + * Exclude object from result + * + * @param ChildProduct $product Object to remove from the list of results + * + * @return $this|ChildProductQuery The current query, for fluid interface + */ + public function prune($product = null) + { + if ($product) { + $this->addUsingAlias(ProductTableMap::COL_ID, $product->getId(), Criteria::NOT_EQUAL); + } + + return $this; + } + + /** + * Deletes all rows from the product table. + * + * @param ConnectionInterface $con the connection to use + * @return int The number of affected rows (if supported by underlying database driver). + */ + public function doDeleteAll(ConnectionInterface $con = null) + { + if (null === $con) { + $con = Propel::getServiceContainer()->getWriteConnection(ProductTableMap::DATABASE_NAME); + } + + // use transaction because $criteria could contain info + // for more than one table or we could emulating ON DELETE CASCADE, etc. + return $con->transaction(function () use ($con) { + $affectedRows = 0; // initialize var to track total num of affected rows + $affectedRows += parent::doDeleteAll($con); + // Because this db requires some delete cascade/set null emulation, we have to + // clear the cached instance *after* the emulation has happened (since + // instances get re-added by the select statement contained therein). + ProductTableMap::clearInstancePool(); + ProductTableMap::clearRelatedInstancePool(); + + return $affectedRows; + }); + } + + /** + * Performs a DELETE on the database based on the current ModelCriteria + * + * @param ConnectionInterface $con the connection to use + * @return int The number of affected rows (if supported by underlying database driver). This includes CASCADE-related rows + * if supported by native driver or if emulated using Propel. + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public function delete(ConnectionInterface $con = null) + { + if (null === $con) { + $con = Propel::getServiceContainer()->getWriteConnection(ProductTableMap::DATABASE_NAME); + } + + $criteria = $this; + + // Set the correct dbName + $criteria->setDbName(ProductTableMap::DATABASE_NAME); + + // use transaction because $criteria could contain info + // for more than one table or we could emulating ON DELETE CASCADE, etc. + return $con->transaction(function () use ($con, $criteria) { + $affectedRows = 0; // initialize var to track total num of affected rows + + ProductTableMap::removeInstanceFromPool($criteria); + + $affectedRows += ModelCriteria::delete($con); + ProductTableMap::clearRelatedInstancePool(); + + return $affectedRows; + }); + } + +} // ProductQuery |