- Add support for MDB2's 'sqlsrv' driver (#1486395)
44 files modified
6 files added
| | |
| | | CHANGELOG RoundCube Webmail |
| | | =========================== |
| | | |
| | | - Add support for MDB2's 'sqlsrv' driver (#1486395) |
| | | - Use jQuery-1.4 |
| | | - Removed problematic browser-caching of messages |
| | | - Fix incompatybility with suhosin.executor.disable_emodifier (#1486321) |
| | |
| | | // PEAR database DSN for read/write operations |
| | | // format is db_provider://user:password@host/database |
| | | // For examples see http://pear.php.net/manual/en/package.database.mdb2.intro-dsn.php |
| | | // currently supported db_providers: mysql, mysqli, pgsql, sqlite, mssql |
| | | // currently supported db_providers: mysql, mysqli, pgsql, sqlite, mssql or sqlsrv |
| | | |
| | | $rcmail_config['db_dsnw'] = 'mysql://roundcube:pass@localhost/roundcubemail'; |
| | | // postgres example: 'pgsql://roundcube:pass@localhost/roundcubemail'; |
| | |
| | | return; |
| | | |
| | | $cookie = session_get_cookie_params(); |
| | | |
| | | setcookie($name, $value, $exp, $cookie['path'], $cookie['domain'], |
| | | rcube_https_check(), true); |
| | | } |
| | |
| | | if (!filesize($dsn_array['database']) && !empty($this->sqlite_initials)) |
| | | $this->_sqlite_create_database($dbh, $this->sqlite_initials); |
| | | } |
| | | else if ($this->db_provider!='mssql') |
| | | else if ($this->db_provider!='mssql' && $this->db_provider!='sqlsrv') |
| | | $dbh->setCharset('utf8'); |
| | | |
| | | return $dbh; |
| | |
| | | switch($this->db_provider) |
| | | { |
| | | case 'mssql': |
| | | case 'sqlsrv': |
| | | return "getdate()"; |
| | | |
| | | default: |
| | |
| | | break; |
| | | |
| | | case 'mssql': |
| | | case 'sqlsrv': |
| | | return "DATEDIFF(second, '19700101', $field) + DATEDIFF(second, GETDATE(), GETUTCDATE())"; |
| | | |
| | | default: |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: MDB2.php,v 1.318 2008/03/08 14:18:38 quipo Exp $ |
| | | // $Id: MDB2.php 292663 2009-12-26 18:21:46Z quipo $ |
| | | // |
| | | |
| | | /** |
| | |
| | | define('MDB2_ERROR_LOADMODULE', -34); |
| | | define('MDB2_ERROR_INSUFFICIENT_DATA', -35); |
| | | define('MDB2_ERROR_NO_PERMISSION', -36); |
| | | define('MDB2_ERROR_DISCONNECT_FAILED', -37); |
| | | |
| | | // }}} |
| | | // {{{ Verbose constants |
| | |
| | | $err =& MDB2::raiseError(MDB2_ERROR_NOT_FOUND, null, null, $msg); |
| | | return $err; |
| | | } |
| | | if (!MDB2::classExists($class_name)) { |
| | | $msg = "unable to load class '$class_name' from file '$file_name'"; |
| | | $err =& MDB2::raiseError(MDB2_ERROR_NOT_FOUND, null, null, $msg); |
| | | return $err; |
| | | } |
| | | } |
| | | return MDB2_OK; |
| | | } |
| | |
| | | // {{{ function &connect($dsn, $options = false) |
| | | |
| | | /** |
| | | * Create a new MDB2 connection object and connect to the specified |
| | | * Create a new MDB2_Driver_* connection object and connect to the specified |
| | | * database |
| | | * |
| | | * IMPORTANT: In order for MDB2 to work properly it is necessary that |
| | |
| | | * $db = MDB2::connect($dsn); |
| | | * ^^ |
| | | * |
| | | * @param mixed 'data source name', see the MDB2::parseDSN |
| | | * @param mixed $dsn 'data source name', see the MDB2::parseDSN |
| | | * method for a description of the dsn format. |
| | | * Can also be specified as an array of the |
| | | * format returned by MDB2::parseDSN. |
| | | * @param array An associative array of option names and |
| | | * @param array $options An associative array of option names and |
| | | * their values. |
| | | * |
| | | * @return mixed a newly created MDB2 connection object, or a MDB2 |
| | |
| | | */ |
| | | function apiVersion() |
| | | { |
| | | return '2.5.0b1'; |
| | | return '@package_version@'; |
| | | } |
| | | |
| | | // }}} |
| | |
| | | function isError($data, $code = null) |
| | | { |
| | | if (is_a($data, 'MDB2_Error')) { |
| | | if (is_null($code)) { |
| | | if (null === $code) { |
| | | return true; |
| | | } elseif (is_string($code)) { |
| | | return $data->getMessage() === $code; |
| | |
| | | MDB2_ERROR_TRUNCATED => 'truncated', |
| | | MDB2_ERROR_DEADLOCK => 'deadlock detected', |
| | | MDB2_ERROR_NO_PERMISSION => 'no permission', |
| | | MDB2_ERROR_DISCONNECT_FAILED => 'disconnect failed', |
| | | ); |
| | | } |
| | | |
| | | if (is_null($value)) { |
| | | if (null === $value) { |
| | | return $errorMessages; |
| | | } |
| | | |
| | |
| | | */ |
| | | function parseDSN($dsn) |
| | | { |
| | | $parsed = array(); |
| | | $parsed = $GLOBALS['_MDB2_dsninfo_default']; |
| | | |
| | | if (is_array($dsn)) { |
| | | $dsn = array_merge($parsed, $dsn); |
| | |
| | | $dsn = null; |
| | | } |
| | | |
| | | |
| | | // Get phptype and dbsyntax |
| | | // $str => phptype(dbsyntax) |
| | | if (preg_match('|^(.+?)\((.*?)\)$|', $str, $arr)) { |
| | |
| | | } |
| | | |
| | | if (!count($dsn)) { |
| | | return array_merge($GLOBALS['_MDB2_dsninfo_default'], $parsed); |
| | | return $parsed; |
| | | } |
| | | |
| | | // Get (if found): username and password |
| | |
| | | //"username/password@[//]host[:port][/service_name]" |
| | | //e.g. "scott/tiger@//mymachine:1521/oracle" |
| | | $proto_opts = $dsn; |
| | | $dsn = substr($proto_opts, strrpos($proto_opts, '/') + 1); |
| | | $pos = strrpos($proto_opts, '/'); |
| | | $dsn = substr($proto_opts, $pos + 1); |
| | | $proto_opts = substr($proto_opts, 0, $pos); |
| | | } elseif (strpos($dsn, '/') !== false) { |
| | | list($proto_opts, $dsn) = explode('/', $dsn, 2); |
| | | } else { |
| | |
| | | } |
| | | foreach ($opts as $opt) { |
| | | list($key, $value) = explode('=', $opt); |
| | | if (!isset($parsed[$key])) { |
| | | if (!array_key_exists($key, $parsed) || false === $parsed[$key]) { |
| | | // don't allow params overwrite |
| | | $parsed[$key] = rawurldecode($value); |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | return array_merge($GLOBALS['_MDB2_dsninfo_default'], $parsed); |
| | | return $parsed; |
| | | } |
| | | |
| | | // }}} |
| | |
| | | function MDB2_Error($code = MDB2_ERROR, $mode = PEAR_ERROR_RETURN, |
| | | $level = E_USER_NOTICE, $debuginfo = null, $dummy = null) |
| | | { |
| | | if (is_null($code)) { |
| | | if (null === $code) { |
| | | $code = MDB2_ERROR; |
| | | } |
| | | $this->PEAR_Error('MDB2 Error: '.MDB2::errorMessage($code), $code, |
| | |
| | | * <li>$options['emulate_prepared'] -> boolean: force prepared statements to be emulated</li> |
| | | * <li>$options['datatype_map'] -> array: map user defined datatypes to other primitive datatypes</li> |
| | | * <li>$options['datatype_map_callback'] -> array: callback function/method that should be called</li> |
| | | * <li>$options['bindname_format'] -> string: regular expression pattern for named parameters |
| | | * <li>$options['bindname_format'] -> string: regular expression pattern for named parameters</li> |
| | | * <li>$options['multi_query'] -> boolean: determines if queries returning multiple result sets should be executed</li> |
| | | * <li>$options['max_identifiers_length'] -> integer: max identifier length</li> |
| | | * <li>$options['default_fk_action_onupdate'] -> string: default FOREIGN KEY ON UPDATE action ['RESTRICT'|'NO ACTION'|'SET DEFAULT'|'SET NULL'|'CASCADE']</li> |
| | | * <li>$options['default_fk_action_ondelete'] -> string: default FOREIGN KEY ON DELETE action ['RESTRICT'|'NO ACTION'|'SET DEFAULT'|'SET NULL'|'CASCADE']</li> |
| | | * </ul> |
| | | * |
| | | * @var array |
| | |
| | | 'lob_allow_url_include' => false, |
| | | 'bindname_format' => '(?:\d+)|(?:[a-zA-Z][a-zA-Z0-9_]*)', |
| | | 'max_identifiers_length' => 30, |
| | | 'default_fk_action_onupdate' => 'RESTRICT', |
| | | 'default_fk_action_ondelete' => 'RESTRICT', |
| | | ); |
| | | |
| | | /** |
| | |
| | | * callbacks etc. Basically a wrapper for PEAR::raiseError |
| | | * without the message string. |
| | | * |
| | | * @param mixed integer error code, or a PEAR error object (all other |
| | | * parameters are ignored if this parameter is an object |
| | | * @param int error mode, see PEAR_Error docs |
| | | * @param mixed If error mode is PEAR_ERROR_TRIGGER, this is the |
| | | * @param mixed $code integer error code, or a PEAR error object (all |
| | | * other parameters are ignored if this parameter is |
| | | * an object |
| | | * @param int $mode error mode, see PEAR_Error docs |
| | | * @param mixed $options If error mode is PEAR_ERROR_TRIGGER, this is the |
| | | * error level (E_USER_NOTICE etc). If error mode is |
| | | * PEAR_ERROR_CALLBACK, this is the callback function, |
| | | * either as a function name, or as an array of an |
| | | * object and method name. For other error modes this |
| | | * parameter is ignored. |
| | | * @param string Extra debug information. Defaults to the last |
| | | * @param string $userinfo Extra debug information. Defaults to the last |
| | | * query and native error code. |
| | | * @param string name of the method that triggered the error |
| | | * @param string $method name of the method that triggered the error |
| | | * @param string $dummy1 not used |
| | | * @param bool $dummy2 not used |
| | | * |
| | | * @return PEAR_Error instance of a PEAR Error object |
| | | * |
| | | * @access public |
| | | * @see PEAR_Error |
| | | */ |
| | | function &raiseError($code = null, $mode = null, $options = null, $userinfo = null, $method = null) |
| | | { |
| | | function &raiseError($code = null, |
| | | $mode = null, |
| | | $options = null, |
| | | $userinfo = null, |
| | | $method = null, |
| | | $dummy1 = null, |
| | | $dummy2 = false |
| | | ) { |
| | | $userinfo = "[Error message: $userinfo]\n"; |
| | | // The error is yet a MDB2 error object |
| | | if (PEAR::isError($code)) { |
| | | // because we use the static PEAR::raiseError, our global |
| | | // handler should be used if it is set |
| | | if (is_null($mode) && !empty($this->_default_error_mode)) { |
| | | if ((null === $mode) && !empty($this->_default_error_mode)) { |
| | | $mode = $this->_default_error_mode; |
| | | $options = $this->_default_error_options; |
| | | } |
| | | if (is_null($userinfo)) { |
| | | if (null === $userinfo) { |
| | | $userinfo = $code->getUserinfo(); |
| | | } |
| | | $code = $code->getCode(); |
| | |
| | | } |
| | | $native_errno = $native_msg = null; |
| | | list($code, $native_errno, $native_msg) = $this->errorInfo($code); |
| | | if (!is_null($native_errno) && $native_errno !== '') { |
| | | if ((null !== $native_errno) && $native_errno !== '') { |
| | | $userinfo.= "[Native code: $native_errno]\n"; |
| | | } |
| | | if (!is_null($native_msg) && $native_msg !== '') { |
| | | if ((null !== $native_msg) && $native_msg !== '') { |
| | | $userinfo.= "[Native message: ". strip_tags($native_msg) ."]\n"; |
| | | } |
| | | if (!is_null($method)) { |
| | | if (null !== $method) { |
| | | $userinfo = $method.': '.$userinfo; |
| | | } |
| | | } |
| | |
| | | return $err; |
| | | } |
| | | $this->{$property} = new $class_name($this->db_index); |
| | | $this->modules[$module] = $this->{$property}; |
| | | $this->modules[$module] =& $this->{$property}; |
| | | if ($version) { |
| | | // this will be used in the connect method to determine if the module |
| | | // needs to be loaded with a different version if the server |
| | |
| | | } |
| | | } |
| | | } |
| | | if (!is_null($module)) { |
| | | if (null !== $module) { |
| | | return call_user_func_array(array(&$this->modules[$module], $method), $params); |
| | | } |
| | | trigger_error(sprintf('Call to undefined function: %s::%s().', get_class($this), $method), E_USER_ERROR); |
| | |
| | | */ |
| | | function failNestedTransaction($error = null, $immediately = false) |
| | | { |
| | | if (is_null($error)) { |
| | | if (null !== $error) { |
| | | $error = $this->has_transaction_error ? $this->has_transaction_error : true; |
| | | } elseif (!$error) { |
| | | $error = true; |
| | |
| | | /** |
| | | * Log out and disconnect from the database. |
| | | * |
| | | * @param bool if the disconnect should be forced even if the |
| | | * @param boolean $force whether the disconnect should be forced even if the |
| | | * connection is opened persistently |
| | | * |
| | | * @return mixed true on success, false if not connected and error |
| | | * object on error |
| | | * @return mixed true on success, false if not connected and error object on error |
| | | * |
| | | * @access public |
| | | */ |
| | |
| | | break; |
| | | } |
| | | return $dsn; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _isNewLinkSet() |
| | | |
| | | /** |
| | | * Check if the 'new_link' option is set |
| | | * |
| | | * @return boolean |
| | | * |
| | | * @access protected |
| | | */ |
| | | function _isNewLinkSet() |
| | | { |
| | | return (isset($this->dsn['new_link']) |
| | | && ($this->dsn['new_link'] === true |
| | | || (is_string($this->dsn['new_link']) && preg_match('/^true$/i', $this->dsn['new_link'])) |
| | | || (is_numeric($this->dsn['new_link']) && 0 != (int)$this->dsn['new_link']) |
| | | ) |
| | | ); |
| | | } |
| | | |
| | | // }}} |
| | |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ function &_wrapResult($result, $types = array(), $result_class = true, $result_wrap_class = false, $limit = null, $offset = null) |
| | | // {{{ function &_wrapResult($result_resource, $types = array(), $result_class = true, $result_wrap_class = false, $limit = null, $offset = null) |
| | | |
| | | /** |
| | | * wrap a result set into the correct class |
| | |
| | | 'result wrap class does not exist '.$result_wrap_class, __FUNCTION__); |
| | | return $err; |
| | | } |
| | | $result = new $result_wrap_class($result, $this->fetchmode); |
| | | $result = new $result_wrap_class($result_resource, $this->fetchmode); |
| | | } |
| | | return $result; |
| | | } |
| | |
| | | 'it was not specified a valid selected range row limit', __FUNCTION__); |
| | | } |
| | | $this->limit = $limit; |
| | | if (!is_null($offset)) { |
| | | if (null !== $offset) { |
| | | $offset = (int)$offset; |
| | | if ($offset < 0) { |
| | | return $this->raiseError(MDB2_ERROR_SYNTAX, null, null, |
| | |
| | | /** |
| | | * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT |
| | | * query, except that if there is already a row in the table with the same |
| | | * key field values, the REPLACE query just updates its values instead of |
| | | * inserting a new row. |
| | | * key field values, the old row is deleted before the new row is inserted. |
| | | * |
| | | * The REPLACE type of query does not make part of the SQL standards. Since |
| | | * practically only MySQL and SQLite implement it natively, this type of |
| | |
| | | $colon = ':'; |
| | | $positions = array(); |
| | | $position = 0; |
| | | |
| | | while ($position < strlen($query)) { |
| | | $q_position = strpos($query, $question, $position); |
| | | $c_position = strpos($query, $colon, $position); |
| | |
| | | } else { |
| | | break; |
| | | } |
| | | if (is_null($placeholder_type)) { |
| | | if (null === $placeholder_type) { |
| | | $placeholder_type_guess = $query[$p_position]; |
| | | } |
| | | |
| | |
| | | } |
| | | |
| | | if ($query[$position] == $placeholder_type_guess) { |
| | | if (is_null($placeholder_type)) { |
| | | if (null === $placeholder_type) { |
| | | $placeholder_type = $query[$p_position]; |
| | | $question = $colon = $placeholder_type; |
| | | if (!empty($types) && is_array($types)) { |
| | |
| | | */ |
| | | function _skipDelimitedStrings($query, $position, $p_position) |
| | | { |
| | | $ignores[] = $this->string_quoting; |
| | | $ignores = $this->string_quoting; |
| | | $ignores[] = $this->identifier_quoting;
|
| | | $ignores = array_merge($ignores, $this->sql_comments); |
| | | |
| | |
| | | && $end_quote-1 != $start_quote |
| | | && $query[($end_quote - 1)] == $ignore['escape'] |
| | | && ($ignore['escape_pattern'] !== $ignore['escape'] |
| | | || $query[($end_quote - 2)] != $ignore['escape'])); |
| | | || $query[($end_quote - 2)] != $ignore['escape']) |
| | | ); |
| | | |
| | | $position = $end_quote + 1; |
| | | return $position; |
| | | } |
| | |
| | | function getIndexName($idx) |
| | | { |
| | | return sprintf($this->options['idxname_format'], |
| | | preg_replace('/[^a-z0-9_\$]/i', '_', $idx)); |
| | | preg_replace('/[^a-z0-9_\-\$.]/i', '_', $idx)); |
| | | } |
| | | |
| | | // }}} |
| | |
| | | * the first row of the result set and then frees |
| | | * the result set. |
| | | * |
| | | * @param string the SELECT query statement to be executed. |
| | | * @param string optional argument that specifies the expected |
| | | * datatype of the result set field, so that an eventual conversion |
| | | * may be performed. The default datatype is text, meaning that no |
| | | * conversion is performed |
| | | * @param int the column number to fetch |
| | | * @param string $query the SELECT query statement to be executed. |
| | | * @param string $type optional argument that specifies the expected |
| | | * datatype of the result set field, so that an eventual |
| | | * conversion may be performed. The default datatype is |
| | | * text, meaning that no conversion is performed |
| | | * @param mixed $colnum the column number (or name) to fetch |
| | | * |
| | | * @return mixed MDB2_OK or field value on success, a MDB2 error on failure |
| | | * |
| | |
| | | * Execute the specified query, fetch the value from the first column of |
| | | * each row of the result set into an array and then frees the result set. |
| | | * |
| | | * @param string the SELECT query statement to be executed. |
| | | * @param string optional argument that specifies the expected |
| | | * datatype of the result set field, so that an eventual conversion |
| | | * may be performed. The default datatype is text, meaning that no |
| | | * conversion is performed |
| | | * @param int the row number to fetch |
| | | * @param string $query the SELECT query statement to be executed. |
| | | * @param string $type optional argument that specifies the expected |
| | | * datatype of the result set field, so that an eventual |
| | | * conversion may be performed. The default datatype is text, |
| | | * meaning that no conversion is performed |
| | | * @param mixed $colnum the column number (or name) to fetch |
| | | * |
| | | * @return mixed MDB2_OK or data array on success, a MDB2 error on failure |
| | | * |
| | | * @access public |
| | | */ |
| | | function queryCol($query, $type = null, $colnum = 0) |
| | |
| | | /** |
| | | * fetch single column from the next row from a result set |
| | | * |
| | | * @param int the column number to fetch |
| | | * @param int|string the column number (or name) to fetch |
| | | * @param int number of the row where the data can be found |
| | | * |
| | | * @return string data on success, a MDB2 error on failure |
| | | * |
| | | * @access public |
| | | */ |
| | | function fetchOne($colnum = 0, $rownum = null) |
| | |
| | | /** |
| | | * Fetch and return a column from the current row pointer position |
| | | * |
| | | * @param int the column number to fetch |
| | | * @param int|string the column number (or name) to fetch |
| | | * |
| | | * @return mixed data array on success, a MDB2 error on failure |
| | | * |
| | | * @access public |
| | | */ |
| | | function fetchCol($colnum = 0) |
| | |
| | | } |
| | | |
| | | $shift_array = $rekey ? false : null; |
| | | if (!is_null($shift_array)) { |
| | | if (null !== $shift_array) { |
| | | if (is_object($row)) { |
| | | $colnum = count(get_object_vars($row)); |
| | | } else { |
| | |
| | | $column = $column_names[$column]; |
| | | } |
| | | $this->values[$column] =& $value; |
| | | if (!is_null($type)) { |
| | | if (null !== $type) { |
| | | $this->types[$column] = $type; |
| | | } |
| | | return MDB2_OK; |
| | |
| | | 'Unable to bind to missing placeholder: '.$parameter, __FUNCTION__); |
| | | } |
| | | $this->values[$parameter] = $value; |
| | | if (!is_null($type)) { |
| | | if (null !== $type) { |
| | | $this->types[$parameter] = $type; |
| | | } |
| | | return MDB2_OK; |
| | |
| | | 'Unable to bind to missing placeholder: '.$parameter, __FUNCTION__); |
| | | } |
| | | $this->values[$parameter] =& $value; |
| | | if (!is_null($type)) { |
| | | if (null !== $type) { |
| | | $this->types[$parameter] = $type; |
| | | } |
| | | return MDB2_OK; |
| | |
| | | * Execute a prepared query statement. |
| | | * |
| | | * @param array specifies all necessary information |
| | | * for bindParam() the array elements must use keys corresponding to |
| | | * the number of the position of the parameter. |
| | | * for bindParam() the array elements must use keys corresponding |
| | | * to the number of the position of the parameter. |
| | | * @param mixed specifies which result class to use |
| | | * @param mixed specifies which class to wrap results in |
| | | * |
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure |
| | | * |
| | | * @return mixed MDB2_Result or integer (affected rows) on success, |
| | | * a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function &execute($values = null, $result_class = true, $result_wrap_class = false) |
| | | { |
| | | if (is_null($this->positions)) { |
| | | if (null === $this->positions) { |
| | | return $this->db->raiseError(MDB2_ERROR, null, null, |
| | | 'Prepared statement has already been freed', __FUNCTION__); |
| | | } |
| | |
| | | * @param mixed specifies which result class to use |
| | | * @param mixed specifies which class to wrap results in |
| | | * |
| | | * @return mixed MDB2_Result or integer on success, a MDB2 error on failure |
| | | * |
| | | * @return mixed MDB2_Result or integer (affected rows) on success, |
| | | * a MDB2 error on failure |
| | | * @access private |
| | | */ |
| | | function &_execute($result_class = true, $result_wrap_class = false) |
| | |
| | | */ |
| | | function free() |
| | | { |
| | | if (is_null($this->positions)) { |
| | | if (null === $this->positions) { |
| | | return $this->db->raiseError(MDB2_ERROR, null, null, |
| | | 'Prepared statement has already been freed', __FUNCTION__); |
| | | } |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: Date.php,v 1.10 2006/03/01 12:15:32 lsmith Exp $ |
| | | // $Id: Date.php 208329 2006-03-01 12:15:38Z lsmith $ |
| | | // |
| | | |
| | | /** |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: Common.php,v 1.137 2008/02/17 18:53:40 afz Exp $ |
| | | // $Id: Common.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | |
| | | require_once 'MDB2/LOB.php'; |
| | | |
| | |
| | | */ |
| | | function convertResult($value, $type, $rtrim = true) |
| | | { |
| | | if (is_null($value)) { |
| | | if (null === $value) { |
| | | return null; |
| | | } |
| | | $db =& $this->getDBInstance(); |
| | |
| | | if (count($types)) { |
| | | reset($types); |
| | | foreach (array_keys($sorted_types) as $k) { |
| | | if (is_null($sorted_types[$k])) { |
| | | if (null === $sorted_types[$k]) { |
| | | $sorted_types[$k] = current($types); |
| | | next($types); |
| | | } |
| | |
| | | $field['default'] = ' '; |
| | | } |
| | | } |
| | | if (!is_null($field['default'])) { |
| | | if (null !== $field['default']) { |
| | | $default = ' DEFAULT ' . $this->quote($field['default'], $field['type']); |
| | | } |
| | | } |
| | |
| | | return $db; |
| | | } |
| | | |
| | | if (is_null($value) |
| | | if ((null === $value) |
| | | || ($value === '' && $db->options['portability'] & MDB2_PORTABILITY_EMPTY_TO_NULL) |
| | | ) { |
| | | if (!$quote) { |
| | |
| | | return 'NULL'; |
| | | } |
| | | |
| | | if (is_null($type)) { |
| | | if (null === $type) { |
| | | switch (gettype($value)) { |
| | | case 'integer': |
| | | $type = 'integer'; |
| | |
| | | */ |
| | | function _quoteLOB($value, $quote, $escape_wildcards) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | if ($db->options['lob_allow_url_include']) { |
| | | $value = $this->_readFile($value); |
| | | if (PEAR::isError($value)) { |
| | | return $value; |
| | | } |
| | | } |
| | | return $this->_quoteText($value, $quote, $escape_wildcards); |
| | | } |
| | |
| | | */ |
| | | function _retrieveLOB(&$lob) |
| | | { |
| | | if (is_null($lob['value'])) { |
| | | if (null === $lob['value']) { |
| | | $lob['value'] = $lob['resource']; |
| | | } |
| | | $lob['loaded'] = true; |
| | |
| | | } |
| | | |
| | | $match = ''; |
| | | if (!is_null($operator)) { |
| | | if (null !== $operator) { |
| | | $operator = strtoupper($operator); |
| | | switch ($operator) { |
| | | // case insensitive |
| | | case 'ILIKE': |
| | | if (is_null($field)) { |
| | | if (null === $field) { |
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'case insensitive LIKE matching requires passing the field name', __FUNCTION__); |
| | | } |
| | | $db->loadModule('Function', null, true); |
| | | $match = $db->function->lower($field).' LIKE '; |
| | | break; |
| | | case 'NOT ILIKE': |
| | | if (null === $field) { |
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'case insensitive NOT ILIKE matching requires passing the field name', __FUNCTION__); |
| | | } |
| | | $db->loadModule('Function', null, true); |
| | | $match = $db->function->lower($field).' NOT LIKE '; |
| | | break; |
| | | // case sensitive |
| | | case 'LIKE': |
| | | $match = is_null($field) ? 'LIKE ' : $field.' LIKE '; |
| | | $match = (null === $field) ? 'LIKE ' : ($field.' LIKE '); |
| | | break; |
| | | case 'NOT LIKE': |
| | | $match = (null === $field) ? 'NOT LIKE ' : ($field.' NOT LIKE '); |
| | | break; |
| | | default: |
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | |
| | | if ($key % 2) { |
| | | $match.= $value; |
| | | } else { |
| | | if ($operator === 'ILIKE') { |
| | | $value = strtolower($value); |
| | | } |
| | | $escaped = $db->escape($value); |
| | | if (PEAR::isError($escaped)) { |
| | | return $escaped; |
| | |
| | | // | Daniel Convissor <danielc@php.net> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mssql.php,v 1.65 2008/02/19 14:54:17 afz Exp $ |
| | | // $Id: mssql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Datatype/Common.php'; |
| | |
| | | */ |
| | | function _baseConvertResult($value, $type, $rtrim = true) |
| | | { |
| | | if (is_null($value)) { |
| | | if (null === $value) { |
| | | return null; |
| | | } |
| | | switch ($type) { |
| | |
| | | if ($field['default'] === '') { |
| | | $field['default'] = 0; |
| | | } |
| | | if (is_null($field['default'])) { |
| | | if (null === $field['default']) { |
| | | $default = ' DEFAULT (null)'; |
| | | } else { |
| | | $default = ' DEFAULT (' . $this->quote($field['default'], 'integer') . ')'; |
| | |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ matchPattern() |
| | | |
| | | /** |
| | | * build a pattern matching string |
| | | * |
| | | * @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 |
| | | */ |
| | | function matchPattern($pattern, $operator = null, $field = null) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $match = ''; |
| | | if (null !== $operator) { |
| | | $field = (null === $field) ? '' : $field.' '; |
| | | $operator = strtoupper($operator); |
| | | switch ($operator) { |
| | | // case insensitive |
| | | case 'ILIKE': |
| | | $match = $field.'LIKE '; |
| | | break; |
| | | case 'NOT ILIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | // case sensitive |
| | | case 'LIKE': |
| | | $match = $field.'LIKE '; |
| | | break; |
| | | case 'NOT LIKE': |
| | | $match = $field.'NOT 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; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _mapNativeDatatype() |
| | | |
| | | /** |
| | |
| | | $type[0] = 'integer'; |
| | | $length = 8; |
| | | break; |
| | | case 'smalldatetime': |
| | | case 'datetime': |
| | | $type[0] = 'timestamp'; |
| | | break; |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysql.php,v 1.65 2008/02/22 19:23:49 quipo Exp $
|
| | | // $Id: mysql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Datatype/Common.php';
|
| | |
| | | }
|
| | |
|
| | | $match = '';
|
| | | if (!is_null($operator)) {
|
| | | $field = is_null($field) ? '' : $field.' ';
|
| | | if (null !== $operator) { |
| | | $field = (null === $field) ? '' : $field.' '; |
| | | $operator = strtoupper($operator);
|
| | | switch ($operator) {
|
| | | // case insensitive
|
| | | case 'ILIKE':
|
| | | $match = $field.'LIKE ';
|
| | | break;
|
| | | case 'NOT ILIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | // case sensitive
|
| | | case 'LIKE':
|
| | | $match = $field.'LIKE BINARY ';
|
| | | break;
|
| | | case 'NOT LIKE': |
| | | $match = $field.'NOT LIKE BINARY '; |
| | | break; |
| | | default:
|
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'not a supported operator type:'. $operator, __FUNCTION__);
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysqli.php,v 1.63 2008/02/22 19:23:49 quipo Exp $
|
| | | // $Id: mysqli.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Datatype/Common.php';
|
| | |
| | | }
|
| | |
|
| | | $match = '';
|
| | | if (!is_null($operator)) {
|
| | | $field = is_null($field) ? '' : $field.' ';
|
| | | if (null !== $operator) { |
| | | $field = (null === $field) ? '' : $field.' '; |
| | | $operator = strtoupper($operator);
|
| | | switch ($operator) {
|
| | | // case insensitive
|
| | | case 'ILIKE':
|
| | | $match = $field.'LIKE ';
|
| | | break;
|
| | | case 'NOT ILIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | // case sensitive
|
| | | case 'LIKE':
|
| | | $match = $field.'LIKE BINARY ';
|
| | | break;
|
| | | case 'NOT LIKE': |
| | | $match = $field.'NOT LIKE BINARY '; |
| | | break; |
| | | default:
|
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'not a supported operator type:'. $operator, __FUNCTION__);
|
| | |
| | | // | Author: Paul Cooper <pgc@ucecom.com> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: pgsql.php,v 1.91 2008/03/09 12:28:08 quipo Exp $
|
| | | // $Id: pgsql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | |
|
| | | require_once 'MDB2/Driver/Datatype/Common.php';
|
| | |
|
| | |
| | | */
|
| | | function _baseConvertResult($value, $type, $rtrim = true)
|
| | | {
|
| | | if (is_null($value)) {
|
| | | if (null === $value) { |
| | | return null;
|
| | | }
|
| | | switch ($type) {
|
| | |
| | |
|
| | | switch ($field['type']) {
|
| | | case 'text':
|
| | | $length = !empty($field['length'])
|
| | | ? $field['length'] : $db->options['default_text_field_length'];
|
| | | $length = !empty($field['length']) ? $field['length'] : false; |
| | | $fixed = !empty($field['fixed']) ? $field['fixed'] : false;
|
| | | return $fixed ? ($length ? 'CHAR('.$length.')' : 'CHAR('.$db->options['default_text_field_length'].')')
|
| | | : ($length ? 'VARCHAR('.$length.')' : 'TEXT');
|
| | |
| | | */
|
| | | function _quoteCLOB($value, $quote, $escape_wildcards)
|
| | | {
|
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | if ($db->options['lob_allow_url_include']) { |
| | | $value = $this->_readFile($value); |
| | | if (PEAR::isError($value)) { |
| | | return $value; |
| | | } |
| | | } |
| | | return $this->_quoteText($value, $quote, $escape_wildcards);
|
| | | }
|
| | |
|
| | |
| | | if (!$quote) {
|
| | | return $value;
|
| | | }
|
| | | if (version_compare(PHP_VERSION, '5.2.0RC6', '>=')) {
|
| | | $db =& $this->getDBInstance();
|
| | | if (PEAR::isError($db)) {
|
| | | return $db;
|
| | | }
|
| | | if ($db->options['lob_allow_url_include']) { |
| | | $value = $this->_readFile($value); |
| | | if (PEAR::isError($value)) { |
| | | return $value; |
| | | } |
| | | } |
| | | if (version_compare(PHP_VERSION, '5.2.0RC6', '>=')) { |
| | | $connection = $db->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | }
|
| | |
|
| | | $match = '';
|
| | | if (!is_null($operator)) {
|
| | | $field = is_null($field) ? '' : $field.' ';
|
| | | if (null !== $operator) { |
| | | $field = (null === $field) ? '' : $field.' '; |
| | | $operator = strtoupper($operator);
|
| | | switch ($operator) {
|
| | | // case insensitive
|
| | | case 'ILIKE':
|
| | | $match = $field.'ILIKE ';
|
| | | break;
|
| | | case 'NOT ILIKE': |
| | | $match = $field.'NOT ILIKE '; |
| | | break; |
| | | // case sensitive
|
| | | case 'LIKE':
|
| | | $match = $field.'LIKE ';
|
| | | break;
|
| | | case 'NOT LIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | default:
|
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'not a supported operator type:'. $operator, __FUNCTION__);
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: sqlite.php,v 1.67 2008/02/22 19:58:06 quipo Exp $
|
| | | // $Id: sqlite.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Datatype/Common.php';
|
| | |
| | | }
|
| | |
|
| | | $match = '';
|
| | | if (!is_null($operator)) {
|
| | | $field = is_null($field) ? '' : $field.' ';
|
| | | if (null !== $operator) { |
| | | $field = (null === $field) ? '' : $field.' '; |
| | | $operator = strtoupper($operator);
|
| | | switch ($operator) {
|
| | | // case insensitive
|
| | | case 'ILIKE':
|
| | | $match = $field.'LIKE ';
|
| | | break;
|
| | | case 'NOT ILIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | // case sensitive
|
| | | case 'LIKE':
|
| | | $match = $field.'LIKE ';
|
| | | break;
|
| | | case 'NOT LIKE': |
| | | $match = $field.'NOT LIKE '; |
| | | break; |
| | | default:
|
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'not a supported operator type:'. $operator, __FUNCTION__);
|
New file |
| | |
| | | <?php |
| | | // vim: set et ts=4 sw=4 fdm=marker: |
| | | // +----------------------------------------------------------------------+ |
| | | // | PHP versions 4 and 5 | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Copyright (c) 1998-2007 Manuel Lemos, Tomas V.V.Cox, | |
| | | // | Stig. S. Bakken, Lukas Smith | |
| | | // | All rights reserved. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB | |
| | | // | API as well as database abstraction for PHP applications. | |
| | | // | This LICENSE is in the BSD license style. | |
| | | // | | |
| | | // | Redistribution and use in source and binary forms, with or without | |
| | | // | modification, are permitted provided that the following conditions | |
| | | // | are met: | |
| | | // | | |
| | | // | Redistributions of source code must retain the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer. | |
| | | // | | |
| | | // | Redistributions in binary form must reproduce the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer in the | |
| | | // | documentation and/or other materials provided with the distribution. | |
| | | // | | |
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, | |
| | | // | Lukas Smith nor the names of his contributors may be used to endorse | |
| | | // | or promote products derived from this software without specific prior| |
| | | // | written permission. | |
| | | // | | |
| | | // | 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 | |
| | | // | REGENTS 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. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Authors: Lukas Smith <smith@pooteeweet.org> | |
| | | // | Daniel Convissor <danielc@php.net> | |
| | | // +----------------------------------------------------------------------+ |
| | | |
| | | require_once 'MDB2/Driver/Datatype/Common.php'; |
| | | |
| | | /** |
| | | * MDB2 MS SQL driver |
| | | * |
| | | * @package MDB2 |
| | | * @category Database |
| | | */ |
| | | class MDB2_Driver_Datatype_sqlsrv extends MDB2_Driver_Datatype_Common |
| | | { |
| | | // {{{ _baseConvertResult() |
| | | |
| | | /** |
| | | * general type conversion method |
| | | * |
| | | * @param mixed $value refernce to a value to be converted |
| | | * @param string $type specifies which type to convert to |
| | | * @param boolean $rtrim [optional] when TRUE [default], apply rtrim() to text |
| | | * @return object a MDB2 error on failure |
| | | * @access protected |
| | | */ |
| | | function _baseConvertResult($value, $type, $rtrim = true) |
| | | { |
| | | if (null === $value) { |
| | | return null; |
| | | } |
| | | switch ($type) { |
| | | case 'boolean': |
| | | return $value == '1'; |
| | | case 'date': |
| | | if (strlen($value) > 10) { |
| | | $value = substr($value,0,10); |
| | | } |
| | | return $value; |
| | | case 'time': |
| | | if (strlen($value) > 8) { |
| | | $value = substr($value,11,8); |
| | | } |
| | | return $value; |
| | | } |
| | | return parent::_baseConvertResult($value, $type, $rtrim); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getCollationFieldDeclaration() |
| | | |
| | | /** |
| | | * Obtain DBMS specific SQL code portion needed to set the COLLATION |
| | | * of a field declaration to be used in statements like CREATE TABLE. |
| | | * |
| | | * @param string $collation name of the collation |
| | | * |
| | | * @return string DBMS specific SQL code portion needed to set the COLLATION |
| | | * of a field declaration. |
| | | */ |
| | | function _getCollationFieldDeclaration($collation) |
| | | { |
| | | return 'COLLATE '.$collation; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ getTypeDeclaration() |
| | | |
| | | /** |
| | | * Obtain DBMS specific SQL code portion needed to declare an text type |
| | | * field to be used in statements like CREATE TABLE. |
| | | * |
| | | * @param array $field associative array with the name of the properties |
| | | * of the field being declared as array indexes. Currently, the types |
| | | * of supported field properties are as follows: |
| | | * |
| | | * length |
| | | * Integer value that determines the maximum length of the text |
| | | * field. If this argument is missing the field should be |
| | | * declared to have the longest length allowed by the DBMS. |
| | | * |
| | | * default |
| | | * Text value to be used as default for this field. |
| | | * |
| | | * notnull |
| | | * Boolean flag that indicates whether this field is constrained |
| | | * to not be set to null. |
| | | * @return string DBMS specific SQL code portion that should be used to |
| | | * declare the specified field. |
| | | * @access public |
| | | */ |
| | | function getTypeDeclaration($field) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | switch ($field['type']) { |
| | | case 'text': |
| | | $length = !empty($field['length']) |
| | | ? $field['length'] : false; |
| | | $fixed = !empty($field['fixed']) ? $field['fixed'] : false; |
| | | return $fixed ? ($length ? 'CHAR('.$length.')' : 'CHAR('.$db->options['default_text_field_length'].')') |
| | | : ($length ? 'VARCHAR('.$length.')' : 'VARCHAR(MAX)'); |
| | | case 'clob': |
| | | if (!empty($field['length'])) { |
| | | $length = $field['length']; |
| | | if ($length <= 8000) { |
| | | return 'VARCHAR('.$length.')'; |
| | | } |
| | | } |
| | | return 'VARCHAR(MAX)'; |
| | | case 'blob': |
| | | if (!empty($field['length'])) { |
| | | $length = $field['length']; |
| | | if ($length <= 8000) { |
| | | return "VARBINARY($length)"; |
| | | } |
| | | } |
| | | return 'IMAGE'; |
| | | case 'integer': |
| | | return 'INT'; |
| | | case 'boolean': |
| | | return 'BIT'; |
| | | case 'date': |
| | | return 'CHAR ('.strlen('YYYY-MM-DD').')'; |
| | | case 'time': |
| | | return 'CHAR ('.strlen('HH:MM:SS').')'; |
| | | case 'timestamp': |
| | | return 'CHAR ('.strlen('YYYY-MM-DD HH:MM:SS').')'; |
| | | case 'float': |
| | | return 'FLOAT'; |
| | | case 'decimal': |
| | | $length = !empty($field['length']) ? $field['length'] : 18; |
| | | $scale = !empty($field['scale']) ? $field['scale'] : $db->options['decimal_places']; |
| | | return 'DECIMAL('.$length.','.$scale.')'; |
| | | } |
| | | return ''; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getIntegerDeclaration() |
| | | |
| | | /** |
| | | * Obtain DBMS specific SQL code portion needed to declare an integer type |
| | | * field to be used in statements like CREATE TABLE. |
| | | * |
| | | * @param string $name name the field to be declared. |
| | | * @param string $field associative array with the name of the properties |
| | | * of the field being declared as array indexes. |
| | | * Currently, the types of supported field |
| | | * properties are as follows: |
| | | * |
| | | * unsigned |
| | | * Boolean flag that indicates whether the field |
| | | * should be declared as unsigned integer if |
| | | * possible. |
| | | * |
| | | * default |
| | | * Integer value to be used as default for this |
| | | * field. |
| | | * |
| | | * notnull |
| | | * Boolean flag that indicates whether this field is |
| | | * constrained to not be set to null. |
| | | * @return string DBMS specific SQL code portion that should be used to |
| | | * declare the specified field. |
| | | * @access protected |
| | | */ |
| | | function _getIntegerDeclaration($name, $field) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $notnull = empty($field['notnull']) ? ' NULL' : ' NOT NULL'; |
| | | $default = $autoinc = ''; |
| | | if (!empty($field['autoincrement'])) { |
| | | $autoinc = ' IDENTITY PRIMARY KEY'; |
| | | } elseif (array_key_exists('default', $field)) { |
| | | if ($field['default'] === '') { |
| | | $field['default'] = 0; |
| | | } |
| | | if (null === $field['default']) { |
| | | $default = ' DEFAULT (NULL)'; |
| | | } else { |
| | | $default = ' DEFAULT (' . $this->quote($field['default'], 'integer') . ')'; |
| | | } |
| | | } |
| | | |
| | | if (!empty($field['unsigned'])) { |
| | | $db->warnings[] = "unsigned integer field \"$name\" is being declared as signed integer"; |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $name.' '.$this->getTypeDeclaration($field).$notnull.$default.$autoinc; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getCLOBDeclaration() |
| | | |
| | | /** |
| | | * Obtain DBMS specific SQL code portion needed to declare an character |
| | | * large object type field to be used in statements like CREATE TABLE. |
| | | * |
| | | * @param string $name name the field to be declared. |
| | | * @param array $field associative array with the name of the properties |
| | | * of the field being declared as array indexes. Currently, the types |
| | | * of supported field properties are as follows: |
| | | * |
| | | * length |
| | | * Integer value that determines the maximum length of the large |
| | | * object field. If this argument is missing the field should be |
| | | * declared to have the longest length allowed by the DBMS. |
| | | * |
| | | * notnull |
| | | * Boolean flag that indicates whether this field is constrained |
| | | * to not be set to null. |
| | | * @return string DBMS specific SQL code portion that should be used to |
| | | * declare the specified field. |
| | | * @access public |
| | | */ |
| | | function _getCLOBDeclaration($name, $field) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $notnull = empty($field['notnull']) ? ' NULL' : ' NOT NULL'; |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $name.' '.$this->getTypeDeclaration($field).$notnull; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getBLOBDeclaration() |
| | | |
| | | /** |
| | | * Obtain DBMS specific SQL code portion needed to declare an binary large |
| | | * object type field to be used in statements like CREATE TABLE. |
| | | * |
| | | * @param string $name name the field to be declared. |
| | | * @param array $field associative array with the name of the properties |
| | | * of the field being declared as array indexes. Currently, the types |
| | | * of supported field properties are as follows: |
| | | * |
| | | * length |
| | | * Integer value that determines the maximum length of the large |
| | | * object field. If this argument is missing the field should be |
| | | * declared to have the longest length allowed by the DBMS. |
| | | * |
| | | * notnull |
| | | * Boolean flag that indicates whether this field is constrained |
| | | * to not be set to null. |
| | | * @return string DBMS specific SQL code portion that should be used to |
| | | * declare the specified field. |
| | | * @access protected |
| | | */ |
| | | function _getBLOBDeclaration($name, $field) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $notnull = empty($field['notnull']) ? ' NULL' : ' NOT NULL'; |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $name.' '.$this->getTypeDeclaration($field).$notnull; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _quoteBLOB() |
| | | |
| | | /** |
| | | * Convert a text value into a DBMS specific format that is suitable to |
| | | * compose query statements. |
| | | * |
| | | * @param string $value text string value that is intended to be converted. |
| | | * @param bool $quote determines if the value should be quoted and escaped |
| | | * @param bool $escape_wildcards if to escape escape wildcards |
| | | * @return string text string that represents the given argument value in |
| | | * a DBMS specific format. |
| | | * @access protected |
| | | */ |
| | | function _quoteBLOB($value, $quote, $escape_wildcards) |
| | | { |
| | | if (!$quote) { |
| | | return $value; |
| | | } |
| | | $value = '0x'.bin2hex($this->_readFile($value)); |
| | | return $value; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _mapNativeDatatype() |
| | | |
| | | /** |
| | | * Maps a native array description of a field to a MDB2 datatype and length |
| | | * |
| | | * @param array $field native field description |
| | | * @return array containing the various possible types, length, sign, fixed |
| | | * @access public |
| | | */ |
| | | function _mapNativeDatatype($field) |
| | | { |
| | | // todo: handle length of various int variations |
| | | $db_type = $field['type']; |
| | | $length = $field['length']; |
| | | $type = array(); |
| | | // todo: unsigned handling seems to be missing |
| | | $unsigned = $fixed = null; |
| | | switch ($db_type) { |
| | | case 'bit': |
| | | case SQLSRV_SQLTYPE_BIT: |
| | | $type[0] = 'boolean'; |
| | | break; |
| | | case 'tinyint': |
| | | case SQLSRV_SQLTYPE_TINYINT: |
| | | $type[0] = 'integer'; |
| | | $length = 1; |
| | | break; |
| | | case 'smallint': |
| | | case SQLSRV_SQLTYPE_SMALLINT: |
| | | $type[0] = 'integer'; |
| | | $length = 2; |
| | | break; |
| | | case 'int': |
| | | case SQLSRV_SQLTYPE_INT: |
| | | $type[0] = 'integer'; |
| | | $length = 4; |
| | | break; |
| | | case 'bigint': |
| | | case SQLSRV_SQLTYPE_BIGINT: |
| | | $type[0] = 'integer'; |
| | | $length = 8; |
| | | break; |
| | | case 'datetime': |
| | | case SQLSRV_SQLTYPE_DATETIME: |
| | | $type[0] = 'timestamp'; |
| | | break; |
| | | case 'float': |
| | | case SQLSRV_SQLTYPE_FLOAT: |
| | | case 'real': |
| | | case SQLSRV_SQLTYPE_REAL: |
| | | $type[0] = 'float'; |
| | | break; |
| | | case 'numeric': |
| | | case SQLSRV_SQLTYPE_NUMERIC: |
| | | case 'decimal': |
| | | case SQLSRV_SQLTYPE_DECIMAL: |
| | | case 'money': |
| | | case SQLSRV_SQLTYPE_MONEY: |
| | | $type[0] = 'decimal'; |
| | | $length = $field['numeric_precision'].','.$field['numeric_scale']; |
| | | break; |
| | | case 'text': |
| | | case SQLSRV_SQLTYPE_TEXT: |
| | | case 'ntext': |
| | | case SQLSRV_SQLTYPE_NTEXT: |
| | | case 'varchar': |
| | | case SQLSRV_SQLTYPE_VARCHAR: |
| | | case 'nvarchar': |
| | | case SQLSRV_SQLTYPE_NVARCHAR: |
| | | $fixed = false; |
| | | case 'char': |
| | | case SQLSRV_SQLTYPE_CHAR: |
| | | case 'nchar': |
| | | case SQLSRV_SQLTYPE_NCHAR: |
| | | $type[0] = 'text'; |
| | | if ($length == '1') { |
| | | $type[] = 'boolean'; |
| | | if (preg_match('/^(is|has)/', $field['name'])) { |
| | | $type = array_reverse($type); |
| | | } |
| | | } elseif (strstr($db_type, 'text') || strstr($db_type, SQLSRV_SQLTYPE_TEXT)) { |
| | | $type[] = 'clob'; |
| | | $type = array_reverse($type); |
| | | } |
| | | if ($fixed !== false) { |
| | | $fixed = true; |
| | | } |
| | | break; |
| | | case 'image': |
| | | case SQLSRV_SQLTYPE_IMAGE: |
| | | case 'varbinary': |
| | | case SQLSRV_SQLTYPE_VARBINARY: |
| | | $type[] = 'blob'; |
| | | $length = null; |
| | | break; |
| | | default: |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'unknown database attribute type: '.$db_type, __FUNCTION__); |
| | | } |
| | | |
| | | if ((int)$length <= 0) { |
| | | $length = null; |
| | | } |
| | | |
| | | return array($type, $length, $unsigned, $fixed); |
| | | } |
| | | // }}} |
| | | } |
| | | |
| | | ?> |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: Common.php,v 1.21 2008/02/17 18:51:39 quipo Exp $
|
| | | // $Id: Common.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | /**
|
| | |
| | | */
|
| | | function substring($value, $position = 1, $length = null)
|
| | | {
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | return "SUBSTRING($value FROM $position FOR $length)";
|
| | | }
|
| | | return "SUBSTRING($value FROM $position)";
|
| | |
| | | // | Author: Frank M. Kromann <frank@kromann.info> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mssql.php,v 1.16 2008/02/17 18:54:08 quipo Exp $
|
| | | // $Id: mssql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Function/Common.php';
|
| | |
| | | */
|
| | | function substring($value, $position = 1, $length = null)
|
| | | {
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | return "SUBSTRING($value, $position, $length)";
|
| | | }
|
| | | return "SUBSTRING($value, $position, LEN($value) - $position + 1)";
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysql.php,v 1.12 2008/02/17 18:54:08 quipo Exp $
|
| | | // $Id: mysql.php 253106 2008-02-17 18:54:08Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Function/Common.php';
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysqli.php,v 1.14 2008/02/17 18:54:08 quipo Exp $
|
| | | // $Id: mysqli.php 253106 2008-02-17 18:54:08Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Function/Common.php';
|
| | |
| | | // | Author: Paul Cooper <pgc@ucecom.com> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: pgsql.php,v 1.10 2008/02/17 18:54:08 quipo Exp $
|
| | | // $Id: pgsql.php 268669 2008-11-09 19:46:50Z quipo $ |
| | |
|
| | | require_once 'MDB2/Driver/Function/Common.php';
|
| | |
|
| | |
| | | */
|
| | | function unixtimestamp($expression)
|
| | | {
|
| | | return 'EXTRACT(EPOCH FROM DATE_TRUNC(\'seconds\', TIMESTAMP '. $expression.'))';
|
| | | return 'EXTRACT(EPOCH FROM DATE_TRUNC(\'seconds\', CAST ((' . $expression . ') AS TIMESTAMP)))'; |
| | | }
|
| | |
|
| | | // }}}
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: sqlite.php,v 1.10 2008/02/17 18:54:08 quipo Exp $
|
| | | // $Id: sqlite.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Function/Common.php';
|
| | |
| | | */
|
| | | function substring($value, $position = 1, $length = null)
|
| | | {
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | return "substr($value,$position,$length)";
|
| | | }
|
| | | return "substr($value,$position,length($value))";
|
New file |
| | |
| | | <?php |
| | | // +----------------------------------------------------------------------+ |
| | | // | PHP versions 4 and 5 | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Copyright (c) 1998-2008 Manuel Lemos, Tomas V.V.Cox, | |
| | | // | Stig. S. Bakken, Lukas Smith | |
| | | // | All rights reserved. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB | |
| | | // | API as well as database abstraction for PHP applications. | |
| | | // | This LICENSE is in the BSD license style. | |
| | | // | | |
| | | // | Redistribution and use in source and binary forms, with or without | |
| | | // | modification, are permitted provided that the following conditions | |
| | | // | are met: | |
| | | // | | |
| | | // | Redistributions of source code must retain the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer. | |
| | | // | | |
| | | // | Redistributions in binary form must reproduce the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer in the | |
| | | // | documentation and/or other materials provided with the distribution. | |
| | | // | | |
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, | |
| | | // | Lukas Smith nor the names of his contributors may be used to endorse | |
| | | // | or promote products derived from this software without specific prior| |
| | | // | written permission. | |
| | | // | | |
| | | // | 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 | |
| | | // | REGENTS 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. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Author: Frank M. Kromann <frank@kromann.info> | |
| | | // +----------------------------------------------------------------------+ |
| | | |
| | | require_once 'MDB2/Driver/Function/Common.php'; |
| | | |
| | | // {{{ class MDB2_Driver_Function_sqlsrv |
| | | /** |
| | | * MDB2 MSSQL driver for the function modules |
| | | * |
| | | * @package MDB2 |
| | | * @category Database |
| | | */ |
| | | class MDB2_Driver_Function_sqlsrv extends MDB2_Driver_Function_Common |
| | | { |
| | | // {{{ executeStoredProc() |
| | | |
| | | /** |
| | | * Execute a stored procedure and return any results |
| | | * |
| | | * @param string $name string that identifies the function to execute |
| | | * @param mixed $params array that contains the paramaters to pass the stored proc |
| | | * @param mixed $types array that contains the types of the columns in |
| | | * the result set |
| | | * @param mixed $result_class string which specifies which result class to use |
| | | * @param mixed $result_wrap_class string which specifies which class to wrap results in |
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function &executeStoredProc($name, $params = null, $types = null, $result_class = true, $result_wrap_class = false) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = 'EXECUTE '.$name; |
| | | $query .= $params ? ' '.implode(', ', $params) : ''; |
| | | return $db->query($query, $types, $result_class, $result_wrap_class); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ now() |
| | | |
| | | /** |
| | | * Return string to call a variable with the current timestamp inside an SQL statement |
| | | * There are three special variables for current date and time: |
| | | * - CURRENT_TIMESTAMP (date and time, TIMESTAMP type) |
| | | * - CURRENT_DATE (date, DATE type) |
| | | * - CURRENT_TIME (time, TIME type) |
| | | * |
| | | * @return string to call a variable with the current timestamp |
| | | * @access public |
| | | */ |
| | | function now($type = 'timestamp') |
| | | { |
| | | switch ($type) { |
| | | case 'time': |
| | | case 'date': |
| | | case 'timestamp': |
| | | default: |
| | | return 'GETDATE()'; |
| | | } |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ unixtimestamp() |
| | | |
| | | /** |
| | | * return string to call a function to get the unix timestamp from a iso timestamp |
| | | * |
| | | * @param string $expression |
| | | * |
| | | * @return string to call a variable with the timestamp |
| | | * @access public |
| | | */ |
| | | function unixtimestamp($expression) |
| | | { |
| | | return 'DATEDIFF(second, \'19700101\', '. $expression.') + DATEDIFF(second, GETDATE(), GETUTCDATE())'; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ substring() |
| | | |
| | | /** |
| | | * return string to call a function to get a substring inside an SQL statement |
| | | * |
| | | * @return string to call a function to get a substring |
| | | * @access public |
| | | */ |
| | | function substring($value, $position = 1, $length = null) |
| | | { |
| | | if (null !== $length) { |
| | | return "SUBSTRING($value, $position, $length)"; |
| | | } |
| | | return "SUBSTRING($value, $position, LEN($value) - $position + 1)"; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ concat() |
| | | |
| | | /** |
| | | * Returns string to concatenate two or more string parameters |
| | | * |
| | | * @param string $value1 |
| | | * @param string $value2 |
| | | * @param string $values... |
| | | * @return string to concatenate two strings |
| | | * @access public |
| | | **/ |
| | | function concat($value1, $value2) |
| | | { |
| | | $args = func_get_args(); |
| | | return "(".implode(' + ', $args).")"; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ length() |
| | | |
| | | /** |
| | | * return string to call a function to get the length of a string expression |
| | | * |
| | | * @param string $expression |
| | | * @return return string to get the string expression length |
| | | * @access public |
| | | */ |
| | | function length($expression) |
| | | { |
| | | return "LEN($expression)"; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ guid() |
| | | |
| | | /** |
| | | * Returns global unique identifier |
| | | * |
| | | * @return string to get global unique identifier |
| | | * @access public |
| | | */ |
| | | function guid() |
| | | { |
| | | return 'NEWID()'; |
| | | } |
| | | |
| | | // }}} |
| | | } |
| | | // }}} |
| | | ?> |
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: Common.php,v 1.71 2008/02/12 23:12:27 quipo Exp $
|
| | | // $Id: Common.php 273526 2009-01-14 15:01:21Z quipo $ |
| | | //
|
| | |
|
| | | /**
|
| | |
| | |
|
| | | /**
|
| | | * Split the "[owner|schema].table" notation into an array
|
| | | * |
| | | * @param string $table [schema and] table name |
| | | * |
| | | * @return array array(schema, table) |
| | | * @access private
|
| | | */
|
| | | function splitTableSchema($table)
|
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mssql.php,v 1.109 2008/03/05 12:55:57 afz Exp $ |
| | | // $Id: mssql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Manager/Common.php'; |
| | |
| | | return $db; |
| | | } |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $table = $db->quote($table, 'text'); |
| | | $columns = $db->queryCol("SELECT c.name |
| | | FROM syscolumns c |
| | | LEFT JOIN sysobjects o ON c.id = o.id |
| | | WHERE o.name = '$table'"); |
| | | WHERE o.name = $table"); |
| | | if (PEAR::isError($columns)) { |
| | | return $columns; |
| | | } |
| | |
| | | FROM sysobjects o |
| | | WHERE xtype = 'TR' |
| | | AND OBJECTPROPERTY(o.id, 'IsMSShipped') = 0"; |
| | | if (!is_null($table)) { |
| | | if (null !== $table) { |
| | | $query .= " AND object_name(parent_obj) = $table"; |
| | | } |
| | | |
| | |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $table = $db->quote($table, 'text'); |
| | | |
| | | $query = "SELECT c.constraint_name |
| | | FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS c |
| | | WHERE c.constraint_catalog = DB_NAME() |
| | | AND c.table_name = '$table'"; |
| | | AND c.table_name = $table"; |
| | | $constraints = $db->queryCol($query); |
| | | if (PEAR::isError($constraints)) { |
| | | return $constraints; |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysql.php,v 1.108 2008/03/11 19:58:12 quipo Exp $
|
| | | // $Id: mysql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Manager/Common.php';
|
| | |
| | | $autoincrement = $fieldname;
|
| | | }
|
| | | }
|
| | | if (!is_null($autoincrement) && count($pk_fields) > 1) {
|
| | | if ((null !== $autoincrement) && count($pk_fields) > 1) { |
| | | $options['primary'] = $pk_fields;
|
| | | } else {
|
| | | // the PK constraint is on max one field => OK
|
| | |
| | | return $query;
|
| | | }
|
| | |
|
| | | if (!is_null($autoincrement)) {
|
| | | if (null !== $autoincrement) { |
| | | // we have to remove the PK clause added by _getIntegerDeclaration()
|
| | | $query = str_replace('AUTO_INCREMENT PRIMARY KEY', 'AUTO_INCREMENT', $query);
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | $query = 'SHOW TRIGGERS';
|
| | | if (!is_null($table)) {
|
| | | if (null !== $table) { |
| | | $table = $db->quote($table, 'text');
|
| | | $query .= " LIKE $table";
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | $query = "SHOW /*!50002 FULL*/ TABLES";
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query .= " FROM $database";
|
| | | }
|
| | | $query.= "/*!50002 WHERE Table_type = 'BASE TABLE'*/";
|
| | |
| | | }
|
| | |
|
| | | $query = 'SHOW FULL TABLES';
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query.= " FROM $database";
|
| | | }
|
| | | $query.= " WHERE Table_type = 'VIEW'";
|
| | |
| | | }
|
| | |
|
| | | $type = '';
|
| | | $name = $db->quoteIdentifier($db->getIndexName($name), true);
|
| | | $idx_name = $db->quoteIdentifier($db->getIndexName($name), true); |
| | | if (!empty($definition['primary'])) {
|
| | | $type = 'PRIMARY';
|
| | | $name = 'KEY';
|
| | | $idx_name = 'KEY'; |
| | | } elseif (!empty($definition['unique'])) {
|
| | | $type = 'UNIQUE';
|
| | | } elseif (!empty($definition['foreign'])) {
|
| | |
| | | }
|
| | |
|
| | | $table_quoted = $db->quoteIdentifier($table, true);
|
| | | $query = "ALTER TABLE $table_quoted ADD $type $name";
|
| | | $query = "ALTER TABLE $table_quoted ADD $type $idx_name"; |
| | | if (!empty($definition['foreign'])) {
|
| | | $query .= ' FOREIGN KEY';
|
| | | }
|
| | | $fields = array();
|
| | | foreach (array_keys($definition['fields']) as $field) {
|
| | | $fields[] = $db->quoteIdentifier($field, true);
|
| | | foreach ($definition['fields'] as $field => $fieldinfo) { |
| | | $quoted = $db->quoteIdentifier($field, true); |
| | | if (!empty($fieldinfo['length'])) { |
| | | $quoted .= '(' . $fieldinfo['length'] . ')'; |
| | | } |
| | | $fields[] = $quoted; |
| | | }
|
| | | $query .= ' ('. implode(', ', $fields) . ')';
|
| | | if (!empty($definition['foreign'])) {
|
| | |
| | | }
|
| | | $query .= ' ('. implode(', ', $referenced_fields) . ')';
|
| | | $query .= $this->_getAdvancedFKOptions($definition);
|
| | | |
| | | // add index on FK column(s) or we can't add a FK constraint |
| | | // @see http://forums.mysql.com/read.php?22,19755,226009 |
| | | $result = $this->createIndex($table, $name.'_fkidx', $definition); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | }
|
| | | $res = $db->exec($query);
|
| | | if (PEAR::isError($res)) {
|
| | |
| | | }
|
| | | // create triggers to enforce FOREIGN KEY constraints
|
| | | if ($db->supports('triggers') && !empty($foreign_keys)) {
|
| | | $table = $db->quoteIdentifier($table, true);
|
| | | $table_quoted = $db->quoteIdentifier($table, true); |
| | | foreach ($foreign_keys as $fkname => $fkdef) {
|
| | | if (empty($fkdef)) {
|
| | | continue;
|
| | | }
|
| | | //set actions to 'RESTRICT' if not set
|
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? 'RESTRICT' : strtoupper($fkdef['onupdate']);
|
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? 'RESTRICT' : strtoupper($fkdef['ondelete']);
|
| | | //set actions to default if not set |
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? $db->options['default_fk_action_onupdate'] : strtoupper($fkdef['onupdate']); |
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? $db->options['default_fk_action_ondelete'] : strtoupper($fkdef['ondelete']); |
| | |
|
| | | $trigger_names = array(
|
| | | 'insert' => $fkname.'_insert_trg',
|
| | |
| | | $restrict_action = ' IF (SELECT ';
|
| | | $aliased_fields = array();
|
| | | foreach ($table_fields as $field) {
|
| | | $aliased_fields[] = $table .'.'.$field .' AS '.$field;
|
| | | $aliased_fields[] = $table_quoted .'.'.$field .' AS '.$field; |
| | | }
|
| | | $restrict_action .= implode(',', $aliased_fields)
|
| | | .' FROM '.$table
|
| | | .' FROM '.$table_quoted |
| | | .' WHERE ';
|
| | | $conditions = array();
|
| | | $new_values = array();
|
| | |
| | | $new_values[] = $table_fields[$i] .' = NEW.'.$referenced_fields[$i];
|
| | | $null_values[] = $table_fields[$i] .' = NULL';
|
| | | }
|
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL'
|
| | | .' THEN CALL %s_ON_TABLE_'.$table.'_VIOLATES_FOREIGN_KEY_CONSTRAINT();'
|
| | | $conditions2 = array(); |
| | | if ('NO ACTION' != $fkdef['ondelete']) { |
| | | // There is no NEW row in on DELETE trigger |
| | | for ($i=0; $i<count($referenced_fields); $i++) { |
| | | $conditions2[] = 'NEW.'.$referenced_fields[$i] .' <> OLD.'.$referenced_fields[$i]; |
| | | } |
| | | } |
| | | |
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL'; |
| | | if (!empty($conditions2)) { |
| | | $restrict_action .= ' AND (' .implode(' OR ', $conditions2) .')'; |
| | | } |
| | | $restrict_action .= ' THEN CALL %s_ON_TABLE_'.$table.'_VIOLATES_FOREIGN_KEY_CONSTRAINT();' |
| | | .' END IF;';
|
| | |
|
| | | $cascade_action_update = 'UPDATE '.$table.' SET '.implode(', ', $new_values) .' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $cascade_action_delete = 'DELETE FROM '.$table.' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $setnull_action = 'UPDATE '.$table.' SET '.implode(', ', $null_values).' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $cascade_action_update = 'UPDATE '.$table_quoted.' SET '.implode(', ', $new_values) .' WHERE '.implode(' AND ', $conditions). ';'; |
| | | $cascade_action_delete = 'DELETE FROM '.$table_quoted.' WHERE '.implode(' AND ', $conditions). ';'; |
| | | $setnull_action = 'UPDATE '.$table_quoted.' SET '.implode(', ', $null_values).' WHERE '.implode(' AND ', $conditions). ';'; |
| | |
|
| | | if ('SET DEFAULT' == $fkdef['onupdate'] || 'SET DEFAULT' == $fkdef['ondelete']) {
|
| | | $db->loadModule('Reverse', null, true);
|
| | |
| | | }
|
| | | $default_values[] = $table_field .' = '. $field_definition[0]['default'];
|
| | | }
|
| | | $setdefault_action = 'UPDATE '.$table.' SET '.implode(', ', $default_values).' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $setdefault_action = 'UPDATE '.$table_quoted.' SET '.implode(', ', $default_values).' WHERE '.implode(' AND ', $conditions). ';'; |
| | | }
|
| | |
|
| | | $query = 'CREATE TRIGGER %s'
|
| | |
| | | $sql_update = sprintf($query, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update') . $setdefault_action;
|
| | | } elseif ('NO ACTION' == $fkdef['onupdate']) {
|
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'AFTER UPDATE', 'update');
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['onupdate']) { |
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update');
|
| | | }
|
| | | if ('CASCADE' == $fkdef['ondelete']) {
|
| | |
| | | $sql_delete = sprintf($query, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete') . $setdefault_action;
|
| | | } elseif ('NO ACTION' == $fkdef['ondelete']) {
|
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'AFTER DELETE', 'delete');
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['ondelete']) { |
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete');
|
| | | }
|
| | | $sql_update .= ' SET FOREIGN_KEY_CHECKS = 1; END;';
|
| | |
| | | }
|
| | |
|
| | | $query = "SHOW TABLES";
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query .= " FROM $database";
|
| | | }
|
| | | $table_names = $db->queryCol($query);
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysqli.php,v 1.95 2008/03/11 19:58:12 quipo Exp $
|
| | | // $Id: mysqli.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Manager/Common.php';
|
| | |
| | | $autoincrement = $fieldname;
|
| | | }
|
| | | }
|
| | | if (!is_null($autoincrement) && count($pk_fields) > 1) {
|
| | | if ((null !== $autoincrement) && count($pk_fields) > 1) { |
| | | $options['primary'] = $pk_fields;
|
| | | } else {
|
| | | // the PK constraint is on max one field => OK
|
| | |
| | | return $query;
|
| | | }
|
| | |
|
| | | if (!is_null($autoincrement)) {
|
| | | if (null !== $autoincrement) { |
| | | // we have to remove the PK clause added by _getIntegerDeclaration()
|
| | | $query = str_replace('AUTO_INCREMENT PRIMARY KEY', 'AUTO_INCREMENT', $query);
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | $query = 'SHOW TRIGGERS';
|
| | | if (!is_null($table)) {
|
| | | if (null !== $table) { |
| | | $table = $db->quote($table, 'text');
|
| | | $query .= " LIKE $table";
|
| | | }
|
| | |
| | | }
|
| | |
|
| | | $query = "SHOW /*!50002 FULL*/ TABLES";
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query .= " FROM $database";
|
| | | }
|
| | | $query.= "/*!50002 WHERE Table_type = 'BASE TABLE'*/";
|
| | |
| | | }
|
| | |
|
| | | $query = 'SHOW FULL TABLES';
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query.= " FROM $database";
|
| | | }
|
| | | $query.= " WHERE Table_type = 'VIEW'";
|
| | |
| | | }
|
| | |
|
| | | $type = '';
|
| | | $name = $db->quoteIdentifier($db->getIndexName($name), true);
|
| | | $idx_name = $db->quoteIdentifier($db->getIndexName($name), true); |
| | | if (!empty($definition['primary'])) {
|
| | | $type = 'PRIMARY';
|
| | | $name = 'KEY';
|
| | | $idx_name = 'KEY'; |
| | | } elseif (!empty($definition['unique'])) {
|
| | | $type = 'UNIQUE';
|
| | | } elseif (!empty($definition['foreign'])) {
|
| | |
| | | }
|
| | |
|
| | | $table_quoted = $db->quoteIdentifier($table, true);
|
| | | $query = "ALTER TABLE $table_quoted ADD $type $name";
|
| | | $query = "ALTER TABLE $table_quoted ADD $type $idx_name"; |
| | | if (!empty($definition['foreign'])) {
|
| | | $query .= ' FOREIGN KEY';
|
| | | }
|
| | | $fields = array();
|
| | | foreach (array_keys($definition['fields']) as $field) {
|
| | | $fields[] = $db->quoteIdentifier($field, true);
|
| | | foreach ($definition['fields'] as $field => $fieldinfo) { |
| | | $quoted = $db->quoteIdentifier($field, true); |
| | | if (!empty($fieldinfo['length'])) { |
| | | $quoted .= '(' . $fieldinfo['length'] . ')'; |
| | | } |
| | | $fields[] = $quoted; |
| | | }
|
| | | $query .= ' ('. implode(', ', $fields) . ')';
|
| | | if (!empty($definition['foreign'])) {
|
| | |
| | | }
|
| | | $query .= ' ('. implode(', ', $referenced_fields) . ')';
|
| | | $query .= $this->_getAdvancedFKOptions($definition);
|
| | | |
| | | // add index on FK column(s) or we can't add a FK constraint |
| | | // @see http://forums.mysql.com/read.php?22,19755,226009 |
| | | $result = $this->createIndex($table, $name.'_fkidx', $definition); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | }
|
| | | $res = $db->exec($query);
|
| | | if (PEAR::isError($res)) {
|
| | |
| | | }
|
| | | // create triggers to enforce FOREIGN KEY constraints
|
| | | if ($db->supports('triggers') && !empty($foreign_keys)) {
|
| | | $table = $db->quoteIdentifier($table, true);
|
| | | $table_quoted = $db->quoteIdentifier($table, true); |
| | | foreach ($foreign_keys as $fkname => $fkdef) {
|
| | | if (empty($fkdef)) {
|
| | | continue;
|
| | | }
|
| | | //set actions to 'RESTRICT' if not set
|
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? 'RESTRICT' : strtoupper($fkdef['onupdate']);
|
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? 'RESTRICT' : strtoupper($fkdef['ondelete']);
|
| | | //set actions to default if not set |
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? $db->options['default_fk_action_onupdate'] : strtoupper($fkdef['onupdate']); |
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? $db->options['default_fk_action_ondelete'] : strtoupper($fkdef['ondelete']); |
| | |
|
| | | $trigger_names = array(
|
| | | 'insert' => $fkname.'_insert_trg',
|
| | |
| | | $restrict_action = ' IF (SELECT ';
|
| | | $aliased_fields = array();
|
| | | foreach ($table_fields as $field) {
|
| | | $aliased_fields[] = $table .'.'.$field .' AS '.$field;
|
| | | $aliased_fields[] = $table_quoted .'.'.$field .' AS '.$field; |
| | | }
|
| | | $restrict_action .= implode(',', $aliased_fields)
|
| | | .' FROM '.$table
|
| | | .' FROM '.$table_quoted |
| | | .' WHERE ';
|
| | | $conditions = array();
|
| | | $new_values = array();
|
| | |
| | | $new_values[] = $table_fields[$i] .' = NEW.'.$referenced_fields[$i];
|
| | | $null_values[] = $table_fields[$i] .' = NULL';
|
| | | }
|
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL'
|
| | | .' THEN CALL %s_ON_TABLE_'.$table.'_VIOLATES_FOREIGN_KEY_CONSTRAINT();'
|
| | | $conditions2 = array(); |
| | | if ('NO ACTION' != $fkdef['ondelete']) { |
| | | // There is no NEW row in on DELETE trigger |
| | | for ($i=0; $i<count($referenced_fields); $i++) { |
| | | $conditions2[] = 'NEW.'.$referenced_fields[$i] .' <> OLD.'.$referenced_fields[$i]; |
| | | } |
| | | } |
| | | |
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL'; |
| | | if (!empty($conditions2)) { |
| | | $restrict_action .= ' AND (' .implode(' OR ', $conditions2) .')'; |
| | | } |
| | | $restrict_action .= ' THEN CALL %s_ON_TABLE_'.$table.'_VIOLATES_FOREIGN_KEY_CONSTRAINT();' |
| | | .' END IF;';
|
| | |
|
| | | $cascade_action_update = 'UPDATE '.$table.' SET '.implode(', ', $new_values) .' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $cascade_action_delete = 'DELETE FROM '.$table.' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $setnull_action = 'UPDATE '.$table.' SET '.implode(', ', $null_values).' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $cascade_action_update = 'UPDATE '.$table_quoted.' SET '.implode(', ', $new_values) .' WHERE '.implode(' AND ', $conditions). ';'; |
| | | $cascade_action_delete = 'DELETE FROM '.$table_quoted.' WHERE '.implode(' AND ', $conditions). ';'; |
| | | $setnull_action = 'UPDATE '.$table_quoted.' SET '.implode(', ', $null_values).' WHERE '.implode(' AND ', $conditions). ';'; |
| | |
|
| | | if ('SET DEFAULT' == $fkdef['onupdate'] || 'SET DEFAULT' == $fkdef['ondelete']) {
|
| | | $db->loadModule('Reverse', null, true);
|
| | |
| | | }
|
| | | $default_values[] = $table_field .' = '. $field_definition[0]['default'];
|
| | | }
|
| | | $setdefault_action = 'UPDATE '.$table.' SET '.implode(', ', $default_values).' WHERE '.implode(' AND ', $conditions). ';';
|
| | | $setdefault_action = 'UPDATE '.$table_quoted.' SET '.implode(', ', $default_values).' WHERE '.implode(' AND ', $conditions). ';'; |
| | | }
|
| | |
|
| | | $query = 'CREATE TRIGGER %s'
|
| | |
| | | $sql_update = sprintf($query, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update') . $setdefault_action;
|
| | | } elseif ('NO ACTION' == $fkdef['onupdate']) {
|
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'AFTER UPDATE', 'update');
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['onupdate']) { |
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update');
|
| | | }
|
| | | if ('CASCADE' == $fkdef['ondelete']) {
|
| | |
| | | $sql_delete = sprintf($query, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete') . $setdefault_action;
|
| | | } elseif ('NO ACTION' == $fkdef['ondelete']) {
|
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'AFTER DELETE', 'delete');
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['ondelete']) { |
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete');
|
| | | }
|
| | | $sql_update .= ' SET FOREIGN_KEY_CHECKS = 1; END;';
|
| | |
| | | }
|
| | |
|
| | | $query = "SHOW TABLES";
|
| | | if (!is_null($database)) {
|
| | | if (null !== $database) { |
| | | $query .= " FROM $database";
|
| | | }
|
| | | $table_names = $db->queryCol($query);
|
| | |
| | | // | Author: Paul Cooper <pgc@ucecom.com> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: pgsql.php,v 1.82 2008/03/05 12:55:57 afz Exp $ |
| | | // $Id: pgsql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | |
| | | require_once 'MDB2/Driver/Manager/Common.php'; |
| | | |
| | |
| | | return MDB2_OK; |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | |
| | | if (!empty($changes['remove']) && is_array($changes['remove'])) { |
| | | foreach ($changes['remove'] as $field_name => $field) { |
| | | $field_name = $db->quoteIdentifier($field_name, true); |
| | |
| | | 'changing column type for "'.$change_name.'\" requires PostgreSQL 8.0 or above', __FUNCTION__); |
| | | } |
| | | $db->loadModule('Datatype', null, true); |
| | | $query = "ALTER $field_name TYPE ".$db->datatype->getTypeDeclaration($field['definition']); |
| | | $type = $db->datatype->getTypeDeclaration($field['definition']); |
| | | $query = "ALTER $field_name TYPE $type USING CAST($field_name AS $type)"; |
| | | $result = $db->exec("ALTER TABLE $name $query"); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | return $result; |
| | | } |
| | | } |
| | | if (!empty($field['definition']['notnull'])) { |
| | | if (array_key_exists('notnull', $field['definition'])) { |
| | | $query = "ALTER $field_name ".($field['definition']['notnull'] ? 'SET' : 'DROP').' NOT NULL'; |
| | | $result = $db->exec("ALTER TABLE $name $query"); |
| | | if (PEAR::isError($result)) { |
| | |
| | | } |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | if (!empty($changes['name'])) { |
| | | $change_name = $db->quoteIdentifier($changes['name'], true); |
| | | $result = $db->exec("ALTER TABLE $name RENAME TO ".$change_name); |
| | |
| | | FROM pg_trigger trg, |
| | | pg_class tbl |
| | | WHERE trg.tgrelid = tbl.oid'; |
| | | if (!is_null($table)) { |
| | | if (null !== $table) { |
| | | $table = $db->quote(strtoupper($table), 'text'); |
| | | $query .= " AND tbl.relname = $table"; |
| | | $query .= " AND UPPER(tbl.relname) = $table"; |
| | | } |
| | | $result = $db->queryCol($query); |
| | | if (PEAR::isError($result)) { |
| | |
| | | return $db; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table); |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | if (!empty($schema)) { |
| | | $table = $db->quoteIdentifier($schema, true) . '.' .$table; |
| | | } |
| | | $db->setLimit(1); |
| | | $result2 = $db->query("SELECT * FROM $table"); |
| | | if (PEAR::isError($result2)) { |
| | |
| | | return $db; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table); |
| | | |
| | | $table = $db->quote($table, 'text'); |
| | | $subquery = "SELECT indexrelid FROM pg_index, pg_class"; |
| | | $subquery.= " WHERE pg_class.relname=$table AND pg_class.oid=pg_index.indrelid AND indisunique != 't' AND indisprimary != 't'"; |
| | | $subquery = "SELECT indexrelid |
| | | FROM pg_index |
| | | LEFT JOIN pg_class ON pg_class.oid = pg_index.indrelid |
| | | LEFT JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid |
| | | WHERE pg_class.relname = $table |
| | | AND indisunique != 't' |
| | | AND indisprimary != 't'"; |
| | | if (!empty($schema)) { |
| | | $subquery .= ' AND pg_namespace.nspname = '.$db->quote($schema, 'text'); |
| | | } |
| | | $query = "SELECT relname FROM pg_class WHERE oid IN ($subquery)"; |
| | | $indexes = $db->queryCol($query, 'text'); |
| | | if (PEAR::isError($indexes)) { |
| | |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ dropConstraint() |
| | | |
| | | /** |
| | | * drop existing constraint |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * @param string $name name of the constraint to be dropped |
| | | * @param string $primary hint if the constraint is primary |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function dropConstraint($table, $name, $primary = false) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | // is it an UNIQUE index? |
| | | $query = 'SELECT relname |
| | | FROM pg_class |
| | | WHERE oid IN ( |
| | | SELECT indexrelid |
| | | FROM pg_index, pg_class |
| | | WHERE pg_class.relname = '.$db->quote($table, 'text').' |
| | | AND pg_class.oid = pg_index.indrelid |
| | | AND indisunique = \'t\') |
| | | EXCEPT |
| | | SELECT conname |
| | | FROM pg_constraint, pg_class |
| | | WHERE pg_constraint.conrelid = pg_class.oid |
| | | AND relname = '. $db->quote($table, 'text'); |
| | | $unique = $db->queryCol($query, 'text'); |
| | | if (PEAR::isError($unique) || empty($unique)) { |
| | | // not an UNIQUE index, maybe a CONSTRAINT |
| | | return parent::dropConstraint($table, $name, $primary); |
| | | } |
| | | |
| | | if (in_array($name, $unique)) { |
| | | return $db->exec('DROP INDEX '.$db->quoteIdentifier($name, true)); |
| | | } |
| | | $idxname = $db->getIndexName($name); |
| | | if (in_array($idxname, $unique)) { |
| | | return $db->exec('DROP INDEX '.$db->quoteIdentifier($idxname, true)); |
| | | } |
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null, |
| | | $name . ' is not an existing constraint for table ' . $table, __FUNCTION__); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTableConstraints() |
| | | |
| | | /** |
| | |
| | | return $db; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table); |
| | | |
| | | $table = $db->quote($table, 'text'); |
| | | $query = 'SELECT conname |
| | | FROM pg_constraint, pg_class |
| | | WHERE pg_constraint.conrelid = pg_class.oid |
| | | AND relname = ' .$table; |
| | | FROM pg_constraint |
| | | LEFT JOIN pg_class ON pg_constraint.conrelid = pg_class.oid |
| | | LEFT JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid |
| | | WHERE relname = ' .$table; |
| | | if (!empty($schema)) { |
| | | $query .= ' AND pg_namespace.nspname = ' . $db->quote($schema, 'text'); |
| | | } |
| | | $query .= ' |
| | | UNION DISTINCT |
| | | SELECT relname |
| | | FROM pg_class |
| | | WHERE oid IN ( |
| | | SELECT indexrelid |
| | | FROM pg_index |
| | | LEFT JOIN pg_class ON pg_class.oid = pg_index.indrelid |
| | | LEFT JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid |
| | | WHERE pg_class.relname = '.$table.' |
| | | AND indisunique = \'t\''; |
| | | if (!empty($schema)) { |
| | | $query .= ' AND pg_namespace.nspname = ' . $db->quote($schema, 'text'); |
| | | } |
| | | $query .= ')'; |
| | | $constraints = $db->queryCol($query); |
| | | if (PEAR::isError($constraints)) { |
| | | return $constraints; |
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: sqlite.php,v 1.74 2008/03/05 11:08:53 quipo Exp $
|
| | | // $Id: sqlite.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Manager/Common.php';
|
| | |
| | | * create a new table
|
| | | *
|
| | | * @param string $name Name of the database that should be created
|
| | | * @param array $fields Associative array that contains the definition of each field of the new table
|
| | | * @param array $fields Associative array that contains the definition |
| | | * of each field of the new table |
| | | * @param array $options An associative array of table options
|
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | |
| | | if (empty($fkdef)) {
|
| | | continue;
|
| | | }
|
| | | //set actions to 'RESTRICT' if not set
|
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? 'RESTRICT' : strtoupper($fkdef['onupdate']);
|
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? 'RESTRICT' : strtoupper($fkdef['ondelete']);
|
| | | //set actions to default if not set |
| | | $fkdef['onupdate'] = empty($fkdef['onupdate']) ? $db->options['default_fk_action_onupdate'] : strtoupper($fkdef['onupdate']); |
| | | $fkdef['ondelete'] = empty($fkdef['ondelete']) ? $db->options['default_fk_action_ondelete'] : strtoupper($fkdef['ondelete']); |
| | |
|
| | | $trigger_names = array(
|
| | | 'insert' => $fkname.'_insert_trg',
|
| | |
| | | $new_values[] = $table_fields[$i] .' = NEW.'.$referenced_fields[$i];
|
| | | $null_values[] = $table_fields[$i] .' = NULL';
|
| | | }
|
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL';
|
| | | $conditions2 = array(); |
| | | for ($i=0; $i<count($referenced_fields); $i++) { |
| | | $conditions2[] = 'NEW.'.$referenced_fields[$i] .' <> OLD.'.$referenced_fields[$i]; |
| | | } |
| | | $restrict_action .= implode(' AND ', $conditions).') IS NOT NULL' |
| | | .' AND (' .implode(' OR ', $conditions2) .')'; |
| | |
|
| | | $cascade_action_update = 'UPDATE '.$name.' SET '.implode(', ', $new_values) .' WHERE '.implode(' AND ', $conditions);
|
| | | $cascade_action_delete = 'DELETE FROM '.$name.' WHERE '.implode(' AND ', $conditions);
|
| | |
| | | $sql_update = sprintf($query, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update') . $setdefault_action. '; END;';
|
| | | } elseif ('NO ACTION' == $fkdef['onupdate']) {
|
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'AFTER UPDATE', 'update') . '; END;';
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['onupdate']) { |
| | | $sql_update = sprintf($query.$restrict_action, $trigger_names['pk_update'], 'BEFORE UPDATE', 'update') . '; END;';
|
| | | }
|
| | | if ('CASCADE' == $fkdef['ondelete']) {
|
| | |
| | | $sql_delete = sprintf($query, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete') . $setdefault_action. '; END;';
|
| | | } elseif ('NO ACTION' == $fkdef['ondelete']) {
|
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'AFTER DELETE', 'delete') . '; END;';
|
| | | } else {
|
| | | //'RESTRICT'
|
| | | } elseif ('RESTRICT' == $fkdef['ondelete']) { |
| | | $sql_delete = sprintf($query.$restrict_action, $trigger_names['pk_delete'], 'BEFORE DELETE', 'delete') . '; END;';
|
| | | }
|
| | |
|
| | |
| | | }
|
| | |
|
| | | $query = "SELECT name FROM sqlite_master WHERE type='trigger' AND sql NOT NULL";
|
| | | if (!is_null($table)) {
|
| | | if (null !== $table) { |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) {
|
| | | $query.= ' AND LOWER(tbl_name)='.$db->quote(strtolower($table), 'text');
|
| | | } else {
|
| | |
| | | * @param string $table table name
|
| | | * @param string $fkname FOREIGN KEY constraint name
|
| | | * @param string $referenced_table referenced table name
|
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @access private
|
| | | */
|
| | |
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }]]
|
| | | // }}} |
| | | // {{{ listTableConstraints()
|
| | |
|
| | | /**
|
New file |
| | |
| | | <?php |
| | | // +----------------------------------------------------------------------+ |
| | | // | PHP versions 4 and 5 | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Copyright (c) 1998-2008 Manuel Lemos, Tomas V.V.Cox, | |
| | | // | Stig. S. Bakken, Lukas Smith | |
| | | // | All rights reserved. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB | |
| | | // | API as well as database abstraction for PHP applications. | |
| | | // | This LICENSE is in the BSD license style. | |
| | | // | | |
| | | // | Redistribution and use in source and binary forms, with or without | |
| | | // | modification, are permitted provided that the following conditions | |
| | | // | are met: | |
| | | // | | |
| | | // | Redistributions of source code must retain the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer. | |
| | | // | | |
| | | // | Redistributions in binary form must reproduce the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer in the | |
| | | // | documentation and/or other materials provided with the distribution. | |
| | | // | | |
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, | |
| | | // | Lukas Smith nor the names of his contributors may be used to endorse | |
| | | // | or promote products derived from this software without specific prior| |
| | | // | written permission. | |
| | | // | | |
| | | // | 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 | |
| | | // | REGENTS 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. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Authors: Frank M. Kromann <frank@kromann.info> | |
| | | // | David Coallier <davidc@php.net> | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> | |
| | | // +----------------------------------------------------------------------+ |
| | | |
| | | require_once 'MDB2/Driver/Manager/Common.php'; |
| | | |
| | | // {{{ class MDB2_Driver_Manager_sqlsrv |
| | | |
| | | /** |
| | | * MDB2 MSSQL driver for the management modules |
| | | * |
| | | * @package MDB2 |
| | | * @category Database |
| | | * @author Frank M. Kromann <frank@kromann.info> |
| | | * @author David Coallier <davidc@php.net> |
| | | * @author Lorenzo Alberton <l.alberton@quipo.it> |
| | | */ |
| | | class MDB2_Driver_Manager_sqlsrv extends MDB2_Driver_Manager_Common |
| | | { |
| | | // {{{ createDatabase() |
| | | /** |
| | | * create a new database |
| | | * |
| | | * @param string $name name of the database that should be created |
| | | * @param array $options array with collation info |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function createDatabase($name, $options = array()) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | $query = "CREATE DATABASE $name"; |
| | | if ($db->options['database_device']) { |
| | | $query.= ' ON '.$db->options['database_device']; |
| | | $query.= $db->options['database_size'] ? '=' . |
| | | $db->options['database_size'] : ''; |
| | | } |
| | | if (!empty($options['collation'])) { |
| | | $query .= ' COLLATE ' . $options['collation']; |
| | | } |
| | | return $db->standaloneQuery($query, null, true); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ alterDatabase() |
| | | |
| | | /** |
| | | * alter an existing database |
| | | * |
| | | * @param string $name name of the database that is intended to be changed |
| | | * @param array $options array with name, collation info |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function alterDatabase($name, $options = array()) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = ''; |
| | | if (!empty($options['name'])) { |
| | | $query .= ' MODIFY NAME = ' .$db->quoteIdentifier($options['name'], true); |
| | | } |
| | | if (!empty($options['collation'])) { |
| | | $query .= ' COLLATE ' . $options['collation']; |
| | | } |
| | | if (!empty($query)) { |
| | | $query = 'ALTER DATABASE '. $db->quoteIdentifier($name, true) . $query; |
| | | return $db->standaloneQuery($query, null, true); |
| | | } |
| | | return MDB2_OK; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ dropDatabase() |
| | | |
| | | /** |
| | | * drop an existing database |
| | | * |
| | | * @param string $name name of the database that should be dropped |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function dropDatabase($name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $db->standaloneQuery("DROP DATABASE $name", null, true); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ dropTable() |
| | | |
| | | /** |
| | | * drop an existing table |
| | | * |
| | | * @param string $name name of the table that should be dropped |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function dropTable($name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $db->exec("IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='$name') DROP TABLE $name"); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getTemporaryTableQuery() |
| | | |
| | | /** |
| | | * Override the parent method. |
| | | * |
| | | * @return string The string required to be placed between "CREATE" and "TABLE" |
| | | * to generate a temporary table, if possible. |
| | | */ |
| | | function _getTemporaryTableQuery() |
| | | { |
| | | return ''; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getAdvancedFKOptions() |
| | | |
| | | /** |
| | | * Return the FOREIGN KEY query section dealing with non-standard options |
| | | * as MATCH, INITIALLY DEFERRED, ON UPDATE, ... |
| | | * |
| | | * @param array $definition |
| | | * |
| | | * @return string |
| | | * @access protected |
| | | */ |
| | | function _getAdvancedFKOptions($definition) |
| | | { |
| | | $query = ''; |
| | | if (!empty($definition['onupdate'])) { |
| | | $query .= ' ON UPDATE '.$definition['onupdate']; |
| | | } |
| | | if (!empty($definition['ondelete'])) { |
| | | $query .= ' ON DELETE '.$definition['ondelete']; |
| | | } |
| | | return $query; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ createTable() |
| | | |
| | | /** |
| | | * create a new table |
| | | * |
| | | * @param string $name Name of the database that should be created |
| | | * @param array $fields Associative array that contains the definition of each field of the new table |
| | | * The indexes of the array entries are the names of the fields of the table an |
| | | * the array entry values are associative arrays like those that are meant to be |
| | | * passed with the field definitions to get[Type]Declaration() functions. |
| | | * |
| | | * Example |
| | | * array( |
| | | * |
| | | * 'id' => array( |
| | | * 'type' => 'integer', |
| | | * 'unsigned' => 1, |
| | | * 'notnull' => 1, |
| | | * 'default' => 0, |
| | | * ), |
| | | * 'name' => array( |
| | | * 'type' => 'text', |
| | | * 'length' => 12, |
| | | * ), |
| | | * 'description' => array( |
| | | * 'type' => 'text', |
| | | * 'length' => 12, |
| | | * ) |
| | | * ); |
| | | * @param array $options An associative array of table options: |
| | | * array( |
| | | * 'comment' => 'Foo', |
| | | * 'temporary' => true|false, |
| | | * ); |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function createTable($name, $fields, $options = array()) |
| | | { |
| | | /*if (!empty($options['temporary'])) { |
| | | $name = '#'.$name;//would make subsequent calls fail because it would go out ot scope and be destroyed already |
| | | }*/ |
| | | return parent::createTable($name, $fields, $options); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ truncateTable() |
| | | |
| | | /** |
| | | * Truncate an existing table (if the TRUNCATE TABLE syntax is not supported, |
| | | * it falls back to a DELETE FROM TABLE query) |
| | | * |
| | | * @param string $name name of the table that should be truncated |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function truncateTable($name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | return $db->exec("TRUNCATE TABLE $name"); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ vacuum() |
| | | |
| | | /** |
| | | * Optimize (vacuum) all the tables in the db (or only the specified table) |
| | | * and optionally run ANALYZE. |
| | | * |
| | | * @param string $table table name (all the tables if empty) |
| | | * @param array $options an array with driver-specific options: |
| | | * - timeout [int] (in seconds) [mssql-only] |
| | | * - analyze [boolean] [pgsql and mysql] |
| | | * - full [boolean] [pgsql-only] |
| | | * - freeze [boolean] [pgsql-only] |
| | | * |
| | | * NB: you have to run the NSControl Create utility to enable VACUUM |
| | | * |
| | | * @return mixed MDB2_OK success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function vacuum($table = null, $options = array()) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $timeout = isset($options['timeout']) ? (int)$options['timeout'] : 300; |
| | | |
| | | $query = 'NSControl Create'; |
| | | $result = $db->exec($query); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | return $db->exec('EXEC NSVacuum '.$timeout); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ alterTable() |
| | | |
| | | /** |
| | | * alter an existing table |
| | | * |
| | | * @param string $name name of the table that is intended to be changed. |
| | | * @param array $changes associative array that contains the details of each type |
| | | * of change that is intended to be performed. The types of |
| | | * changes that are currently supported are defined as follows: |
| | | * |
| | | * name |
| | | * |
| | | * New name for the table. |
| | | * |
| | | * add |
| | | * |
| | | * Associative array with the names of fields to be added as |
| | | * indexes of the array. The value of each entry of the array |
| | | * should be set to another associative array with the properties |
| | | * of the fields to be added. The properties of the fields should |
| | | * be the same as defined by the MDB2 parser. |
| | | * |
| | | * |
| | | * remove |
| | | * |
| | | * Associative array with the names of fields to be removed as indexes |
| | | * of the array. Currently the values assigned to each entry are ignored. |
| | | * An empty array should be used for future compatibility. |
| | | * |
| | | * rename |
| | | * |
| | | * Associative array with the names of fields to be renamed as indexes |
| | | * of the array. The value of each entry of the array should be set to |
| | | * another associative array with the entry named name with the new |
| | | * field name and the entry named Declaration that is expected to contain |
| | | * the portion of the field declaration already in DBMS specific SQL code |
| | | * as it is used in the CREATE TABLE statement. |
| | | * |
| | | * change |
| | | * |
| | | * Associative array with the names of the fields to be changed as indexes |
| | | * of the array. Keep in mind that if it is intended to change either the |
| | | * name of a field and any other properties, the change array entries |
| | | * should have the new names of the fields as array indexes. |
| | | * |
| | | * The value of each entry of the array should be set to another associative |
| | | * array with the properties of the fields to that are meant to be changed as |
| | | * array entries. These entries should be assigned to the new values of the |
| | | * respective properties. The properties of the fields should be the same |
| | | * as defined by the MDB2 parser. |
| | | * |
| | | * Example |
| | | * array( |
| | | * 'name' => 'userlist', |
| | | * 'add' => array( |
| | | * 'quota' => array( |
| | | * 'type' => 'integer', |
| | | * 'unsigned' => 1 |
| | | * ) |
| | | * ), |
| | | * 'remove' => array( |
| | | * 'file_limit' => array(), |
| | | * 'time_limit' => array() |
| | | * ), |
| | | * 'change' => array( |
| | | * 'name' => array( |
| | | * 'length' => '20', |
| | | * 'definition' => array( |
| | | * 'type' => 'text', |
| | | * 'length' => 20, |
| | | * ), |
| | | * ) |
| | | * ), |
| | | * 'rename' => array( |
| | | * 'sex' => array( |
| | | * 'name' => 'gender', |
| | | * 'definition' => array( |
| | | * 'type' => 'text', |
| | | * 'length' => 1, |
| | | * 'default' => 'M', |
| | | * ), |
| | | * ) |
| | | * ) |
| | | * ) |
| | | * |
| | | * @param boolean $check indicates whether the function should just check if the DBMS driver |
| | | * can perform the requested table alterations if the value is true or |
| | | * actually perform them otherwise. |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function alterTable($name, $changes, $check) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $name_quoted = $db->quoteIdentifier($name, true); |
| | | |
| | | foreach ($changes as $change_name => $change) { |
| | | switch ($change_name) { |
| | | case 'remove': |
| | | case 'rename': |
| | | case 'add': |
| | | case 'change': |
| | | case 'name': |
| | | break; |
| | | default: |
| | | return $db->raiseError(MDB2_ERROR_CANNOT_ALTER, null, null, |
| | | 'change type "'.$change_name.'" not yet supported', __FUNCTION__); |
| | | } |
| | | } |
| | | |
| | | if ($check) { |
| | | return MDB2_OK; |
| | | } |
| | | |
| | | $idxname_format = $db->getOption('idxname_format'); |
| | | $db->setOption('idxname_format', '%s'); |
| | | |
| | | if (!empty($changes['remove']) && is_array($changes['remove'])) { |
| | | $result = $this->_dropConflictingIndices($name, array_keys($changes['remove'])); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | $result = $this->_dropConflictingConstraints($name, array_keys($changes['remove'])); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | |
| | | $query = ''; |
| | | foreach ($changes['remove'] as $field_name => $field) { |
| | | if ($query) { |
| | | $query.= ', '; |
| | | } |
| | | $field_name = $db->quoteIdentifier($field_name, true); |
| | | $query.= 'COLUMN ' . $field_name; |
| | | } |
| | | |
| | | $result = $db->exec("ALTER TABLE $name_quoted DROP $query"); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | |
| | | if (!empty($changes['rename']) && is_array($changes['rename'])) { |
| | | foreach ($changes['rename'] as $field_name => $field) { |
| | | $field_name = $db->quoteIdentifier($field_name, true); |
| | | $result = $db->exec("sp_rename '$name_quoted.$field_name', '".$field['name']."', 'COLUMN'"); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | } |
| | | |
| | | if (!empty($changes['add']) && is_array($changes['add'])) { |
| | | $query = ''; |
| | | foreach ($changes['add'] as $field_name => $field) { |
| | | if ($query) { |
| | | $query.= ', '; |
| | | } else { |
| | | $query.= 'ADD '; |
| | | } |
| | | $query.= $db->getDeclaration($field['type'], $field_name, $field); |
| | | } |
| | | |
| | | $result = $db->exec("ALTER TABLE $name_quoted $query"); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | |
| | | $dropped_indices = array(); |
| | | $dropped_constraints = array(); |
| | | |
| | | if (!empty($changes['change']) && is_array($changes['change'])) { |
| | | $dropped = $this->_dropConflictingIndices($name, array_keys($changes['change'])); |
| | | if (PEAR::isError($dropped)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $dropped; |
| | | } |
| | | $dropped_indices = array_merge($dropped_indices, $dropped); |
| | | $dropped = $this->_dropConflictingConstraints($name, array_keys($changes['change'])); |
| | | if (PEAR::isError($dropped)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $dropped; |
| | | } |
| | | $dropped_constraints = array_merge($dropped_constraints, $dropped); |
| | | |
| | | foreach ($changes['change'] as $field_name => $field) { |
| | | //MSSQL doesn't allow multiple ALTER COLUMNs in one query |
| | | $query = 'ALTER COLUMN '; |
| | | |
| | | //MSSQL doesn't allow changing the DEFAULT value of a field in altering mode |
| | | if (array_key_exists('default', $field['definition'])) { |
| | | unset($field['definition']['default']); |
| | | } |
| | | |
| | | $query .= $db->getDeclaration($field['definition']['type'], $field_name, $field['definition']); |
| | | $result = $db->exec("ALTER TABLE $name_quoted $query"); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | } |
| | | |
| | | // restore the dropped conflicting indices and constraints |
| | | foreach ($dropped_indices as $index_name => $index) { |
| | | $result = $this->createIndex($name, $index_name, $index); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | foreach ($dropped_constraints as $constraint_name => $constraint) { |
| | | $result = $this->createConstraint($name, $constraint_name, $constraint); |
| | | if (PEAR::isError($result)) { |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | return $result; |
| | | } |
| | | } |
| | | |
| | | $db->setOption('idxname_format', $idxname_format); |
| | | |
| | | if (!empty($changes['name'])) { |
| | | $new_name = $db->quoteIdentifier($changes['name'], true); |
| | | $result = $db->exec("sp_rename '$name_quoted', '$new_name'"); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | } |
| | | |
| | | return MDB2_OK; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _dropConflictingIndices() |
| | | |
| | | /** |
| | | * Drop the indices that prevent a successful ALTER TABLE action |
| | | * |
| | | * @param string $table table name |
| | | * @param array $fields array of names of the fields affected by the change |
| | | * |
| | | * @return array dropped indices definitions |
| | | */ |
| | | function _dropConflictingIndices($table, $fields) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $dropped = array(); |
| | | $index_names = $this->listTableIndexes($table); |
| | | if (PEAR::isError($index_names)) { |
| | | return $index_names; |
| | | } |
| | | $db->loadModule('Reverse'); |
| | | $indexes = array(); |
| | | foreach ($index_names as $index_name) { |
| | | $idx_def = $db->reverse->getTableIndexDefinition($table, $index_name); |
| | | if (!PEAR::isError($idx_def)) { |
| | | $indexes[$index_name] = $idx_def; |
| | | } |
| | | } |
| | | foreach ($fields as $field_name) { |
| | | foreach ($indexes as $index_name => $index) { |
| | | if (!isset($dropped[$index_name]) && array_key_exists($field_name, $index['fields'])) { |
| | | $dropped[$index_name] = $index; |
| | | $result = $this->dropIndex($table, $index_name); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | return $dropped; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _dropConflictingConstraints() |
| | | |
| | | /** |
| | | * Drop the constraints that prevent a successful ALTER TABLE action |
| | | * |
| | | * @param string $table table name |
| | | * @param array $fields array of names of the fields affected by the change |
| | | * |
| | | * @return array dropped constraints definitions |
| | | */ |
| | | function _dropConflictingConstraints($table, $fields) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $dropped = array(); |
| | | $constraint_names = $this->listTableConstraints($table); |
| | | if (PEAR::isError($constraint_names)) { |
| | | return $constraint_names; |
| | | } |
| | | $db->loadModule('Reverse'); |
| | | $constraints = array(); |
| | | foreach ($constraint_names as $constraint_name) { |
| | | $cons_def = $db->reverse->getTableConstraintDefinition($table, $constraint_name); |
| | | if (!PEAR::isError($cons_def)) { |
| | | $constraints[$constraint_name] = $cons_def; |
| | | } |
| | | } |
| | | foreach ($fields as $field_name) { |
| | | foreach ($constraints as $constraint_name => $constraint) { |
| | | if (!isset($dropped[$constraint_name]) && array_key_exists($field_name, $constraint['fields'])) { |
| | | $dropped[$constraint_name] = $constraint; |
| | | $result = $this->dropConstraint($table, $constraint_name); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | } |
| | | } |
| | | // also drop implicit DEFAULT constraints |
| | | $default = $this->_getTableFieldDefaultConstraint($table, $field_name); |
| | | if (!PEAR::isError($default) && !empty($default)) { |
| | | $result = $this->dropConstraint($table, $default); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | } |
| | | } |
| | | |
| | | return $dropped; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getTableFieldDefaultConstraint() |
| | | |
| | | /** |
| | | * Get the default constraint for a table field |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * @param string $field name of field that should be used in method |
| | | * |
| | | * @return mixed name of default constraint on success, a MDB2 error on failure |
| | | * @access private |
| | | */ |
| | | function _getTableFieldDefaultConstraint($table, $field) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $field = $db->quote($field, 'text'); |
| | | $query = "SELECT OBJECT_NAME(syscolumns.cdefault) |
| | | FROM syscolumns |
| | | WHERE syscolumns.id = object_id('$table') |
| | | AND syscolumns.name = $field |
| | | AND syscolumns.cdefault <> 0"; |
| | | return $db->queryOne($query); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTables() |
| | | |
| | | /** |
| | | * list all tables in the current database |
| | | * |
| | | * @return mixed array of table names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listTables() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = 'EXEC sp_tables @table_type = "\'TABLE\'"'; |
| | | $table_names = $db->queryCol($query, null, 2); |
| | | if (PEAR::isError($table_names)) { |
| | | return $table_names; |
| | | } |
| | | $result = array(); |
| | | foreach ($table_names as $table_name) { |
| | | if (!$this->_fixSequenceName($table_name, true)) { |
| | | $result[] = $table_name; |
| | | } |
| | | } |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? |
| | | 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTableFields() |
| | | |
| | | /** |
| | | * list all fields in a table in the current database |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * |
| | | * @return mixed array of field names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listTableFields($table) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $columns = $db->queryCol("SELECT c.name |
| | | FROM syscolumns c |
| | | LEFT JOIN sysobjects o ON c.id = o.id |
| | | WHERE o.name = '$table'"); |
| | | if (PEAR::isError($columns)) { |
| | | return $columns; |
| | | } |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $columns = array_map(($db->options['field_case'] == CASE_LOWER ? 'strtolower' : 'strtoupper'), $columns); |
| | | } |
| | | return $columns; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTableIndexes() |
| | | |
| | | /** |
| | | * list all indexes in a table |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * |
| | | * @return mixed array of index names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listTableIndexes($table) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $key_name = 'INDEX_NAME'; |
| | | $pk_name = 'PK_NAME'; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $key_name = strtolower($key_name); |
| | | $pk_name = strtolower($pk_name); |
| | | } else { |
| | | $key_name = strtoupper($key_name); |
| | | $pk_name = strtoupper($pk_name); |
| | | } |
| | | } |
| | | $table = $db->quote($table, 'text'); |
| | | $query = "EXEC sp_statistics @table_name=$table"; |
| | | $indexes = $db->queryCol($query, 'text', $key_name); |
| | | if (PEAR::isError($indexes)) { |
| | | return $indexes; |
| | | } |
| | | $query = "EXEC sp_pkeys @table_name=$table"; |
| | | $pk_all = $db->queryCol($query, 'text', $pk_name); |
| | | $result = array(); |
| | | foreach ($indexes as $index) { |
| | | if (!in_array($index, $pk_all) && ($index = $this->_fixIndexName($index))) { |
| | | $result[$index] = true; |
| | | } |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_change_key_case($result, $db->options['field_case']); |
| | | } |
| | | return array_keys($result); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listDatabases() |
| | | |
| | | /** |
| | | * list all databases |
| | | * |
| | | * @return mixed array of database names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listDatabases() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $result = $db->queryCol('SELECT name FROM sys.databases'); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listUsers() |
| | | |
| | | /** |
| | | * list all users |
| | | * |
| | | * @return mixed array of user names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listUsers() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $result = $db->queryCol('SELECT DISTINCT loginame FROM master..sysprocesses'); |
| | | if (PEAR::isError($result) || empty($result)) { |
| | | return $result; |
| | | } |
| | | foreach (array_keys($result) as $k) { |
| | | $result[$k] = trim($result[$k]); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listFunctions() |
| | | |
| | | /** |
| | | * list all functions in the current database |
| | | * |
| | | * @return mixed array of function names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listFunctions() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = "SELECT name |
| | | FROM sysobjects |
| | | WHERE objectproperty(id, N'IsMSShipped') = 0 |
| | | AND (objectproperty(id, N'IsTableFunction') = 1 |
| | | OR objectproperty(id, N'IsScalarFunction') = 1)"; |
| | | /* |
| | | SELECT ROUTINE_NAME |
| | | FROM INFORMATION_SCHEMA.ROUTINES |
| | | WHERE ROUTINE_TYPE = 'FUNCTION' |
| | | */ |
| | | $result = $db->queryCol($query); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTableTriggers() |
| | | |
| | | /** |
| | | * list all triggers in the database that reference a given table |
| | | * |
| | | * @param string table for which all referenced triggers should be found |
| | | * |
| | | * @return mixed array of trigger names on success, otherwise, false which |
| | | * could be a db error if the db is not instantiated or could |
| | | * be the results of the error that occured during the |
| | | * querying of the sysobject module. |
| | | * @access public |
| | | */ |
| | | function listTableTriggers($table = null) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $table = $db->quote($table, 'text'); |
| | | $query = "SELECT o.name |
| | | FROM sysobjects o |
| | | WHERE xtype = 'TR' |
| | | AND OBJECTPROPERTY(o.id, 'IsMSShipped') = 0"; |
| | | if (null !== $table) { |
| | | $query .= " AND object_name(parent_obj) = $table"; |
| | | } |
| | | |
| | | $result = $db->queryCol($query); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE && |
| | | $db->options['field_case'] == CASE_LOWER) |
| | | { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? |
| | | 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listViews() |
| | | |
| | | /** |
| | | * list all views in the current database |
| | | * |
| | | * @param string database, the current is default |
| | | * |
| | | * @return mixed array of view names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listViews() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = "SELECT name |
| | | FROM sysobjects |
| | | WHERE xtype = 'V'"; |
| | | /* |
| | | SELECT * |
| | | FROM sysobjects |
| | | WHERE objectproperty(id, N'IsMSShipped') = 0 |
| | | AND objectproperty(id, N'IsView') = 1 |
| | | */ |
| | | |
| | | $result = $db->queryCol($query); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE && |
| | | $db->options['field_case'] == CASE_LOWER) |
| | | { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? |
| | | 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ dropIndex() |
| | | |
| | | /** |
| | | * drop existing index |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * @param string $name name of the index to be dropped |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function dropIndex($table, $name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $name = $db->quoteIdentifier($db->getIndexName($name), true); |
| | | return $db->exec("DROP INDEX $table.$name"); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listTableConstraints() |
| | | |
| | | /** |
| | | * list all constraints in a table |
| | | * |
| | | * @param string $table name of table that should be used in method |
| | | * |
| | | * @return mixed array of constraint names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listTableConstraints($table) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $query = "SELECT c.constraint_name |
| | | FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS c |
| | | WHERE c.constraint_catalog = DB_NAME() |
| | | AND c.table_name = '$table'"; |
| | | $constraints = $db->queryCol($query); |
| | | if (PEAR::isError($constraints)) { |
| | | return $constraints; |
| | | } |
| | | |
| | | $result = array(); |
| | | foreach ($constraints as $constraint) { |
| | | $constraint = $this->_fixIndexName($constraint); |
| | | if (!empty($constraint)) { |
| | | $result[$constraint] = true; |
| | | } |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_change_key_case($result, $db->options['field_case']); |
| | | } |
| | | return array_keys($result); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ |
| | | |
| | | /** |
| | | * Create a basic SQL query for a new table creation |
| | | * |
| | | * @param string $name Name of the database that should be created |
| | | * @param array $fields Associative array that contains the definition of each field of the new table |
| | | * @param array $options An associative array of table options |
| | | * Supported options are: |
| | | * 'primary' An array of column names in the array keys |
| | | * that form the primary key of the table |
| | | * 'temporary' If true, creates the table as a temporary table |
| | | * @return mixed string The SQL query on success, or MDB2 error on failure |
| | | * @see createTable() |
| | | */ |
| | | function _getCreateTableQuery($name, $fields, $options = array()) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | if (!$name) { |
| | | return $db->raiseError(MDB2_ERROR_CANNOT_CREATE, null, null, |
| | | 'no valid table name specified', __FUNCTION__); |
| | | } |
| | | if (empty($fields)) { |
| | | return $db->raiseError(MDB2_ERROR_CANNOT_CREATE, null, null, |
| | | 'no fields specified for table "'.$name.'"', __FUNCTION__); |
| | | } |
| | | $query_fields = $this->getFieldDeclarationList($fields); |
| | | if (PEAR::isError($query_fields)) { |
| | | return $query_fields; |
| | | } |
| | | /*Removed since you can't get the PK name from Schema here, will result in a redefinition of PK index error |
| | | if (!empty($options['primary'])) { |
| | | $query_fields.= ', PRIMARY KEY ('.implode(', ', array_keys($options['primary'])).')'; |
| | | }*/ |
| | | |
| | | $name = $db->quoteIdentifier($name, true); |
| | | $result = 'CREATE '; |
| | | if (!empty($options['temporary']) && $options['temporary']) { |
| | | $result .= $this->_getTemporaryTableQuery() . ' '; |
| | | } |
| | | $result .= "TABLE $name ($query_fields)"; |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ createSequence() |
| | | |
| | | /** |
| | | * create sequence |
| | | * |
| | | * @param string $seq_name name of the sequence to be created |
| | | * @param string $start start value of the sequence; default is 1 |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function createSequence($seq_name, $start = 1) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $sequence_name = $db->quoteIdentifier($db->getSequenceName($seq_name), true); |
| | | $seqcol_name = $db->quoteIdentifier($db->options['seqcol_name'], true); |
| | | $query = "CREATE TABLE $sequence_name ($seqcol_name " . |
| | | "INT PRIMARY KEY CLUSTERED IDENTITY($start,1) NOT NULL)"; |
| | | |
| | | $res = $db->exec($query); |
| | | if (PEAR::isError($res)) { |
| | | return $res; |
| | | } |
| | | |
| | | $query = "SET IDENTITY_INSERT $sequence_name ON ". |
| | | "INSERT INTO $sequence_name ($seqcol_name) VALUES ($start)"; |
| | | $res = $db->exec($query); |
| | | |
| | | if (!PEAR::isError($res)) { |
| | | return MDB2_OK; |
| | | } |
| | | |
| | | $result = $db->exec("DROP TABLE $sequence_name"); |
| | | if (PEAR::isError($result)) { |
| | | return $db->raiseError($result, null, null, |
| | | 'could not drop inconsistent sequence table', __FUNCTION__); |
| | | } |
| | | |
| | | return $db->raiseError($res, null, null, |
| | | 'could not create sequence table', __FUNCTION__); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ dropSequence() |
| | | |
| | | /** |
| | | * This function drops an existing sequence |
| | | * |
| | | * @param string $seq_name name of the sequence to be dropped |
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function dropSequence($seq_name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $sequence_name = $db->quoteIdentifier($db->getSequenceName($seq_name), true); |
| | | return $db->exec("DROP TABLE $sequence_name"); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ listSequences() |
| | | |
| | | /** |
| | | * list all sequences in the current database |
| | | * |
| | | * @return mixed array of sequence names on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function listSequences() |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = "SELECT name FROM sysobjects WHERE xtype = 'U'"; |
| | | $table_names = $db->queryCol($query); |
| | | if (PEAR::isError($table_names)) { |
| | | return $table_names; |
| | | } |
| | | $result = array(); |
| | | foreach ($table_names as $table_name) { |
| | | if ($sqn = $this->_fixSequenceName($table_name, true)) { |
| | | $result[] = $sqn; |
| | | } |
| | | } |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | $result = array_map(($db->options['field_case'] == CASE_LOWER ? |
| | | 'strtolower' : 'strtoupper'), $result); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | // }}} |
| | | /** |
| | | * New OPENX method to check table name according to specifications: |
| | | * http://msdn.microsoft.com/en-us/library/aa258255(SQL.80).aspx |
| | | * |
| | | * Table names must conform to the rules for identifiers. The combination of owner.table_name |
| | | * must be unique within the database. table_name can contain a maximum of 128 characters, |
| | | * except for local temporary table names (names prefixed with a single number sign (#)) that |
| | | * cannot exceed 116 characters. |
| | | * |
| | | * @param string $name table name to check |
| | | * @return true if name is correct and PEAR error on failure |
| | | */ |
| | | function validateTableName($name) |
| | | { |
| | | // Table name maximum length is 128 |
| | | if (strlen($name) > 128) { |
| | | return PEAR::raiseError( |
| | | 'SQL Server table names are limited to 128 characters in length'); |
| | | } |
| | | return true; |
| | | } |
| | | |
| | | /** |
| | | * New OpenX method |
| | | * |
| | | * @param string $table |
| | | * @return array |
| | | */ |
| | | function getTableStatus($table) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = "exec sp_spaceused '{$table}'"; |
| | | $result = $db->queryAll($query, null, MDB2_FETCHMODE_ASSOC); |
| | | if (PEAR::isError($result)) |
| | | { |
| | | return array(); |
| | | } |
| | | $result[0]['data_length'] = (isset($result[0]['data'])) ? $result[0]['data'] : 0; |
| | | $result[0]['data_free'] = (isset($result[0]['unused'])) ? $result[0]['unused'] : 0; |
| | | //data_length,rows,auto_increment,data_free |
| | | $query = "SELECT IDENT_CURRENT ('{$table}') + IDENT_INCR ('{$table}') AS auto_increment"; |
| | | $resultIdentity = $db->queryAll($query, null, MDB2_FETCHMODE_ASSOC); |
| | | $result[0]['auto_increment'] = (isset($resultIdentity[0]['auto_increment'])) ? $resultIdentity[0]['auto_increment'] : 0; |
| | | return $result; |
| | | } |
| | | |
| | | function checkTable($tableName) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $query = 'CHECK TABLE '.$tableName; |
| | | $result = $db->queryRow($query, null, MDB2_FETCHMODE_ASSOC); |
| | | if (PEAR::isError($result)) |
| | | { |
| | | return array('msg_text' => $result->getUserInfo()); |
| | | } |
| | | return $result; |
| | | } |
| | | |
| | | /** |
| | | * New OPENX method to check database name according to specifications: |
| | | * Mysql specification: http://dev.mysql.com/doc/refman/4.1/en/identifiers.html |
| | | * Mysql specification: http://dev.mysql.com/doc/refman/5.0/en/identifiers.html |
| | | * For 4.0, 4.1, 5.0 seem to be the same |
| | | * |
| | | * @param string $name database name to check |
| | | * @return true in name is correct and PEAR error on failure |
| | | */ |
| | | function validateDatabaseName($name) |
| | | { |
| | | return $this->_validateEntityName($name, 'Database'); |
| | | } |
| | | |
| | | /** |
| | | * New OPENX method to check entity name according to specifications: |
| | | * Mysql specification: http://dev.mysql.com/doc/refman/4.1/en/identifiers.html |
| | | * Mysql specification: http://dev.mysql.com/doc/refman/5.0/en/identifiers.html |
| | | * For 4.0, 4.1, 5.0 seem to be the same |
| | | * |
| | | * There are some restrictions on the characters that may appear in identifiers: |
| | | * - No identifier can contain ASCII 0 (0x00) or a byte with a value of 255. |
| | | * - Before MySQL 4.1, identifier quote characters should not be used in identifiers. |
| | | * - Database, table, and column names should not end with space characters. |
| | | * - Database and table names cannot contain “/”, “\”, “.”, or characters that are not allowed in filenames. |
| | | * |
| | | * Table/Database name maximum length: |
| | | * - 64 |
| | | * |
| | | * @param string $name table name to check |
| | | * @return true if name is correct and PEAR error on failure |
| | | * * |
| | | * @param unknown_type $name |
| | | * @param unknown_type $entityType |
| | | * @return unknown |
| | | */ |
| | | function _validateEntityName($name, $entityType) |
| | | { |
| | | // Table name maximum length is 64 |
| | | if (strlen($name) > 64) { |
| | | return PEAR::raiseError( |
| | | $entityType.' names are limited to 64 characters in length'); |
| | | } |
| | | |
| | | // Database, table, and column names should not end with space characters. |
| | | // Extended for leading and ending spaces |
| | | if ($name != trim($name)) { |
| | | return PEAR::raiseError( |
| | | $entityType.' names should not start or end with space characters'); |
| | | } |
| | | |
| | | // No identifier can contain ASCII 0 (0x00) or a byte with a value of 255. |
| | | if (preg_match( '/([\x00\xff])/', $name)) { |
| | | return PEAR::raiseError( |
| | | $entityType.' names cannot contain ASCII 0 (0x00) or a byte with a value of 255'); |
| | | } |
| | | |
| | | //Before MySQL 4.1, identifier quote characters should not be used in identifiers. |
| | | //we actually extend that and disallow quoting at all |
| | | if (preg_match( '/(\\\\|\/|\.|\"|\\\'| |\\(|\\)|\\:|\\;)/', $name)) { |
| | | return PEAR::raiseError( |
| | | $entityType.' names cannot contain "/", "\\", ".", or characters that are not allowed in filenames'); |
| | | } |
| | | |
| | | return true; |
| | | } |
| | | |
| | | // {{{ createConstraint() |
| | | |
| | | /** |
| | | * create a constraint on a table |
| | | * |
| | | * @param string $table name of the table on which the constraint is to be created |
| | | * @param string $name name of the constraint to be created |
| | | * @param array $definition associative array that defines properties of the constraint to be created. |
| | | * Currently, only one property named FIELDS is supported. This property |
| | | * is also an associative with the names of the constraint fields as array |
| | | * constraints. Each entry of this array is set to another type of associative |
| | | * array that specifies properties of the constraint that are specific to |
| | | * each field. |
| | | * |
| | | * Example |
| | | * array( |
| | | * 'fields' => array( |
| | | * 'user_name' => array(), |
| | | * 'last_login' => array() |
| | | * ) |
| | | * ) |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function createConstraint($table, $name, $definition) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $name = $db->quoteIdentifier($db->getIndexName($name), true); |
| | | if (!empty($definition['primary']) && empty($definition['unique'])) { |
| | | $query = "ALTER TABLE $table ADD CONSTRAINT $name"; |
| | | if (!empty($definition['primary'])) { |
| | | $query.= ' PRIMARY KEY'; |
| | | } elseif (!empty($definition['unique'])) { |
| | | $query.= ' UNIQUE'; |
| | | } |
| | | } elseif (!empty($definition['unique'])) { |
| | | $query = "CREATE UNIQUE NONCLUSTERED INDEX $name ON $table"; |
| | | } |
| | | $fields = array(); |
| | | foreach (array_keys($definition['fields']) as $field) { |
| | | $fields[] = $db->quoteIdentifier($field, true); |
| | | } |
| | | $query .= ' ('. implode(', ', $fields) . ')'; |
| | | //deals with NULL values and UNIQUE indexes, this solution is only available in SQL Server 2008 |
| | | //https://connect.microsoft.com/SQLServer/feedback/ViewFeedback.aspx?FeedbackID=299229 |
| | | if (!empty($definition['unique']) && empty($definition['primary'])) { |
| | | for($i=0;$i<count($fields);$i++) $fields[$i] .= ' is NOT NULL'; |
| | | $query .= ' WHERE '. implode(' AND ', $fields); |
| | | } |
| | | return $db->exec($query); |
| | | } |
| | | |
| | | // }}} |
| | | |
| | | } |
| | | |
| | | // }}} |
| | | ?> |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: Common.php,v 1.2 2007/09/09 13:47:36 quipo Exp $ |
| | | // $Id: Common.php 242348 2007-09-09 13:47:36Z quipo $ |
| | | // |
| | | |
| | | /** |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mssql.php,v 1.9 2006/06/18 21:59:05 lsmith Exp $ |
| | | // $Id: mssql.php 215004 2006-06-18 21:59:05Z lsmith $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mysql.php,v 1.9 2006/06/18 21:59:05 lsmith Exp $ |
| | | // $Id: mysql.php 215004 2006-06-18 21:59:05Z lsmith $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mysqli.php,v 1.8 2006/06/18 21:59:05 lsmith Exp $ |
| | | // $Id: mysqli.php 215004 2006-06-18 21:59:05Z lsmith $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
| | |
| | | // | Author: Paul Cooper <pgc@ucecom.com> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: pgsql.php,v 1.12 2006/07/15 13:07:15 lsmith Exp $ |
| | | // $Id: pgsql.php 216444 2006-07-15 13:07:15Z lsmith $ |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
| | | |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: sqlite.php,v 1.9 2006/06/18 21:59:05 lsmith Exp $ |
| | | // $Id: sqlite.php 215004 2006-06-18 21:59:05Z lsmith $ |
| | | // |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
New file |
| | |
| | | <?php |
| | | // +----------------------------------------------------------------------+ |
| | | // | PHP versions 4 and 5 | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Copyright (c) 1998-2006 Manuel Lemos, Tomas V.V.Cox, | |
| | | // | Stig. S. Bakken, Lukas Smith, Frank M. Kromann | |
| | | // | All rights reserved. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB | |
| | | // | API as well as database abstraction for PHP applications. | |
| | | // | This LICENSE is in the BSD license style. | |
| | | // | | |
| | | // | Redistribution and use in source and binary forms, with or without | |
| | | // | modification, are permitted provided that the following conditions | |
| | | // | are met: | |
| | | // | | |
| | | // | Redistributions of source code must retain the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer. | |
| | | // | | |
| | | // | Redistributions in binary form must reproduce the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer in the | |
| | | // | documentation and/or other materials provided with the distribution. | |
| | | // | | |
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, | |
| | | // | Lukas Smith nor the names of his contributors may be used to endorse | |
| | | // | or promote products derived from this software without specific prior| |
| | | // | written permission. | |
| | | // | | |
| | | // | 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 | |
| | | // | REGENTS 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. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | |
| | | require_once 'MDB2/Driver/Native/Common.php'; |
| | | |
| | | /** |
| | | * MDB2 MSSQL driver for the native module |
| | | * |
| | | * @package MDB2 |
| | | * @category Database |
| | | * @author Lukas Smith <smith@dybnet.de> |
| | | */ |
| | | class MDB2_Driver_Native_sqlsrv extends MDB2_Driver_Native_Common |
| | | { |
| | | } |
| | | ?> |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: Common.php,v 1.42 2008/01/12 12:50:58 quipo Exp $
|
| | | // $Id: Common.php 273526 2009-01-14 15:01:21Z quipo $ |
| | | //
|
| | |
|
| | | /**
|
| | |
| | |
|
| | | /**
|
| | | * Split the "[owner|schema].table" notation into an array
|
| | | * |
| | | * @param string $table [schema and] table name |
| | | * |
| | | * @return array array(schema, table) |
| | | * @access private
|
| | | */
|
| | | function splitTableSchema($table)
|
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mssql.php,v 1.49 2008/02/17 15:30:57 quipo Exp $
|
| | | // $Id: mssql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Reverse/Common.php';
|
| | |
| | | $default = false;
|
| | | if (array_key_exists('column_default', $column)) {
|
| | | $default = $column['column_default'];
|
| | | if (is_null($default) && $notnull) {
|
| | | if ((null === $default) && $notnull) { |
| | | $default = '';
|
| | | } elseif (strlen($default) > 4
|
| | | && substr($default, 0, 1) == '('
|
| | |
| | | 'notnull' => $notnull,
|
| | | 'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i', '\\1', $column['type'])
|
| | | );
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length;
|
| | | }
|
| | | if (!is_null($unsigned)) {
|
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned;
|
| | | }
|
| | | if (!is_null($fixed)) {
|
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed;
|
| | | }
|
| | | if ($default !== false) {
|
| | | if (false !== $default) { |
| | | $definition[0]['default'] = $default;
|
| | | }
|
| | | foreach ($types as $key => $type) {
|
| | |
| | |
|
| | | $index_name_mdb2 = $db->getIndexName($index_name);
|
| | | $result = $db->queryRow(sprintf($query, $index_name_mdb2));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $index_name = $index_name_mdb2;
|
| | |
| | |
|
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name);
|
| | | $result = $db->queryRow(sprintf($query, $constraint_name_mdb2));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $constraint_name = $constraint_name_mdb2;
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysql.php,v 1.79 2007/11/25 13:38:29 quipo Exp $
|
| | | // $Id: mysql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Reverse/Common.php';
|
| | |
| | | $default = false;
|
| | | if (array_key_exists('default', $column)) {
|
| | | $default = $column['default'];
|
| | | if (is_null($default) && $notnull) {
|
| | | if ((null === $default) && $notnull) { |
| | | $default = '';
|
| | | }
|
| | | }
|
| | |
| | | 'notnull' => $notnull,
|
| | | 'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i', '\\1', $column['type'])
|
| | | );
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length;
|
| | | }
|
| | | if (!is_null($unsigned)) {
|
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned;
|
| | | }
|
| | | if (!is_null($fixed)) {
|
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed;
|
| | | }
|
| | | if ($default !== false) {
|
| | |
| | | if ($autoincrement !== false) {
|
| | | $definition[0]['autoincrement'] = $autoincrement;
|
| | | }
|
| | | if (!is_null($collate)) {
|
| | | if (null !== $collate) { |
| | | $definition[0]['collate'] = $collate;
|
| | | $definition[0]['charset'] = $charset;
|
| | | }
|
| | |
| | | $query = "SHOW INDEX FROM $table /*!50002 WHERE Key_name = %s */";
|
| | | $index_name_mdb2 = $db->getIndexName($index_name);
|
| | | $result = $db->queryRow(sprintf($query, $db->quote($index_name_mdb2)));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $index_name = $index_name_mdb2;
|
| | |
| | | if (strtolower($constraint_name) != 'primary') {
|
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name);
|
| | | $result = $db->queryRow(sprintf($query, $db->quote($constraint_name_mdb2)));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $constraint_name = $constraint_name_mdb2;
|
| | |
| | | if ($constraint_name == $key_name) {
|
| | | if ($row['non_unique']) {
|
| | | //FOREIGN KEY?
|
| | | return $this->_getTableFKConstraintDefinition($table, $constraint_name_original, $definition); |
| | | } |
| | | if ($row['key_name'] == 'PRIMARY') { |
| | | $definition['primary'] = true; |
| | | } elseif (!$row['non_unique']) { |
| | | $definition['unique'] = true; |
| | | } |
| | | $column_name = $row['column_name']; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $column_name = strtolower($column_name); |
| | | } else { |
| | | $column_name = strtoupper($column_name); |
| | | } |
| | | } |
| | | $definition['fields'][$column_name] = array( |
| | | 'position' => $colpos++ |
| | | ); |
| | | if (!empty($row['collation'])) { |
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'A' |
| | | ? 'ascending' : 'descending'); |
| | | } |
| | | } |
| | | } |
| | | $result->free(); |
| | | if (empty($definition['fields'])) { |
| | | return $this->_getTableFKConstraintDefinition($table, $constraint_name_original, $definition); |
| | | } |
| | | return $definition; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getTableFKConstraintDefinition() |
| | | |
| | | /** |
| | | * Get the FK definition from the CREATE TABLE statement |
| | | * |
| | | * @param string $table table name |
| | | * @param string $constraint_name constraint name |
| | | * @param array $definition default values for constraint definition |
| | | * |
| | | * @return array|PEAR_Error |
| | | * @access private |
| | | */ |
| | | function _getTableFKConstraintDefinition($table, $constraint_name, $definition) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $query = 'SHOW CREATE TABLE '. $db->escape($table);
|
| | | $constraint = $db->queryOne($query, 'text', 1);
|
| | | if (!PEAR::isError($constraint) && !empty($constraint)) {
|
| | |
| | | $constraint = strtoupper($constraint);
|
| | | }
|
| | | }
|
| | | $constraint_name_original = $constraint_name; |
| | | $constraint_name = $db->getIndexName($constraint_name); |
| | | $pattern = '/\bCONSTRAINT\s+'.$constraint_name.'\s+FOREIGN KEY\s+\(([^\)]+)\) \bREFERENCES\b ([^ ]+) \(([^\)]+)\)/i';
|
| | | if (!preg_match($pattern, str_replace('`', '', $constraint), $matches)) {
|
| | | //fallback to original constraint name
|
| | |
| | | return $definition;
|
| | | }
|
| | | }
|
| | |
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__);
|
| | | }
|
| | | if ($row['key_name'] == 'PRIMARY') {
|
| | | $definition['primary'] = true;
|
| | | } elseif (!$row['non_unique']) {
|
| | | $definition['unique'] = true;
|
| | | }
|
| | | $column_name = $row['column_name'];
|
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) {
|
| | | if ($db->options['field_case'] == CASE_LOWER) {
|
| | | $column_name = strtolower($column_name);
|
| | | } else {
|
| | | $column_name = strtoupper($column_name);
|
| | | }
|
| | | }
|
| | | $definition['fields'][$column_name] = array(
|
| | | 'position' => $colpos++
|
| | | );
|
| | | if (!empty($row['collation'])) {
|
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'A'
|
| | | ? 'ascending' : 'descending');
|
| | | }
|
| | | }
|
| | | }
|
| | | $result->free();
|
| | | if (empty($definition['fields'])) {
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__);
|
| | | }
|
| | | return $definition;
|
| | | }
|
| | |
|
| | | // }}}
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mysqli.php,v 1.69 2007/11/25 13:38:29 quipo Exp $
|
| | | // $Id: mysqli.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Reverse/Common.php';
|
| | |
| | | $default = false;
|
| | | if (array_key_exists('default', $column)) {
|
| | | $default = $column['default'];
|
| | | if (is_null($default) && $notnull) {
|
| | | if ((null === $default) && $notnull) { |
| | | $default = '';
|
| | | }
|
| | | }
|
| | |
| | | 'notnull' => $notnull,
|
| | | 'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i', '\\1', $column['type'])
|
| | | );
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length;
|
| | | }
|
| | | if (!is_null($unsigned)) {
|
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned;
|
| | | }
|
| | | if (!is_null($fixed)) {
|
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed;
|
| | | }
|
| | | if ($default !== false) {
|
| | |
| | | if ($autoincrement !== false) {
|
| | | $definition[0]['autoincrement'] = $autoincrement;
|
| | | }
|
| | | if (!is_null($collate)) {
|
| | | if (null !== $collate) { |
| | | $definition[0]['collate'] = $collate;
|
| | | $definition[0]['charset'] = $charset;
|
| | | }
|
| | |
| | | $query = "SHOW INDEX FROM $table /*!50002 WHERE Key_name = %s */";
|
| | | $index_name_mdb2 = $db->getIndexName($index_name);
|
| | | $result = $db->queryRow(sprintf($query, $db->quote($index_name_mdb2)));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $index_name = $index_name_mdb2;
|
| | |
| | | if (strtolower($constraint_name) != 'primary') {
|
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name);
|
| | | $result = $db->queryRow(sprintf($query, $db->quote($constraint_name_mdb2)));
|
| | | if (!PEAR::isError($result) && !is_null($result)) {
|
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise
|
| | | // fallback to the given $index_name, without transformation
|
| | | $constraint_name = $constraint_name_mdb2;
|
| | |
| | | if ($constraint_name == $key_name) {
|
| | | if ($row['non_unique']) {
|
| | | //FOREIGN KEY?
|
| | | return $this->_getTableFKConstraintDefinition($table, $constraint_name_original, $definition); |
| | | } |
| | | if ($row['key_name'] == 'PRIMARY') { |
| | | $definition['primary'] = true; |
| | | } elseif (!$row['non_unique']) { |
| | | $definition['unique'] = true; |
| | | } |
| | | $column_name = $row['column_name']; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $column_name = strtolower($column_name); |
| | | } else { |
| | | $column_name = strtoupper($column_name); |
| | | } |
| | | } |
| | | $definition['fields'][$column_name] = array( |
| | | 'position' => $colpos++ |
| | | ); |
| | | if (!empty($row['collation'])) { |
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'A' |
| | | ? 'ascending' : 'descending'); |
| | | } |
| | | } |
| | | } |
| | | $result->free(); |
| | | if (empty($definition['fields'])) { |
| | | return $this->_getTableFKConstraintDefinition($table, $constraint_name_original, $definition); |
| | | } |
| | | return $definition; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _getTableFKConstraintDefinition() |
| | | |
| | | /** |
| | | * Get the FK definition from the CREATE TABLE statement |
| | | * |
| | | * @param string $table table name |
| | | * @param string $constraint_name constraint name |
| | | * @param array $definition default values for constraint definition |
| | | * |
| | | * @return array|PEAR_Error |
| | | * @access private |
| | | */ |
| | | function _getTableFKConstraintDefinition($table, $constraint_name, $definition) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | $query = 'SHOW CREATE TABLE '. $db->escape($table);
|
| | | $constraint = $db->queryOne($query, 'text', 1);
|
| | | if (!PEAR::isError($constraint) && !empty($constraint)) {
|
| | |
| | | $constraint = strtoupper($constraint);
|
| | | }
|
| | | }
|
| | | $constraint_name_original = $constraint_name; |
| | | $constraint_name = $db->getIndexName($constraint_name); |
| | | $pattern = '/\bCONSTRAINT\s+'.$constraint_name.'\s+FOREIGN KEY\s+\(([^\)]+)\) \bREFERENCES\b ([^ ]+) \(([^\)]+)\)/i';
|
| | | if (!preg_match($pattern, str_replace('`', '', $constraint), $matches)) {
|
| | | //fallback to original constraint name
|
| | |
| | | return $definition;
|
| | | }
|
| | | }
|
| | |
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__);
|
| | | }
|
| | | if ($row['key_name'] == 'PRIMARY') {
|
| | | $definition['primary'] = true;
|
| | | } elseif (!$row['non_unique']) {
|
| | | $definition['unique'] = true;
|
| | | }
|
| | | $column_name = $row['column_name'];
|
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) {
|
| | | if ($db->options['field_case'] == CASE_LOWER) {
|
| | | $column_name = strtolower($column_name);
|
| | | } else {
|
| | | $column_name = strtoupper($column_name);
|
| | | }
|
| | | }
|
| | | $definition['fields'][$column_name] = array(
|
| | | 'position' => $colpos++
|
| | | );
|
| | | if (!empty($row['collation'])) {
|
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'A'
|
| | | ? 'ascending' : 'descending');
|
| | | }
|
| | | }
|
| | | }
|
| | | $result->free();
|
| | | if (empty($definition['fields'])) {
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__);
|
| | | }
|
| | | return $definition;
|
| | | }
|
| | |
|
| | | // }}}
|
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: pgsql.php,v 1.70 2008/03/13 20:38:09 quipo Exp $
|
| | | // $Id: pgsql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | |
|
| | | require_once 'MDB2/Driver/Reverse/Common.php';
|
| | |
|
| | |
| | | }
|
| | | $default = null;
|
| | | if ($column['atthasdef'] === 't'
|
| | | && strpos($column['default'], 'NULL') !== 0 |
| | | && !preg_match("/nextval\('([^']+)'/", $column['default'])
|
| | | ) {
|
| | | $pattern = '/(\'.*\')::[\w ]+$/i';
|
| | | $pattern = '/^\'(.*)\'::[\w ]+$/i'; |
| | | $default = $column['default'];#substr($column['adsrc'], 1, -1);
|
| | | if (is_null($default) && $notnull) {
|
| | | if ((null === $default) && $notnull) { |
| | | $default = '';
|
| | | } elseif (!empty($default) && preg_match($pattern, $default)) {
|
| | | //remove data type cast
|
| | |
| | | $autoincrement = true;
|
| | | }
|
| | | $definition[0] = array('notnull' => $notnull, 'nativetype' => $column['type']);
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length;
|
| | | }
|
| | | if (!is_null($unsigned)) {
|
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned;
|
| | | }
|
| | | if (!is_null($fixed)) {
|
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed;
|
| | | }
|
| | | if ($default !== false) {
|
| | |
| | | if (PEAR::isError($row)) {
|
| | | return $row;
|
| | | }
|
| | |
|
| | | $uniqueIndex = false; |
| | | if (empty($row)) { |
| | | // We might be looking for a UNIQUE index that was not created |
| | | // as a constraint but should be treated as such. |
| | | $query = 'SELECT relname AS constraint_name, |
| | | indkey, |
| | | 0 AS "check", |
| | | 0 AS "foreign", |
| | | 0 AS "primary", |
| | | 1 AS "unique", |
| | | 0 AS deferrable, |
| | | 0 AS initiallydeferred, |
| | | NULL AS references_table, |
| | | NULL AS onupdate, |
| | | NULL AS ondelete, |
| | | NULL AS match |
| | | FROM pg_index, pg_class |
| | | WHERE pg_class.oid = pg_index.indexrelid |
| | | AND indisunique = \'t\' |
| | | AND pg_class.relname = %s'; |
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name); |
| | | $row = $db->queryRow(sprintf($query, $db->quote($constraint_name_mdb2, 'text')), null, MDB2_FETCHMODE_ASSOC); |
| | | if (PEAR::isError($row) || empty($row)) { |
| | | // fallback to the given $index_name, without transformation |
| | | $constraint_name_mdb2 = $constraint_name; |
| | | $row = $db->queryRow(sprintf($query, $db->quote($constraint_name_mdb2, 'text')), null, MDB2_FETCHMODE_ASSOC); |
| | | } |
| | | if (PEAR::isError($row)) { |
| | | return $row; |
| | | } |
| | | if (empty($row)) {
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__);
|
| | | } |
| | | $uniqueIndex = true; |
| | | }
|
| | |
|
| | | $row = array_change_key_case($row, CASE_LOWER);
|
| | |
| | | 'match' => $row['match'],
|
| | | );
|
| | |
|
| | | if ($uniqueIndex) { |
| | | $db->loadModule('Manager', null, true); |
| | | $columns = $db->manager->listTableFields($table_name); |
| | | $index_column_numbers = explode(' ', $row['indkey']); |
| | | $colpos = 1; |
| | | foreach ($index_column_numbers as $number) { |
| | | $definition['fields'][$columns[($number - 1)]] = array( |
| | | 'position' => $colpos++, |
| | | 'sorting' => 'ascending', |
| | | ); |
| | | } |
| | | return $definition; |
| | | } |
| | | |
| | | $query = 'SELECT a.attname
|
| | | FROM pg_constraint c
|
| | | LEFT JOIN pg_class t ON c.conrelid = t.oid
|
| | | LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(c.conkey)
|
| | | WHERE c.conname = %s
|
| | | AND t.relname = ' . $db->quote($table, 'text');
|
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name);
|
| | | $fields = $db->queryCol(sprintf($query, $db->quote($constraint_name_mdb2, 'text')), null);
|
| | | if (PEAR::isError($fields)) {
|
| | | return $fields;
|
| | |
| | | LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(c.confkey)
|
| | | WHERE c.conname = %s
|
| | | AND t.relname = ' . $db->quote($definition['references']['table'], 'text');
|
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name);
|
| | | $foreign_fields = $db->queryCol(sprintf($query, $db->quote($constraint_name_mdb2, 'text')), null);
|
| | | if (PEAR::isError($foreign_fields)) {
|
| | | return $foreign_fields;
|
| | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: sqlite.php,v 1.79 2008/03/05 11:08:53 quipo Exp $
|
| | | // $Id: sqlite.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | require_once 'MDB2/Driver/Reverse/Common.php';
|
| | |
| | | */
|
| | | class MDB2_Driver_Reverse_sqlite extends MDB2_Driver_Reverse_Common
|
| | | {
|
| | | /** |
| | | * Remove SQL comments from the field definition |
| | | * |
| | | * @access private |
| | | */ |
| | | function _removeComments($sql) { |
| | | $lines = explode("\n", $sql); |
| | | foreach ($lines as $k => $line) { |
| | | $pieces = explode('--', $line); |
| | | if (count($pieces) > 1 && (substr_count($pieces[0], '\'') % 2) == 0) { |
| | | $lines[$k] = substr($line, 0, strpos($line, '--')); |
| | | } |
| | | } |
| | | return implode("\n", $lines); |
| | | } |
| | | |
| | | /** |
| | | * |
| | | */ |
| | | function _getTableColumns($sql)
|
| | | {
|
| | | $db =& $this->getDBInstance();
|
| | |
| | | $column_def = substr($sql, $start_pos+1, $end_pos-$start_pos-1);
|
| | | // replace the decimal length-places-separator with a colon
|
| | | $column_def = preg_replace('/(\d),(\d)/', '\1:\2', $column_def);
|
| | | $column_sql = split(',', $column_def);
|
| | | $column_def = $this->_removeComments($column_def); |
| | | $column_sql = explode(',', $column_def); |
| | | $columns = array();
|
| | | $count = count($column_sql);
|
| | | if ($count == 0) {
|
| | | return $db->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'unexpected empty table column definition list', __FUNCTION__);
|
| | | }
|
| | | $regexp = '/^\s*([^\s]+) +(CHAR|VARCHAR|VARCHAR2|TEXT|BOOLEAN|SMALLINT|INT|INTEGER|DECIMAL|BIGINT|DOUBLE|FLOAT|DATETIME|DATE|TIME|LONGTEXT|LONGBLOB)( ?\(([1-9][0-9]*)(:([1-9][0-9]*))?\))?( UNSIGNED)?( PRIMARY KEY)?( DEFAULT (\'[^\']*\'|[^ ]+))?( NULL| NOT NULL)?( PRIMARY KEY)?$/i';
|
| | | $regexp = '/^\s*([^\s]+) +(CHAR|VARCHAR|VARCHAR2|TEXT|BOOLEAN|SMALLINT|INT|INTEGER|DECIMAL|BIGINT|DOUBLE|FLOAT|DATETIME|DATE|TIME|LONGTEXT|LONGBLOB)( ?\(([1-9][0-9]*)(:([1-9][0-9]*))?\))?( NULL| NOT NULL)?( UNSIGNED)?( NULL| NOT NULL)?( PRIMARY KEY)?( DEFAULT (\'[^\']*\'|[^ ]+))?( NULL| NOT NULL)?( PRIMARY KEY)?(\s*\-\-.*)?$/i'; |
| | | $regexp2 = '/^\s*([^ ]+) +(PRIMARY|UNIQUE|CHECK)$/i';
|
| | | for ($i=0, $j=0; $i<$count; ++$i) {
|
| | | if (!preg_match($regexp, trim($column_sql[$i]), $matches)) {
|
| | |
| | | if (isset($matches[6]) && strlen($matches[6])) {
|
| | | $columns[$j]['decimal'] = $matches[6];
|
| | | }
|
| | | if (isset($matches[7]) && strlen($matches[7])) {
|
| | | if (isset($matches[8]) && strlen($matches[8])) { |
| | | $columns[$j]['unsigned'] = true;
|
| | | }
|
| | | if (isset($matches[8]) && strlen($matches[8])) {
|
| | | if (isset($matches[9]) && strlen($matches[9])) { |
| | | $columns[$j]['autoincrement'] = true;
|
| | | }
|
| | | if (isset($matches[10]) && strlen($matches[10])) {
|
| | | $default = $matches[10];
|
| | | if (isset($matches[12]) && strlen($matches[12])) { |
| | | $default = $matches[12]; |
| | | if (strlen($default) && $default[0]=="'") {
|
| | | $default = str_replace("''", "'", substr($default, 1, strlen($default)-2));
|
| | | }
|
| | |
| | | }
|
| | | $columns[$j]['default'] = $default;
|
| | | }
|
| | | if (isset($matches[11]) && strlen($matches[11])) {
|
| | | $columns[$j]['notnull'] = ($matches[11] === ' NOT NULL');
|
| | | if (isset($matches[7]) && strlen($matches[7])) { |
| | | $columns[$j]['notnull'] = ($matches[7] === ' NOT NULL'); |
| | | } else if (isset($matches[9]) && strlen($matches[9])) { |
| | | $columns[$j]['notnull'] = ($matches[9] === ' NOT NULL'); |
| | | } else if (isset($matches[13]) && strlen($matches[13])) { |
| | | $columns[$j]['notnull'] = ($matches[13] === ' NOT NULL'); |
| | | }
|
| | | ++$j;
|
| | | }
|
| | |
| | | $default = false;
|
| | | if (array_key_exists('default', $column)) {
|
| | | $default = $column['default'];
|
| | | if (is_null($default) && $notnull) {
|
| | | if ((null === $default) && $notnull) { |
| | | $default = '';
|
| | | }
|
| | | }
|
| | |
| | | 'notnull' => $notnull,
|
| | | 'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i', '\\1', $column['type'])
|
| | | );
|
| | | if (!is_null($length)) {
|
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length;
|
| | | }
|
| | | if (!is_null($unsigned)) {
|
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned;
|
| | | }
|
| | | if (!is_null($fixed)) {
|
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed;
|
| | | }
|
| | | if ($default !== false) {
|
| | |
| | | $start_pos = strpos($sql, '(');
|
| | | $end_pos = strrpos($sql, ')');
|
| | | $column_names = substr($sql, $start_pos+1, $end_pos-$start_pos-1);
|
| | | $column_names = split(',', $column_names);
|
| | | $column_names = explode(',', $column_names); |
| | |
|
| | | if (preg_match("/^create unique/", $sql)) {
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | |
| | | if (preg_match("/\bPRIMARY\s+KEY\b\s*\(([^)]+)/i", $sql, $tmp)) {
|
| | | $definition['primary'] = true;
|
| | | $definition['fields'] = array();
|
| | | $column_names = split(',', $tmp[1]);
|
| | | $column_names = explode(',', $tmp[1]); |
| | | $colpos = 1;
|
| | | foreach ($column_names as $column_name) {
|
| | | $definition['fields'][trim($column_name)] = array(
|
| | |
| | | if (preg_match("/\"([^\"]+)\"[^\,\"]+\bPRIMARY\s+KEY\b[^\,\)]*/i", $sql, $tmp)) {
|
| | | $definition['primary'] = true;
|
| | | $definition['fields'] = array();
|
| | | $column_names = split(',', $tmp[1]);
|
| | | $column_names = explode(',', $tmp[1]); |
| | | $colpos = 1;
|
| | | foreach ($column_names as $column_name) {
|
| | | $definition['fields'][trim($column_name)] = array(
|
| | |
| | | $definition['onupdate'] = 'NO ACTION';
|
| | | $definition['ondelete'] = 'NO ACTION';
|
| | | $definition['references']['table'] = $tmp[2];
|
| | | $column_names = split(',', $tmp[1]);
|
| | | $column_names = explode(',', $tmp[1]); |
| | | $colpos = 1;
|
| | | foreach ($column_names as $column_name) {
|
| | | $definition['fields'][trim($column_name)] = array(
|
| | | 'position' => $colpos++
|
| | | );
|
| | | }
|
| | | $referenced_cols = split(',', $tmp[3]);
|
| | | $referenced_cols = explode(',', $tmp[3]); |
| | | $colpos = 1;
|
| | | foreach ($referenced_cols as $column_name) {
|
| | | $definition['references']['fields'][trim($column_name)] = array(
|
| | |
| | | $start_pos = strpos($sql, '(');
|
| | | $end_pos = strrpos($sql, ')');
|
| | | $column_names = substr($sql, $start_pos+1, $end_pos-$start_pos-1);
|
| | | $column_names = split(',', $column_names);
|
| | | $column_names = explode(',', $column_names); |
| | |
|
| | | if (!preg_match("/^create unique/", $sql)) {
|
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
New file |
| | |
| | | <?php |
| | | // +----------------------------------------------------------------------+ |
| | | // | PHP versions 4 and 5 | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Copyright (c) 1998-2007 Manuel Lemos, Tomas V.V.Cox, | |
| | | // | Stig. S. Bakken, Lukas Smith, Frank M. Kromann, Lorenzo Alberton | |
| | | // | All rights reserved. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB | |
| | | // | API as well as database abstraction for PHP applications. | |
| | | // | This LICENSE is in the BSD license style. | |
| | | // | | |
| | | // | Redistribution and use in source and binary forms, with or without | |
| | | // | modification, are permitted provided that the following conditions | |
| | | // | are met: | |
| | | // | | |
| | | // | Redistributions of source code must retain the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer. | |
| | | // | | |
| | | // | Redistributions in binary form must reproduce the above copyright | |
| | | // | notice, this list of conditions and the following disclaimer in the | |
| | | // | documentation and/or other materials provided with the distribution. | |
| | | // | | |
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, | |
| | | // | Lukas Smith nor the names of his contributors may be used to endorse | |
| | | // | or promote products derived from this software without specific prior| |
| | | // | written permission. | |
| | | // | | |
| | | // | 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 | |
| | | // | REGENTS 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. | |
| | | // +----------------------------------------------------------------------+ |
| | | // | Authors: Lukas Smith <smith@pooteeweet.org> | |
| | | // | Lorenzo Alberton <l.alberton@quipo.it> | |
| | | // +----------------------------------------------------------------------+ |
| | | |
| | | require_once 'MDB2/Driver/Reverse/Common.php'; |
| | | |
| | | /** |
| | | * MDB2 MSSQL driver for the schema reverse engineering module |
| | | * |
| | | * @package MDB2 |
| | | * @category Database |
| | | * @author Lukas Smith <smith@dybnet.de> |
| | | * @author Lorenzo Alberton <l.alberton@quipo.it> |
| | | */ |
| | | class MDB2_Driver_Reverse_sqlsrv extends MDB2_Driver_Reverse_Common |
| | | { |
| | | // {{{ getTableFieldDefinition() |
| | | |
| | | /** |
| | | * Get the structure of a field into an array |
| | | * |
| | | * @param string $table_name name of table that should be used in method |
| | | * @param string $field_name name of field that should be used in method |
| | | * @return mixed data array on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function getTableFieldDefinition($table_name, $field_name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $result = $db->loadModule('Datatype', null, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table_name); |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $fldname = $db->quoteIdentifier($field_name, true); |
| | | |
| | | $query = "SELECT t.table_name, |
| | | c.column_name 'name', |
| | | c.data_type 'type', |
| | | CASE c.is_nullable WHEN 'YES' THEN 1 ELSE 0 END AS 'is_nullable', |
| | | c.column_default, |
| | | c.character_maximum_length 'length', |
| | | c.numeric_precision, |
| | | c.numeric_scale, |
| | | c.character_set_name, |
| | | c.collation_name |
| | | FROM INFORMATION_SCHEMA.TABLES t, |
| | | INFORMATION_SCHEMA.COLUMNS c |
| | | WHERE t.table_name = c.table_name |
| | | AND t.table_name = '$table' |
| | | AND c.column_name = '$fldname'"; |
| | | if (!empty($schema)) { |
| | | $query .= " AND t.table_schema = '" .$db->quoteIdentifier($schema, true) ."'"; |
| | | } |
| | | $query .= ' ORDER BY t.table_name'; |
| | | $column = $db->queryRow($query, null, MDB2_FETCHMODE_ASSOC); |
| | | if (PEAR::isError($column)) { |
| | | return $column; |
| | | } |
| | | if (empty($column)) { |
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null, |
| | | 'it was not specified an existing table column', __FUNCTION__); |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $column['name'] = strtolower($column['name']); |
| | | } else { |
| | | $column['name'] = strtoupper($column['name']); |
| | | } |
| | | } else { |
| | | $column = array_change_key_case($column, $db->options['field_case']); |
| | | } |
| | | $mapped_datatype = $db->datatype->mapNativeDatatype($column); |
| | | if (PEAR::isError($mapped_datatype)) { |
| | | return $mapped_datatype; |
| | | } |
| | | list($types, $length, $unsigned, $fixed) = $mapped_datatype; |
| | | $notnull = true; |
| | | if ($column['is_nullable']) { |
| | | $notnull = false; |
| | | } |
| | | $default = false; |
| | | if (array_key_exists('column_default', $column)) { |
| | | $default = $column['column_default']; |
| | | if ((null === $default) && $notnull) { |
| | | $default = ''; |
| | | } elseif (strlen($default) > 4 |
| | | && substr($default, 0, 1) == '(' |
| | | && substr($default, -1, 1) == ')' |
| | | ) { |
| | | //mssql wraps the default value in parentheses: "((1234))", "(NULL)" |
| | | $default = trim($default, '()'); |
| | | if ($default == 'NULL') { |
| | | $default = null; |
| | | } |
| | | } |
| | | } |
| | | $definition[0] = array( |
| | | 'notnull' => $notnull, |
| | | 'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i', '\\1', $column['type']) |
| | | ); |
| | | if (null !== $length) { |
| | | $definition[0]['length'] = $length; |
| | | } |
| | | if (null !== $unsigned) { |
| | | $definition[0]['unsigned'] = $unsigned; |
| | | } |
| | | if (null !== $fixed) { |
| | | $definition[0]['fixed'] = $fixed; |
| | | } |
| | | if ($default !== false) { |
| | | $definition[0]['default'] = $default; |
| | | } |
| | | foreach ($types as $key => $type) { |
| | | $definition[$key] = $definition[0]; |
| | | if ($type == 'clob' || $type == 'blob') { |
| | | unset($definition[$key]['default']); |
| | | } |
| | | $definition[$key]['type'] = $type; |
| | | $definition[$key]['mdb2type'] = $type; |
| | | } |
| | | return $definition; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ getTableIndexDefinition() |
| | | |
| | | /** |
| | | * Get the structure of an index into an array |
| | | * |
| | | * @param string $table_name name of table that should be used in method |
| | | * @param string $index_name name of index that should be used in method |
| | | * @return mixed data array on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function getTableIndexDefinition($table_name, $index_name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table_name); |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | //$idxname = $db->quoteIdentifier($index_name, true); |
| | | |
| | | $query = "SELECT OBJECT_NAME(i.id) tablename, |
| | | i.name indexname, |
| | | c.name field_name, |
| | | CASE INDEXKEY_PROPERTY(i.id, i.indid, ik.keyno, 'IsDescending') |
| | | WHEN 1 THEN 'DESC' ELSE 'ASC' |
| | | END 'collation', |
| | | ik.keyno 'position' |
| | | FROM sysindexes i |
| | | JOIN sysindexkeys ik ON ik.id = i.id AND ik.indid = i.indid |
| | | JOIN syscolumns c ON c.id = ik.id AND c.colid = ik.colid |
| | | WHERE OBJECT_NAME(i.id) = '$table' |
| | | AND i.name = '%s' |
| | | AND NOT EXISTS ( |
| | | SELECT * |
| | | FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE k |
| | | WHERE k.table_name = OBJECT_NAME(i.id) |
| | | AND k.constraint_name = i.name"; |
| | | if (!empty($schema)) { |
| | | $query .= " AND k.table_schema = '" .$db->quoteIdentifier($schema, true) ."'"; |
| | | } |
| | | $query .= ') |
| | | ORDER BY tablename, indexname, ik.keyno'; |
| | | |
| | | $index_name_mdb2 = $db->getIndexName($index_name); |
| | | $result = $db->queryRow(sprintf($query, $index_name_mdb2)); |
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise |
| | | // fallback to the given $index_name, without transformation |
| | | $index_name = $index_name_mdb2; |
| | | } |
| | | $result = $db->query(sprintf($query, $index_name)); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | $definition = array(); |
| | | while (is_array($row = $result->fetchRow(MDB2_FETCHMODE_ASSOC))) { |
| | | $column_name = $row['field_name']; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $column_name = strtolower($column_name); |
| | | } else { |
| | | $column_name = strtoupper($column_name); |
| | | } |
| | | } |
| | | $definition['fields'][$column_name] = array( |
| | | 'position' => (int)$row['position'], |
| | | ); |
| | | if (!empty($row['collation'])) { |
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'ASC' |
| | | ? 'ascending' : 'descending'); |
| | | } |
| | | } |
| | | $result->free(); |
| | | if (empty($definition['fields'])) { |
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null, |
| | | 'it was not specified an existing table index', __FUNCTION__); |
| | | } |
| | | return $definition; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ getTableConstraintDefinition() |
| | | |
| | | /** |
| | | * Get the structure of a constraint into an array |
| | | * |
| | | * @param string $table_name name of table that should be used in method |
| | | * @param string $constraint_name name of constraint that should be used in method |
| | | * @return mixed data array on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function getTableConstraintDefinition($table_name, $constraint_name) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | list($schema, $table) = $this->splitTableSchema($table_name); |
| | | |
| | | $table = $db->quoteIdentifier($table, true); |
| | | $query = "SELECT k.table_name, |
| | | k.column_name field_name, |
| | | CASE c.constraint_type WHEN 'PRIMARY KEY' THEN 1 ELSE 0 END 'primary', |
| | | CASE c.constraint_type WHEN 'UNIQUE' THEN 1 ELSE 0 END 'unique', |
| | | CASE c.constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE 0 END 'foreign', |
| | | CASE c.constraint_type WHEN 'CHECK' THEN 1 ELSE 0 END 'check', |
| | | CASE c.is_deferrable WHEN 'NO' THEN 0 ELSE 1 END 'deferrable', |
| | | CASE c.initially_deferred WHEN 'NO' THEN 0 ELSE 1 END 'initiallydeferred', |
| | | rc.match_option 'match', |
| | | rc.update_rule 'onupdate', |
| | | rc.delete_rule 'ondelete', |
| | | kcu.table_name 'references_table', |
| | | kcu.column_name 'references_field', |
| | | k.ordinal_position 'field_position' |
| | | FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE k |
| | | LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS c |
| | | ON k.table_name = c.table_name |
| | | AND k.table_schema = c.table_schema |
| | | AND k.table_catalog = c.table_catalog |
| | | AND k.constraint_catalog = c.constraint_catalog |
| | | AND k.constraint_name = c.constraint_name |
| | | LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc |
| | | ON rc.constraint_schema = c.constraint_schema |
| | | AND rc.constraint_catalog = c.constraint_catalog |
| | | AND rc.constraint_name = c.constraint_name |
| | | LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu |
| | | ON rc.unique_constraint_schema = kcu.constraint_schema |
| | | AND rc.unique_constraint_catalog = kcu.constraint_catalog |
| | | AND rc.unique_constraint_name = kcu.constraint_name |
| | | AND k.ordinal_position = kcu.ordinal_position |
| | | WHERE k.constraint_catalog = DB_NAME() |
| | | AND k.table_name = '$table' |
| | | AND k.constraint_name = '%s'"; |
| | | if (!empty($schema)) { |
| | | $query .= " AND k.table_schema = '" .$db->quoteIdentifier($schema, true) ."'"; |
| | | } |
| | | $query .= ' ORDER BY k.constraint_name, |
| | | k.ordinal_position'; |
| | | |
| | | $constraint_name_mdb2 = $db->getIndexName($constraint_name); |
| | | $result = $db->queryRow(sprintf($query, $constraint_name_mdb2)); |
| | | if (!PEAR::isError($result) && (null !== $result)) { |
| | | // apply 'idxname_format' only if the query succeeded, otherwise |
| | | // fallback to the given $index_name, without transformation |
| | | $constraint_name = $constraint_name_mdb2; |
| | | } |
| | | $result = $db->query(sprintf($query, $constraint_name)); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | | } |
| | | |
| | | $definition = array( |
| | | 'fields' => array() |
| | | ); |
| | | while (is_array($row = $result->fetchRow(MDB2_FETCHMODE_ASSOC))) { |
| | | $row = array_change_key_case($row, CASE_LOWER); |
| | | $column_name = $row['field_name']; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $column_name = strtolower($column_name); |
| | | } else { |
| | | $column_name = strtoupper($column_name); |
| | | } |
| | | } |
| | | $definition['fields'][$column_name] = array( |
| | | 'position' => (int)$row['field_position'] |
| | | ); |
| | | if ($row['foreign']) { |
| | | $ref_column_name = $row['references_field']; |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $ref_column_name = strtolower($ref_column_name); |
| | | } else { |
| | | $ref_column_name = strtoupper($ref_column_name); |
| | | } |
| | | } |
| | | $definition['references']['table'] = $row['references_table']; |
| | | $definition['references']['fields'][$ref_column_name] = array( |
| | | 'position' => (int)$row['field_position'] |
| | | ); |
| | | } |
| | | //collation?!? |
| | | /* |
| | | if (!empty($row['collation'])) { |
| | | $definition['fields'][$column_name]['sorting'] = ($row['collation'] == 'ASC' |
| | | ? 'ascending' : 'descending'); |
| | | } |
| | | */ |
| | | $lastrow = $row; |
| | | // otherwise $row is no longer usable on exit from loop |
| | | } |
| | | $result->free(); |
| | | if (empty($definition['fields'])) { |
| | | return $db->raiseError(MDB2_ERROR_NOT_FOUND, null, null, |
| | | $constraint_name . ' is not an existing table constraint', __FUNCTION__); |
| | | } |
| | | |
| | | $definition['primary'] = (boolean)$lastrow['primary']; |
| | | $definition['unique'] = (boolean)$lastrow['unique']; |
| | | $definition['foreign'] = (boolean)$lastrow['foreign']; |
| | | $definition['check'] = (boolean)$lastrow['check']; |
| | | $definition['deferrable'] = (boolean)$lastrow['deferrable']; |
| | | $definition['initiallydeferred'] = (boolean)$lastrow['initiallydeferred']; |
| | | $definition['onupdate'] = $lastrow['onupdate']; |
| | | $definition['ondelete'] = $lastrow['ondelete']; |
| | | $definition['match'] = $lastrow['match']; |
| | | |
| | | return $definition; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ getTriggerDefinition() |
| | | |
| | | /** |
| | | * Get the structure of a trigger into an array |
| | | * |
| | | * EXPERIMENTAL |
| | | * |
| | | * WARNING: this function is experimental and may change the returned value |
| | | * at any time until labelled as non-experimental |
| | | * |
| | | * @param string $trigger name of trigger that should be used in method |
| | | * @return mixed data array on success, a MDB2 error on failure |
| | | * @access public |
| | | */ |
| | | function getTriggerDefinition($trigger) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $query = "SELECT sys1.name trigger_name, |
| | | sys2.name table_name, |
| | | c.text trigger_body, |
| | | c.encrypted is_encripted, |
| | | CASE |
| | | WHEN OBJECTPROPERTY(sys1.id, 'ExecIsTriggerDisabled') = 1 |
| | | THEN 0 ELSE 1 |
| | | END trigger_enabled, |
| | | CASE |
| | | WHEN OBJECTPROPERTY(sys1.id, 'ExecIsInsertTrigger') = 1 |
| | | THEN 'INSERT' |
| | | WHEN OBJECTPROPERTY(sys1.id, 'ExecIsUpdateTrigger') = 1 |
| | | THEN 'UPDATE' |
| | | WHEN OBJECTPROPERTY(sys1.id, 'ExecIsDeleteTrigger') = 1 |
| | | THEN 'DELETE' |
| | | END trigger_event, |
| | | CASE WHEN OBJECTPROPERTY(sys1.id, 'ExecIsInsteadOfTrigger') = 1 |
| | | THEN 'INSTEAD OF' ELSE 'AFTER' |
| | | END trigger_type, |
| | | '' trigger_comment |
| | | FROM sysobjects sys1 |
| | | JOIN sysobjects sys2 ON sys1.parent_obj = sys2.id |
| | | JOIN syscomments c ON sys1.id = c.id |
| | | WHERE sys1.xtype = 'TR' |
| | | AND sys1.name = ". $db->quote($trigger, 'text'); |
| | | |
| | | $types = array( |
| | | 'trigger_name' => 'text', |
| | | 'table_name' => 'text', |
| | | 'trigger_body' => 'text', |
| | | 'trigger_type' => 'text', |
| | | 'trigger_event' => 'text', |
| | | 'trigger_comment' => 'text', |
| | | 'trigger_enabled' => 'boolean', |
| | | 'is_encripted' => 'boolean', |
| | | ); |
| | | |
| | | $def = $db->queryRow($query, $types, MDB2_FETCHMODE_ASSOC); |
| | | if (PEAR::isError($def)) { |
| | | return $def; |
| | | } |
| | | $trg_body = $db->queryCol('EXEC sp_helptext '. $db->quote($trigger, 'text'), 'text'); |
| | | if (!PEAR::isError($trg_body)) { |
| | | $def['trigger_body'] = implode(' ', $trg_body); |
| | | } |
| | | return $def; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ tableInfo() |
| | | |
| | | /** |
| | | * Returns information about a table or a result set |
| | | * |
| | | * NOTE: only supports 'table' and 'flags' if <var>$result</var> |
| | | * is a table name. |
| | | * |
| | | * @param object|string $result MDB2_result object from a query or a |
| | | * string containing the name of a table. |
| | | * While this also accepts a query result |
| | | * resource identifier, this behavior is |
| | | * deprecated. |
| | | * @param int $mode a valid tableInfo mode |
| | | * |
| | | * @return array an associative array with the information requested. |
| | | * A MDB2_Error object on failure. |
| | | * |
| | | * @see MDB2_Driver_Common::tableInfo() |
| | | */ |
| | | function tableInfo($result, $mode = null) |
| | | { |
| | | if (is_string($result)) { |
| | | return parent::tableInfo($result, $mode); |
| | | } |
| | | |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | $resource = MDB2::isResultCommon($result) ? $result->getResource() : $result; |
| | | if (!is_resource($resource)) { |
| | | return $db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null, |
| | | 'Could not generate result resource', __FUNCTION__); |
| | | } |
| | | |
| | | if ($db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) { |
| | | if ($db->options['field_case'] == CASE_LOWER) { |
| | | $case_func = 'strtolower'; |
| | | } else { |
| | | $case_func = 'strtoupper'; |
| | | } |
| | | } else { |
| | | $case_func = 'strval'; |
| | | } |
| | | |
| | | $meta = @sqlsrv_field_metadata($resource); |
| | | $count = count($meta); |
| | | $res = array(); |
| | | |
| | | if ($mode) { |
| | | $res['num_fields'] = $count; |
| | | } |
| | | |
| | | $db->loadModule('Datatype', null, true); |
| | | for ($i = 0; $i < $count; $i++) { |
| | | $res[$i] = array( |
| | | 'table' => '', |
| | | 'name' => $case_func($meta[$i]['Name']), |
| | | 'type' => $meta[$i]['Type'], |
| | | 'length' => $meta[$i]['Size'], |
| | | 'numeric_precision' => $meta[$i]['Precision'], |
| | | 'numeric_scale' => $meta[$i]['Scale'], |
| | | 'flags' => '' |
| | | ); |
| | | $mdb2type_info = $db->datatype->mapNativeDatatype($res[$i]); |
| | | if (PEAR::isError($mdb2type_info)) { |
| | | return $mdb2type_info; |
| | | } |
| | | $res[$i]['mdb2type'] = $mdb2type_info[0][0]; |
| | | if ($mode & MDB2_TABLEINFO_ORDER) { |
| | | $res['order'][$res[$i]['name']] = $i; |
| | | } |
| | | if ($mode & MDB2_TABLEINFO_ORDERTABLE) { |
| | | $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i; |
| | | } |
| | | } |
| | | |
| | | return $res; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _mssql_field_flags() |
| | | |
| | | /** |
| | | * Get a column's flags |
| | | * |
| | | * Supports "not_null", "primary_key", |
| | | * "auto_increment" (mssql identity), "timestamp" (mssql timestamp), |
| | | * "unique_key" (mssql unique index, unique check or primary_key) and |
| | | * "multiple_key" (multikey index) |
| | | * |
| | | * mssql timestamp is NOT similar to the mysql timestamp so this is maybe |
| | | * not useful at all - is the behaviour of mysql_field_flags that primary |
| | | * keys are alway unique? is the interpretation of multiple_key correct? |
| | | * |
| | | * @param string $table the table name |
| | | * @param string $column the field name |
| | | * |
| | | * @return string the flags |
| | | * |
| | | * @access protected |
| | | * @author Joern Barthel <j_barthel@web.de> |
| | | */ |
| | | function _mssql_field_flags($table, $column) |
| | | { |
| | | $db =& $this->getDBInstance(); |
| | | if (PEAR::isError($db)) { |
| | | return $db; |
| | | } |
| | | |
| | | static $tableName = null; |
| | | static $flags = array(); |
| | | |
| | | if ($table != $tableName) { |
| | | |
| | | $flags = array(); |
| | | $tableName = $table; |
| | | |
| | | // get unique and primary keys |
| | | $res = $db->queryAll("EXEC SP_HELPINDEX[$table]", null, MDB2_FETCHMODE_ASSOC); |
| | | |
| | | foreach ($res as $val) { |
| | | $val = array_change_key_case($val, CASE_LOWER); |
| | | $keys = explode(', ', $val['index_keys']); |
| | | |
| | | if (sizeof($keys) > 1) { |
| | | foreach ($keys as $key) { |
| | | $this->_add_flag($flags[$key], 'multiple_key'); |
| | | } |
| | | } |
| | | |
| | | if (strpos($val['index_description'], 'primary key')) { |
| | | foreach ($keys as $key) { |
| | | $this->_add_flag($flags[$key], 'primary_key'); |
| | | } |
| | | } elseif (strpos($val['index_description'], 'unique')) { |
| | | foreach ($keys as $key) { |
| | | $this->_add_flag($flags[$key], 'unique_key'); |
| | | } |
| | | } |
| | | } |
| | | |
| | | // get auto_increment, not_null and timestamp |
| | | $res = $db->queryAll("EXEC SP_COLUMNS[$table]", null, MDB2_FETCHMODE_ASSOC); |
| | | |
| | | foreach ($res as $val) { |
| | | $val = array_change_key_case($val, CASE_LOWER); |
| | | if ($val['nullable'] == '0') { |
| | | $this->_add_flag($flags[$val['column_name']], 'not_null'); |
| | | } |
| | | if (strpos($val['type_name'], 'identity')) { |
| | | $this->_add_flag($flags[$val['column_name']], 'auto_increment'); |
| | | } |
| | | if (strpos($val['type_name'], 'timestamp')) { |
| | | $this->_add_flag($flags[$val['column_name']], 'timestamp'); |
| | | } |
| | | } |
| | | } |
| | | |
| | | if (!empty($flags[$column])) { |
| | | return(implode(' ', $flags[$column])); |
| | | } |
| | | return ''; |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ _add_flag() |
| | | |
| | | /** |
| | | * Adds a string to the flags array if the flag is not yet in there |
| | | * - if there is no flag present the array is created |
| | | * |
| | | * @param array &$array the reference to the flag-array |
| | | * @param string $value the flag value |
| | | * |
| | | * @return void |
| | | * |
| | | * @access protected |
| | | * @author Joern Barthel <j_barthel@web.de> |
| | | */ |
| | | function _add_flag(&$array, $value) |
| | | { |
| | | if (!is_array($array)) { |
| | | $array = array($value); |
| | | } elseif (!in_array($value, $array)) { |
| | | array_push($array, $value); |
| | | } |
| | | } |
| | | |
| | | // }}} |
| | | } |
| | | ?> |
| | |
| | | // | Author: Frank M. Kromann <frank@kromann.info> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: mssql.php,v 1.174 2008/03/08 14:18:39 quipo Exp $
|
| | | // $Id: mssql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | | // {{{ Class MDB2_Driver_mssql
|
| | | /**
|
| | |
| | | */
|
| | | function errorInfo($error = null, $connection = null)
|
| | | {
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->connection;
|
| | | }
|
| | |
|
| | |
| | | }
|
| | | }
|
| | | $native_msg = @mssql_get_last_message();
|
| | | if (is_null($error)) {
|
| | | if (null === $error) { |
| | | static $ecode_map;
|
| | | if (empty($ecode_map)) {
|
| | | $ecode_map = array(
|
| | |
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ escape() |
| | | |
| | | /** |
| | | * Quotes a string so it can be safely used in a query. It will quote |
| | | * the text so it can safely be used within a query. |
| | | * |
| | | * @param string $text the input string to quote |
| | | * @param bool $escape_wildcards flag |
| | | * |
| | | * @return string quoted string |
| | | * @access public |
| | | */ |
| | | function escape($text, $escape_wildcards = false) |
| | | { |
| | | $text = parent::escape($text, $escape_wildcards); |
| | | // http://pear.php.net/bugs/bug.php?id=16118 |
| | | // http://support.microsoft.com/kb/164291 |
| | | return preg_replace("/\\\\(\r\n|\r|\n)/", '\\\\$1', $text); |
| | | } |
| | | |
| | | // }}} |
| | | // {{{ beginTransaction()
|
| | |
|
| | | /**
|
| | | * Start a transaction or set a savepoint.
|
| | | *
|
| | | * @param string name of a savepoint to set
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @param string $savepoint name of a savepoint to set |
| | | *
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public
|
| | | */
|
| | | function beginTransaction($savepoint = null)
|
| | | {
|
| | | $this->debug('Starting transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | if (!$this->in_transaction) {
|
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'savepoint cannot be released when changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | $query = 'SAVE TRANSACTION '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | } elseif ($this->in_transaction) {
|
| | | } |
| | | if ($this->in_transaction) { |
| | | return MDB2_OK; //nothing to do
|
| | | }
|
| | | if (!$this->destructor_registered && $this->opened_persistent) {
|
| | |
| | | * auto-committing is disabled, otherwise it will fail. Therefore, a new
|
| | | * transaction is implicitly started after committing the pending changes.
|
| | | *
|
| | | * @param string name of a savepoint to release
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @param string $savepoint name of a savepoint to release |
| | | *
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public
|
| | | */
|
| | | function commit($savepoint = null)
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'commit/release savepoint cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | |
| | | * auto-committing is disabled, otherwise it will fail. Therefore, a new
|
| | | * transaction is implicitly started after canceling the pending changes.
|
| | | *
|
| | | * @param string name of a savepoint to rollback to
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @param string $savepoint name of a savepoint to rollback to |
| | | *
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | * @access public
|
| | | */
|
| | | function rollback($savepoint = null)
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'rollback cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | $query = 'ROLLBACK TRANSACTION '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | }
|
| | |
| | | /**
|
| | | * do the grunt work of the connect
|
| | | *
|
| | | * @param string $username |
| | | * @param string $password |
| | | * @param boolean $persistent |
| | | * |
| | | * @return connection on success or MDB2 Error Object on failure
|
| | | * @access protected
|
| | | */
|
| | | function _doConnect($username, $password, $persistent = false)
|
| | | {
|
| | | if (!PEAR::loadExtension($this->phptype) && !PEAR::loadExtension('sybase_ct')) {
|
| | | if ( !PEAR::loadExtension($this->phptype) |
| | | && !PEAR::loadExtension('sybase_ct') |
| | | && !PEAR::loadExtension('odbtp') |
| | | && !function_exists('mssql_connect') |
| | | ) { |
| | | return $this->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | 'extension '.$this->phptype.' is not compiled into PHP', __FUNCTION__);
|
| | | }
|
| | |
| | | $params[0].= ((substr(PHP_OS, 0, 3) == 'WIN') ? ',' : ':').$this->dsn['port'];
|
| | | }
|
| | | if (!$persistent) {
|
| | | if (isset($this->dsn['new_link'])
|
| | | && ($this->dsn['new_link'] == 'true' || $this->dsn['new_link'] === true)
|
| | | ) {
|
| | | if ($this->_isNewLinkSet()) { |
| | | $params[] = true;
|
| | | } else {
|
| | | $params[] = false;
|
| | |
| | | */ |
| | |
|
| | | if ((bool)ini_get('mssql.datetimeconvert')) {
|
| | | // his isn't the most elegant way of doing it but it prevents from |
| | | // breaking anything thus preserves BC. Bug #11849 |
| | | if (isset($this->options['datetimeconvert']) && (bool)$this->options['datetimeconvert'] !== false) { |
| | | @ini_set('mssql.datetimeconvert', '1'); |
| | | } else { |
| | | @ini_set('mssql.datetimeconvert', '0');
|
| | | } |
| | | }
|
| | |
|
| | | if (empty($this->dsn['disable_iso_date'])) {
|
| | |
| | | }
|
| | |
|
| | | if (!$this->opened_persistent || $force) {
|
| | | @mssql_close($this->connection);
|
| | | $ok = @mssql_close($this->connection); |
| | | if (!$ok) { |
| | | return $this->raiseError(MDB2_ERROR_DISCONNECT_FAILED, |
| | | null, null, null, __FUNCTION__); |
| | | }
|
| | | } |
| | | } else { |
| | | return false; |
| | | }
|
| | | return parent::disconnect($force);
|
| | | }
|
| | |
| | | return $result;
|
| | | }
|
| | |
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | | }
|
| | | }
|
| | | if (is_null($database_name)) {
|
| | | if (null === $database_name) { |
| | | $database_name = $this->database_name;
|
| | | }
|
| | |
|
| | |
| | | */
|
| | | function _affectedRows($connection, $result = null)
|
| | | {
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | function lastInsertID($table = null, $field = null)
|
| | | {
|
| | | $server_info = $this->getServerVersion();
|
| | | if (is_array($server_info) && !is_null($server_info['major'])
|
| | | if (is_array($server_info) && (null !== $server_info['major']) |
| | | && $server_info['major'] >= 8
|
| | | ) {
|
| | | $query = "SELECT IDENT_CURRENT('$table')";
|
| | | } else {
|
| | | $query = "SELECT @@IDENTITY";
|
| | | if (!is_null($table)) {
|
| | | if (null !== $table) { |
| | | $query .= ' FROM '.$this->quoteIdentifier($table, true);
|
| | | }
|
| | | }
|
| | |
| | | *
|
| | | * @param int $fetchmode how the array data should be indexed
|
| | | * @param int $rownum number of the row where the data can be found
|
| | | * |
| | | * @return int data array on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | |
| | | $null = null;
|
| | | return $null;
|
| | | }
|
| | | if (!is_null($rownum)) {
|
| | | if (null !== $rownum) { |
| | | $seek = $this->seek($rownum);
|
| | | if (PEAR::isError($seek)) {
|
| | | return $seek;
|
| | |
| | | $row = @mssql_fetch_row($this->result);
|
| | | }
|
| | | if (!$row) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | $err =& $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | return $err;
|
| | |
| | | if ($object_class == 'stdClass') {
|
| | | $row = (object) $row;
|
| | | } else {
|
| | | $row = new $object_class($row);
|
| | | $rowObj = new $object_class($row); |
| | | $row = $rowObj; |
| | | }
|
| | | }
|
| | | ++$this->rownum;
|
| | |
| | | function numCols()
|
| | | {
|
| | | $cols = @mssql_num_fields($this->result);
|
| | | if (is_null($cols)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $cols) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return count($this->types);
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | |
| | | */
|
| | | function nextResult()
|
| | | {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return false;
|
| | | }
|
| | | return @mssql_next_result($this->result);
|
| | |
| | | {
|
| | | if (is_resource($this->result) && $this->db->connection) {
|
| | | $free = @mssql_free_result($this->result);
|
| | | if ($free === false) {
|
| | | if (false === $free) { |
| | | return $this->db->raiseError(null, null, null,
|
| | | 'Could not free result', __FUNCTION__);
|
| | | }
|
| | |
| | | * Seek to a specific row in a result set
|
| | | *
|
| | | * @param int $rownum number of the row where the data can be found
|
| | | * |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | | function seek($rownum = 0)
|
| | | {
|
| | | if ($this->rownum != ($rownum - 1) && !@mssql_data_seek($this->result, $rownum)) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return MDB2_OK;
|
| | | }
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | |
| | | function numRows()
|
| | | {
|
| | | $rows = @mssql_num_rows($this->result);
|
| | | if (is_null($rows)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $rows) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return 0;
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | | 'Could not get row count', __FUNCTION__);
|
| | | }
|
| | | if ($this->limit) {
|
| | | $rows -= $this->limit -1 + $this->offset;
|
| | | $rows -= $this->offset; |
| | | if ($rows > $this->limit + 1) { |
| | | $rows = $this->limit + 1; |
| | | } |
| | | if ($rows < 0) {
|
| | | $rows = 0;
|
| | | }
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mysql.php,v 1.208 2008/03/13 03:31:55 afz Exp $ |
| | | // $Id: mysql.php 292659 2009-12-26 17:31:01Z quipo $ |
| | | // |
| | | |
| | | /** |
| | |
| | | $this->destructor_registered = true; |
| | | register_shutdown_function('MDB2_closeOpenTransactions'); |
| | | } |
| | | $query = $this->start_transaction ? 'START TRANSACTION' : 'SET AUTOCOMMIT = 1'; |
| | | $query = $this->start_transaction ? 'START TRANSACTION' : 'SET AUTOCOMMIT = 0'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | return $result; |
| | | } |
| | | if (!$this->start_transaction) { |
| | | $query = 'SET AUTOCOMMIT = 0'; |
| | | $query = 'SET AUTOCOMMIT = 1'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | return $result; |
| | | } |
| | | if (!$this->start_transaction) { |
| | | $query = 'SET AUTOCOMMIT = 0'; |
| | | $query = 'SET AUTOCOMMIT = 1'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | } |
| | | |
| | | $params = array(); |
| | | if ($this->dsn['protocol'] && $this->dsn['protocol'] == 'unix') { |
| | | $params[0] = ':' . $this->dsn['socket']; |
| | | } else { |
| | | $params[0] = $this->dsn['hostspec'] ? $this->dsn['hostspec'] |
| | | : 'localhost'; |
| | | if ($this->dsn['port']) { |
| | | $params[0].= ':' . $this->dsn['port']; |
| | | $unix = ($this->dsn['protocol'] && $this->dsn['protocol'] == 'unix'); |
| | | if (empty($this->dsn['hostspec'])) { |
| | | $this->dsn['hostspec'] = $unix ? '' : 'localhost'; |
| | | } |
| | | if ($this->dsn['hostspec']) { |
| | | $params[0] = $this->dsn['hostspec'] . ($this->dsn['port'] ? ':' . $this->dsn['port'] : ''); |
| | | } else { |
| | | $params[0] = ':' . $this->dsn['socket']; |
| | | } |
| | | $params[] = $username ? $username : null; |
| | | $params[] = $password ? $password : null; |
| | | if (!$persistent) { |
| | | if (isset($this->dsn['new_link']) |
| | | && ($this->dsn['new_link'] == 'true' || $this->dsn['new_link'] === true) |
| | | ) { |
| | | if ($this->_isNewLinkSet()) { |
| | | $params[] = true; |
| | | } else { |
| | | $params[] = false; |
| | |
| | | $collation = array_pop($charset); |
| | | $charset = array_pop($charset); |
| | | } |
| | | $client_info = mysql_get_client_info(); |
| | | if (function_exists('mysql_set_charset') && version_compare($client_info, '5.0.6')) { |
| | | if (!$result = mysql_set_charset($charset, $connection)) { |
| | | $err =& $this->raiseError(null, null, null, |
| | | 'Could not set client character set', __FUNCTION__); |
| | | return $err; |
| | | } |
| | | return $result; |
| | | } |
| | | $query = "SET NAMES '".mysql_real_escape_string($charset, $connection)."'"; |
| | | if (!is_null($collation)) { |
| | | $query .= " COLLATE '".mysqli_real_escape_string($connection, $collation)."'"; |
| | | $query .= " COLLATE '".mysql_real_escape_string($collation, $connection)."'"; |
| | | } |
| | | return $this->_doQuery($query, true, $connection); |
| | | } |
| | |
| | | } |
| | | |
| | | if (!$this->opened_persistent || $force) { |
| | | @mysql_close($this->connection); |
| | | $ok = @mysql_close($this->connection); |
| | | if (!$ok) { |
| | | return $this->raiseError(MDB2_ERROR_DISCONNECT_FAILED, |
| | | null, null, null, __FUNCTION__); |
| | | } |
| | | } |
| | | } else { |
| | | return false; |
| | | } |
| | | return parent::disconnect($force); |
| | | } |
| | |
| | | $function = $this->options['result_buffering'] |
| | | ? 'mysql_query' : 'mysql_unbuffered_query'; |
| | | $result = @$function($query, $connection); |
| | | if (!$result) { |
| | | if (!$result && 0 !== mysql_errno($connection)) { |
| | | $err =& $this->raiseError(null, null, null, |
| | | 'Could not execute statement', __FUNCTION__); |
| | | return $err; |
| | |
| | | */ |
| | | function &prepare($query, $types = null, $result_types = null, $lobs = array()) |
| | | { |
| | | // connect to get server capabilities (http://pear.php.net/bugs/16147) |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | | } |
| | | |
| | | if ($this->options['emulate_prepared'] |
| | | || $this->supported['prepared_statements'] !== true |
| | | ) { |
| | |
| | | $position = $p_position; |
| | | } |
| | | } |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | | } |
| | | |
| | | static $prep_statement_counter = 1; |
| | | $statement_name = sprintf($this->options['statement_format'], $this->phptype, $prep_statement_counter++ . sha1(microtime() + mt_rand())); |
| | | $statement_name = substr(strtolower($statement_name), 0, $this->options['max_identifiers_length']); |
| | |
| | | /** |
| | | * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT |
| | | * query, except that if there is already a row in the table with the same |
| | | * key field values, the REPLACE query just updates its values instead of |
| | | * inserting a new row. |
| | | * key field values, the old row is deleted before the new row is inserted. |
| | | * |
| | | * The REPLACE type of query does not make part of the SQL standards. Since |
| | | * practically only MySQL implements it natively, this type of query is |
| | |
| | | * |
| | | * Default: 0 |
| | | * |
| | | * @see http://dev.mysql.com/doc/refman/5.0/en/replace.html |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | */ |
| | | function replace($table, $fields) |
| | |
| | | if ($object_class == 'stdClass') { |
| | | $row = (object) $row; |
| | | } else { |
| | | $row = new $object_class($row); |
| | | $rowObj = new $object_class($row); |
| | | $row = $rowObj; |
| | | } |
| | | } |
| | | ++$this->rownum; |
| | |
| | | } |
| | | return $rows; |
| | | } |
| | | |
| | | // }}} |
| | | } |
| | | |
| | | /** |
| | |
| | | * |
| | | * @param mixed $result_class string which specifies which result class to use |
| | | * @param mixed $result_wrap_class string which specifies which class to wrap results in |
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure |
| | | * |
| | | * @return mixed MDB2_Result or integer (affected rows) on success, |
| | | * a MDB2 error on failure |
| | | * @access private |
| | | */ |
| | | function &_execute($result_class = true, $result_wrap_class = false) |
| | |
| | | return $this->db->raiseError(MDB2_ERROR_NOT_FOUND, null, null, |
| | | 'Unable to bind to missing placeholder: '.$parameter, __FUNCTION__); |
| | | } |
| | | $close = false; |
| | | $value = $this->values[$parameter]; |
| | | $type = array_key_exists($parameter, $this->types) ? $this->types[$parameter] : null; |
| | | if (is_resource($value) || $type == 'clob' || $type == 'blob' && $this->db->options['lob_allow_url_include']) { |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: mysqli.php,v 1.188 2008/03/13 03:31:55 afz Exp $ |
| | | // $Id: mysqli.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | // |
| | | |
| | | /** |
| | |
| | | $native_code = @mysqli_connect_errno(); |
| | | $native_msg = @mysqli_connect_error(); |
| | | } |
| | | if (is_null($error)) { |
| | | if (null === $error) { |
| | | static $ecode_map; |
| | | if (empty($ecode_map)) { |
| | | $ecode_map = array( |
| | |
| | | { |
| | | $this->debug('Starting transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint)); |
| | | $this->_getServerCapabilities(); |
| | | if (!is_null($savepoint)) { |
| | | if (null !== $savepoint) { |
| | | if (!$this->supports('savepoints')) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'savepoints are not supported', __FUNCTION__); |
| | |
| | | } |
| | | $query = 'SAVEPOINT '.$savepoint; |
| | | return $this->_doQuery($query, true); |
| | | } elseif ($this->in_transaction) { |
| | | } |
| | | if ($this->in_transaction) { |
| | | return MDB2_OK; //nothing to do |
| | | } |
| | | $query = $this->start_transaction ? 'START TRANSACTION' : 'SET AUTOCOMMIT = 1'; |
| | | $query = $this->start_transaction ? 'START TRANSACTION' : 'SET AUTOCOMMIT = 0'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null, |
| | | 'commit/release savepoint cannot be done changes are auto committed', __FUNCTION__); |
| | | } |
| | | if (!is_null($savepoint)) { |
| | | if (null !== $savepoint) { |
| | | if (!$this->supports('savepoints')) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'savepoints are not supported', __FUNCTION__); |
| | |
| | | return $result; |
| | | } |
| | | if (!$this->start_transaction) { |
| | | $query = 'SET AUTOCOMMIT = 0'; |
| | | $query = 'SET AUTOCOMMIT = 1'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null, |
| | | 'rollback cannot be done changes are auto committed', __FUNCTION__); |
| | | } |
| | | if (!is_null($savepoint)) { |
| | | if (null !== $savepoint) { |
| | | if (!$this->supports('savepoints')) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null, |
| | | 'savepoints are not supported', __FUNCTION__); |
| | |
| | | return $result; |
| | | } |
| | | if (!$this->start_transaction) { |
| | | $query = 'SET AUTOCOMMIT = 0'; |
| | | $query = 'SET AUTOCOMMIT = 1'; |
| | | $result =& $this->_doQuery($query, true); |
| | | if (PEAR::isError($result)) { |
| | | return $result; |
| | |
| | | */ |
| | | function setCharset($charset, $connection = null) |
| | | { |
| | | if (is_null($connection)) { |
| | | if (null === $connection) { |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | |
| | | ((50000 <= $client_info) && (50006 > $client_info))) |
| | | ) { |
| | | $query = "SET NAMES '".mysqli_real_escape_string($connection, $charset)."'"; |
| | | if (!is_null($collation)) { |
| | | if (null !== $collation) { |
| | | $query .= " COLLATE '".mysqli_real_escape_string($connection, $collation)."'"; |
| | | } |
| | | return $this->_doQuery($query, true, $connection); |
| | |
| | | } |
| | | |
| | | if ($force) { |
| | | @mysqli_close($this->connection); |
| | | $ok = @mysqli_close($this->connection); |
| | | if (!$ok) { |
| | | return $this->raiseError(MDB2_ERROR_DISCONNECT_FAILED, |
| | | null, null, null, __FUNCTION__); |
| | | } |
| | | } |
| | | } else { |
| | | return false; |
| | | } |
| | | return parent::disconnect($force); |
| | | } |
| | |
| | | return $result; |
| | | } |
| | | |
| | | if (is_null($connection)) { |
| | | if (null === $connection) { |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | | } |
| | | } |
| | | if (is_null($database_name)) { |
| | | if (null === $database_name) { |
| | | $database_name = $this->database_name; |
| | | } |
| | | |
| | |
| | | $result = mysqli_query($connection, $query); |
| | | } |
| | | |
| | | if (!$result) { |
| | | if (!$result && 0 !== mysqli_errno($connection)) { |
| | | $err =& $this->raiseError(null, null, null, |
| | | 'Could not execute statement', __FUNCTION__); |
| | | return $err; |
| | |
| | | */ |
| | | function _affectedRows($connection, $result = null) |
| | | { |
| | | if (is_null($connection)) { |
| | | if (null === $connection) { |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | |
| | | $this->supported['prepared_statements'] = true; |
| | | } |
| | | |
| | | // SAVEPOINTS were introduced in MySQL 4.0.14 and 4.1.1 (InnoDB) |
| | | // SAVEPOINTs were introduced in MySQL 4.0.14 and 4.1.1 (InnoDB) |
| | | if (version_compare($server_version, '4.1.0', '>=')) { |
| | | if (version_compare($server_version, '4.1.1', '<')) { |
| | | $this->supported['savepoints'] = false; |
| | |
| | | function _skipUserDefinedVariable($query, $position) |
| | | { |
| | | $found = strpos(strrev(substr($query, 0, $position)), '@'); |
| | | if ($found === false) { |
| | | if (false === $found) { |
| | | return $position; |
| | | } |
| | | $pos = strlen($query) - strlen(substr($query, $position)) - $found - 1; |
| | |
| | | */ |
| | | function &prepare($query, $types = null, $result_types = null, $lobs = array()) |
| | | { |
| | | // connect to get server capabilities (http://pear.php.net/bugs/16147) |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | | } |
| | | |
| | | if ($this->options['emulate_prepared'] |
| | | || $this->supported['prepared_statements'] !== true |
| | | ) { |
| | |
| | | } else { |
| | | break; |
| | | } |
| | | if (is_null($placeholder_type)) { |
| | | if (null === $placeholder_type) { |
| | | $placeholder_type_guess = $query[$p_position]; |
| | | } |
| | | |
| | |
| | | } |
| | | |
| | | if ($query[$position] == $placeholder_type_guess) { |
| | | if (is_null($placeholder_type)) { |
| | | if (null === $placeholder_type) { |
| | | $placeholder_type = $query[$p_position]; |
| | | $question = $colon = $placeholder_type; |
| | | } |
| | |
| | | } else { |
| | | $position = $p_position; |
| | | } |
| | | } |
| | | $connection = $this->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | | } |
| | | |
| | | if (!$is_manip) { |
| | |
| | | /** |
| | | * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT |
| | | * query, except that if there is already a row in the table with the same |
| | | * key field values, the REPLACE query just updates its values instead of |
| | | * inserting a new row. |
| | | * key field values, the old row is deleted before the new row is inserted. |
| | | * |
| | | * The REPLACE type of query does not make part of the SQL standards. Since |
| | | * practically only MySQL implements it natively, this type of query is |
| | |
| | | * |
| | | * Default: 0 |
| | | * |
| | | * @see http://dev.mysql.com/doc/refman/5.0/en/replace.html |
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure |
| | | */ |
| | | function replace($table, $fields) |
| | |
| | | */ |
| | | function &fetchRow($fetchmode = MDB2_FETCHMODE_DEFAULT, $rownum = null) |
| | | { |
| | | if (!is_null($rownum)) { |
| | | if (null !== $rownum) { |
| | | $seek = $this->seek($rownum); |
| | | if (PEAR::isError($seek)) { |
| | | return $seek; |
| | |
| | | } |
| | | |
| | | if (!$row) { |
| | | if ($this->result === false) { |
| | | if (false === $this->result) { |
| | | $err =& $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null, |
| | | 'resultset has already been freed', __FUNCTION__); |
| | | return $err; |
| | |
| | | if ($object_class == 'stdClass') { |
| | | $row = (object) $row; |
| | | } else { |
| | | $row = new $object_class($row); |
| | | $rowObj = new $object_class($row); |
| | | $row = $rowObj; |
| | | } |
| | | } |
| | | ++$this->rownum; |
| | |
| | | function numCols() |
| | | { |
| | | $cols = @mysqli_num_fields($this->result); |
| | | if (is_null($cols)) { |
| | | if ($this->result === false) { |
| | | if (null === $cols) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null, |
| | | 'resultset has already been freed', __FUNCTION__); |
| | | } elseif (is_null($this->result)) { |
| | | } |
| | | if (null === $this->result) { |
| | | return count($this->types); |
| | | } |
| | | return $this->db->raiseError(null, null, null, |
| | |
| | | */ |
| | | function free() |
| | | { |
| | | do { |
| | | if (is_object($this->result) && $this->db->connection) { |
| | | $free = @mysqli_free_result($this->result); |
| | | if ($free === false) { |
| | | if (false === $free) { |
| | | return $this->db->raiseError(null, null, null, |
| | | 'Could not free result', __FUNCTION__); |
| | | } |
| | | } |
| | | } while ($this->result = $this->nextResult()); |
| | | |
| | | $this->result = false; |
| | | return MDB2_OK; |
| | | } |
| | |
| | | function seek($rownum = 0) |
| | | { |
| | | if ($this->rownum != ($rownum - 1) && !@mysqli_data_seek($this->result, $rownum)) { |
| | | if ($this->result === false) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null, |
| | | 'resultset has already been freed', __FUNCTION__); |
| | | } elseif (is_null($this->result)) { |
| | | } |
| | | if (null === $this->result) { |
| | | return MDB2_OK; |
| | | } |
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null, |
| | |
| | | function numRows() |
| | | { |
| | | $rows = @mysqli_num_rows($this->result); |
| | | if (is_null($rows)) { |
| | | if ($this->result === false) { |
| | | if (null === $rows) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null, |
| | | 'resultset has already been freed', __FUNCTION__); |
| | | } elseif (is_null($this->result)) { |
| | | } |
| | | if (null === $this->result) { |
| | | return 0; |
| | | } |
| | | return $this->db->raiseError(null, null, null, |
| | |
| | | * |
| | | * @param mixed $result_class string which specifies which result class to use |
| | | * @param mixed $result_wrap_class string which specifies which class to wrap results in |
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure |
| | | * |
| | | * @return mixed MDB2_Result or integer (affected rows) on success, |
| | | * a MDB2 error on failure |
| | | * @access private |
| | | */ |
| | | function &_execute($result_class = true, $result_wrap_class = false) |
| | | { |
| | | if (is_null($this->statement)) { |
| | | if (null === $this->statement) { |
| | | $result =& parent::_execute($result_class, $result_wrap_class); |
| | | return $result; |
| | | } |
| | |
| | | $query.= ' USING @'.implode(', @', array_values($this->positions)); |
| | | } else { |
| | | $result = @call_user_func_array('mysqli_stmt_bind_param', $parameters); |
| | | if ($result === false) { |
| | | if (false === $result) { |
| | | $err =& $this->db->raiseError(null, null, null, |
| | | 'Unable to bind parameters', __FUNCTION__); |
| | | return $err; |
| | |
| | | */ |
| | | function free() |
| | | { |
| | | if (is_null($this->positions)) { |
| | | if (null === $this->positions) { |
| | | return $this->db->raiseError(MDB2_ERROR, null, null, |
| | | 'Prepared statement has already been freed', __FUNCTION__); |
| | | } |
| | |
| | | $result = $this->db->raiseError(null, null, null, |
| | | 'Could not free statement', __FUNCTION__); |
| | | } |
| | | } elseif (!is_null($this->statement)) { |
| | | } elseif (null !== $this->statement) { |
| | | $connection = $this->db->getConnection(); |
| | | if (PEAR::isError($connection)) { |
| | | return $connection; |
| | |
| | | // | Author: Paul Cooper <pgc@ucecom.com> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: pgsql.php,v 1.197 2008/03/08 14:18:39 quipo Exp $
|
| | | // $Id: pgsql.php 292715 2009-12-28 14:06:34Z quipo $ |
| | |
|
| | | /**
|
| | | * MDB2 PostGreSQL driver
|
| | |
| | | $this->options['DBA_username'] = false;
|
| | | $this->options['DBA_password'] = false;
|
| | | $this->options['multi_query'] = false;
|
| | | $this->options['disable_smart_seqname'] = false;
|
| | | $this->options['disable_smart_seqname'] = true; |
| | | $this->options['max_identifiers_length'] = 63;
|
| | | }
|
| | |
|
| | |
| | | '/(relation|sequence|table).*does not exist|class .* not found/i'
|
| | | => MDB2_ERROR_NOSUCHTABLE,
|
| | | '/database .* does not exist/'
|
| | | => MDB2_ERROR_NOT_FOUND, |
| | | '/constraint .* does not exist/' |
| | | => MDB2_ERROR_NOT_FOUND,
|
| | | '/index .* does not exist/'
|
| | | => MDB2_ERROR_NOT_FOUND,
|
| | |
| | | function beginTransaction($savepoint = null)
|
| | | {
|
| | | $this->debug('Starting transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | if (!$this->in_transaction) {
|
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'savepoint cannot be released when changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | $query = 'SAVEPOINT '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | } elseif ($this->in_transaction) {
|
| | | } |
| | | if ($this->in_transaction) { |
| | | return MDB2_OK; //nothing to do
|
| | | }
|
| | | if (!$this->destructor_registered && $this->opened_persistent) {
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'commit/release savepoint cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | $query = 'RELEASE SAVEPOINT '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | }
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'rollback cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | $query = 'ROLLBACK TO SAVEPOINT '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | }
|
| | |
| | | $params[0].= ' service=' . $this->dsn['service'];
|
| | | }
|
| | |
|
| | | if (!empty($this->dsn['new_link'])
|
| | | && ($this->dsn['new_link'] == 'true' || $this->dsn['new_link'] === true))
|
| | | {
|
| | | if ($this->_isNewLinkSet()) { |
| | | if (version_compare(phpversion(), '4.3.0', '>=')) {
|
| | | $params[] = PGSQL_CONNECT_FORCE_NEW;
|
| | | }
|
| | |
| | | $result = $this->setCharset($this->dsn['charset'], $connection);
|
| | | if (PEAR::isError($result)) {
|
| | | return $result;
|
| | | } |
| | | } |
| | | |
| | | // Enable extra compatibility settings on 8.2 and later |
| | | if (function_exists('pg_parameter_status')) { |
| | | $version = pg_parameter_status($connection, 'server_version'); |
| | | if ($version == false) { |
| | | return $this->raiseError(null, null, null, |
| | | 'Unable to retrieve server version', __FUNCTION__); |
| | | } |
| | | $version = explode ('.', $version); |
| | | if ( $version['0'] > 8 |
| | | || ($version['0'] == 8 && $version['1'] >= 2) |
| | | ) { |
| | | if (!@pg_query($connection, "SET SESSION STANDARD_CONFORMING_STRINGS = OFF")) { |
| | | return $this->raiseError(null, null, null, |
| | | 'Unable to set standard_conforming_strings to off', __FUNCTION__); |
| | | } |
| | | |
| | | if (!@pg_query($connection, "SET SESSION ESCAPE_STRING_WARNING = OFF")) { |
| | | return $this->raiseError(null, null, null, |
| | | 'Unable to set escape_string_warning to off', __FUNCTION__); |
| | | } |
| | | }
|
| | | }
|
| | |
|
| | |
| | | */
|
| | | function setCharset($charset, $connection = null)
|
| | | {
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | }
|
| | |
|
| | | if (!$this->opened_persistent || $force) {
|
| | | @pg_close($this->connection);
|
| | | $ok = @pg_close($this->connection); |
| | | if (!$ok) { |
| | | return $this->raiseError(MDB2_ERROR_DISCONNECT_FAILED, |
| | | null, null, null, __FUNCTION__); |
| | | }
|
| | | } |
| | | } else { |
| | | return false; |
| | | }
|
| | | return parent::disconnect($force);
|
| | | }
|
| | |
| | | return $result;
|
| | | }
|
| | |
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | */
|
| | | function _affectedRows($connection, $result = null)
|
| | | {
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | } else {
|
| | | break;
|
| | | }
|
| | | if (is_null($placeholder_type)) {
|
| | | if (null === $placeholder_type) { |
| | | $placeholder_type_guess = $query[$p_position];
|
| | | }
|
| | |
|
| | |
| | | }
|
| | |
|
| | | if ($query[$position] == $placeholder_type_guess) {
|
| | | if (is_null($placeholder_type)) {
|
| | | if (null === $placeholder_type) { |
| | | $placeholder_type = $query[$p_position];
|
| | | $question = $colon = $placeholder_type;
|
| | | if (!empty($types) && is_array($types)) {
|
| | |
| | | static $prep_statement_counter = 1;
|
| | | $statement_name = sprintf($this->options['statement_format'], $this->phptype, $prep_statement_counter++ . sha1(microtime() + mt_rand()));
|
| | | $statement_name = substr(strtolower($statement_name), 0, $this->options['max_identifiers_length']);
|
| | | if ($pgtypes === false) {
|
| | | if (false === $pgtypes) { |
| | | $result = @pg_prepare($connection, $statement_name, $query);
|
| | | if (!$result) {
|
| | | $err =& $this->raiseError(null, null, null,
|
| | |
| | | }
|
| | | }
|
| | |
|
| | | return sprintf($this->options['seqname_format'],
|
| | | preg_replace('/[^\w\$.]/i', '_', $sqn));
|
| | | return parent::getSequenceName($sqn); |
| | | }
|
| | |
|
| | | // }}}
|
| | |
| | | */
|
| | | function &fetchRow($fetchmode = MDB2_FETCHMODE_DEFAULT, $rownum = null)
|
| | | {
|
| | | if (!is_null($rownum)) {
|
| | | if (null !== $rownum) { |
| | | $seek = $this->seek($rownum);
|
| | | if (PEAR::isError($seek)) {
|
| | | return $seek;
|
| | |
| | | $row = @pg_fetch_row($this->result);
|
| | | }
|
| | | if (!$row) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | $err =& $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | return $err;
|
| | |
| | | if ($object_class == 'stdClass') {
|
| | | $row = (object) $row;
|
| | | } else {
|
| | | $row = new $object_class($row);
|
| | | $rowObj = new $object_class($row); |
| | | $row = $rowObj; |
| | | }
|
| | | }
|
| | | ++$this->rownum;
|
| | |
| | | function numCols()
|
| | | {
|
| | | $cols = @pg_num_fields($this->result);
|
| | | if (is_null($cols)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $cols) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return count($this->types);
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | |
| | | {
|
| | | if (is_resource($this->result) && $this->db->connection) {
|
| | | $free = @pg_free_result($this->result);
|
| | | if ($free === false) {
|
| | | if (false === $free) { |
| | | return $this->db->raiseError(null, null, null,
|
| | | 'Could not free result', __FUNCTION__);
|
| | | }
|
| | |
| | | function seek($rownum = 0)
|
| | | {
|
| | | if ($this->rownum != ($rownum - 1) && !@pg_result_seek($this->result, $rownum)) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return MDB2_OK;
|
| | | }
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | |
| | | function numRows()
|
| | | {
|
| | | $rows = @pg_num_rows($this->result);
|
| | | if (is_null($rows)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $rows) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return 0;
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | |
| | | *
|
| | | * @param mixed $result_class string which specifies which result class to use
|
| | | * @param mixed $result_wrap_class string which specifies which class to wrap results in
|
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure
|
| | | * |
| | | * @return mixed MDB2_Result or integer (affected rows) on success, |
| | | * a MDB2 error on failure |
| | | * @access private
|
| | | */
|
| | | function &_execute($result_class = true, $result_wrap_class = false)
|
| | | {
|
| | | if (is_null($this->statement)) {
|
| | | if (null === $this->statement) { |
| | | $result =& parent::_execute($result_class, $result_wrap_class);
|
| | | return $result;
|
| | | }
|
| | |
| | | */
|
| | | function free()
|
| | | {
|
| | | if (is_null($this->positions)) {
|
| | | if (null === $this->positions) { |
| | | return $this->db->raiseError(MDB2_ERROR, null, null,
|
| | | 'Prepared statement has already been freed', __FUNCTION__);
|
| | | }
|
| | | $result = MDB2_OK;
|
| | |
|
| | | if (!is_null($this->statement)) {
|
| | | if (null !== $this->statement) { |
| | | $connection = $this->db->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: sqlite.php,v 1.158 2008/03/08 14:18:39 quipo Exp $
|
| | | // $Id: sqlite.php 292715 2009-12-28 14:06:34Z quipo $ |
| | | //
|
| | |
|
| | | /**
|
| | |
| | | // this hack to work around it, per bug #9599.
|
| | | $native_msg = preg_replace('/^sqlite[a-z_]+\(\)[^:]*: /', '', $native_msg);
|
| | |
|
| | | if (is_null($error)) {
|
| | | if (null === $error) { |
| | | static $error_regexps;
|
| | | if (empty($error_regexps)) {
|
| | | $error_regexps = array(
|
| | |
| | | function beginTransaction($savepoint = null)
|
| | | {
|
| | | $this->debug('Starting transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'savepoints are not supported', __FUNCTION__);
|
| | | } elseif ($this->in_transaction) {
|
| | | } |
| | | if ($this->in_transaction) { |
| | | return MDB2_OK; //nothing to do
|
| | | }
|
| | | if (!$this->destructor_registered && $this->opened_persistent) {
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'commit/release savepoint cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'savepoints are not supported', __FUNCTION__);
|
| | | }
|
| | |
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'rollback cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (!is_null($savepoint)) {
|
| | | if (null !== $savepoint) { |
| | | return $this->raiseError(MDB2_ERROR_UNSUPPORTED, null, null,
|
| | | 'savepoints are not supported', __FUNCTION__);
|
| | | }
|
| | |
| | | 'extension '.$this->phptype.' is not compiled into PHP', __FUNCTION__);
|
| | | }
|
| | |
|
| | | if (!empty($this->database_name)) {
|
| | | if (empty($this->database_name)) { |
| | | return $this->raiseError(MDB2_ERROR_CONNECT_FAILED, null, null, |
| | | 'unable to establish a connection', __FUNCTION__); |
| | | } |
| | | |
| | | if ($database_file !== ':memory:') {
|
| | | if (!file_exists($database_file)) {
|
| | | if (!touch($database_file)) {
|
| | |
| | | 'unable to establish a connection', __FUNCTION__);
|
| | | }
|
| | |
|
| | | /* |
| | | if (!empty($this->dsn['charset'])) {
|
| | | $result = $this->setCharset($this->dsn['charset'], $connection);
|
| | | if (PEAR::isError($result)) {
|
| | | return $result;
|
| | | if ($this->fix_assoc_fields_names || |
| | | $this->options['portability'] & MDB2_PORTABILITY_FIX_ASSOC_FIELD_NAMES) |
| | | { |
| | | @sqlite_query("PRAGMA short_column_names = 1", $connection); |
| | | $this->fix_assoc_fields_names = true; |
| | | }
|
| | | }
|
| | | */ |
| | |
|
| | | $this->connection = $connection;
|
| | | $this->connected_dsn = $this->dsn;
|
| | | $this->connected_database_name = $database_file;
|
| | | $this->opened_persistent = $this->getoption('persistent');
|
| | | $this->dbsyntax = $this->dsn['dbsyntax'] ? $this->dsn['dbsyntax'] : $this->phptype;
|
| | | }
|
| | | |
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | |
| | | if (!$this->opened_persistent || $force) {
|
| | | @sqlite_close($this->connection);
|
| | | }
|
| | | } else { |
| | | return false; |
| | | }
|
| | | return parent::disconnect($force);
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ getConnection()
|
| | |
|
| | | /**
|
| | | * Returns a native connection
|
| | | *
|
| | | * @return mixed a valid MDB2 connection object,
|
| | | * or a MDB2 error object on error
|
| | | * @access public
|
| | | */
|
| | | function getConnection()
|
| | | {
|
| | | $connection = parent::getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | | }
|
| | |
|
| | | $fix_assoc_fields_names = $this->options['portability'] & MDB2_PORTABILITY_FIX_ASSOC_FIELD_NAMES;
|
| | | if ($fix_assoc_fields_names !== $this->fix_assoc_fields_names) {
|
| | | @sqlite_query("PRAGMA short_column_names = $fix_assoc_fields_names;", $connection);
|
| | | $this->fix_assoc_fields_names = $fix_assoc_fields_names;
|
| | | }
|
| | |
|
| | | return $connection;
|
| | | }
|
| | |
|
| | | // }}}
|
| | |
| | | return $result;
|
| | | }
|
| | |
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | */
|
| | | function _affectedRows($connection, $result = null)
|
| | | {
|
| | | if (is_null($connection)) {
|
| | | if (null === $connection) { |
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | |
| | | /**
|
| | | * Execute a SQL REPLACE query. A REPLACE query is identical to a INSERT
|
| | | * query, except that if there is already a row in the table with the same
|
| | | * key field values, the REPLACE query just updates its values instead of
|
| | | * inserting a new row.
|
| | | * key field values, the old row is deleted before the new row is inserted. |
| | | *
|
| | | * The REPLACE type of query does not make part of the SQL standards. Since
|
| | | * practically only SQLite implements it natively, this type of query is
|
| | |
| | | */
|
| | | function &fetchRow($fetchmode = MDB2_FETCHMODE_DEFAULT, $rownum = null)
|
| | | {
|
| | | if (!is_null($rownum)) {
|
| | | if (null !== $rownum) { |
| | | $seek = $this->seek($rownum);
|
| | | if (PEAR::isError($seek)) {
|
| | | return $seek;
|
| | |
| | | $row = @sqlite_fetch_array($this->result, SQLITE_NUM);
|
| | | }
|
| | | if (!$row) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | $err =& $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | return $err;
|
| | |
| | | if ($object_class == 'stdClass') {
|
| | | $row = (object) $row;
|
| | | } else {
|
| | | $row = new $object_class($row);
|
| | | $rowObj = new $object_class($row); |
| | | $row = $rowObj; |
| | | }
|
| | | }
|
| | | ++$this->rownum;
|
| | |
| | | function numCols()
|
| | | {
|
| | | $cols = @sqlite_num_fields($this->result);
|
| | | if (is_null($cols)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $cols) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return count($this->types);
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | |
| | | function seek($rownum = 0)
|
| | | {
|
| | | if (!@sqlite_seek($this->result, $rownum)) {
|
| | | if ($this->result === false) {
|
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return MDB2_OK;
|
| | | }
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | |
| | | function numRows()
|
| | | {
|
| | | $rows = @sqlite_num_rows($this->result);
|
| | | if (is_null($rows)) {
|
| | | if ($this->result === false) {
|
| | | if (null === $rows) { |
| | | if (false === $this->result) { |
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | } elseif (is_null($this->result)) {
|
| | | } |
| | | if (null === $this->result) { |
| | | return 0;
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | |
| | | {
|
| | |
|
| | | }
|
| | |
|
| | | ?> |
New file |
| | |
| | | <?php
|
| | | // vim: set et ts=4 sw=4 fdm=marker:
|
| | | // +----------------------------------------------------------------------+
|
| | | // | PHP versions 4 and 5 |
|
| | | // +----------------------------------------------------------------------+
|
| | | // | Copyright (c) 1998-2008 Manuel Lemos, Tomas V.V.Cox, |
|
| | | // | Stig. S. Bakken, Lukas Smith, Frank M. Kromann |
|
| | | // | All rights reserved. |
|
| | | // +----------------------------------------------------------------------+
|
| | | // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB |
|
| | | // | API as well as database abstraction for PHP applications. |
|
| | | // | This LICENSE is in the BSD license style. |
|
| | | // | |
|
| | | // | Redistribution and use in source and binary forms, with or without |
|
| | | // | modification, are permitted provided that the following conditions |
|
| | | // | are met: |
|
| | | // | |
|
| | | // | Redistributions of source code must retain the above copyright |
|
| | | // | notice, this list of conditions and the following disclaimer. |
|
| | | // | |
|
| | | // | Redistributions in binary form must reproduce the above copyright |
|
| | | // | notice, this list of conditions and the following disclaimer in the |
|
| | | // | documentation and/or other materials provided with the distribution. |
|
| | | // | |
|
| | | // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, |
|
| | | // | Lukas Smith nor the names of his contributors may be used to endorse |
|
| | | // | or promote products derived from this software without specific prior|
|
| | | // | written permission. |
|
| | | // | |
|
| | | // | 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 |
|
| | | // | REGENTS 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. |
|
| | | // +----------------------------------------------------------------------+
|
| | | // | Author: Frank M. Kromann <frank@kromann.info> |
|
| | | // +----------------------------------------------------------------------+
|
| | | // {{{ Class MDB2_Driver_sqlsrv
|
| | | /**
|
| | | * MDB2 MSSQL Server (native) driver
|
| | | *
|
| | | * @package MDB2
|
| | | * @category Database
|
| | | */
|
| | | class MDB2_Driver_sqlsrv extends MDB2_Driver_Common
|
| | | {
|
| | | // {{{ properties
|
| | |
|
| | | var $string_quoting = array('start' => "'", 'end' => "'", 'escape' => "'", 'escape_pattern' => false);
|
| | |
|
| | | var $identifier_quoting = array('start' => '[', 'end' => ']', 'escape' => ']');
|
| | | |
| | | var $connection = null;
|
| | |
|
| | | // }}}
|
| | | // {{{ constructor
|
| | |
|
| | | /**
|
| | | * Constructor
|
| | | */
|
| | | function __construct()
|
| | | {
|
| | | parent::__construct();
|
| | |
|
| | | $this->phptype = 'sqlsrv';
|
| | | $this->dbsyntax = 'sqlsrv';
|
| | |
|
| | | $this->supported['sequences'] = 'emulated';
|
| | | $this->supported['indexes'] = true;
|
| | | $this->supported['affected_rows'] = true;
|
| | | $this->supported['summary_functions'] = true;
|
| | | $this->supported['transactions'] = true;
|
| | | $this->supported['order_by_text'] = true;
|
| | | $this->supported['savepoints'] = false;
|
| | | $this->supported['current_id'] = 'emulated';
|
| | | $this->supported['limit_queries'] = 'emulated';
|
| | | $this->supported['LOBs'] = true;
|
| | | $this->supported['replace'] = 'emulated';
|
| | | $this->supported['sub_selects'] = true;
|
| | | $this->supported['triggers'] = true;
|
| | | $this->supported['auto_increment'] = true;
|
| | | $this->supported['primary_key'] = true;
|
| | | $this->supported['result_introspection'] = true;
|
| | | $this->supported['prepared_statements'] = 'emulated';
|
| | | $this->supported['identifier_quoting'] = false;
|
| | | $this->supported['pattern_escaping'] = true;
|
| | | $this->supported['new_link'] = true;
|
| | |
|
| | | $this->options['DBA_username'] = false;
|
| | | $this->options['DBA_password'] = false;
|
| | | $this->options['database_device'] = false;
|
| | | $this->options['database_size'] = false;
|
| | | $this->options['max_identifiers_length'] = 128; // MS Access: 64
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ errorInfo()
|
| | |
|
| | | /**
|
| | | * This method is used to collect information about an error
|
| | | *
|
| | | * @param integer $error
|
| | | * @return array
|
| | | * @access public
|
| | | */
|
| | | function errorInfo($error = null, $connection = null)
|
| | | {
|
| | | if (null === $connection) {
|
| | | if (!$this->connection) {
|
| | | $this->connect();
|
| | | }
|
| | | $connection = $this->connection;
|
| | | }
|
| | |
|
| | | $native_code = null;
|
| | | $native_msg = null;
|
| | | if ($connection) {
|
| | | $retErrors = sqlsrv_errors(SQLSRV_ERR_ALL); |
| | | if ($retErrors !== null) {
|
| | | foreach ($retErrors as $arrError) {
|
| | | $native_msg .= "SQLState: ".$arrError[ 'SQLSTATE']."\n"; |
| | | $native_msg .= "Error Code: ".$arrError[ 'code']."\n"; |
| | | $native_msg .= "Message: ".$arrError[ 'message']."\n"; |
| | | $native_code = $arrError[ 'code'];
|
| | | } |
| | | } |
| | | }
|
| | | if (null === $error) {
|
| | | static $ecode_map;
|
| | | if (empty($ecode_map)) {
|
| | | $ecode_map = array(
|
| | | 102 => MDB2_ERROR_SYNTAX,
|
| | | 110 => MDB2_ERROR_VALUE_COUNT_ON_ROW,
|
| | | 155 => MDB2_ERROR_NOSUCHFIELD,
|
| | | 156 => MDB2_ERROR_SYNTAX,
|
| | | 170 => MDB2_ERROR_SYNTAX,
|
| | | 207 => MDB2_ERROR_NOSUCHFIELD,
|
| | | 208 => MDB2_ERROR_NOSUCHTABLE,
|
| | | 245 => MDB2_ERROR_INVALID_NUMBER,
|
| | | 319 => MDB2_ERROR_SYNTAX,
|
| | | 321 => MDB2_ERROR_NOSUCHFIELD,
|
| | | 325 => MDB2_ERROR_SYNTAX,
|
| | | 336 => MDB2_ERROR_SYNTAX,
|
| | | 515 => MDB2_ERROR_CONSTRAINT_NOT_NULL,
|
| | | 547 => MDB2_ERROR_CONSTRAINT,
|
| | | 911 => MDB2_ERROR_NOT_FOUND,
|
| | | 1018 => MDB2_ERROR_SYNTAX,
|
| | | 1035 => MDB2_ERROR_SYNTAX,
|
| | | 1801 => MDB2_ERROR_ALREADY_EXISTS,
|
| | | 1913 => MDB2_ERROR_ALREADY_EXISTS,
|
| | | 2209 => MDB2_ERROR_SYNTAX,
|
| | | 2223 => MDB2_ERROR_SYNTAX,
|
| | | 2248 => MDB2_ERROR_SYNTAX,
|
| | | 2256 => MDB2_ERROR_SYNTAX,
|
| | | 2257 => MDB2_ERROR_SYNTAX,
|
| | | 2627 => MDB2_ERROR_CONSTRAINT,
|
| | | 2714 => MDB2_ERROR_ALREADY_EXISTS,
|
| | | 3607 => MDB2_ERROR_DIVZERO,
|
| | | 3701 => MDB2_ERROR_NOSUCHTABLE,
|
| | | 7630 => MDB2_ERROR_SYNTAX,
|
| | | 8134 => MDB2_ERROR_DIVZERO,
|
| | | 9303 => MDB2_ERROR_SYNTAX,
|
| | | 9317 => MDB2_ERROR_SYNTAX,
|
| | | 9318 => MDB2_ERROR_SYNTAX,
|
| | | 9331 => MDB2_ERROR_SYNTAX,
|
| | | 9332 => MDB2_ERROR_SYNTAX,
|
| | | 15253 => MDB2_ERROR_SYNTAX,
|
| | | );
|
| | | }
|
| | | if (isset($ecode_map[$native_code])) {
|
| | | if ($native_code == 3701
|
| | | && preg_match('/Cannot drop the index/i', $native_msg)
|
| | | ) {
|
| | | $error = MDB2_ERROR_NOT_FOUND;
|
| | | } else {
|
| | | $error = $ecode_map[$native_code];
|
| | | }
|
| | | }
|
| | | }
|
| | | return array($error, $native_code, $native_msg);
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ function escapePattern($text)
|
| | |
|
| | | /**
|
| | | * Quotes pattern (% and _) characters in a string)
|
| | | *
|
| | | * @param string the input string to quote
|
| | | *
|
| | | * @return string quoted string
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function escapePattern($text)
|
| | | {
|
| | | $text = str_replace("[", "[ [ ]", $text);
|
| | | foreach ($this->wildcards as $wildcard) {
|
| | | $text = str_replace($wildcard, '[' . $wildcard . ']', $text);
|
| | | }
|
| | | return $text;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ beginTransaction()
|
| | |
|
| | | /**
|
| | | * Start a transaction or set a savepoint.
|
| | | *
|
| | | * @param string name of a savepoint to set
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function beginTransaction($savepoint = null)
|
| | | {
|
| | | $this->debug('Starting transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (null !== $savepoint) {
|
| | | if (!$this->in_transaction) {
|
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'savepoint cannot be released when changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | $query = 'SAVE TRANSACTION '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | }
|
| | | if ($this->in_transaction) {
|
| | | return MDB2_OK; //nothing to do
|
| | | }
|
| | | if (!$this->destructor_registered && $this->opened_persistent) {
|
| | | $this->destructor_registered = true;
|
| | | register_shutdown_function('MDB2_closeOpenTransactions');
|
| | | }
|
| | | if (PEAR::isError(sqlsrv_begin_transaction($this->connection))) {
|
| | | return MDB2_ERROR;
|
| | | }
|
| | | $this->in_transaction = true;
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ commit()
|
| | |
|
| | | /**
|
| | | * Commit the database changes done during a transaction that is in
|
| | | * progress or release a savepoint. This function may only be called when
|
| | | * auto-committing is disabled, otherwise it will fail. Therefore, a new
|
| | | * transaction is implicitly started after committing the pending changes.
|
| | | *
|
| | | * @param string name of a savepoint to release
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function commit($savepoint = null)
|
| | | {
|
| | | $this->debug('Committing transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (!$this->in_transaction) {
|
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'commit/release savepoint cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (null !== $savepoint) {
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | if (PEAR::isError(sqlsrv_commit($this->connection))) {
|
| | | return MDB2_ERROR;
|
| | | }
|
| | | $this->in_transaction = false;
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ rollback()
|
| | |
|
| | | /**
|
| | | * Cancel any database changes done during a transaction or since a specific
|
| | | * savepoint that is in progress. This function may only be called when
|
| | | * auto-committing is disabled, otherwise it will fail. Therefore, a new
|
| | | * transaction is implicitly started after canceling the pending changes.
|
| | | *
|
| | | * @param string name of a savepoint to rollback to
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function rollback($savepoint = null)
|
| | | {
|
| | | $this->debug('Rolling back transaction/savepoint', __FUNCTION__, array('is_manip' => true, 'savepoint' => $savepoint));
|
| | | if (!$this->in_transaction) {
|
| | | return $this->raiseError(MDB2_ERROR_INVALID, null, null,
|
| | | 'rollback cannot be done changes are auto committed', __FUNCTION__);
|
| | | }
|
| | | if (null !== $savepoint) {
|
| | | $query = 'ROLLBACK TRANSACTION '.$savepoint;
|
| | | return $this->_doQuery($query, true);
|
| | | }
|
| | |
|
| | | if (PEAR::isError(sqlsrv_rollback($this->connection))) {
|
| | | return MDB2_ERROR;
|
| | | }
|
| | | $this->in_transaction = false;
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _doConnect()
|
| | |
|
| | | /**
|
| | | * do the grunt work of the connect
|
| | | *
|
| | | * @return connection on success or MDB2 Error Object on failure
|
| | | * @access protected
|
| | | */
|
| | | function _doConnect($username, $password, $database=null, $persistent = false)
|
| | | {
|
| | | if (!PEAR::loadExtension($this->phptype)) {
|
| | | return $this->raiseError(MDB2_ERROR_NOT_FOUND, null, null,
|
| | | 'extension '.$this->phptype.' is not installed PHP', __FUNCTION__);
|
| | | }
|
| | |
|
| | | $host = $this->dsn['hostspec'] ? $this->dsn['hostspec'] : '.\\SQLEXPRESS';
|
| | | $params = array(
|
| | | 'UID' => $username ? $username : null,
|
| | | 'PWD' => $password ? $password : null,
|
| | | );
|
| | | if ($database) {
|
| | | $params['Database'] = $database;
|
| | | }
|
| | | |
| | | if ($this->dsn['port'] && $this->dsn['port'] != 1433) {
|
| | | $host .= ','.$this->dsn['port'];
|
| | | }
|
| | |
|
| | | $connection = @sqlsrv_connect($host, $params);
|
| | | if (!$connection) {
|
| | | return $this->raiseError(MDB2_ERROR_CONNECT_FAILED, null, null,
|
| | | 'unable to establish a connection', __FUNCTION__, __FUNCTION__);
|
| | | }
|
| | | if (null !== $database) {
|
| | | $this->connected_database_name = $database;
|
| | | }
|
| | |
|
| | | if (!empty($this->dsn['charset'])) {
|
| | | $result = $this->setCharset($this->dsn['charset'], $connection);
|
| | | if (PEAR::isError($result)) {
|
| | | return $result;
|
| | | }
|
| | | }
|
| | |
|
| | | if (empty($this->dsn['disable_iso_date'])) {
|
| | | @sqlsrv_query($connection,'SET DATEFORMAT ymd');
|
| | | }
|
| | |
|
| | | return $connection;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ connect()
|
| | |
|
| | | /**
|
| | | * Connect to the database
|
| | | *
|
| | | * @return true on success, MDB2 Error Object on failure
|
| | | */
|
| | | function connect()
|
| | | {
|
| | | if (is_resource($this->connection)) {
|
| | | if (MDB2::areEquals($this->connected_dsn, $this->dsn)) {
|
| | | return MDB2_OK;
|
| | | }
|
| | | $this->disconnect(false);
|
| | | }
|
| | |
|
| | | $connection = $this->_doConnect(
|
| | | $this->dsn['username'],
|
| | | $this->dsn['password'],
|
| | | $this->database_name,
|
| | | $this->options['persistent']
|
| | | );
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | | }
|
| | |
|
| | | $this->connection = $connection;
|
| | | $this->connected_dsn = $this->dsn;
|
| | | $this->connected_database_name = $this->database_name;
|
| | | $this->opened_persistent = $this->options['persistent'];
|
| | | $this->dbsyntax = $this->dsn['dbsyntax'] ? $this->dsn['dbsyntax'] : $this->phptype;
|
| | |
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ databaseExists()
|
| | |
|
| | | /**
|
| | | * check if given database name exists?
|
| | | *
|
| | | * @param string $name name of the database that should be checked
|
| | | *
|
| | | * @return mixed true/false on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | | function databaseExists($name)
|
| | | {
|
| | | $connection = $this->_doConnect($this->dsn['username'],$this->dsn['password']);
|
| | | if (PEAR::isError($connection)) {
|
| | | return MDB2_ERROR_CONNECT_FAILED;
|
| | | }
|
| | | $result = @sqlsrv_query($connection,'select name from master..sysdatabases where name = \''.strtolower($name).'\'');
|
| | | if (@sqlsrv_fetch($result)) {
|
| | | return true;
|
| | | }
|
| | | return MDB2_ERROR_NOT_FOUND;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ disconnect()
|
| | |
|
| | | /**
|
| | | * Log out and disconnect from the database.
|
| | | *
|
| | | * @param boolean $force if the disconnect should be forced even if the
|
| | | * connection is opened persistently
|
| | | * @return mixed true on success, false if not connected and error
|
| | | * object on error
|
| | | * @access public
|
| | | */
|
| | | function disconnect($force = true)
|
| | | {
|
| | | if (is_resource($this->connection)) {
|
| | | if ($this->in_transaction) {
|
| | | $dsn = $this->dsn;
|
| | | $database_name = $this->database_name;
|
| | | $persistent = $this->options['persistent'];
|
| | | $this->dsn = $this->connected_dsn;
|
| | | $this->database_name = $this->connected_database_name;
|
| | | $this->options['persistent'] = $this->opened_persistent;
|
| | | $this->rollback();
|
| | | $this->dsn = $dsn;
|
| | | $this->database_name = $database_name;
|
| | | $this->options['persistent'] = $persistent;
|
| | | }
|
| | |
|
| | | @sqlsrv_close($this->connection);
|
| | | }
|
| | | return parent::disconnect($force);
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ standaloneQuery()
|
| | |
|
| | | /**
|
| | | * execute a query as DBA
|
| | | *
|
| | | * @param string $query the SQL query
|
| | | * @param mixed $types array that contains the types of the columns in
|
| | | * the result set
|
| | | * @param boolean $is_manip if the query is a manipulation query
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | | function &standaloneQuery($query, $types = null, $is_manip = false)
|
| | | {
|
| | | $user = $this->options['DBA_username']? $this->options['DBA_username'] : $this->dsn['username'];
|
| | | $pass = $this->options['DBA_password']? $this->options['DBA_password'] : $this->dsn['password'];
|
| | | $connection = $this->_doConnect($user, $pass, $this->database_name, $this->options['persistent']);
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | | }
|
| | |
|
| | | $query = $this->_modifyQuery($query, $is_manip, $this->limit, $this->offset);
|
| | | $this->offset = $this->limit = 0;
|
| | | |
| | | $result =& $this->_doQuery($query, $is_manip, $connection);
|
| | | if (!PEAR::isError($result)) {
|
| | | $result = $this->_affectedRows($connection, $result);
|
| | | }
|
| | |
|
| | | @sqlsrv_close($connection);
|
| | | return $result;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _doQuery()
|
| | |
|
| | | /**
|
| | | * Execute a query
|
| | | * @param string $query query
|
| | | * @param boolean $is_manip if the query is a manipulation query
|
| | | * @param resource $connection
|
| | | * @param string $database_name
|
| | | * @return result or error object
|
| | | * @access protected
|
| | | */
|
| | | function &_doQuery($query, $is_manip = false, $connection = null, $database_name = null)
|
| | | {
|
| | | $this->last_query = $query;
|
| | | $result = $this->debug($query, 'query', array('is_manip' => $is_manip, 'when' => 'pre'));
|
| | | if ($result) {
|
| | | if (PEAR::isError($result)) {
|
| | | return $result;
|
| | | }
|
| | | $query = $result;
|
| | | }
|
| | | if ($this->options['disable_query']) {
|
| | | $result = $is_manip ? 0 : null;
|
| | | return $result;
|
| | | }
|
| | |
|
| | | if (null === $connection) {
|
| | | $connection = $this->getConnection();
|
| | | if (PEAR::isError($connection)) {
|
| | | return $connection;
|
| | | }
|
| | | }
|
| | | if (null === $database_name) {
|
| | | $database_name = $this->database_name;
|
| | | }
|
| | |
|
| | | if ($database_name && $database_name != $this->connected_database_name) {
|
| | | $connection = $this->_doConnect($this->dsn['username'],$this->dsn['password'],$database_name);
|
| | | if (PEAR::isError($connection)) {
|
| | | $err = $this->raiseError(null, null, null,
|
| | | 'Could not select the database: '.$database_name, __FUNCTION__);
|
| | | return $err;
|
| | | }
|
| | | $this->connected_database_name = $database_name;
|
| | | }
|
| | |
|
| | | $query = preg_replace('/DATE_FORMAT\((MIN\()?([\w|.]*)(\))?\\Q, \'%Y-%m-%d\')\E/i','CONVERT(varchar(10),$1$2$3,120)',$query); |
| | | $query = preg_replace('/DATE_FORMAT\(([\w|.]*)\, \'\%Y\-\%m\-\%d %H\:00\:00\'\)/i','CONVERT(varchar(13),$1,120)+\':00:00\'',$query); |
| | | $result = @sqlsrv_query($connection,$query);
|
| | | if (!$result) {
|
| | | $err =& $this->raiseError(null, null, null,
|
| | | 'Could not execute statement', __FUNCTION__);
|
| | | return $err;
|
| | | }
|
| | | $this->result = $result;
|
| | | $this->debug($query, 'query', array('is_manip' => $is_manip, 'when' => 'post', 'result' => $result));
|
| | | return $result;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _affectedRows()
|
| | |
|
| | | /**
|
| | | * Returns the number of rows affected
|
| | | *
|
| | | * @param resource $result
|
| | | * @param resource $connection
|
| | | * @return mixed MDB2 Error Object or the number of rows affected
|
| | | * @access private
|
| | | */
|
| | | function _affectedRows($connection, $result = null)
|
| | | {
|
| | | if (null === $result) {
|
| | | $result = $this->result;
|
| | | }
|
| | | return sqlsrv_rows_affected($this->result);
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _modifyQuery()
|
| | |
|
| | | /**
|
| | | * Changes a query string for various DBMS specific reasons
|
| | | *
|
| | | * @param string $query query to modify
|
| | | * @param boolean $is_manip if it is a DML query
|
| | | * @param integer $limit limit the number of rows
|
| | | * @param integer $offset start reading from given offset
|
| | | * @return string modified query
|
| | | * @access protected
|
| | | */
|
| | | function _modifyQuery($query, $is_manip, $limit, $offset)
|
| | | {
|
| | | if ($limit > 0) {
|
| | | $fetch = $offset + $limit;
|
| | | if (!$is_manip) {
|
| | | return preg_replace('/^([\s(])*SELECT( DISTINCT)?(?!\s*TOP\s*\()/i',
|
| | | "\\1SELECT\\2 TOP $fetch", $query);
|
| | | }
|
| | | }
|
| | | return $query;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ getServerVersion()
|
| | |
|
| | | /**
|
| | | * return version information about the server
|
| | | *
|
| | | * @param bool $native determines if the raw version string should be returned
|
| | | * @return mixed array/string with version information or MDB2 error object
|
| | | * @access public
|
| | | */
|
| | | function getServerVersion($native = false)
|
| | | {
|
| | | if ($this->connected_server_info) {
|
| | | $server_info = $this->connected_server_info;
|
| | | } else {
|
| | | $server_info = sqlsrv_server_info($this->connection);
|
| | | }
|
| | | // cache server_info
|
| | | $this->connected_server_info = $server_info;
|
| | | $version = $server_info['SQLServerVersion'];
|
| | | if (!$native) {
|
| | | if (preg_match('/(\d+)\.(\d+)\.(\d+)/', $version, $tmp)) {
|
| | | $version = array(
|
| | | 'major' => $tmp[1],
|
| | | 'minor' => $tmp[2],
|
| | | 'patch' => $tmp[3],
|
| | | 'extra' => null,
|
| | | 'native' => $version,
|
| | | );
|
| | | } else {
|
| | | $version = array(
|
| | | 'major' => null,
|
| | | 'minor' => null,
|
| | | 'patch' => null,
|
| | | 'extra' => null,
|
| | | 'native' => $version,
|
| | | );
|
| | | }
|
| | | }
|
| | | return $version;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _checkSequence
|
| | |
|
| | | /**
|
| | | * Checks if there's a sequence that exists.
|
| | | *
|
| | | * @param string $seq_name The sequence name to verify.
|
| | | * @return bool $tableExists The value if the table exists or not
|
| | | * @access private
|
| | | */
|
| | | function _checkSequence($seq_name)
|
| | | {
|
| | | $query = "SELECT * FROM $seq_name";
|
| | | $tableExists =& $this->_doQuery($query, true);
|
| | | if (PEAR::isError($tableExists)) {
|
| | | if ($tableExists->getCode() == MDB2_ERROR_NOSUCHTABLE) {
|
| | | return false;
|
| | | }
|
| | | return false;
|
| | | }
|
| | | if (@sqlsrv_fetch($tableExits)) {
|
| | | return true;
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ nextID()
|
| | |
|
| | | /**
|
| | | * Returns the next free id of a sequence
|
| | | *
|
| | | * @param string $seq_name name of the sequence
|
| | | * @param boolean $ondemand when true the sequence is
|
| | | * automatic created, if it
|
| | | * not exists
|
| | | *
|
| | | * @return mixed MDB2 Error Object or id
|
| | | * @access public
|
| | | */
|
| | | function nextID($seq_name, $ondemand = true)
|
| | | {
|
| | | $sequence_name = $this->quoteIdentifier($this->getSequenceName($seq_name), true);
|
| | | $seqcol_name = $this->quoteIdentifier($this->options['seqcol_name'], true);
|
| | | $this->pushErrorHandling(PEAR_ERROR_RETURN);
|
| | | $this->expectError(MDB2_ERROR_NOSUCHTABLE);
|
| | | |
| | | $seq_val = $this->_checkSequence($sequence_name);
|
| | |
|
| | | if ($seq_val) {
|
| | | $query = "SET IDENTITY_INSERT $sequence_name OFF ".
|
| | | "INSERT INTO $sequence_name DEFAULT VALUES";
|
| | | } else {
|
| | | $query = "INSERT INTO $sequence_name ($seqcol_name) VALUES (0)";
|
| | | }
|
| | | $result =& $this->_doQuery($query, true);
|
| | | $this->popExpect();
|
| | | $this->popErrorHandling();
|
| | | if (PEAR::isError($result)) {
|
| | | if ($ondemand && !$this->_checkSequence($sequence_name)) {
|
| | | $this->loadModule('Manager', null, true);
|
| | | $result = $this->manager->createSequence($seq_name);
|
| | | if (PEAR::isError($result)) {
|
| | | return $this->raiseError($result, null, null,
|
| | | 'on demand sequence '.$seq_name.' could not be created', __FUNCTION__);
|
| | | } else {
|
| | | /**
|
| | | * Little off-by-one problem with the sequence emulation
|
| | | * here being fixed, that instead of re-calling nextID
|
| | | * and forcing an increment by one, we simply check if it
|
| | | * exists, then we get the last inserted id if it does.
|
| | | *
|
| | | * In theory, $seq_name should be created otherwise there would
|
| | | * have been an error thrown somewhere up there.. |
| | | *
|
| | | * @todo confirm
|
| | | */
|
| | | if ($this->_checkSequence($seq_name)) {
|
| | | return $this->lastInsertID($seq_name);
|
| | | }
|
| | |
|
| | | return $this->nextID($seq_name, false);
|
| | | }
|
| | | }
|
| | | return $result;
|
| | | }
|
| | | $value = $this->lastInsertID($sequence_name);
|
| | | if (is_numeric($value)) {
|
| | | $query = "DELETE FROM $sequence_name WHERE $seqcol_name < $value";
|
| | | $result =& $this->_doQuery($query, true);
|
| | | if (PEAR::isError($result)) {
|
| | | $this->warnings[] = 'nextID: could not delete previous sequence table values from '.$seq_name;
|
| | | }
|
| | | }
|
| | | return $value;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ lastInsertID()
|
| | |
|
| | | /**
|
| | | * Returns the autoincrement ID if supported or $id or fetches the current
|
| | | * ID in a sequence called: $table.(empty($field) ? '' : '_'.$field)
|
| | | *
|
| | | * @param string $table name of the table into which a new row was inserted
|
| | | * @param string $field name of the field into which a new row was inserted
|
| | | *
|
| | | * @return mixed MDB2 Error Object or id
|
| | | * @access public
|
| | | */
|
| | | function lastInsertID($table = null, $field = null)
|
| | | {
|
| | | return $this->queryOne("SELECT IDENT_CURRENT('$table')", 'integer');
|
| | | }
|
| | |
|
| | | // }}}
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ Class MDB2_Result_mssql
|
| | |
|
| | | /**
|
| | | * MDB2 MSSQL Server result driver
|
| | | *
|
| | | * @package MDB2
|
| | | * @category Database
|
| | | * @author Frank M. Kromann <frank@kromann.info>
|
| | | */
|
| | | class MDB2_Result_sqlsrv extends MDB2_Result_Common
|
| | | {
|
| | | // {{{ constructor: function __construct(&$db, &$result, $limit = 0, $offset = 0)
|
| | |
|
| | | /**
|
| | | * Constructor
|
| | | */
|
| | | function __construct(&$db, &$result, $limit = 0, $offset = 0)
|
| | | {
|
| | | $this->db =& $db;
|
| | | $this->result =& $result;
|
| | | $this->offset = $offset;
|
| | | $this->limit = max(0, $limit - 1);
|
| | | $this->cursor = 0;
|
| | | $this->rows = array();
|
| | | $this->numFields = sqlsrv_num_fields($result);
|
| | | $this->fieldMeta = sqlsrv_field_metadata($result);
|
| | | $this->numRowsAffected = sqlsrv_rows_affected($result);
|
| | | while ($row = sqlsrv_fetch_array($result, SQLSRV_FETCH_ASSOC)) {
|
| | | if ($row !== null) {
|
| | | if ($this->offset && $this->offset_count < $this->offset) {
|
| | | $this->offset_count++;
|
| | | continue;
|
| | | }
|
| | | foreach ($row as $k => $v) {
|
| | | if (is_object($v) && method_exists($v, 'format')) {//DateTime Object
|
| | | $row[$k] = $v->format("Y-m-d H:i:s");
|
| | | }
|
| | | }
|
| | | $this->rows[] = $row;//read results into memory, cursors are not supported
|
| | | }
|
| | | }
|
| | | $this->rowcnt = count($this->rows);
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _skipLimitOffset()
|
| | |
|
| | | /**
|
| | | * Skip the first row of a result set.
|
| | | *
|
| | | * @param resource $result
|
| | | * @return mixed a result handle or MDB2_OK on success, a MDB2 error on failure
|
| | | * @access protected
|
| | | */
|
| | | /* function _skipLimitOffset()
|
| | | {
|
| | | if ($this->limit) {
|
| | | if ($this->rownum >= $this->limit) {
|
| | | return false;
|
| | | }
|
| | | }
|
| | | if ($this->offset) {
|
| | | while ($this->offset_count < $this->offset) {
|
| | | ++$this->offset_count;
|
| | | if (!is_array(@sqlsrv_fetch_array($this->result))) {
|
| | | $this->offset_count = $this->limit;
|
| | | return false;
|
| | | }
|
| | | }
|
| | | }
|
| | | return MDB2_OK;
|
| | | }*/
|
| | |
|
| | | // }}}
|
| | | function array_to_obj($array, &$obj) {
|
| | | foreach ($array as $key => $value) {
|
| | | if (is_array($value)) {
|
| | | $obj->$key = new stdClass();
|
| | | array_to_obj($value, $obj->$key);
|
| | | } else {
|
| | | $obj->$key = $value;
|
| | | }
|
| | | }
|
| | | return $obj;
|
| | | } |
| | | // {{{ fetchRow()
|
| | |
|
| | | /**
|
| | | * Fetch a row and insert the data into an existing array.
|
| | | *
|
| | | * @param int $fetchmode how the array data should be indexed
|
| | | * @param int $rownum number of the row where the data can be found
|
| | | * @return int data array on success, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | | function &fetchRow($fetchmode = MDB2_FETCHMODE_DEFAULT, $rownum = null)
|
| | | {
|
| | | if (!$this->result) {
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null, 'no valid statement given', __FUNCTION__);
|
| | | }
|
| | | if (($this->limit && $this->rownum >= $this->limit) || ($this->cursor >= $this->rowcnt || $this->rowcnt == 0)) {
|
| | | $null = null;
|
| | | return $null;
|
| | | }
|
| | | if (null !== $rownum) {
|
| | | $seek = $this->seek($rownum);
|
| | | if (PEAR::isError($seek)) {
|
| | | return $seek;
|
| | | }
|
| | | }
|
| | | |
| | | $row = false;
|
| | | $arrNum = array();
|
| | | if ($fetchmode == MDB2_FETCHMODE_ORDERED || $fetchmode == MDB2_FETCHMODE_DEFAULT) {
|
| | | foreach ($this->rows[$this->cursor] as $key=>$value) {
|
| | | $arrNum[] = $value;
|
| | | }
|
| | | }
|
| | | switch($fetchmode) {
|
| | | case MDB2_FETCHMODE_ASSOC:
|
| | | $row = $this->rows[$this->cursor]; break;
|
| | | case MDB2_FETCHMODE_ORDERED:
|
| | | $row = $arrNum; break;
|
| | | case MDB2_FETCHMODE_OBJECT:
|
| | | $row = $this->array_to_obj($this->rows[$this->cursor],$o = new $this->db->options['fetch_class']); break;
|
| | | case MDB2_FETCHMODE_DEFAULT:
|
| | | default:
|
| | | $row = $this->rows[$this->cursor] + $arrNum; break;
|
| | | } |
| | | $this->cursor++;
|
| | | |
| | | /*
|
| | | if ($fetchmode == MDB2_FETCHMODE_OBJECT) {
|
| | | $row = sqlsrv_fetch_object($this->result,$this->db->options['fetch_class']);
|
| | | } else {
|
| | | switch($fetchmode) {
|
| | | case MDB2_FETCHMODE_ASSOC: $fetchmode = SQLSRV_FETCH_ASSOC; break;
|
| | | case MDB2_FETCHMODE_ORDERED: $fetchmode = SQLSRV_FETCH_NUMERIC; break;
|
| | | case MDB2_FETCHMODE_DEFAULT: |
| | | default: |
| | | $fetchmode = SQLSRV_FETCH_BOTH;
|
| | | }
|
| | | $row = sqlsrv_fetch_array($this->result,$fetchmode);
|
| | | }
|
| | | foreach ($row as $key=>$value) {
|
| | | if (is_object($value) && method_exists($value, 'format')) {//is DateTime object
|
| | | $row[$key] = $value->format("Y-m-d H:i:s");
|
| | | }
|
| | | }*/
|
| | | |
| | | /*if ($fetchmode == MDB2_FETCHMODE_DEFAULT) {
|
| | | $fetchmode = $this->db->fetchmode;
|
| | | }*/
|
| | | if ($fetchmode == MDB2_FETCHMODE_ASSOC && is_array($row) && $this->db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) {
|
| | | $row = array_change_key_case($row, $this->db->options['field_case']);
|
| | | }
|
| | | if (!$row) {
|
| | | if (false === $this->result) {
|
| | | $err =& $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | return $err;
|
| | | }
|
| | | $null = null;
|
| | | return $null;
|
| | | }
|
| | | $mode = $this->db->options['portability'] & MDB2_PORTABILITY_EMPTY_TO_NULL;
|
| | | $rtrim = false;
|
| | | if ($this->db->options['portability'] & MDB2_PORTABILITY_RTRIM) {
|
| | | if (empty($this->types)) {
|
| | | $mode += MDB2_PORTABILITY_RTRIM;
|
| | | } else {
|
| | | $rtrim = true;
|
| | | }
|
| | | }
|
| | | if ($mode) {
|
| | | $this->db->_fixResultArrayValues($row, $mode);
|
| | | }
|
| | | if (!empty($this->types)) {
|
| | | $row = $this->db->datatype->convertResultRow($this->types, $row, $rtrim);
|
| | | }
|
| | | if (!empty($this->values)) {
|
| | | $this->_assignBindColumns($row);
|
| | | }
|
| | | ++$this->rownum;
|
| | | return $row;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ _getColumnNames()
|
| | |
|
| | | /**
|
| | | * Retrieve the names of columns returned by the DBMS in a query result.
|
| | | *
|
| | | * @return mixed Array variable that holds the names of columns as keys
|
| | | * or an MDB2 error on failure.
|
| | | * Some DBMS may not return any columns when the result set
|
| | | * does not contain any rows.
|
| | | * @access private
|
| | | */
|
| | | function _getColumnNames()
|
| | | {
|
| | | if (!$this->result) {
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null, 'no valid statement given', __FUNCTION__);
|
| | | }
|
| | | $columns = array();
|
| | | foreach ($this->fieldMeta as $col) {
|
| | | $columns[$col['Name']] = $col['Type'];
|
| | | }
|
| | | if ($this->db->options['portability'] & MDB2_PORTABILITY_FIX_CASE) {
|
| | | $columns = array_change_key_case($columns, $this->db->options['field_case']);
|
| | | }
|
| | | return $columns;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ numCols()
|
| | |
|
| | | /**
|
| | | * Count the number of columns returned by the DBMS in a query result.
|
| | | *
|
| | | * @return mixed integer value with the number of columns, a MDB2 error
|
| | | * on failure
|
| | | * @access public
|
| | | */
|
| | | function numCols()
|
| | | {
|
| | | if (!$this->result) {
|
| | | return $this->db->raiseError(MDB2_ERROR_INVALID, null, null, 'no valid statement given', __FUNCTION__);
|
| | | }
|
| | | $cols = $this->numFields;
|
| | | if (!$cols) {
|
| | | if (false === $this->result) {
|
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | }
|
| | | if (null === $this->result) {
|
| | | return count($this->types);
|
| | | }
|
| | | return $this->db->raiseError(null, null, null,
|
| | | 'Could not get column count', __FUNCTION__);
|
| | | }
|
| | | return $cols;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ nextResult()
|
| | |
|
| | | /**
|
| | | * Move the internal result pointer to the next available result
|
| | | *
|
| | | * @return true on success, false if there is no more result set or an error object on failure
|
| | | * @access public
|
| | | */
|
| | | function nextResult()
|
| | | {
|
| | | if (false === $this->result) {
|
| | | return $this->db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
|
| | | 'resultset has already been freed', __FUNCTION__);
|
| | | }
|
| | | if (null === $this->result)) {
|
| | | return false;
|
| | | }
|
| | | $ret = sqlsrv_next_result($this->result);
|
| | | if ($ret) {
|
| | | $this->cursor = 0;
|
| | | $this->rows = array();
|
| | | $this->numFields = sqlsrv_num_fields($this->result);
|
| | | $this->fieldMeta = sqlsrv_field_metadata($this->result);
|
| | | $this->numRowsAffected = sqlsrv_rows_affected($this->result);
|
| | | while ($row = sqlsrv_fetch_array($this->result, SQLSRV_FETCH_ASSOC)) {
|
| | | if ($row !== null) {
|
| | | if ($this->offset && $this->offset_count < $this->offset) {
|
| | | $this->offset_count++;
|
| | | continue;
|
| | | }
|
| | | foreach ($row as $k => $v) {
|
| | | if (is_object($v) && method_exists($v, 'format')) {//DateTime Object
|
| | | //$v->setTimezone(new DateTimeZone('GMT'));//TS_ISO_8601 with a trailing 'Z' is GMT
|
| | | $row[$k] = $v->format("Y-m-d H:i:s");
|
| | | }
|
| | | }
|
| | | $this->rows[] = $row;//read results into memory, cursors are not supported
|
| | | }
|
| | | }
|
| | | $this->rowcnt = count($this->rows); |
| | | }
|
| | | return $ret;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ free()
|
| | |
|
| | | /**
|
| | | * Free the internal resources associated with $result.
|
| | | *
|
| | | * @return boolean true on success, false if $result is invalid
|
| | | * @access public
|
| | | */
|
| | | function free()
|
| | | {
|
| | | if (is_resource($this->result) && $this->db->connection) {
|
| | | if (!@sqlsrv_free_stmt($this->result)) {
|
| | | return $this->db->raiseError(null, null, null,
|
| | | 'Could not free result', __FUNCTION__);
|
| | | }
|
| | | }
|
| | | $this->result = false;
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ function rowCount()
|
| | | /**
|
| | | * Returns the actual row number that was last fetched (count from 0)
|
| | | * @return int
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function rowCount()
|
| | | {
|
| | | return $this->cursor;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ function numRows()
|
| | |
|
| | | /**
|
| | | * Returns the number of rows in a result object
|
| | | *
|
| | | * @return mixed MDB2 Error Object or the number of rows
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function numRows()
|
| | | {
|
| | | return $this->rowcnt;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ function seek($rownum = 0)
|
| | |
|
| | | /**
|
| | | * Seek to a specific row in a result set
|
| | | *
|
| | | * @param int number of the row where the data can be found
|
| | | *
|
| | | * @return mixed MDB2_OK on success, a MDB2 error on failure
|
| | | *
|
| | | * @access public
|
| | | */
|
| | | function seek($rownum = 0)
|
| | | {
|
| | | $this->cursor = min($rownum, $this->rowcnt);
|
| | | return MDB2_OK;
|
| | | }
|
| | |
|
| | | // }}}
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ class MDB2_BufferedResult_mssql
|
| | |
|
| | | /**
|
| | | * MDB2 MSSQL Server buffered result driver
|
| | | *
|
| | | * @package MDB2
|
| | | * @category Database
|
| | | * @author Frank M. Kromann <frank@kromann.info>
|
| | | */
|
| | | class MDB2_BufferedResult_sqlsrv extends MDB2_Result_sqlsrv
|
| | | {
|
| | | // {{{ valid()
|
| | |
|
| | | /**
|
| | | * Check if the end of the result set has been reached
|
| | | *
|
| | | * @return mixed true or false on sucess, a MDB2 error on failure
|
| | | * @access public
|
| | | */
|
| | | function valid()
|
| | | {
|
| | | $numrows = $this->numRows();
|
| | | if (PEAR::isError($numrows)) {
|
| | | return $numrows;
|
| | | }
|
| | | return $this->rownum < ($numrows - 1);
|
| | | }
|
| | |
|
| | | // }}}
|
| | |
|
| | | }
|
| | |
|
| | | // }}}
|
| | | // {{{ MDB2_Statement_mssql
|
| | |
|
| | | /**
|
| | | * MDB2 MSSQL Server statement driver
|
| | | *
|
| | | * @package MDB2
|
| | | * @category Database
|
| | | * @author Frank M. Kromann <frank@kromann.info>
|
| | | */
|
| | | class MDB2_Statement_sqlsrv extends MDB2_Statement_Common
|
| | | {
|
| | |
|
| | | }
|
| | |
|
| | | // }}}
|
| | |
|
| | | ?> |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> |
|
| | | // +----------------------------------------------------------------------+
|
| | | //
|
| | | // $Id: Extended.php,v 1.60 2007/11/28 19:49:34 quipo Exp $
|
| | | // $Id: Extended.php 292715 2009-12-28 14:06:34Z quipo $ |
| | |
|
| | | /**
|
| | | * @package MDB2
|
| | |
| | | }
|
| | | }
|
| | |
|
| | | if ($where !== false && !is_null($where)) {
|
| | | if ((false !== $where) && (null !== $where)) { |
| | | if (is_array($where)) {
|
| | | $where = implode(' AND ', $where);
|
| | | }
|
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: Iterator.php,v 1.22 2006/05/06 14:03:41 lsmith Exp $ |
| | | // $Id: Iterator.php 212543 2006-05-06 14:03:41Z lsmith $ |
| | | |
| | | /** |
| | | * PHP5 Iterator |
| | |
| | | // | Author: Lukas Smith <smith@pooteeweet.org> | |
| | | // +----------------------------------------------------------------------+ |
| | | // |
| | | // $Id: LOB.php,v 1.34 2006/10/25 11:52:21 lsmith Exp $ |
| | | // $Id: LOB.php 222350 2006-10-25 11:52:21Z lsmith $ |
| | | |
| | | /** |
| | | * @package MDB2 |