diff options
Diffstat (limited to 'Aufgabe06/generated-classes/Base/ProductCategoryQuery.php')
| -rw-r--r-- | Aufgabe06/generated-classes/Base/ProductCategoryQuery.php | 571 |
1 files changed, 571 insertions, 0 deletions
diff --git a/Aufgabe06/generated-classes/Base/ProductCategoryQuery.php b/Aufgabe06/generated-classes/Base/ProductCategoryQuery.php new file mode 100644 index 0000000..b2827c4 --- /dev/null +++ b/Aufgabe06/generated-classes/Base/ProductCategoryQuery.php @@ -0,0 +1,571 @@ +<?php + +namespace Base; + +use \ProductCategory as ChildProductCategory; +use \ProductCategoryQuery as ChildProductCategoryQuery; +use \Exception; +use \PDO; +use Map\ProductCategoryTableMap; +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_category' table. + * + * + * + * @method ChildProductCategoryQuery orderByProductId($order = Criteria::ASC) Order by the product_id column + * @method ChildProductCategoryQuery orderByCategoryId($order = Criteria::ASC) Order by the category_id column + * + * @method ChildProductCategoryQuery groupByProductId() Group by the product_id column + * @method ChildProductCategoryQuery groupByCategoryId() Group by the category_id column + * + * @method ChildProductCategoryQuery leftJoin($relation) Adds a LEFT JOIN clause to the query + * @method ChildProductCategoryQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query + * @method ChildProductCategoryQuery innerJoin($relation) Adds a INNER JOIN clause to the query + * + * @method ChildProductCategoryQuery leftJoinCategory($relationAlias = null) Adds a LEFT JOIN clause to the query using the Category relation + * @method ChildProductCategoryQuery rightJoinCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Category relation + * @method ChildProductCategoryQuery innerJoinCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the Category relation + * + * @method ChildProductCategoryQuery leftJoinProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the Product relation + * @method ChildProductCategoryQuery rightJoinProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Product relation + * @method ChildProductCategoryQuery innerJoinProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the Product relation + * + * @method \CategoryQuery|\ProductQuery endUse() Finalizes a secondary criteria and merges it with its primary Criteria + * + * @method ChildProductCategory findOne(ConnectionInterface $con = null) Return the first ChildProductCategory matching the query + * @method ChildProductCategory findOneOrCreate(ConnectionInterface $con = null) Return the first ChildProductCategory matching the query, or a new ChildProductCategory object populated from the query conditions when no match is found + * + * @method ChildProductCategory findOneByProductId(int $product_id) Return the first ChildProductCategory filtered by the product_id column + * @method ChildProductCategory findOneByCategoryId(int $category_id) Return the first ChildProductCategory filtered by the category_id column * + + * @method ChildProductCategory requirePk($key, ConnectionInterface $con = null) Return the ChildProductCategory by primary key and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProductCategory requireOne(ConnectionInterface $con = null) Return the first ChildProductCategory matching the query and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildProductCategory requireOneByProductId(int $product_id) Return the first ChildProductCategory filtered by the product_id column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildProductCategory requireOneByCategoryId(int $category_id) Return the first ChildProductCategory filtered by the category_id column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildProductCategory[]|ObjectCollection find(ConnectionInterface $con = null) Return ChildProductCategory objects based on current ModelCriteria + * @method ChildProductCategory[]|ObjectCollection findByProductId(int $product_id) Return ChildProductCategory objects filtered by the product_id column + * @method ChildProductCategory[]|ObjectCollection findByCategoryId(int $category_id) Return ChildProductCategory objects filtered by the category_id column + * @method ChildProductCategory[]|\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 ProductCategoryQuery extends ModelCriteria +{ + protected $entityNotFoundExceptionClass = '\\Propel\\Runtime\\Exception\\EntityNotFoundException'; + + /** + * Initializes internal state of \Base\ProductCategoryQuery 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 = '\\ProductCategory', $modelAlias = null) + { + parent::__construct($dbName, $modelName, $modelAlias); + } + + /** + * Returns a new ChildProductCategoryQuery object. + * + * @param string $modelAlias The alias of a model in the query + * @param Criteria $criteria Optional Criteria to build the query from + * + * @return ChildProductCategoryQuery + */ + public static function create($modelAlias = null, Criteria $criteria = null) + { + if ($criteria instanceof ChildProductCategoryQuery) { + return $criteria; + } + $query = new ChildProductCategoryQuery(); + 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(array(12, 34), $con); + * </code> + * + * @param array[$product_id, $category_id] $key Primary key to use for the query + * @param ConnectionInterface $con an optional connection object + * + * @return ChildProductCategory|array|mixed the result, formatted by the current formatter + */ + public function findPk($key, ConnectionInterface $con = null) + { + if ($key === null) { + return null; + } + if ((null !== ($obj = ProductCategoryTableMap::getInstanceFromPool(serialize(array((string) $key[0], (string) $key[1]))))) && !$this->formatter) { + // the object is already in the instance pool + return $obj; + } + if ($con === null) { + $con = Propel::getServiceContainer()->getReadConnection(ProductCategoryTableMap::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 ChildProductCategory A model object, or null if the key is not found + */ + protected function findPkSimple($key, ConnectionInterface $con) + { + $sql = 'SELECT product_id, category_id FROM product_category WHERE product_id = :p0 AND category_id = :p1'; + try { + $stmt = $con->prepare($sql); + $stmt->bindValue(':p0', $key[0], PDO::PARAM_INT); + $stmt->bindValue(':p1', $key[1], 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 ChildProductCategory $obj */ + $obj = new ChildProductCategory(); + $obj->hydrate($row); + ProductCategoryTableMap::addInstanceToPool($obj, serialize(array((string) $key[0], (string) $key[1]))); + } + $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 ChildProductCategory|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(array(12, 56), array(832, 123), array(123, 456)), $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|ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByPrimaryKey($key) + { + $this->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $key[0], Criteria::EQUAL); + $this->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $key[1], Criteria::EQUAL); + + return $this; + } + + /** + * Filter the query by a list of primary keys + * + * @param array $keys The list of primary key to use for the query + * + * @return $this|ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByPrimaryKeys($keys) + { + if (empty($keys)) { + return $this->add(null, '1<>1', Criteria::CUSTOM); + } + foreach ($keys as $key) { + $cton0 = $this->getNewCriterion(ProductCategoryTableMap::COL_PRODUCT_ID, $key[0], Criteria::EQUAL); + $cton1 = $this->getNewCriterion(ProductCategoryTableMap::COL_CATEGORY_ID, $key[1], Criteria::EQUAL); + $cton0->addAnd($cton1); + $this->addOr($cton0); + } + + return $this; + } + + /** + * Filter the query on the product_id column + * + * Example usage: + * <code> + * $query->filterByProductId(1234); // WHERE product_id = 1234 + * $query->filterByProductId(array(12, 34)); // WHERE product_id IN (12, 34) + * $query->filterByProductId(array('min' => 12)); // WHERE product_id > 12 + * </code> + * + * @see filterByProduct() + * + * @param mixed $productId 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|ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByProductId($productId = null, $comparison = null) + { + if (is_array($productId)) { + $useMinMax = false; + if (isset($productId['min'])) { + $this->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $productId['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($productId['max'])) { + $this->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $productId['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $productId, $comparison); + } + + /** + * Filter the query on the category_id column + * + * Example usage: + * <code> + * $query->filterByCategoryId(1234); // WHERE category_id = 1234 + * $query->filterByCategoryId(array(12, 34)); // WHERE category_id IN (12, 34) + * $query->filterByCategoryId(array('min' => 12)); // WHERE category_id > 12 + * </code> + * + * @see filterByCategory() + * + * @param mixed $categoryId 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|ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByCategoryId($categoryId = null, $comparison = null) + { + if (is_array($categoryId)) { + $useMinMax = false; + if (isset($categoryId['min'])) { + $this->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $categoryId['min'], Criteria::GREATER_EQUAL); + $useMinMax = true; + } + if (isset($categoryId['max'])) { + $this->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $categoryId['max'], Criteria::LESS_EQUAL); + $useMinMax = true; + } + if ($useMinMax) { + return $this; + } + if (null === $comparison) { + $comparison = Criteria::IN; + } + } + + return $this->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $categoryId, $comparison); + } + + /** + * Filter the query by a related \Category object + * + * @param \Category|ObjectCollection $category The related object(s) to use as filter + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @throws \Propel\Runtime\Exception\PropelException + * + * @return ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByCategory($category, $comparison = null) + { + if ($category instanceof \Category) { + return $this + ->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $category->getId(), $comparison); + } elseif ($category instanceof ObjectCollection) { + if (null === $comparison) { + $comparison = Criteria::IN; + } + + return $this + ->addUsingAlias(ProductCategoryTableMap::COL_CATEGORY_ID, $category->toKeyValue('PrimaryKey', 'Id'), $comparison); + } else { + throw new PropelException('filterByCategory() only accepts arguments of type \Category or Collection'); + } + } + + /** + * Adds a JOIN clause to the query using the Category relation + * + * @param string $relationAlias optional alias for the relation + * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join' + * + * @return $this|ChildProductCategoryQuery The current query, for fluid interface + */ + public function joinCategory($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + $tableMap = $this->getTableMap(); + $relationMap = $tableMap->getRelation('Category'); + + // 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, 'Category'); + } + + return $this; + } + + /** + * Use the Category relation Category 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 \CategoryQuery A secondary query class using the current class as primary query + */ + public function useCategoryQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + return $this + ->joinCategory($relationAlias, $joinType) + ->useQuery($relationAlias ? $relationAlias : 'Category', '\CategoryQuery'); + } + + /** + * Filter the query by a related \Product object + * + * @param \Product|ObjectCollection $product The related object(s) to use as filter + * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL + * + * @throws \Propel\Runtime\Exception\PropelException + * + * @return ChildProductCategoryQuery The current query, for fluid interface + */ + public function filterByProduct($product, $comparison = null) + { + if ($product instanceof \Product) { + return $this + ->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $product->getId(), $comparison); + } elseif ($product instanceof ObjectCollection) { + if (null === $comparison) { + $comparison = Criteria::IN; + } + + return $this + ->addUsingAlias(ProductCategoryTableMap::COL_PRODUCT_ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison); + } else { + throw new PropelException('filterByProduct() only accepts arguments of type \Product or Collection'); + } + } + + /** + * Adds a JOIN clause to the query using the Product relation + * + * @param string $relationAlias optional alias for the relation + * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join' + * + * @return $this|ChildProductCategoryQuery The current query, for fluid interface + */ + public function joinProduct($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + $tableMap = $this->getTableMap(); + $relationMap = $tableMap->getRelation('Product'); + + // 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, 'Product'); + } + + return $this; + } + + /** + * Use the Product relation Product 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 \ProductQuery A secondary query class using the current class as primary query + */ + public function useProductQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN) + { + return $this + ->joinProduct($relationAlias, $joinType) + ->useQuery($relationAlias ? $relationAlias : 'Product', '\ProductQuery'); + } + + /** + * Exclude object from result + * + * @param ChildProductCategory $productCategory Object to remove from the list of results + * + * @return $this|ChildProductCategoryQuery The current query, for fluid interface + */ + public function prune($productCategory = null) + { + if ($productCategory) { + $this->addCond('pruneCond0', $this->getAliasedColName(ProductCategoryTableMap::COL_PRODUCT_ID), $productCategory->getProductId(), Criteria::NOT_EQUAL); + $this->addCond('pruneCond1', $this->getAliasedColName(ProductCategoryTableMap::COL_CATEGORY_ID), $productCategory->getCategoryId(), Criteria::NOT_EQUAL); + $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR); + } + + return $this; + } + + /** + * Deletes all rows from the product_category 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(ProductCategoryTableMap::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). + ProductCategoryTableMap::clearInstancePool(); + ProductCategoryTableMap::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(ProductCategoryTableMap::DATABASE_NAME); + } + + $criteria = $this; + + // Set the correct dbName + $criteria->setDbName(ProductCategoryTableMap::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 + + ProductCategoryTableMap::removeInstanceFromPool($criteria); + + $affectedRows += ModelCriteria::delete($con); + ProductCategoryTableMap::clearRelatedInstancePool(); + + return $affectedRows; + }); + } + +} // ProductCategoryQuery |