diff options
Diffstat (limited to 'Aufgabe06/generated-classes/Base/UserQuery.php')
| -rw-r--r-- | Aufgabe06/generated-classes/Base/UserQuery.php | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/Aufgabe06/generated-classes/Base/UserQuery.php b/Aufgabe06/generated-classes/Base/UserQuery.php new file mode 100644 index 0000000..2e87ec4 --- /dev/null +++ b/Aufgabe06/generated-classes/Base/UserQuery.php @@ -0,0 +1,364 @@ +<?php + +namespace Base; + +use \User as ChildUser; +use \UserQuery as ChildUserQuery; +use \Exception; +use \PDO; +use Map\UserTableMap; +use Propel\Runtime\Propel; +use Propel\Runtime\ActiveQuery\Criteria; +use Propel\Runtime\ActiveQuery\ModelCriteria; +use Propel\Runtime\Collection\ObjectCollection; +use Propel\Runtime\Connection\ConnectionInterface; +use Propel\Runtime\Exception\PropelException; + +/** + * Base class that represents a query for the 'user' table. + * + * + * + * @method ChildUserQuery orderByUsername($order = Criteria::ASC) Order by the username column + * @method ChildUserQuery orderByPassword($order = Criteria::ASC) Order by the password column + * + * @method ChildUserQuery groupByUsername() Group by the username column + * @method ChildUserQuery groupByPassword() Group by the password column + * + * @method ChildUserQuery leftJoin($relation) Adds a LEFT JOIN clause to the query + * @method ChildUserQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query + * @method ChildUserQuery innerJoin($relation) Adds a INNER JOIN clause to the query + * + * @method ChildUser findOne(ConnectionInterface $con = null) Return the first ChildUser matching the query + * @method ChildUser findOneOrCreate(ConnectionInterface $con = null) Return the first ChildUser matching the query, or a new ChildUser object populated from the query conditions when no match is found + * + * @method ChildUser findOneByUsername(string $username) Return the first ChildUser filtered by the username column + * @method ChildUser findOneByPassword(string $password) Return the first ChildUser filtered by the password column * + + * @method ChildUser requirePk($key, ConnectionInterface $con = null) Return the ChildUser by primary key and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildUser requireOne(ConnectionInterface $con = null) Return the first ChildUser matching the query and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildUser requireOneByUsername(string $username) Return the first ChildUser filtered by the username column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * @method ChildUser requireOneByPassword(string $password) Return the first ChildUser filtered by the password column and throws \Propel\Runtime\Exception\EntityNotFoundException when not found + * + * @method ChildUser[]|ObjectCollection find(ConnectionInterface $con = null) Return ChildUser objects based on current ModelCriteria + * @method ChildUser[]|ObjectCollection findByUsername(string $username) Return ChildUser objects filtered by the username column + * @method ChildUser[]|ObjectCollection findByPassword(string $password) Return ChildUser objects filtered by the password column + * @method ChildUser[]|\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 UserQuery extends ModelCriteria +{ + protected $entityNotFoundExceptionClass = '\\Propel\\Runtime\\Exception\\EntityNotFoundException'; + + /** + * Initializes internal state of \Base\UserQuery 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 = '\\User', $modelAlias = null) + { + parent::__construct($dbName, $modelName, $modelAlias); + } + + /** + * Returns a new ChildUserQuery object. + * + * @param string $modelAlias The alias of a model in the query + * @param Criteria $criteria Optional Criteria to build the query from + * + * @return ChildUserQuery + */ + public static function create($modelAlias = null, Criteria $criteria = null) + { + if ($criteria instanceof ChildUserQuery) { + return $criteria; + } + $query = new ChildUserQuery(); + 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 ChildUser|array|mixed the result, formatted by the current formatter + */ + public function findPk($key, ConnectionInterface $con = null) + { + if ($key === null) { + return null; + } + if ((null !== ($obj = UserTableMap::getInstanceFromPool((string) $key))) && !$this->formatter) { + // the object is already in the instance pool + return $obj; + } + if ($con === null) { + $con = Propel::getServiceContainer()->getReadConnection(UserTableMap::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 ChildUser A model object, or null if the key is not found + */ + protected function findPkSimple($key, ConnectionInterface $con) + { + $sql = 'SELECT username, password FROM user WHERE username = :p0'; + try { + $stmt = $con->prepare($sql); + $stmt->bindValue(':p0', $key, PDO::PARAM_STR); + $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 ChildUser $obj */ + $obj = new ChildUser(); + $obj->hydrate($row); + UserTableMap::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 ChildUser|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|ChildUserQuery The current query, for fluid interface + */ + public function filterByPrimaryKey($key) + { + + return $this->addUsingAlias(UserTableMap::COL_USERNAME, $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|ChildUserQuery The current query, for fluid interface + */ + public function filterByPrimaryKeys($keys) + { + + return $this->addUsingAlias(UserTableMap::COL_USERNAME, $keys, Criteria::IN); + } + + /** + * Filter the query on the username column + * + * Example usage: + * <code> + * $query->filterByUsername('fooValue'); // WHERE username = 'fooValue' + * $query->filterByUsername('%fooValue%'); // WHERE username LIKE '%fooValue%' + * </code> + * + * @param string $username 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|ChildUserQuery The current query, for fluid interface + */ + public function filterByUsername($username = null, $comparison = null) + { + if (null === $comparison) { + if (is_array($username)) { + $comparison = Criteria::IN; + } elseif (preg_match('/[\%\*]/', $username)) { + $username = str_replace('*', '%', $username); + $comparison = Criteria::LIKE; + } + } + + return $this->addUsingAlias(UserTableMap::COL_USERNAME, $username, $comparison); + } + + /** + * Filter the query on the password column + * + * Example usage: + * <code> + * $query->filterByPassword('fooValue'); // WHERE password = 'fooValue' + * $query->filterByPassword('%fooValue%'); // WHERE password LIKE '%fooValue%' + * </code> + * + * @param string $password 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|ChildUserQuery The current query, for fluid interface + */ + public function filterByPassword($password = null, $comparison = null) + { + if (null === $comparison) { + if (is_array($password)) { + $comparison = Criteria::IN; + } elseif (preg_match('/[\%\*]/', $password)) { + $password = str_replace('*', '%', $password); + $comparison = Criteria::LIKE; + } + } + + return $this->addUsingAlias(UserTableMap::COL_PASSWORD, $password, $comparison); + } + + /** + * Exclude object from result + * + * @param ChildUser $user Object to remove from the list of results + * + * @return $this|ChildUserQuery The current query, for fluid interface + */ + public function prune($user = null) + { + if ($user) { + $this->addUsingAlias(UserTableMap::COL_USERNAME, $user->getUsername(), Criteria::NOT_EQUAL); + } + + return $this; + } + + /** + * Deletes all rows from the user 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(UserTableMap::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). + UserTableMap::clearInstancePool(); + UserTableMap::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(UserTableMap::DATABASE_NAME); + } + + $criteria = $this; + + // Set the correct dbName + $criteria->setDbName(UserTableMap::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 + + UserTableMap::removeInstanceFromPool($criteria); + + $affectedRows += ModelCriteria::delete($con); + UserTableMap::clearRelatedInstancePool(); + + return $affectedRows; + }); + } + +} // UserQuery |