. */ Doctrine::autoload('Doctrine_Expression'); /** * Doctrine_Expression_Pgsql * * @package Doctrine * @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @category Object Relational Mapping * @link www.phpdoctrine.com * @since 1.0 * @version $Revision$ * @author Konsta Vesterinen */ class Doctrine_Expression_Pgsql extends Doctrine_Expression { /** * Returns the md5 sum of a field. * * Note: Not SQL92, but common functionality * * md5() works with the default PostgreSQL 8 versions. * * If you are using PostgreSQL 7.x or older you need * to make sure that the digest procedure is installed. * If you use RPMS (Redhat and Mandrake) install the postgresql-contrib * package. You must then install the procedure by running this shell command: * * psql [dbname] < /usr/share/pgsql/contrib/pgcrypto.sql * * You should make sure you run this as the postgres user. * * @return string */ public function md5($column) { $column = $this->getIdentifier($column); if ($this->version > 7) { return 'MD5(' . $column . ')'; } else { return 'encode(digest(' . $column .', md5), hex)'; } } /** * Returns part of a string. * * Note: Not SQL92, but common functionality. * * @param string $value the target $value the string or the string column. * @param int $from extract from this characeter. * @param int $len extract this amount of characters. * @return string sql that extracts part of a string. */ public function substring($value, $from, $len = null) { $value = $this->getIdentifier($value); if ($len === null) { $len = $this->getIdentifier($len); return 'SUBSTR(' . $value . ', ' . $from . ')'; } else { return 'SUBSTR(' . $value . ', ' . $from . ', ' . $len . ')'; } } /** * Returns a series of strings concatinated * * concat() accepts an arbitrary number of parameters. Each parameter * must contain an expression or an array with expressions. * * @param string|array(string) strings that will be concatinated. * @return string */ public function concat($arg1, $arg2) { $args = func_get_args(); $cols = $this->getIdentifiers($cols); return join(' || ' , $cols); } /** * regexp * * @return string the regular expression operator */ public function regexp() { return 'SIMILAR TO'; } /** * return string to call a function to get random value inside an SQL statement * * @return return string to generate float between 0 and 1 * @access public */ public function random() { return 'RANDOM()'; } /** * build a pattern matching string * * EXPERIMENTAL * * WARNING: this function is experimental and may change signature at * any time until labelled as non-experimental * * @access public * * @param array $pattern even keys are strings, odd are patterns (% and _) * @param string $operator optional pattern operator (LIKE, ILIKE and maybe others in the future) * @param string $field optional field name that is being matched against * (might be required when emulating ILIKE) * * @return string SQL pattern */ public function matchPattern($pattern, $operator = null, $field = null) { $match = ''; if (!is_null($operator)) { $field = is_null($field) ? '' : $field.' '; $operator = strtoupper($operator); switch ($operator) { // case insensitive case 'ILIKE': $match = $field.'ILIKE '; break; // case sensitive case 'LIKE': $match = $field.'LIKE '; break; default: return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, 'not a supported operator type:'. $operator, __FUNCTION__); } } $match.= "'"; foreach ($pattern as $key => $value) { if ($key % 2) { $match.= $value; } else { $match.= $db->escapePattern($db->escape($value)); } } $match.= "'"; $match.= $this->patternEscapeString(); return $match; } }