| /trunk/papyrus/bibliotheque/system/database/drivers/sqlite/sqlite_forge.php |
|---|
| New file |
| 0,0 → 1,265 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * SQLite Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_sqlite_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access public |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database() |
| { |
| // In SQLite, a database is created when you connect to the database. |
| // We'll return TRUE so that an error isn't generated |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| if ( ! @file_exists($this->db->database) OR ! @unlink($this->db->database)) |
| { |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unable_to_drop'); |
| } |
| return FALSE; |
| } |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param array the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| // IF NOT EXISTS added to SQLite in 3.3.0 |
| if ($if_not_exists === TRUE && version_compare($this->_version(), '3.3.0', '>=') === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)."("; |
| $current_field_count = 0; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| $sql .= ' '.$attributes['TYPE']; |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes) && $attributes['NULL'] === TRUE) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| if (count($primary_keys) > 0) |
| { |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key = array($this->db->_protect_identifiers($key)); |
| } |
| $sql .= ",\n\tUNIQUE (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n)"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * Unsupported feature in SQLite |
| * |
| * @access private |
| * @return bool |
| */ |
| function _drop_table($table) |
| { |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return array(); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param string the table name |
| * @param string the column definition |
| * @param string the default value |
| * @param boolean should 'NOT NULL' be added |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type ".$this->db->_protect_identifiers($column_name); |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| // SQLite does not support dropping columns |
| // http://www.sqlite.org/omitted.html |
| // http://www.sqlite.org/faq.html#q11 |
| return FALSE; |
| } |
| $sql .= " $column_definition"; |
| if ($default_value != '') |
| { |
| $sql .= " DEFAULT \"$default_value\""; |
| } |
| if ($null === NULL) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file sqlite_forge.php */ |
| /* Location: ./system/database/drivers/sqlite/sqlite_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/sqlite/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/sqlite/sqlite_utility.php |
|---|
| New file |
| 0,0 → 1,141 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * SQLite Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_sqlite_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * I don't believe you can do a database listing with SQLite |
| * since each database is its own file. I suppose we could |
| * try reading a directory looking for SQLite files, but |
| * that doesn't seem like a terribly good idea |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| if ($this->db_debug) |
| { |
| return $this->display_error('db_unsuported_feature'); |
| } |
| return array(); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Is optimization even supported in SQLite? |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Are table repairs even supported in SQLite? |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * SQLite Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access public |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database() |
| { |
| // In SQLite, a database is created when you connect to the database. |
| // We'll return TRUE so that an error isn't generated |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| if ( ! @file_exists($this->db->database) OR ! @unlink($this->db->database)) |
| { |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unable_to_drop'); |
| } |
| return FALSE; |
| } |
| return TRUE; |
| } |
| } |
| /* End of file sqlite_utility.php */ |
| /* Location: ./system/database/drivers/sqlite/sqlite_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/sqlite/sqlite_driver.php |
|---|
| New file |
| 0,0 → 1,601 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * SQLite Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_sqlite_driver extends CI_DB { |
| var $dbdriver = 'sqlite'; |
| // The character used to escape with - not needed for SQLite |
| var $_escape_char = ''; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(*) AS "; |
| var $_random_keyword = ' Random()'; // database specific random keyword |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| if ( ! $conn_id = @sqlite_open($this->database, FILE_WRITE_MODE, $error)) |
| { |
| log_message('error', $error); |
| if ($this->db_debug) |
| { |
| $this->display_error($error, '', TRUE); |
| } |
| return FALSE; |
| } |
| return $conn_id; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| if ( ! $conn_id = @sqlite_popen($this->database, FILE_WRITE_MODE, $error)) |
| { |
| log_message('error', $error); |
| if ($this->db_debug) |
| { |
| $this->display_error($error, '', TRUE); |
| } |
| return FALSE; |
| } |
| return $conn_id; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| // @todo - add support if needed |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return sqlite_libversion(); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| return @sqlite_query($this->conn_id, $sql); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| $this->simple_query('BEGIN TRANSACTION'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('COMMIT'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('ROLLBACK'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| return sqlite_escape_string($str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return sqlite_changes($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| return @sqlite_last_insert_rowid($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return $row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * List table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SELECT name from sqlite_master WHERE type='table'"; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| $sql .= " AND 'name' LIKE '".$this->dbprefix."%'"; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| // Not supported |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT * FROM ".$table." LIMIT 1"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| return sqlite_error_string(sqlite_last_error($this->conn_id)); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| return sqlite_last_error($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return '('.implode(', ', $tables).')'; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return $this->_delete($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| if ($offset == 0) |
| { |
| $offset = ''; |
| } |
| else |
| { |
| $offset .= ", "; |
| } |
| return $sql."LIMIT ".$offset.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @sqlite_close($conn_id); |
| } |
| } |
| /* End of file sqlite_driver.php */ |
| /* Location: ./system/database/drivers/sqlite/sqlite_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/sqlite/sqlite_result.php |
|---|
| New file |
| 0,0 → 1,179 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * SQLite Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_sqlite_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @sqlite_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @sqlite_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $field_names[] = sqlite_field_name($this->result_id, $i); |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $F = new stdClass(); |
| $F->name = sqlite_field_name($this->result_id, $i); |
| $F->type = 'varchar'; |
| $F->max_length = 0; |
| $F->primary_key = 0; |
| $F->default = ''; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| // Not implemented in SQLite |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return sqlite_seek($this->result_id, $n); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| return sqlite_fetch_array($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| if (function_exists('sqlite_fetch_object')) |
| { |
| return sqlite_fetch_object($this->result_id); |
| } |
| else |
| { |
| $arr = sqlite_fetch_array($this->result_id, SQLITE_ASSOC); |
| if (is_array($arr)) |
| { |
| $obj = (object) $arr; |
| return $obj; |
| } else { |
| return NULL; |
| } |
| } |
| } |
| } |
| /* End of file sqlite_result.php */ |
| /* Location: ./system/database/drivers/sqlite/sqlite_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/oci8/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/oci8/oci8_forge.php |
|---|
| New file |
| 0,0 → 1,248 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Oracle Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_oci8_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access public |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param array the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $current_field_count = 0; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| $sql .= ' '.$attributes['TYPE']; |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes) && $attributes['NULL'] === TRUE) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| if (count($primary_keys) > 0) |
| { |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key = array($this->db->_protect_identifiers($key)); |
| } |
| $sql .= ",\n\tUNIQUE COLUMNS (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n)"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return bool |
| */ |
| function _drop_table($table) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param string the table name |
| * @param string the column definition |
| * @param string the default value |
| * @param boolean should 'NOT NULL' be added |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type ".$this->db->_protect_identifiers($column_name); |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql; |
| } |
| $sql .= " $column_definition"; |
| if ($default_value != '') |
| { |
| $sql .= " DEFAULT \"$default_value\""; |
| } |
| if ($null === NULL) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file oci8_forge.php */ |
| /* Location: ./system/database/drivers/oci8/oci8_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/oci8/oci8_utility.php |
|---|
| New file |
| 0,0 → 1,122 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Oracle Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_oci8_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Generates a platform-specific query so that a table can be optimized |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return FALSE; // Is this supported in Oracle? |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Generates a platform-specific query so that a table can be repaired |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return FALSE; // Is this supported in Oracle? |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Oracle Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access public |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return FALSE; |
| } |
| } |
| /* End of file oci8_utility.php */ |
| /* Location: ./system/database/drivers/oci8/oci8_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/oci8/oci8_driver.php |
|---|
| New file |
| 0,0 → 1,726 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * oci8 Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| /** |
| * oci8 Database Adapter Class |
| * |
| * This is a modification of the DB_driver class to |
| * permit access to oracle databases |
| * |
| * NOTE: this uses the PHP 4 oci methods |
| * |
| * @author Kelly McArdle |
| * |
| */ |
| class CI_DB_oci8_driver extends CI_DB { |
| var $dbdriver = 'oci8'; |
| // The character used for excaping |
| var $_escape_char = '"'; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(1) AS "; |
| var $_random_keyword = ' ASC'; // not currently supported |
| // Set "auto commit" by default |
| var $_commit = OCI_COMMIT_ON_SUCCESS; |
| // need to track statement id and cursor id |
| var $stmt_id; |
| var $curs_id; |
| // if we use a limit, we will add a field that will |
| // throw off num_fields later |
| var $limit_used; |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| return @ocilogon($this->username, $this->password, $this->hostname); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| return @ociplogon($this->username, $this->password, $this->hostname); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| // @todo - add support if needed |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return ociserverversion($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| // oracle must parse the query before it is run. All of the actions with |
| // the query are based on the statement id returned by ociparse |
| $this->stmt_id = FALSE; |
| $this->_set_stmt_id($sql); |
| ocisetprefetch($this->stmt_id, 1000); |
| return @ociexecute($this->stmt_id, $this->_commit); |
| } |
| /** |
| * Generate a statement ID |
| * |
| * @access private |
| * @param string an SQL query |
| * @return none |
| */ |
| function _set_stmt_id($sql) |
| { |
| if ( ! is_resource($this->stmt_id)) |
| { |
| $this->stmt_id = ociparse($this->conn_id, $this->_prep_query($sql)); |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * getCursor. Returns a cursor from the datbase |
| * |
| * @access public |
| * @return cursor id |
| */ |
| function get_cursor() |
| { |
| $this->curs_id = ocinewcursor($this->conn_id); |
| return $this->curs_id; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Stored Procedure. Executes a stored procedure |
| * |
| * @access public |
| * @param package package stored procedure is in |
| * @param procedure stored procedure to execute |
| * @param params array of parameters |
| * @return array |
| * |
| * params array keys |
| * |
| * KEY OPTIONAL NOTES |
| * name no the name of the parameter should be in :<param_name> format |
| * value no the value of the parameter. If this is an OUT or IN OUT parameter, |
| * this should be a reference to a variable |
| * type yes the type of the parameter |
| * length yes the max size of the parameter |
| */ |
| function stored_procedure($package, $procedure, $params) |
| { |
| if ($package == '' OR $procedure == '' OR ! is_array($params)) |
| { |
| if ($this->db_debug) |
| { |
| log_message('error', 'Invalid query: '.$package.'.'.$procedure); |
| return $this->display_error('db_invalid_query'); |
| } |
| return FALSE; |
| } |
| // build the query string |
| $sql = "begin $package.$procedure("; |
| $have_cursor = FALSE; |
| foreach($params as $param) |
| { |
| $sql .= $param['name'] . ","; |
| if (array_key_exists('type', $param) && ($param['type'] == OCI_B_CURSOR)) |
| { |
| $have_cursor = TRUE; |
| } |
| } |
| $sql = trim($sql, ",") . "); end;"; |
| $this->stmt_id = FALSE; |
| $this->_set_stmt_id($sql); |
| $this->_bind_params($params); |
| $this->query($sql, FALSE, $have_cursor); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Bind parameters |
| * |
| * @access private |
| * @return none |
| */ |
| function _bind_params($params) |
| { |
| if ( ! is_array($params) OR ! is_resource($this->stmt_id)) |
| { |
| return; |
| } |
| foreach ($params as $param) |
| { |
| foreach (array('name', 'value', 'type', 'length') as $val) |
| { |
| if ( ! isset($param[$val])) |
| { |
| $param[$val] = ''; |
| } |
| } |
| ocibindbyname($this->stmt_id, $param['name'], $param['value'], $param['length'], $param['type']); |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| $this->_commit = OCI_DEFAULT; |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $ret = OCIcommit($this->conn_id); |
| $this->_commit = OCI_COMMIT_ON_SUCCESS; |
| return $ret; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $ret = OCIrollback($this->conn_id); |
| $this->_commit = OCI_COMMIT_ON_SUCCESS; |
| return $ret; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| // Access the CI object |
| $CI =& get_instance(); |
| return $CI->_remove_invisible_characters($str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @ocirowcount($this->stmt_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| // not supported in oracle |
| return $this->display_error('db_unsupported_function'); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query == FALSE) |
| { |
| return 0; |
| } |
| $row = $query->row(); |
| return $row->NUMROWS; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SELECT TABLE_NAME FROM ALL_TABLES"; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| $sql .= " WHERE TABLE_NAME LIKE '".$this->dbprefix."%'"; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SELECT COLUMN_NAME FROM all_tab_columns WHERE table_name = '$table'"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT * FROM ".$table." where rownum = 1"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| $error = ocierror($this->conn_id); |
| return $error['message']; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| $error = ocierror($this->conn_id); |
| return $error['code']; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return implode(', ', $tables); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return "TRUNCATE TABLE ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| $limit = $offset + $limit; |
| $newsql = "SELECT * FROM (select inner_query.*, rownum rnum FROM ($sql) inner_query WHERE rownum < $limit)"; |
| if ($offset != 0) |
| { |
| $newsql .= " WHERE rnum >= $offset"; |
| } |
| // remember that we used limits |
| $this->limit_used = TRUE; |
| return $newsql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @ocilogoff($conn_id); |
| } |
| } |
| /* End of file oci8_driver.php */ |
| /* Location: ./system/database/drivers/oci8/oci8_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/oci8/oci8_result.php |
|---|
| New file |
| 0,0 → 1,249 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * oci8 Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_oci8_result extends CI_DB_result { |
| var $stmt_id; |
| var $curs_id; |
| var $limit_used; |
| /** |
| * Number of rows in the result set. |
| * |
| * Oracle doesn't have a graceful way to retun the number of rows |
| * so we have to use what amounts to a hack. |
| * |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| $rowcount = count($this->result_array()); |
| @ociexecute($this->stmt_id); |
| if ($this->curs_id) |
| { |
| @ociexecute($this->curs_id); |
| } |
| return $rowcount; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| $count = @ocinumcols($this->stmt_id); |
| // if we used a limit we subtract it |
| if ($this->limit_used) |
| { |
| $count = $count - 1; |
| } |
| return $count; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| $fieldCount = $this->num_fields(); |
| for ($c = 1; $c <= $fieldCount; $c++) |
| { |
| $field_names[] = ocicolumnname($this->stmt_id, $c); |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| $fieldCount = $this->num_fields(); |
| for ($c = 1; $c <= $fieldCount; $c++) |
| { |
| $F = new stdClass(); |
| $F->name = ocicolumnname($this->stmt_id, $c); |
| $F->type = ocicolumntype($this->stmt_id, $c); |
| $F->max_length = ocicolumnsize($this->stmt_id, $c); |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_resource($this->result_id)) |
| { |
| ocifreestatement($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc(&$row) |
| { |
| $id = ($this->curs_id) ? $this->curs_id : $this->stmt_id; |
| return ocifetchinto($id, $row, OCI_ASSOC + OCI_RETURN_NULLS); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| $result = array(); |
| // If PHP 5 is being used we can fetch an result object |
| if (function_exists('oci_fetch_object')) |
| { |
| $id = ($this->curs_id) ? $this->curs_id : $this->stmt_id; |
| return @oci_fetch_object($id); |
| } |
| // If PHP 4 is being used we have to build our own result |
| foreach ($this->result_array() as $key => $val) |
| { |
| $obj = new stdClass(); |
| if (is_array($val)) |
| { |
| foreach ($val as $k => $v) |
| { |
| $obj->$k = $v; |
| } |
| } |
| else |
| { |
| $obj->$key = $val; |
| } |
| $result[] = $obj; |
| } |
| return $result; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Query result. "array" version. |
| * |
| * @access public |
| * @return array |
| */ |
| function result_array() |
| { |
| if (count($this->result_array) > 0) |
| { |
| return $this->result_array; |
| } |
| // oracle's fetch functions do not return arrays. |
| // The information is returned in reference parameters |
| $row = NULL; |
| while ($this->_fetch_assoc($row)) |
| { |
| $this->result_array[] = $row; |
| } |
| return $this->result_array; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return FALSE; // Not needed |
| } |
| } |
| /* End of file oci8_result.php */ |
| /* Location: ./system/database/drivers/oci8/oci8_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/postgre/postgre_driver.php |
|---|
| New file |
| 0,0 → 1,625 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Postgre Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_postgre_driver extends CI_DB { |
| var $dbdriver = 'postgre'; |
| var $_escape_char = '"'; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(*) AS "; |
| var $_random_keyword = ' RANDOM()'; // database specific random keyword |
| /** |
| * Connection String |
| * |
| * @access private |
| * @return string |
| */ |
| function _connect_string() |
| { |
| $components = array( |
| 'hostname' => 'host', |
| 'port' => 'port', |
| 'database' => 'dbname', |
| 'username' => 'user', |
| 'password' => 'password' |
| ); |
| $connect_string = ""; |
| foreach ($components as $key => $val) |
| { |
| if (isset($this->$key) && $this->$key != '') |
| { |
| $connect_string .= " $val=".$this->$key; |
| } |
| } |
| return trim($connect_string); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| return @pg_connect($this->_connect_string()); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| return @pg_pconnect($this->_connect_string()); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| // Not needed for Postgre so we'll return TRUE |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| // @todo - add support if needed |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return "SELECT version() AS ver"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| return @pg_query($this->conn_id, $sql); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| return @pg_exec($this->conn_id, "begin"); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| return @pg_exec($this->conn_id, "commit"); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| return @pg_exec($this->conn_id, "rollback"); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| return pg_escape_string($str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @pg_affected_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| $v = $this->_version(); |
| $v = $v['server']; |
| $table = func_num_args() > 0 ? func_get_arg(0) : null; |
| $column = func_num_args() > 1 ? func_get_arg(1) : null; |
| if ($table == null && $v >= '8.1') |
| { |
| $sql='SELECT LASTVAL() as ins_id'; |
| } |
| elseif ($table != null && $column != null && $v >= '8.0') |
| { |
| $sql = sprintf("SELECT pg_get_serial_sequence('%s','%s') as seq", $table, $column); |
| $query = $this->query($sql); |
| $row = $query->row(); |
| $sql = sprintf("SELECT CURRVAL('%s') as ins_id", $row->seq); |
| } |
| elseif ($table != null) |
| { |
| // seq_name passed in table parameter |
| $sql = sprintf("SELECT CURRVAL('%s') as ins_id", $table); |
| } |
| else |
| { |
| return pg_last_oid($this->result_id); |
| } |
| $query = $this->query($sql); |
| $row = $query->row(); |
| return $row->ins_id; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return $row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'"; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| $sql .= " AND table_name LIKE '".$this->dbprefix."%'"; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SELECT column_name FROM information_schema.columns WHERE table_name ='".$table."'"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT * FROM ".$table." LIMIT 1"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| return pg_last_error($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| return ''; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return implode(', ', $tables); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return "TRUNCATE ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| $sql .= "LIMIT ".$limit; |
| if ($offset > 0) |
| { |
| $sql .= " OFFSET ".$offset; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @pg_close($conn_id); |
| } |
| } |
| /* End of file postgre_driver.php */ |
| /* Location: ./system/database/drivers/postgre/postgre_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/postgre/postgre_result.php |
|---|
| New file |
| 0,0 → 1,169 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Postgres Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_postgre_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @pg_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @pg_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $field_names[] = pg_field_name($this->result_id, $i); |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $F = new stdClass(); |
| $F->name = pg_field_name($this->result_id, $i); |
| $F->type = pg_field_type($this->result_id, $i); |
| $F->max_length = pg_field_size($this->result_id, $i); |
| $F->primary_key = 0; |
| $F->default = ''; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_resource($this->result_id)) |
| { |
| pg_free_result($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return pg_result_seek($this->result_id, $n); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| return pg_fetch_assoc($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| return pg_fetch_object($this->result_id); |
| } |
| } |
| /* End of file postgre_result.php */ |
| /* Location: ./system/database/drivers/postgre/postgre_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/postgre/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/postgre/postgre_forge.php |
|---|
| New file |
| 0,0 → 1,248 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Postgre Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_postgre_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param array the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $current_field_count = 0; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| $sql .= ' '.$attributes['TYPE']; |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes) && $attributes['NULL'] === TRUE) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| if (count($primary_keys) > 0) |
| { |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key = array($this->db->_protect_identifiers($key)); |
| } |
| $sql .= ",\n\tFOREIGN KEY (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n);"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return bool |
| */ |
| function _drop_table($table) |
| { |
| return "DROP TABLE ".$this->db->_escape_identifiers($table)." CASCADE"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param string the table name |
| * @param string the column definition |
| * @param string the default value |
| * @param boolean should 'NOT NULL' be added |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type ".$this->db->_protect_identifiers($column_name); |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql; |
| } |
| $sql .= " $column_definition"; |
| if ($default_value != '') |
| { |
| $sql .= " DEFAULT \"$default_value\""; |
| } |
| if ($null === NULL) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file postgre_forge.php */ |
| /* Location: ./system/database/drivers/postgre/postgre_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/postgre/postgre_utility.php |
|---|
| New file |
| 0,0 → 1,124 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * Postgre Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_postgre_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| return "SELECT datname FROM pg_database"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Is table optimization supported in Postgre? |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Are table repairs supported in Postgre? |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Postgre Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| } |
| /* End of file postgre_utility.php */ |
| /* Location: ./system/database/drivers/postgre/postgre_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysql/mysql_utility.php |
|---|
| New file |
| 0,0 → 1,245 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQL Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysql_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| return "SHOW DATABASES"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Generates a platform-specific query so that a table can be optimized |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return "OPTIMIZE TABLE ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Generates a platform-specific query so that a table can be repaired |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return "REPAIR TABLE ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * MySQL Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| if (count($params) == 0) |
| { |
| return FALSE; |
| } |
| // Extract the prefs for simplicity |
| extract($params); |
| // Build the output |
| $output = ''; |
| foreach ((array)$tables as $table) |
| { |
| // Is the table in the "ignore" list? |
| if (in_array($table, (array)$ignore, TRUE)) |
| { |
| continue; |
| } |
| // Get the table schema |
| $query = $this->db->query("SHOW CREATE TABLE `".$this->db->database.'`.'.$table); |
| // No result means the table name was invalid |
| if ($query === FALSE) |
| { |
| continue; |
| } |
| // Write out the table schema |
| $output .= '#'.$newline.'# TABLE STRUCTURE FOR: '.$table.$newline.'#'.$newline.$newline; |
| if ($add_drop == TRUE) |
| { |
| $output .= 'DROP TABLE IF EXISTS '.$table.';'.$newline.$newline; |
| } |
| $i = 0; |
| $result = $query->result_array(); |
| foreach ($result[0] as $val) |
| { |
| if ($i++ % 2) |
| { |
| $output .= $val.';'.$newline.$newline; |
| } |
| } |
| // If inserts are not needed we're done... |
| if ($add_insert == FALSE) |
| { |
| continue; |
| } |
| // Grab all the data from the current table |
| $query = $this->db->query("SELECT * FROM $table"); |
| if ($query->num_rows() == 0) |
| { |
| continue; |
| } |
| // Fetch the field names and determine if the field is an |
| // integer type. We use this info to decide whether to |
| // surround the data with quotes or not |
| $i = 0; |
| $field_str = ''; |
| $is_int = array(); |
| while ($field = mysql_fetch_field($query->result_id)) |
| { |
| // Most versions of MySQL store timestamp as a string |
| $is_int[$i] = (in_array( |
| strtolower(mysql_field_type($query->result_id, $i)), |
| array('tinyint', 'smallint', 'mediumint', 'int', 'bigint'), //, 'timestamp'), |
| TRUE) |
| ) ? TRUE : FALSE; |
| // Create a string of field names |
| $field_str .= '`'.$field->name.'`, '; |
| $i++; |
| } |
| // Trim off the end comma |
| $field_str = preg_replace( "/, $/" , "" , $field_str); |
| // Build the insert string |
| foreach ($query->result_array() as $row) |
| { |
| $val_str = ''; |
| $i = 0; |
| foreach ($row as $v) |
| { |
| // Is the value NULL? |
| if ($v === NULL) |
| { |
| $val_str .= 'NULL'; |
| } |
| else |
| { |
| // Escape the data if it's not an integer |
| if ($is_int[$i] == FALSE) |
| { |
| $val_str .= $this->db->escape($v); |
| } |
| else |
| { |
| $val_str .= $v; |
| } |
| } |
| // Append a comma |
| $val_str .= ', '; |
| $i++; |
| } |
| // Remove the comma at the end of the string |
| $val_str = preg_replace( "/, $/" , "" , $val_str); |
| // Build the INSERT string |
| $output .= 'INSERT INTO '.$table.' ('.$field_str.') VALUES ('.$val_str.');'.$newline; |
| } |
| $output .= $newline.$newline; |
| } |
| return $output; |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| } |
| /* End of file mysql_utility.php */ |
| /* Location: ./system/database/drivers/mysql/mysql_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysql/mysql_driver.php |
|---|
| New file |
| 0,0 → 1,623 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQL Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysql_driver extends CI_DB { |
| var $dbdriver = 'mysql'; |
| // The character used for escaping |
| var $_escape_char = '`'; |
| /** |
| * Whether to use the MySQL "delete hack" which allows the number |
| * of affected rows to be shown. Uses a preg_replace when enabled, |
| * adding a bit more processing to all queries. |
| */ |
| var $delete_hack = TRUE; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = 'SELECT COUNT(*) AS '; |
| var $_random_keyword = ' RAND()'; // database specific random keyword |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| if ($this->port != '') |
| { |
| $this->hostname .= ':'.$this->port; |
| } |
| return @mysql_connect($this->hostname, $this->username, $this->password, TRUE); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| if ($this->port != '') |
| { |
| $this->hostname .= ':'.$this->port; |
| } |
| return @mysql_pconnect($this->hostname, $this->username, $this->password); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| return @mysql_select_db($this->database, $this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| return @mysql_query("SET NAMES '".$this->escape_str($charset)."' COLLATE '".$this->escape_str($collation)."'", $this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return "SELECT version() AS ver"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| return @mysql_query($sql, $this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| // "DELETE FROM TABLE" returns 0 affected rows This hack modifies |
| // the query so that it returns the number of affected rows |
| if ($this->delete_hack === TRUE) |
| { |
| if (preg_match('/^\s*DELETE\s+FROM\s+(\S+)\s*$/i', $sql)) |
| { |
| $sql = preg_replace("/^\s*DELETE\s+FROM\s+(\S+)\s*$/", "DELETE FROM \\1 WHERE 1=1", $sql); |
| } |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| $this->simple_query('SET AUTOCOMMIT=0'); |
| $this->simple_query('START TRANSACTION'); // can also be BEGIN or BEGIN WORK |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('COMMIT'); |
| $this->simple_query('SET AUTOCOMMIT=1'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('ROLLBACK'); |
| $this->simple_query('SET AUTOCOMMIT=1'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| if (is_array($str)) |
| { |
| foreach($str as $key => $val) |
| { |
| $str[$key] = $this->escape_str($val); |
| } |
| return $str; |
| } |
| if (function_exists('mysql_real_escape_string') AND is_resource($this->conn_id)) |
| { |
| return mysql_real_escape_string($str, $this->conn_id); |
| } |
| elseif (function_exists('mysql_escape_string')) |
| { |
| return mysql_escape_string($str); |
| } |
| else |
| { |
| return addslashes($str); |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @mysql_affected_rows($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| return @mysql_insert_id($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return (int)$row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * List table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SHOW TABLES FROM ".$this->_escape_char.$this->database.$this->_escape_char; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| $sql .= " LIKE '".$this->dbprefix."%'"; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SHOW COLUMNS FROM ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT * FROM ".$table." LIMIT 1"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| return mysql_error($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| return mysql_errno($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return '('.implode(', ', $tables).')'; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return "TRUNCATE ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| if ($offset == 0) |
| { |
| $offset = ''; |
| } |
| else |
| { |
| $offset .= ", "; |
| } |
| return $sql."LIMIT ".$offset.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @mysql_close($conn_id); |
| } |
| } |
| /* End of file mysql_driver.php */ |
| /* Location: ./system/database/drivers/mysql/mysql_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysql/mysql_result.php |
|---|
| New file |
| 0,0 → 1,169 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // -------------------------------------------------------------------- |
| /** |
| * MySQL Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysql_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @mysql_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @mysql_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| while ($field = mysql_fetch_field($this->result_id)) |
| { |
| $field_names[] = $field->name; |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| while ($field = mysql_fetch_field($this->result_id)) |
| { |
| $F = new stdClass(); |
| $F->name = $field->name; |
| $F->type = $field->type; |
| $F->default = $field->def; |
| $F->max_length = $field->max_length; |
| $F->primary_key = $field->primary_key; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_resource($this->result_id)) |
| { |
| mysql_free_result($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return mysql_data_seek($this->result_id, $n); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| return mysql_fetch_assoc($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| return mysql_fetch_object($this->result_id); |
| } |
| } |
| /* End of file mysql_result.php */ |
| /* Location: ./system/database/drivers/mysql/mysql_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysql/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysql/mysql_forge.php |
|---|
| New file |
| 0,0 → 1,254 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQL Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysql_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Process Fields |
| * |
| * @access private |
| * @param mixed the fields |
| * @return string |
| */ |
| function _process_fields($fields) |
| { |
| $current_field_count = 0; |
| $sql = ''; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| if (array_key_exists('NAME', $attributes)) |
| { |
| $sql .= ' '.$this->db->_protect_identifiers($attributes['NAME']).' '; |
| } |
| if (array_key_exists('TYPE', $attributes)) |
| { |
| $sql .= ' '.$attributes['TYPE']; |
| } |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes)) |
| { |
| $sql .= ($attributes['NULL'] === TRUE) ? ' NULL' : ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param mixed the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $sql .= $this->_process_fields($fields); |
| if (count($primary_keys) > 0) |
| { |
| $key_name = $this->db->_protect_identifiers(implode('_', $primary_keys)); |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY ".$key_name." (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key_name = $this->db->_protect_identifiers(implode('_', $key)); |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key_name = $this->db->_protect_identifiers($key); |
| $key = array($key_name); |
| } |
| $sql .= ",\n\tKEY {$key_name} (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n) DEFAULT CHARACTER SET {$this->db->char_set} COLLATE {$this->db->dbcollat};"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return string |
| */ |
| function _drop_table($table) |
| { |
| return "DROP TABLE IF EXISTS ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param array fields |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $fields, $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type "; |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql.$this->db->_protect_identifiers($fields); |
| } |
| $sql .= $this->_process_fields($fields); |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file mysql_forge.php */ |
| /* Location: ./system/database/drivers/mysql/mysql_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/odbc/odbc_forge.php |
|---|
| New file |
| 0,0 → 1,266 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * ODBC Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/database/ |
| */ |
| class CI_DB_odbc_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database() |
| { |
| // ODBC has no "create database" command since it's |
| // designed to connect to an existing database |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| // ODBC has no "drop database" command since it's |
| // designed to connect to an existing database |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param array the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $current_field_count = 0; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| $sql .= ' '.$attributes['TYPE']; |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes) && $attributes['NULL'] === TRUE) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| if (count($primary_keys) > 0) |
| { |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key = array($this->db->_protect_identifiers($key)); |
| } |
| $sql .= ",\n\tFOREIGN KEY (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n)"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return bool |
| */ |
| function _drop_table($table) |
| { |
| // Not a supported ODBC feature |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param string the table name |
| * @param string the column definition |
| * @param string the default value |
| * @param boolean should 'NOT NULL' be added |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type ".$this->db->_protect_identifiers($column_name); |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql; |
| } |
| $sql .= " $column_definition"; |
| if ($default_value != '') |
| { |
| $sql .= " DEFAULT \"$default_value\""; |
| } |
| if ($null === NULL) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file odbc_forge.php */ |
| /* Location: ./system/database/drivers/odbc/odbc_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/odbc/odbc_utility.php |
|---|
| New file |
| 0,0 → 1,148 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * ODBC Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/database/ |
| */ |
| class CI_DB_odbc_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| // Not sure if ODBC lets you list all databases... |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Generates a platform-specific query so that a table can be optimized |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| // Not a supported ODBC feature |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Generates a platform-specific query so that a table can be repaired |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| // Not a supported ODBC feature |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * ODBC Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database() |
| { |
| // ODBC has no "create database" command since it's |
| // designed to connect to an existing database |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| // ODBC has no "drop database" command since it's |
| // designed to connect to an existing database |
| if ($this->db->db_debug) |
| { |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| return FALSE; |
| } |
| } |
| /* End of file odbc_utility.php */ |
| /* Location: ./system/database/drivers/odbc/odbc_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/odbc/odbc_driver.php |
|---|
| New file |
| 0,0 → 1,583 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * ODBC Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_odbc_driver extends CI_DB { |
| var $dbdriver = 'odbc'; |
| // the character used to excape - not necessary for ODBC |
| var $_escape_char = ''; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(*) AS "; |
| var $_random_keyword; |
| function CI_DB_odbc_driver($params) |
| { |
| parent::CI_DB($params); |
| $this->_random_keyword = ' RND('.time().')'; // database specific random keyword |
| } |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| return @odbc_connect($this->hostname, $this->username, $this->password); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| return @odbc_pconnect($this->hostname, $this->username, $this->password); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| // Not needed for ODBC |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| // @todo - add support if needed |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return "SELECT version() AS ver"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| return @odbc_exec($this->conn_id, $sql); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| return odbc_autocommit($this->conn_id, FALSE); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $ret = odbc_commit($this->conn_id); |
| odbc_autocommit($this->conn_id, TRUE); |
| return $ret; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $ret = odbc_rollback($this->conn_id); |
| odbc_autocommit($this->conn_id, TRUE); |
| return $ret; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| // Access the CI object |
| $CI =& get_instance(); |
| // ODBC doesn't require escaping |
| return $CI->_remove_invisible_characters($str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @odbc_num_rows($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| return @odbc_insert_id($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return $row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SHOW TABLES FROM `".$this->database."`"; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| //$sql .= " LIKE '".$this->dbprefix."%'"; |
| return FALSE; // not currently supported |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SHOW COLUMNS FROM ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT TOP 1 FROM ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| return odbc_errormsg($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| return odbc_error($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return '('.implode(', ', $tables).')'; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return $this->_delete($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| // Does ODBC doesn't use the LIMIT clause? |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @odbc_close($conn_id); |
| } |
| } |
| /* End of file odbc_driver.php */ |
| /* Location: ./system/database/drivers/odbc/odbc_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/odbc/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/odbc/odbc_result.php |
|---|
| New file |
| 0,0 → 1,228 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * ODBC Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_odbc_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @odbc_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @odbc_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $field_names[] = odbc_field_name($this->result_id, $i); |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| for ($i = 0; $i < $this->num_fields(); $i++) |
| { |
| $F = new stdClass(); |
| $F->name = odbc_field_name($this->result_id, $i); |
| $F->type = odbc_field_type($this->result_id, $i); |
| $F->max_length = odbc_field_len($this->result_id, $i); |
| $F->primary_key = 0; |
| $F->default = ''; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_resource($this->result_id)) |
| { |
| odbc_free_result($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return FALSE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| if (function_exists('odbc_fetch_object')) |
| { |
| return odbc_fetch_array($this->result_id); |
| } |
| else |
| { |
| return $this->_odbc_fetch_array($this->result_id); |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| if (function_exists('odbc_fetch_object')) |
| { |
| return odbc_fetch_object($this->result_id); |
| } |
| else |
| { |
| return $this->_odbc_fetch_object($this->result_id); |
| } |
| } |
| /** |
| * Result - object |
| * |
| * subsititutes the odbc_fetch_object function when |
| * not available (odbc_fetch_object requires unixODBC) |
| * |
| * @access private |
| * @return object |
| */ |
| function _odbc_fetch_object(& $odbc_result) { |
| $rs = array(); |
| $rs_obj = false; |
| if (odbc_fetch_into($odbc_result, $rs)) { |
| foreach ($rs as $k=>$v) { |
| $field_name= odbc_field_name($odbc_result, $k+1); |
| $rs_obj->$field_name = $v; |
| } |
| } |
| return $rs_obj; |
| } |
| /** |
| * Result - array |
| * |
| * subsititutes the odbc_fetch_array function when |
| * not available (odbc_fetch_array requires unixODBC) |
| * |
| * @access private |
| * @return array |
| */ |
| function _odbc_fetch_array(& $odbc_result) { |
| $rs = array(); |
| $rs_assoc = false; |
| if (odbc_fetch_into($odbc_result, $rs)) { |
| $rs_assoc=array(); |
| foreach ($rs as $k=>$v) { |
| $field_name= odbc_field_name($odbc_result, $k+1); |
| $rs_assoc[$field_name] = $v; |
| } |
| } |
| return $rs_assoc; |
| } |
| } |
| /* End of file odbc_result.php */ |
| /* Location: ./system/database/drivers/odbc/odbc_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysqli/mysqli_forge.php |
|---|
| New file |
| 0,0 → 1,254 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQLi Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysqli_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Process Fields |
| * |
| * @access private |
| * @param mixed the fields |
| * @return string |
| */ |
| function _process_fields($fields) |
| { |
| $current_field_count = 0; |
| $sql = ''; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| if (array_key_exists('NAME', $attributes)) |
| { |
| $sql .= ' '.$this->db->_protect_identifiers($attributes['NAME']).' '; |
| } |
| if (array_key_exists('TYPE', $attributes)) |
| { |
| $sql .= ' '.$attributes['TYPE']; |
| } |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes)) |
| { |
| $sql .= ($attributes['NULL'] === TRUE) ? ' NULL' : ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param mixed the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $sql .= $this->_process_fields($fields); |
| if (count($primary_keys) > 0) |
| { |
| $key_name = $this->db->_protect_identifiers(implode('_', $primary_keys)); |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY ".$key_name." (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key_name = $this->db->_protect_identifiers(implode('_', $key)); |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key_name = $this->db->_protect_identifiers($key); |
| $key = array($key_name); |
| } |
| $sql .= ",\n\tKEY {$key_name} (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n) DEFAULT CHARACTER SET {$this->db->char_set} COLLATE {$this->db->dbcollat};"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return string |
| */ |
| function _drop_table($table) |
| { |
| return "DROP TABLE IF EXISTS ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param array fields |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $fields, $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type "; |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql.$this->db->_protect_identifiers($fields); |
| } |
| $sql .= $this->_process_fields($fields); |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file mysqli_forge.php */ |
| /* Location: ./system/database/drivers/mysqli/mysqli_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysqli/mysqli_utility.php |
|---|
| New file |
| 0,0 → 1,123 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQLi Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysqli_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| return "SHOW DATABASES"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Generates a platform-specific query so that a table can be optimized |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return "OPTIMIZE TABLE ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Generates a platform-specific query so that a table can be repaired |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return "REPAIR TABLE ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * MySQLi Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| } |
| /* End of file mysqli_utility.php */ |
| /* Location: ./system/database/drivers/mysqli/mysqli_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysqli/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysqli/mysqli_driver.php |
|---|
| New file |
| 0,0 → 1,606 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQLi Database Adapter Class - MySQLi only works with PHP 5 |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysqli_driver extends CI_DB { |
| var $dbdriver = 'mysqli'; |
| // The character used for escaping |
| var $_escape_char = '`'; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(*) AS "; |
| var $_random_keyword = ' RAND()'; // database specific random keyword |
| /** |
| * Whether to use the MySQL "delete hack" which allows the number |
| * of affected rows to be shown. Uses a preg_replace when enabled, |
| * adding a bit more processing to all queries. |
| */ |
| var $delete_hack = TRUE; |
| // -------------------------------------------------------------------- |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| return @mysqli_connect($this->hostname, $this->username, $this->password, $this->database, $this->port); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| return $this->db_connect(); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| return @mysqli_select_db($this->conn_id, $this->database); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access private |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function _db_set_charset($charset, $collation) |
| { |
| return @mysqli_query($this->conn_id, "SET NAMES '".$this->escape_str($charset)."' COLLATE '".$this->escape_str($collation)."'"); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return "SELECT version() AS ver"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| $result = @mysqli_query($this->conn_id, $sql); |
| return $result; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| // "DELETE FROM TABLE" returns 0 affected rows This hack modifies |
| // the query so that it returns the number of affected rows |
| if ($this->delete_hack === TRUE) |
| { |
| if (preg_match('/^\s*DELETE\s+FROM\s+(\S+)\s*$/i', $sql)) |
| { |
| $sql = preg_replace("/^\s*DELETE\s+FROM\s+(\S+)\s*$/", "DELETE FROM \\1 WHERE 1=1", $sql); |
| } |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| $this->simple_query('SET AUTOCOMMIT=0'); |
| $this->simple_query('START TRANSACTION'); // can also be BEGIN or BEGIN WORK |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('COMMIT'); |
| $this->simple_query('SET AUTOCOMMIT=1'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('ROLLBACK'); |
| $this->simple_query('SET AUTOCOMMIT=1'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| if (function_exists('mysqli_real_escape_string') AND is_object($this->conn_id)) |
| { |
| return mysqli_real_escape_string($this->conn_id, $str); |
| } |
| elseif (function_exists('mysql_escape_string')) |
| { |
| return mysql_escape_string($str); |
| } |
| else |
| { |
| return addslashes($str); |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @mysqli_affected_rows($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| return @mysqli_insert_id($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return $row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * List table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SHOW TABLES FROM ".$this->_escape_char.$this->database.$this->_escape_char; |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| $sql .= " LIKE '".$this->dbprefix."%'"; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Show column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SHOW COLUMNS FROM ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT * FROM ".$table." LIMIT 1"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| return mysqli_error($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| return mysqli_errno($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return '('.implode(', ', $tables).')'; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return "TRUNCATE ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| $sql .= "LIMIT ".$limit; |
| if ($offset > 0) |
| { |
| $sql .= " OFFSET ".$offset; |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @mysqli_close($conn_id); |
| } |
| } |
| /* End of file mysqli_driver.php */ |
| /* Location: ./system/database/drivers/mysqli/mysqli_driver.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mysqli/mysqli_result.php |
|---|
| New file |
| 0,0 → 1,169 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MySQLi Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mysqli_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @mysqli_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @mysqli_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| while ($field = mysqli_fetch_field($this->result_id)) |
| { |
| $field_names[] = $field->name; |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| while ($field = mysqli_fetch_field($this->result_id)) |
| { |
| $F = new stdClass(); |
| $F->name = $field->name; |
| $F->type = $field->type; |
| $F->default = $field->def; |
| $F->max_length = $field->max_length; |
| $F->primary_key = ($field->flags & MYSQLI_PRI_KEY_FLAG) ? 1 : 0; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_object($this->result_id)) |
| { |
| mysqli_free_result($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return mysqli_data_seek($this->result_id, $n); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| return mysqli_fetch_assoc($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| return mysqli_fetch_object($this->result_id); |
| } |
| } |
| /* End of file mysqli_result.php */ |
| /* Location: ./system/database/drivers/mysqli/mysqli_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mssql/mssql_result.php |
|---|
| New file |
| 0,0 → 1,169 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MS SQL Result Class |
| * |
| * This class extends the parent result class: CI_DB_result |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mssql_result extends CI_DB_result { |
| /** |
| * Number of rows in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_rows() |
| { |
| return @mssql_num_rows($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Number of fields in the result set |
| * |
| * @access public |
| * @return integer |
| */ |
| function num_fields() |
| { |
| return @mssql_num_fields($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Fetch Field Names |
| * |
| * Generates an array of column names |
| * |
| * @access public |
| * @return array |
| */ |
| function list_fields() |
| { |
| $field_names = array(); |
| while ($field = mssql_fetch_field($this->result_id)) |
| { |
| $field_names[] = $field->name; |
| } |
| return $field_names; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data |
| * |
| * Generates an array of objects containing field meta-data |
| * |
| * @access public |
| * @return array |
| */ |
| function field_data() |
| { |
| $retval = array(); |
| while ($field = mssql_fetch_field($this->result_id)) |
| { |
| $F = new stdClass(); |
| $F->name = $field->name; |
| $F->type = $field->type; |
| $F->max_length = $field->max_length; |
| $F->primary_key = 0; |
| $F->default = ''; |
| $retval[] = $F; |
| } |
| return $retval; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Free the result |
| * |
| * @return null |
| */ |
| function free_result() |
| { |
| if (is_resource($this->result_id)) |
| { |
| mssql_free_result($this->result_id); |
| $this->result_id = FALSE; |
| } |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Data Seek |
| * |
| * Moves the internal pointer to the desired offset. We call |
| * this internally before fetching results to make sure the |
| * result set starts at zero |
| * |
| * @access private |
| * @return array |
| */ |
| function _data_seek($n = 0) |
| { |
| return mssql_data_seek($this->result_id, $n); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - associative array |
| * |
| * Returns the result set as an array |
| * |
| * @access private |
| * @return array |
| */ |
| function _fetch_assoc() |
| { |
| return mssql_fetch_assoc($this->result_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Result - object |
| * |
| * Returns the result set as an object |
| * |
| * @access private |
| * @return object |
| */ |
| function _fetch_object() |
| { |
| return mssql_fetch_object($this->result_id); |
| } |
| } |
| /* End of file mssql_result.php */ |
| /* Location: ./system/database/drivers/mssql/mssql_result.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mssql/mssql_forge.php |
|---|
| New file |
| 0,0 → 1,248 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MS SQL Forge Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mssql_forge extends CI_DB_forge { |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop Table |
| * |
| * @access private |
| * @return bool |
| */ |
| function _drop_table($table) |
| { |
| return "DROP TABLE ".$this->db->_escape_identifiers($table); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Create Table |
| * |
| * @access private |
| * @param string the table name |
| * @param array the fields |
| * @param mixed primary key(s) |
| * @param mixed key(s) |
| * @param boolean should 'IF NOT EXISTS' be added to the SQL |
| * @return bool |
| */ |
| function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists) |
| { |
| $sql = 'CREATE TABLE '; |
| if ($if_not_exists === TRUE) |
| { |
| $sql .= 'IF NOT EXISTS '; |
| } |
| $sql .= $this->db->_escape_identifiers($table)." ("; |
| $current_field_count = 0; |
| foreach ($fields as $field=>$attributes) |
| { |
| // Numeric field names aren't allowed in databases, so if the key is |
| // numeric, we know it was assigned by PHP and the developer manually |
| // entered the field information, so we'll simply add it to the list |
| if (is_numeric($field)) |
| { |
| $sql .= "\n\t$attributes"; |
| } |
| else |
| { |
| $attributes = array_change_key_case($attributes, CASE_UPPER); |
| $sql .= "\n\t".$this->db->_protect_identifiers($field); |
| $sql .= ' '.$attributes['TYPE']; |
| if (array_key_exists('CONSTRAINT', $attributes)) |
| { |
| $sql .= '('.$attributes['CONSTRAINT'].')'; |
| } |
| if (array_key_exists('UNSIGNED', $attributes) && $attributes['UNSIGNED'] === TRUE) |
| { |
| $sql .= ' UNSIGNED'; |
| } |
| if (array_key_exists('DEFAULT', $attributes)) |
| { |
| $sql .= ' DEFAULT \''.$attributes['DEFAULT'].'\''; |
| } |
| if (array_key_exists('NULL', $attributes) && $attributes['NULL'] === TRUE) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if (array_key_exists('AUTO_INCREMENT', $attributes) && $attributes['AUTO_INCREMENT'] === TRUE) |
| { |
| $sql .= ' AUTO_INCREMENT'; |
| } |
| } |
| // don't add a comma on the end of the last field |
| if (++$current_field_count < count($fields)) |
| { |
| $sql .= ','; |
| } |
| } |
| if (count($primary_keys) > 0) |
| { |
| $primary_keys = $this->db->_protect_identifiers($primary_keys); |
| $sql .= ",\n\tPRIMARY KEY (" . implode(', ', $primary_keys) . ")"; |
| } |
| if (is_array($keys) && count($keys) > 0) |
| { |
| foreach ($keys as $key) |
| { |
| if (is_array($key)) |
| { |
| $key = $this->db->_protect_identifiers($key); |
| } |
| else |
| { |
| $key = array($this->db->_protect_identifiers($key)); |
| } |
| $sql .= ",\n\tFOREIGN KEY (" . implode(', ', $key) . ")"; |
| } |
| } |
| $sql .= "\n)"; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Alter table query |
| * |
| * Generates a platform-specific query so that a table can be altered |
| * Called by add_column(), drop_column(), and column_alter(), |
| * |
| * @access private |
| * @param string the ALTER type (ADD, DROP, CHANGE) |
| * @param string the column name |
| * @param string the table name |
| * @param string the column definition |
| * @param string the default value |
| * @param boolean should 'NOT NULL' be added |
| * @param string the field after which we should add the new field |
| * @return object |
| */ |
| function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '') |
| { |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table)." $alter_type ".$this->db->_protect_identifiers($column_name); |
| // DROP has everything it needs now. |
| if ($alter_type == 'DROP') |
| { |
| return $sql; |
| } |
| $sql .= " $column_definition"; |
| if ($default_value != '') |
| { |
| $sql .= " DEFAULT \"$default_value\""; |
| } |
| if ($null === NULL) |
| { |
| $sql .= ' NULL'; |
| } |
| else |
| { |
| $sql .= ' NOT NULL'; |
| } |
| if ($after_field != '') |
| { |
| $sql .= ' AFTER ' . $this->db->_protect_identifiers($after_field); |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rename a table |
| * |
| * Generates a platform-specific query so that a table can be renamed |
| * |
| * @access private |
| * @param string the old table name |
| * @param string the new table name |
| * @return string |
| */ |
| function _rename_table($table_name, $new_table_name) |
| { |
| // I think this syntax will work, but can find little documentation on renaming tables in MSSQL |
| $sql = 'ALTER TABLE '.$this->db->_protect_identifiers($table_name)." RENAME TO ".$this->db->_protect_identifiers($new_table_name); |
| return $sql; |
| } |
| } |
| /* End of file mssql_forge.php */ |
| /* Location: ./system/database/drivers/mssql/mssql_forge.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mssql/mssql_utility.php |
|---|
| New file |
| 0,0 → 1,123 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MS SQL Utility Class |
| * |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mssql_utility extends CI_DB_utility { |
| /** |
| * List databases |
| * |
| * @access private |
| * @return bool |
| */ |
| function _list_databases() |
| { |
| return "EXEC sp_helpdb"; // Can also be: EXEC sp_databases |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Optimize table query |
| * |
| * Generates a platform-specific query so that a table can be optimized |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _optimize_table($table) |
| { |
| return FALSE; // Is this supported in MS SQL? |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Repair table query |
| * |
| * Generates a platform-specific query so that a table can be repaired |
| * |
| * @access private |
| * @param string the table name |
| * @return object |
| */ |
| function _repair_table($table) |
| { |
| return FALSE; // Is this supported in MS SQL? |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * MSSQL Export |
| * |
| * @access private |
| * @param array Preferences |
| * @return mixed |
| */ |
| function _backup($params = array()) |
| { |
| // Currently unsupported |
| return $this->db->display_error('db_unsuported_feature'); |
| } |
| /** |
| * |
| * The functions below have been deprecated as of 1.6, and are only here for backwards |
| * compatibility. They now reside in dbforge(). The use of dbutils for database manipulation |
| * is STRONGLY discouraged in favour if using dbforge. |
| * |
| */ |
| /** |
| * Create database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _create_database($name) |
| { |
| return "CREATE DATABASE ".$name; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Drop database |
| * |
| * @access private |
| * @param string the database name |
| * @return bool |
| */ |
| function _drop_database($name) |
| { |
| return "DROP DATABASE ".$name; |
| } |
| } |
| /* End of file mssql_utility.php */ |
| /* Location: ./system/database/drivers/mssql/mssql_utility.php */ |
| /trunk/papyrus/bibliotheque/system/database/drivers/mssql/index.html |
|---|
| New file |
| 0,0 → 1,10 |
| <html> |
| <head> |
| <title>403 Forbidden</title> |
| </head> |
| <body> |
| <p>Directory access is forbidden.</p> |
| </body> |
| </html> |
| /trunk/papyrus/bibliotheque/system/database/drivers/mssql/mssql_driver.php |
|---|
| New file |
| 0,0 → 1,611 |
| <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
| /** |
| * CodeIgniter |
| * |
| * An open source application development framework for PHP 4.3.2 or newer |
| * |
| * @package CodeIgniter |
| * @author ExpressionEngine Dev Team |
| * @copyright Copyright (c) 2008, EllisLab, Inc. |
| * @license http://codeigniter.com/user_guide/license.html |
| * @link http://codeigniter.com |
| * @since Version 1.0 |
| * @filesource |
| */ |
| // ------------------------------------------------------------------------ |
| /** |
| * MS SQL Database Adapter Class |
| * |
| * Note: _DB is an extender class that the app controller |
| * creates dynamically based on whether the active record |
| * class is being used or not. |
| * |
| * @package CodeIgniter |
| * @subpackage Drivers |
| * @category Database |
| * @author ExpressionEngine Dev Team |
| * @link http://codeigniter.com/user_guide/database/ |
| */ |
| class CI_DB_mssql_driver extends CI_DB { |
| var $dbdriver = 'mssql'; |
| // The character used for escaping |
| var $_escape_char = ''; |
| /** |
| * The syntax to count rows is slightly different across different |
| * database engines, so this string appears in each driver and is |
| * used for the count_all() and count_all_results() functions. |
| */ |
| var $_count_string = "SELECT COUNT(*) AS "; |
| var $_random_keyword = ' ASC'; // not currently supported |
| /** |
| * Non-persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_connect() |
| { |
| if ($this->port != '') |
| { |
| $this->hostname .= ','.$this->port; |
| } |
| return @mssql_connect($this->hostname, $this->username, $this->password); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Persistent database connection |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_pconnect() |
| { |
| if ($this->port != '') |
| { |
| $this->hostname .= ','.$this->port; |
| } |
| return @mssql_pconnect($this->hostname, $this->username, $this->password); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Select the database |
| * |
| * @access private called by the base class |
| * @return resource |
| */ |
| function db_select() |
| { |
| // Note: The brackets are required in the event that the DB name |
| // contains reserved characters |
| return @mssql_select_db('['.$this->database.']', $this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Set client character set |
| * |
| * @access public |
| * @param string |
| * @param string |
| * @return resource |
| */ |
| function db_set_charset($charset, $collation) |
| { |
| // @todo - add support if needed |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Execute the query |
| * |
| * @access private called by the base class |
| * @param string an SQL query |
| * @return resource |
| */ |
| function _execute($sql) |
| { |
| $sql = $this->_prep_query($sql); |
| return @mssql_query($sql, $this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Prep the query |
| * |
| * If needed, each database adapter can prep the query string |
| * |
| * @access private called by execute() |
| * @param string an SQL query |
| * @return string |
| */ |
| function _prep_query($sql) |
| { |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Begin Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_begin($test_mode = FALSE) |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| // Reset the transaction failure flag. |
| // If the $test_mode flag is set to TRUE transactions will be rolled back |
| // even if the queries produce a successful result. |
| $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; |
| $this->simple_query('BEGIN TRAN'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Commit Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_commit() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('COMMIT TRAN'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Rollback Transaction |
| * |
| * @access public |
| * @return bool |
| */ |
| function trans_rollback() |
| { |
| if ( ! $this->trans_enabled) |
| { |
| return TRUE; |
| } |
| // When transactions are nested we only begin/commit/rollback the outermost ones |
| if ($this->_trans_depth > 0) |
| { |
| return TRUE; |
| } |
| $this->simple_query('ROLLBACK TRAN'); |
| return TRUE; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape String |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function escape_str($str) |
| { |
| // Access the CI object |
| $CI =& get_instance(); |
| // Escape single quotes |
| return str_replace("'", "''", $CI->input->_remove_invisible_characters($str)); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Affected Rows |
| * |
| * @access public |
| * @return integer |
| */ |
| function affected_rows() |
| { |
| return @mssql_rows_affected($this->conn_id); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert ID |
| * |
| * Returns the last id created in the Identity column. |
| * |
| * @access public |
| * @return integer |
| */ |
| function insert_id() |
| { |
| $ver = self::_parse_major_version($this->version()); |
| $sql = ($ver >= 8 ? "SELECT SCOPE_IDENTITY() AS last_id" : "SELECT @@IDENTITY AS last_id"); |
| $query = $this->query($sql); |
| $row = $query->row(); |
| return $row->last_id; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Parse major version |
| * |
| * Grabs the major version number from the |
| * database server version string passed in. |
| * |
| * @access private |
| * @param string $version |
| * @return int16 major version number |
| */ |
| function _parse_major_version($version) |
| { |
| preg_match('/([0-9]+)\.([0-9]+)\.([0-9]+)/', $version, $ver_info); |
| return $ver_info[1]; // return the major version b/c that's all we're interested in. |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Version number query string |
| * |
| * @access public |
| * @return string |
| */ |
| function _version() |
| { |
| return "SELECT @@VERSION AS ver"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * "Count All" query |
| * |
| * Generates a platform-specific query string that counts all records in |
| * the specified database |
| * |
| * @access public |
| * @param string |
| * @return string |
| */ |
| function count_all($table = '') |
| { |
| if ($table == '') |
| return '0'; |
| $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows'). " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); |
| if ($query->num_rows() == 0) |
| return '0'; |
| $row = $query->row(); |
| return $row->numrows; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * List table query |
| * |
| * Generates a platform-specific query string so that the table names can be fetched |
| * |
| * @access private |
| * @param boolean |
| * @return string |
| */ |
| function _list_tables($prefix_limit = FALSE) |
| { |
| $sql = "SELECT name FROM sysobjects WHERE type = 'U' ORDER BY name"; |
| // for future compatibility |
| if ($prefix_limit !== FALSE AND $this->dbprefix != '') |
| { |
| //$sql .= " LIKE '".$this->dbprefix."%'"; |
| return FALSE; // not currently supported |
| } |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * List column query |
| * |
| * Generates a platform-specific query string so that the column names can be fetched |
| * |
| * @access private |
| * @param string the table name |
| * @return string |
| */ |
| function _list_columns($table = '') |
| { |
| return "SELECT * FROM INFORMATION_SCHEMA.Columns WHERE TABLE_NAME = '".$table."'"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Field data query |
| * |
| * Generates a platform-specific query so that the column data can be retrieved |
| * |
| * @access public |
| * @param string the table name |
| * @return object |
| */ |
| function _field_data($table) |
| { |
| return "SELECT TOP 1 * FROM ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message string |
| * |
| * @access private |
| * @return string |
| */ |
| function _error_message() |
| { |
| // Are errros even supported in MS SQL? |
| return ''; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * The error message number |
| * |
| * @access private |
| * @return integer |
| */ |
| function _error_number() |
| { |
| // Are error numbers supported? |
| return ''; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Escape the SQL Identifiers |
| * |
| * This function escapes column and table names |
| * |
| * @access private |
| * @param string |
| * @return string |
| */ |
| function _escape_identifiers($item) |
| { |
| if ($this->_escape_char == '') |
| { |
| return $item; |
| } |
| if (strpos($item, '.') !== FALSE) |
| { |
| $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; |
| } |
| else |
| { |
| $str = $this->_escape_char.$item.$this->_escape_char; |
| } |
| // remove duplicates if the user already included the escape |
| return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * From Tables |
| * |
| * This function implicitly groups FROM tables so there is no confusion |
| * about operator precedence in harmony with SQL standards |
| * |
| * @access public |
| * @param type |
| * @return type |
| */ |
| function _from_tables($tables) |
| { |
| if ( ! is_array($tables)) |
| { |
| $tables = array($tables); |
| } |
| return implode(', ', $tables); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Insert statement |
| * |
| * Generates a platform-specific insert string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the insert keys |
| * @param array the insert values |
| * @return string |
| */ |
| function _insert($table, $keys, $values) |
| { |
| return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")"; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Update statement |
| * |
| * Generates a platform-specific update string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the update data |
| * @param array the where clause |
| * @param array the orderby clause |
| * @param array the limit clause |
| * @return string |
| */ |
| function _update($table, $values, $where, $orderby = array(), $limit = FALSE) |
| { |
| foreach($values as $key => $val) |
| { |
| $valstr[] = $key." = ".$val; |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; |
| $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); |
| $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; |
| $sql .= $orderby.$limit; |
| return $sql; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Truncate statement |
| * |
| * Generates a platform-specific truncate string from the supplied data |
| * If the database does not support the truncate() command |
| * This function maps to "DELETE FROM table" |
| * |
| * @access public |
| * @param string the table name |
| * @return string |
| */ |
| function _truncate($table) |
| { |
| return "TRUNCATE ".$table; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Delete statement |
| * |
| * Generates a platform-specific delete string from the supplied data |
| * |
| * @access public |
| * @param string the table name |
| * @param array the where clause |
| * @param string the limit clause |
| * @return string |
| */ |
| function _delete($table, $where = array(), $like = array(), $limit = FALSE) |
| { |
| $conditions = ''; |
| if (count($where) > 0 OR count($like) > 0) |
| { |
| $conditions = "\nWHERE "; |
| $conditions .= implode("\n", $this->ar_where); |
| if (count($where) > 0 && count($like) > 0) |
| { |
| $conditions .= " AND "; |
| } |
| $conditions .= implode("\n", $like); |
| } |
| $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; |
| return "DELETE FROM ".$table.$conditions.$limit; |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Limit string |
| * |
| * Generates a platform-specific LIMIT clause |
| * |
| * @access public |
| * @param string the sql query string |
| * @param integer the number of rows to limit the query to |
| * @param integer the offset value |
| * @return string |
| */ |
| function _limit($sql, $limit, $offset) |
| { |
| $i = $limit + $offset; |
| return preg_replace('/(^\SELECT (DISTINCT)?)/i','\\1 TOP '.$i.' ', $sql); |
| } |
| // -------------------------------------------------------------------- |
| /** |
| * Close DB Connection |
| * |
| * @access public |
| * @param resource |
| * @return void |
| */ |
| function _close($conn_id) |
| { |
| @mssql_close($conn_id); |
| } |
| } |
| /* End of file mssql_driver.php */ |
| /* Location: ./system/database/drivers/mssql/mssql_driver.php */ |