Subversion-Projekte lars-tiefland.php_share

<?php

/*

 *  $Id: BasePeer.php 1608 2010-03-15 23:09:22Z francois $

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information please see

 * <http://propel.phpdb.org>.

 */

/**

 * This is a utility class for all generated Peer classes in the system.

 *

 * Peer classes are responsible for isolating all of the database access

 * for a specific business object.  They execute all of the SQL

 * against the database.  Over time this class has grown to include

 * utility methods which ease execution of cross-database queries and

 * the implementation of concrete Peers.

 *

 * @author     Hans Lellelid <hans@xmpl.org> (Propel)

 * @author     Kaspars Jaudzems <kaspars.jaudzems@inbox.lv> (Propel)

 * @author     Heltem <heltem@o2php.com> (Propel)

 * @author     Frank Y. Kim <frank.kim@clearink.com> (Torque)

 * @author     John D. McNally <jmcnally@collab.net> (Torque)

 * @author     Brett McLaughlin <bmclaugh@algx.net> (Torque)

 * @author     Stephen Haberman <stephenh@chase3000.com> (Torque)

 * @version    $Revision: 1608 $

 * @package    propel.util

 */

class BasePeer

{

	/** Array (hash) that contains the cached mapBuilders. */

	private static $mapBuilders = array();

	/** Array (hash) that contains cached validators */

	private static $validatorMap = array();

	/**

	 * phpname type

	 * e.g. 'AuthorId'

	 */

	const TYPE_PHPNAME = 'phpName';

	/**

	 * studlyphpname type

	 * e.g. 'authorId'

	 */

	const TYPE_STUDLYPHPNAME = 'studlyPhpName';

	/**

	 * column (peer) name type

	 * e.g. 'book.AUTHOR_ID'

	 */

	const TYPE_COLNAME = 'colName';

	/**

	 * column fieldname type

	 * e.g. 'author_id'

	 */

	const TYPE_FIELDNAME = 'fieldName';

	/**

	 * num type

	 * simply the numerical array index, e.g. 4

	 */

	const TYPE_NUM = 'num';

	static public function getFieldnames ($classname, $type = self::TYPE_PHPNAME) {

		// TODO we should take care of including the peer class here

		$peerclass = 'Base' . $classname . 'Peer'; // TODO is this always true?

		$callable = array($peerclass, 'getFieldnames');

		$args = array($type);

		return call_user_func_array($callable, $args);

	}

	static public function translateFieldname($classname, $fieldname, $fromType, $toType) {

		// TODO we should take care of including the peer class here

		$peerclass = 'Base' . $classname . 'Peer'; // TODO is this always true?

		$callable = array($peerclass, 'translateFieldname');

		$args = array($fieldname, $fromType, $toType);

		return call_user_func_array($callable, $args);

	}

	/**

	 * Method to perform deletes based on values and keys in a

	 * Criteria.

	 *

	 * @param      Criteria $criteria The criteria to use.

	 * @param      PropelPDO $con A PropelPDO connection object.

	 * @return     int	The number of rows affected by last statement execution.  For most

	 * 				uses there is only one delete statement executed, so this number

	 * 				will correspond to the number of rows affected by the call to this

	 * 				method.  Note that the return value does require that this information

	 * 				is returned (supported) by the PDO driver.

	 * @throws     PropelException

	 */

	public static function doDelete(Criteria $criteria, PropelPDO $con)

	{

		$db = Propel::getDB($criteria->getDbName());

		$dbMap = Propel::getDatabaseMap($criteria->getDbName());

		// Set up a list of required tables (one DELETE statement will

		// be executed per table)

		$tables_keys = array();

		foreach ($criteria as $c) {

			foreach ($c->getAllTables() as $tableName) {

				$tableName2 = $criteria->getTableForAlias($tableName);

				if ($tableName2 !== null) {

					$tables_keys[$tableName2 . ' ' . $tableName] = true;

				} else {

					$tables_keys[$tableName] = true;

				}

			}

		} // foreach criteria->keys()

		$affectedRows = 0; // initialize this in case the next loop has no iterations.

		$tables = array_keys($tables_keys);

		foreach ($tables as $tableName) {

			$whereClause = array();

			$selectParams = array();

			foreach ($dbMap->getTable($tableName)->getColumns() as $colMap) {

				$key = $tableName . '.' . $colMap->getColumnName();

				if ($criteria->containsKey($key)) {

					$sb = "";

					$criteria->getCriterion($key)->appendPsTo($sb, $selectParams);

					$whereClause[] = $sb;

				}

			}

			if (empty($whereClause)) {

				throw new PropelException("Cowardly refusing to delete from table $tableName with empty WHERE clause.");

			}

			// Execute the statement.

			try {

				$sql = "DELETE FROM " . $tableName . " WHERE " .  implode(" AND ", $whereClause);

				$stmt = $con->prepare($sql);

				self::populateStmtValues($stmt, $selectParams, $dbMap, $db);

				$stmt->execute();

				$affectedRows = $stmt->rowCount();

			} catch (Exception $e) {

				Propel::log($e->getMessage(), Propel::LOG_ERR);

				throw new PropelException("Unable to execute DELETE statement.",$e);

			}

		} // for each table

		return $affectedRows;

	}

	/**

	 * Method to deletes all contents of specified table.

	 *

	 * This method is invoked from generated Peer classes like this:

	 * <code>

	 * public static function doDeleteAll($con = null)

	 * {

	 *   if ($con === null) $con = Propel::getConnection(self::DATABASE_NAME);

	 *   BasePeer::doDeleteAll(self::TABLE_NAME, $con);

	 * }

	 * </code>

	 *

	 * @param      string $tableName The name of the table to empty.

	 * @param      PropelPDO $con A PropelPDO connection object.

	 * @return     int	The number of rows affected by the statement.  Note

	 * 				that the return value does require that this information

	 * 				is returned (supported) by the Creole db driver.

	 * @throws     PropelException - wrapping SQLException caught from statement execution.

	 */

	public static function doDeleteAll($tableName, PropelPDO $con)

	{

		try {

			$sql = "DELETE FROM " . $tableName;

			$stmt = $con->prepare($sql);

			$stmt->execute();

			return $stmt->rowCount();

		} catch (Exception $e) {

			Propel::log($e->getMessage(), Propel::LOG_ERR);

			throw new PropelException("Unable to perform DELETE ALL operation.", $e);

		}

	}

	/**

	 * Method to perform inserts based on values and keys in a

	 * Criteria.

	 * <p>

	 * If the primary key is auto incremented the data in Criteria

	 * will be inserted and the auto increment value will be returned.

	 * <p>

	 * If the primary key is included in Criteria then that value will

	 * be used to insert the row.

	 * <p>

	 * If no primary key is included in Criteria then we will try to

	 * figure out the primary key from the database map and insert the

	 * row with the next available id using util.db.IDBroker.

	 * <p>

	 * If no primary key is defined for the table the values will be

	 * inserted as specified in Criteria and null will be returned.

	 *

	 * @param      Criteria $criteria Object containing values to insert.

	 * @param      PropelPDO $con A PropelPDO connection.

	 * @return     mixed The primary key for the new row if (and only if!) the primary key

	 *				is auto-generated.  Otherwise will return <code>null</code>.

	 * @throws     PropelException

	 */

	public static function doInsert(Criteria $criteria, PropelPDO $con) {

		// the primary key

		$id = null;

		$db = Propel::getDB($criteria->getDbName());

		// Get the table name and method for determining the primary

		// key value.

		$keys = $criteria->keys();

		if (!empty($keys)) {

			$tableName = $criteria->getTableName( $keys[0] );

		} else {

			throw new PropelException("Database insert attempted without anything specified to insert");

		}

		$dbMap = Propel::getDatabaseMap($criteria->getDbName());

		$tableMap = $dbMap->getTable($tableName);

		$keyInfo = $tableMap->getPrimaryKeyMethodInfo();

		$useIdGen = $tableMap->isUseIdGenerator();

		//$keyGen = $con->getIdGenerator();

		$pk = self::getPrimaryKey($criteria);

		// only get a new key value if you need to

		// the reason is that a primary key might be defined

		// but you are still going to set its value. for example:

		// a join table where both keys are primary and you are

		// setting both columns with your own values

		// pk will be null if there is no primary key defined for the table

		// we're inserting into.

		if ($pk !== null && $useIdGen && !$criteria->keyContainsValue($pk->getFullyQualifiedName()) && $db->isGetIdBeforeInsert()) {

			try {

				$id = $db->getId($con, $keyInfo);

			} catch (Exception $e) {

				throw new PropelException("Unable to get sequence id.", $e);

			}

			$criteria->add($pk->getFullyQualifiedName(), $id);

		}

		try {

			$adapter = Propel::getDB($criteria->getDBName());

			$qualifiedCols = $criteria->keys(); // we need table.column cols when populating values

			$columns = array(); // but just 'column' cols for the SQL

			foreach ($qualifiedCols as $qualifiedCol) {

				$columns[] = substr($qualifiedCol, strrpos($qualifiedCol, '.') + 1);

			}

			// add identifiers

			if ($adapter->useQuoteIdentifier()) {

				$columns = array_map(array($adapter, 'quoteIdentifier'), $columns);

			}

			$sql = 'INSERT INTO ' . $tableName

			. ' (' . implode(',', $columns) . ')'

			. ' VALUES (';

			// . substr(str_repeat("?,", count($columns)), 0, -1) .

			for($p=1, $cnt=count($columns); $p <= $cnt; $p++) {

				$sql .= ':p'.$p;

				if ($p !== $cnt) $sql .= ',';

			}

			$sql .= ')';

			$stmt = $con->prepare($sql);

			self::populateStmtValues($stmt, self::buildParams($qualifiedCols, $criteria), $dbMap, $db);

			$stmt->execute();

		} catch (Exception $e) {

			Propel::log($e->getMessage(), Propel::LOG_ERR);

			throw new PropelException("Unable to execute INSERT statement.", $e);

		}

		// If the primary key column is auto-incremented, get the id now.

		if ($pk !== null && $useIdGen && $db->isGetIdAfterInsert()) {

			try {

				$id = $db->getId($con, $keyInfo);

			} catch (Exception $e) {

				throw new PropelException("Unable to get autoincrement id.", $e);

			}

		}

		return $id;

	}

	/**

	 * Method used to update rows in the DB.  Rows are selected based

	 * on selectCriteria and updated using values in updateValues.

	 * <p>

	 * Use this method for performing an update of the kind:

	 * <p>

	 * WHERE some_column = some value AND could_have_another_column =

	 * another value AND so on.

	 *

	 * @param      $selectCriteria A Criteria object containing values used in where

	 *		clause.

	 * @param      $updateValues A Criteria object containing values used in set

	 *		clause.

	 * @param      PropelPDO $con The PropelPDO connection object to use.

	 * @return     int	The number of rows affected by last update statement.  For most

	 * 				uses there is only one update statement executed, so this number

	 * 				will correspond to the number of rows affected by the call to this

	 * 				method.  Note that the return value does require that this information

	 * 				is returned (supported) by the Creole db driver.

	 * @throws     PropelException

	 */

	public static function doUpdate(Criteria $selectCriteria, Criteria $updateValues, PropelPDO $con) {

		$db = Propel::getDB($selectCriteria->getDbName());

		$dbMap = Propel::getDatabaseMap($selectCriteria->getDbName());

		// Get list of required tables, containing all columns

		$tablesColumns = $selectCriteria->getTablesColumns();

		// we also need the columns for the update SQL

		$updateTablesColumns = $updateValues->getTablesColumns();

		$affectedRows = 0; // initialize this in case the next loop has no iterations.

		foreach ($tablesColumns as $tableName => $columns) {

			$whereClause = array();

			$params = array();

			$stmt = null;

			try {

				$sql = "UPDATE " . $tableName . " SET ";

				$p = 1;

				foreach ($updateTablesColumns[$tableName] as $col) {

					$updateColumnName = substr($col, strrpos($col, '.') + 1);

					// add identifiers for the actual database?

					if ($db->useQuoteIdentifier()) {

						$updateColumnName = $db->quoteIdentifier($updateColumnName);

					}

					if ($updateValues->getComparison($col) != Criteria::CUSTOM_EQUAL) {

						$sql .= $updateColumnName . '=:p'.$p++.', ';

					} else {

						$param = $updateValues->get($col);

						$sql .= $updateColumnName . ' = ';

						if (is_array($param)) {

							if (isset($param['raw'])) {

								$raw = $param['raw'];

								$rawcvt = '';

								// parse the $params['raw'] for ? chars

								for($r=0,$len=strlen($raw); $r < $len; $r++) {

									if ($raw{$r} == '?') {

										$rawcvt .= ':p'.$p++;

									} else {

										$rawcvt .= $raw{$r};

									}

								}

								$sql .= $rawcvt . ', ';

							} else {

								$sql .= ':p'.$p++.', ';

							}

							if (isset($param['value'])) {

								$updateValues->put($col, $param['value']);

							}

						} else {

							$updateValues->remove($col);

							$sql .= $param . ', ';

						}

					}

				}

				$params = self::buildParams($updateTablesColumns[$tableName], $updateValues);

				foreach ($columns as $colName) {

					$sb = "";

					$selectCriteria->getCriterion($colName)->appendPsTo($sb, $params);

					$whereClause[] = $sb;

				}

				$sql = substr($sql, 0, -2) . " WHERE " .  implode(" AND ", $whereClause);

				$stmt = $con->prepare($sql);

				// Replace ':p?' with the actual values

				self::populateStmtValues($stmt, $params, $dbMap, $db);

				$stmt->execute();

				$affectedRows = $stmt->rowCount();

				$stmt = null; // close

			} catch (Exception $e) {

				if ($stmt) $stmt = null; // close

				Propel::log($e->getMessage(), Propel::LOG_ERR);

				throw new PropelException("Unable to execute UPDATE statement.", $e);

			}

		} // foreach table in the criteria

		return $affectedRows;

	}

	/**

	 * Executes query build by createSelectSql() and returns the resultset statement.

	 *

	 * @param      Criteria $criteria A Criteria.

	 * @param      PropelPDO $con A PropelPDO connection to use.

	 * @return     PDOStatement The resultset.

	 * @throws     PropelException

	 * @see        createSelectSql()

	 */

	public static function doSelect(Criteria $criteria, PropelPDO $con = null)

	{

		$dbMap = Propel::getDatabaseMap($criteria->getDbName());

		$db = Propel::getDB($criteria->getDbName());

		if ($con === null) {

			$con = Propel::getConnection($criteria->getDbName(), Propel::CONNECTION_READ);

		}

		$stmt = null;

		if ($criteria->isUseTransaction()) $con->beginTransaction();

		try {

			$params = array();

			$sql = self::createSelectSql($criteria, $params);

			$stmt = $con->prepare($sql);

			self::populateStmtValues($stmt, $params, $dbMap, $db);

			$stmt->execute();

			if ($criteria->isUseTransaction()) $con->commit();

		} catch (Exception $e) {

			if ($stmt) $stmt = null; // close

			if ($criteria->isUseTransaction()) $con->rollBack();

			Propel::log($e->getMessage(), Propel::LOG_ERR);

			throw new PropelException($e);

		}

		return $stmt;

	}

	/**

	 * Executes a COUNT query using either a simple SQL rewrite or, for more complex queries, a

	 * sub-select of the SQL created by createSelectSql() and returns the statement.

	 *

	 * @param      Criteria $criteria A Criteria.

	 * @param      PropelPDO $con A PropelPDO connection to use.

	 * @return     PDOStatement The resultset statement.

	 * @throws     PropelException

	 * @see        createSelectSql()

	 */

	public static function doCount(Criteria $criteria, PropelPDO $con = null)

	{

		$dbMap = Propel::getDatabaseMap($criteria->getDbName());

		$db = Propel::getDB($criteria->getDbName());

		if ($con === null) {

			$con = Propel::getConnection($criteria->getDbName(), Propel::CONNECTION_READ);

		}

		$stmt = null;

		if ($criteria->isUseTransaction()) $con->beginTransaction();

		$needsComplexCount = ($criteria->getGroupByColumns() || $criteria->getOffset()

								|| $criteria->getLimit() || $criteria->getHaving() || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers()));

		try {

			$params = array();

			if ($needsComplexCount) {

				if (self::needsSelectAliases($criteria)) {

					self::turnSelectColumnsToAliases($criteria);

				}

				$selectSql = self::createSelectSql($criteria, $params);

				$sql = 'SELECT COUNT(*) FROM (' . $selectSql . ') AS propelmatch4cnt';

			} else {

				// Replace SELECT columns with COUNT(*)

				$criteria->clearSelectColumns()->addSelectColumn('COUNT(*)');

				$sql = self::createSelectSql($criteria, $params);

			}

			$stmt = $con->prepare($sql);

			self::populateStmtValues($stmt, $params, $dbMap, $db);

			$stmt->execute();

			if ($criteria->isUseTransaction()) $con->commit();

		} catch (Exception $e) {

			if ($stmt) $stmt = null; // close

			if ($criteria->isUseTransaction()) $con->rollBack();

			Propel::log($e->getMessage(), Propel::LOG_ERR);

			throw new PropelException($e);

		}

		return $stmt;

	}

	/**

	 * Populates values in a prepared statement.

	 *

	 * This method is designed to work with the createSelectSql() method, which creates

	 * both the SELECT SQL statement and populates a passed-in array of parameter

	 * values that should be substituted.

	 *

	 * <code>

	 * $params = array();

	 * $sql = BasePeer::createSelectSql($criteria, $params);

	 * BasePeer::populateStmtValues($stmt, $params, Propel::getDatabaseMap($critera->getDbName()), Propel::getDB($criteria->getDbName()));

	 * </code>

	 *

	 * @param      PDOStatement $stmt

	 * @param      array $params array('column' => ..., 'table' => ..., 'value' => ...)

	 * @param      DatabaseMap $dbMap

	 * @return     int The number of params replaced.

	 * @see        createSelectSql()

	 * @see        doSelect()

	 */

	public static function populateStmtValues(PDOStatement $stmt, array $params, DatabaseMap $dbMap, DBAdapter $db)

	{

		$i = 1;

		foreach ($params as $param) {

			$tableName = $param['table'];

			$columnName = $param['column'];

			$value = $param['value'];

			if ($value === null) {

				$stmt->bindValue(':p'.$i++, null, PDO::PARAM_NULL);

			} elseif (isset($tableName) ) {

				$cMap = $dbMap->getTable($tableName)->getColumn($columnName);

				$type = $cMap->getType();

				$pdoType = $cMap->getPdoType();

				// FIXME - This is a temporary hack to get around apparent bugs w/ PDO+MYSQL

				// See http://pecl.php.net/bugs/bug.php?id=9919

				if ($pdoType == PDO::PARAM_BOOL && $db instanceof DBMySQL) {

					$value = (int) $value;

					$pdoType = PDO::PARAM_INT;

				} elseif (is_numeric($value) && $cMap->isEpochTemporal()) { // it's a timestamp that needs to be formatted

					if ($type == PropelColumnTypes::TIMESTAMP) {

						$value = date($db->getTimestampFormatter(), $value);

					} else if ($type == PropelColumnTypes::DATE) {

						$value = date($db->getDateFormatter(), $value);

					} else if ($type == PropelColumnTypes::TIME) {

						$value = date($db->getTimeFormatter(), $value);

					}

				} elseif ($value instanceof DateTime && $cMap->isTemporal()) { // it's a timestamp that needs to be formatted

					if ($type == PropelColumnTypes::TIMESTAMP || $type == PropelColumnTypes::BU_TIMESTAMP) {

						$value = $value->format($db->getTimestampFormatter());

					} else if ($type == PropelColumnTypes::DATE || $type == PropelColumnTypes::BU_DATE) {

						$value = $value->format($db->getDateFormatter());

					} else if ($type == PropelColumnTypes::TIME) {

						$value = $value->format($db->getTimeFormatter());

					}

				} elseif (is_resource($value) && $cMap->isLob()) {

					// we always need to make sure that the stream is rewound, otherwise nothing will

					// get written to database.

					rewind($value);

				}

				$stmt->bindValue(':p'.$i++, $value, $pdoType);

			} else {

				$stmt->bindValue(':p'.$i++, $value);

			}

		} // foreach

	}

	/**

	 * Applies any validators that were defined in the schema to the specified columns.

	 *

	 * @param      string $dbName The name of the database

	 * @param      string $tableName The name of the table

	 * @param      array $columns Array of column names as key and column values as value.

	 */

	public static function doValidate($dbName, $tableName, $columns)

	{

		$dbMap = Propel::getDatabaseMap($dbName);

		$tableMap = $dbMap->getTable($tableName);

		$failureMap = array(); // map of ValidationFailed objects

		foreach ($columns as $colName => $colValue) {

			if ($tableMap->containsColumn($colName)) {

				$col = $tableMap->getColumn($colName);

				foreach ($col->getValidators() as $validatorMap) {

					$validator = BasePeer::getValidator($validatorMap->getClass());

					if ($validator && ($col->isNotNull() || $colValue !== null) && $validator->isValid($validatorMap, $colValue) === false) {

						if (!isset($failureMap[$colName])) { // for now we do one ValidationFailed per column, not per rule

							$failureMap[$colName] = new ValidationFailed($colName, $validatorMap->getMessage(), $validator);

						}

					}

				}

			}

		}

		return (!empty($failureMap) ? $failureMap : true);

	}

	/**

	 * Helper method which returns the primary key contained

	 * in the given Criteria object.

	 *

	 * @param      Criteria $criteria A Criteria.

	 * @return     ColumnMap If the Criteria object contains a primary

	 *		  key, or null if it doesn't.

	 * @throws     PropelException

	 */

	private static function getPrimaryKey(Criteria $criteria)

	{

		// Assume all the keys are for the same table.

		$keys = $criteria->keys();

		$key = $keys[0];

		$table = $criteria->getTableName($key);

		$pk = null;

		if (!empty($table)) {

			$dbMap = Propel::getDatabaseMap($criteria->getDbName());

			if ($dbMap === null) {

				throw new PropelException("\$dbMap is null");

			}

			if ($dbMap->getTable($table) === null) {

				throw new PropelException("\$dbMap->getTable() is null");

			}

			$columns = $dbMap->getTable($table)->getColumns();

			foreach (array_keys($columns) as $key) {

				if ($columns[$key]->isPrimaryKey()) {

					$pk = $columns[$key];

					break;

				}

			}

		}

		return $pk;

	}

	/**

	 * Checks whether the Criteria needs to use column aliasing

	 * This is implemented in a service class rather than in Criteria itself

	 * in order to avoid doing the tests when it's not necessary (e.g. for SELECTs)

	 */

	public static function needsSelectAliases(Criteria $criteria)

	{

		$columnNames = array();

		foreach ($criteria->getSelectColumns() as $fullyQualifiedColumnName) {

			if ($pos = strrpos($fullyQualifiedColumnName, '.')) {

				$columnName = substr($fullyQualifiedColumnName, $pos);

				if (isset($columnNames[$columnName])) {

					// more than one column with the same name, so aliasing is required

					return true;

				}

				$columnNames[$columnName] = true;

			}

		}

		return false;

	}

	/**

	 * Ensures uniqueness of select column names by turning them all into aliases

	 * This is necessary for queries on more than one table when the tables share a column name

	 * @see http://propel.phpdb.org/trac/ticket/795

	 *

	 * @param Criteria $criteria

	 *

	 * @return Criteria The input, with Select columns replaced by aliases

	 */

	public static function turnSelectColumnsToAliases(Criteria $criteria)

	{

		$selectColumns = $criteria->getSelectColumns();

		// clearSelectColumns also clears the aliases, so get them too

		$asColumns = $criteria->getAsColumns();

		$criteria->clearSelectColumns();

		$columnAliases = $asColumns;

		// add the select columns back

		foreach ($selectColumns as $clause) {

			// Generate a unique alias

			$baseAlias = preg_replace('/\W/', '_', $clause);

			$alias = $baseAlias;

			// If it already exists, add a unique suffix

			$i = 0;

			while (isset($columnAliases[$alias])) {

				$i++;

				$alias = $baseAlias . '_' . $i;

			}

			// Add it as an alias

			$criteria->addAsColumn($alias, $clause);

			$columnAliases[$alias] = $clause;

		}

		// Add the aliases back, don't modify them

		foreach ($asColumns as $name => $clause) {

			$criteria->addAsColumn($name, $clause);

		}

		return $criteria;

	}

	/**

	 * Method to create an SQL query based on values in a Criteria.

	 *

	 * This method creates only prepared statement SQL (using ? where values

	 * will go).  The second parameter ($params) stores the values that need

	 * to be set before the statement is executed.  The reason we do it this way

	 * is to let the PDO layer handle all escaping & value formatting.

	 *

	 * @param      Criteria $criteria Criteria for the SELECT query.

	 * @param      array &$params Parameters that are to be replaced in prepared statement.

	 * @return     string

	 * @throws     PropelException Trouble creating the query string.

	 */

	public static function createSelectSql(Criteria $criteria, &$params)

	{

		$db = Propel::getDB($criteria->getDbName());

		$dbMap = Propel::getDatabaseMap($criteria->getDbName());

		// redundant definition $selectModifiers = array();

		$selectClause = array();

		$fromClause = array();

		$joinClause = array();

		$joinTables = array();

		$whereClause = array();

		$orderByClause = array();

		// redundant definition $groupByClause = array();

		$orderBy = $criteria->getOrderByColumns();

		$groupBy = $criteria->getGroupByColumns();

		$ignoreCase = $criteria->isIgnoreCase();

		$select = $criteria->getSelectColumns();

		$aliases = $criteria->getAsColumns();

		// simple copy

		$selectModifiers = $criteria->getSelectModifiers();

		// get selected columns

		foreach ($select as $columnName) {

			// expect every column to be of "table.column" formation

			// it could be a function:  e.g. MAX(books.price)

			$tableName = null;

			$selectClause[] = $columnName; // the full column name: e.g. MAX(books.price)

			$parenPos = strrpos($columnName, '(');

			$dotPos = strrpos($columnName, '.', ($parenPos !== false ? $parenPos : 0));

			// [HL] I think we really only want to worry about adding stuff to

			// the fromClause if this function has a TABLE.COLUMN in it at all.

			// e.g. COUNT(*) should not need this treatment -- or there needs to

			// be special treatment for '*'

			if ($dotPos !== false) {

				if ($parenPos === false) { // table.column

					$tableName = substr($columnName, 0, $dotPos);

				} else { // FUNC(table.column)

					$tableName = substr($columnName, $parenPos + 1, $dotPos - ($parenPos + 1));

					// functions may contain qualifiers so only take the last

					// word as the table name.

					// COUNT(DISTINCT books.price)

					$lastSpace = strpos($tableName, ' ');

					if ($lastSpace !== false) { // COUNT(DISTINCT books.price)

						$tableName = substr($tableName, $lastSpace + 1);

					}

				}

				$tableName2 = $criteria->getTableForAlias($tableName);

				if ($tableName2 !== null) {

					$fromClause[] = $tableName2 . ' ' . $tableName;

				} else {

					$fromClause[] = $tableName;

				}

			} // if $dotPost !== null

		}

		// set the aliases

		foreach ($aliases as $alias => $col) {

			$selectClause[] = $col . " AS " . $alias;

		}

		// add the criteria to WHERE clause

		// this will also add the table names to the FROM clause if they are not already

		// invluded via a LEFT JOIN

		foreach ($criteria->keys() as $key) {

			$criterion = $criteria->getCriterion($key);

			$someCriteria = $criterion->getAttachedCriterion();

			$someCriteriaLength = count($someCriteria);

			$table = null;

			for ($i=0; $i < $someCriteriaLength; $i++) {

				$tableName = $someCriteria[$i]->getTable();

				$table = $criteria->getTableForAlias($tableName);

				if ($table !== null) {

					$fromClause[] = $table . ' ' . $tableName;

				} else {

					$fromClause[] = $tableName;

					$table = $tableName;

				}

				$ignoreCase =

				(($criteria->isIgnoreCase()

				|| $someCriteria[$i]->isIgnoreCase())

				&& (strpos($dbMap->getTable($table)->getColumn($someCriteria[$i]->getColumn())->getType(), "VARCHAR") !== false)

				);

				$someCriteria[$i]->setIgnoreCase($ignoreCase);

			}

			$criterion->setDB($db);

			$sb = "";

			$criterion->appendPsTo($sb, $params);

			$whereClause[] = $sb;

		}

		// Handle joins

		// joins with a null join type will be added to the FROM clause and the condition added to the WHERE clause.

		// joins of a specified type: the LEFT side will be added to the fromClause and the RIGHT to the joinClause

		foreach ((array) $criteria->getJoins() as $join) {

			// The join might have been established using an alias name

			$leftTable = $join->getLeftTableName();

			$leftTableAlias = '';

			if ($realTable = $criteria->getTableForAlias($leftTable)) {

				$leftTableAlias = " $leftTable";

				$leftTable = $realTable;

			}

			$rightTable = $join->getRightTableName();

			$rightTableAlias = '';

			if ($realTable = $criteria->getTableForAlias($rightTable)) {

				$rightTableAlias = " $rightTable";

				$rightTable = $realTable;

			}

			// determine if casing is relevant.

			if ($ignoreCase = $criteria->isIgnoreCase()) {

				$leftColType = $dbMap->getTable($leftTable)->getColumn($join->getLeftColumnName())->getType();

				$rightColType = $dbMap->getTable($rightTable)->getColumn($join->getRightColumnName())->getType();

				$ignoreCase = ($leftColType == 'string' || $rightColType == 'string');

			}

			// build the condition

			$condition = '';

			foreach ($join->getConditions() as $index => $conditionDesc)

			{

				if ($ignoreCase) {

					$condition .= $db->ignoreCase($conditionDesc['left']) . $conditionDesc['operator'] . $db->ignoreCase($conditionDesc['right']);

				} else {

					$condition .= implode($conditionDesc);

				}

				if ($index + 1 < $join->countConditions()) {

					$condition .= ' AND ';

				}

			}

			// add 'em to the queues..

			if ($joinType = $join->getJoinType()) {

			  // real join

				if (!$fromClause) {

					$fromClause[] = $leftTable . $leftTableAlias;

				}

				$joinTables[] = $rightTable . $rightTableAlias;

				$joinClause[] = $join->getJoinType() . ' ' . $rightTable . $rightTableAlias . " ON ($condition)";

			} else {

			  // implicit join, translates to a where

				$fromClause[] = $leftTable . $leftTableAlias;

				$fromClause[] = $rightTable . $rightTableAlias;

				$whereClause[] = $condition;

			}

		}

		// Unique from clause elements

		$fromClause = array_unique($fromClause);

		$fromClause = array_diff($fromClause, array(''));

		// tables should not exist in both the from and join clauses

		if ($joinTables && $fromClause) {

			foreach ($fromClause as $fi => $ftable) {

				if (in_array($ftable, $joinTables)) {

					unset($fromClause[$fi]);

				}

			}

		}

		// Add the GROUP BY columns

		$groupByClause = $groupBy;

		$having = $criteria->getHaving();

		$havingString = null;

		if ($having !== null) {

			$sb = "";

			$having->appendPsTo($sb, $params);

			$havingString = $sb;

		}

		if (!empty($orderBy)) {

			foreach ($orderBy as $orderByColumn) {

				// Add function expression as-is.

				if (strpos($orderByColumn, '(') !== false) {

					$orderByClause[] = $orderByColumn;

					continue;

				}

				// Split orderByColumn (i.e. "table.column DESC")

				$dotPos = strrpos($orderByColumn, '.');

				if ($dotPos !== false) {

					$tableName = substr($orderByColumn, 0, $dotPos);

					$columnName = substr($orderByColumn, $dotPos+1);

				}

				else {

					$tableName = '';

					$columnName = $orderByColumn;

				}

				$spacePos = strpos($columnName, ' ');

				if ($spacePos !== false) {

					$direction = substr($columnName, $spacePos);

					$columnName = substr($columnName, 0, $spacePos);

				}

				else {

					$direction = '';

				}

				$tableAlias = $tableName;

				if ($aliasTableName = $criteria->getTableForAlias($tableName)) {

					$tableName = $aliasTableName;

				}

				$columnAlias = $columnName;

				if ($asColumnName = $criteria->getColumnForAs($columnName)) {

					$columnName = $asColumnName;

				}

				$column = $tableName ? $dbMap->getTable($tableName)->getColumn($columnName) : null;

				if ($criteria->isIgnoreCase() && $column && $column->isText()) {

					$orderByClause[] = $db->ignoreCaseInOrderBy("$tableAlias.$columnAlias") . $direction;

					$selectClause[] = $db->ignoreCaseInOrderBy("$tableAlias.$columnAlias");

				} else {

					$orderByClause[] = $orderByColumn;

				}

			}

		}

		if (empty($fromClause) && $criteria->getPrimaryTableName()) {

			$fromClause[] = $criteria->getPrimaryTableName();

		}

		// from / join tables quoten if it is necessary

		if ($db->useQuoteIdentifier()) {

			$fromClause = array_map(array($db, 'quoteIdentifierTable'), $fromClause);

			$joinClause = $joinClause ? $joinClause : array_map(array($db, 'quoteIdentifierTable'), $joinClause);

		}

		// build from-clause

		$from = '';

		if (!empty($joinClause) && count($fromClause) > 1) {

			$from .= implode(" CROSS JOIN ", $fromClause);

		} else {

			$from .= implode(", ", $fromClause);

		}

		$from .= $joinClause ? ' ' . implode(' ', $joinClause) : '';