MDB2
[ class tree: MDB2 ] [ index: MDB2 ] [ all elements ]

Source for file mysqli.php

Documentation is available at mysqli.php

  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP versions 4 and 5                                                 |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1998-2006 Manuel Lemos, Tomas V.V.Cox,                 |
  6. // | Stig. S. Bakken, Lukas Smith                                         |
  7. // | All rights reserved.                                                 |
  8. // +----------------------------------------------------------------------+
  9. // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB  |
  10. // | API as well as database abstraction for PHP applications.            |
  11. // | This LICENSE is in the BSD license style.                            |
  12. // |                                                                      |
  13. // | Redistribution and use in source and binary forms, with or without   |
  14. // | modification, are permitted provided that the following conditions   |
  15. // | are met:                                                             |
  16. // |                                                                      |
  17. // | Redistributions of source code must retain the above copyright       |
  18. // | notice, this list of conditions and the following disclaimer.        |
  19. // |                                                                      |
  20. // | Redistributions in binary form must reproduce the above copyright    |
  21. // | notice, this list of conditions and the following disclaimer in the  |
  22. // | documentation and/or other materials provided with the distribution. |
  23. // |                                                                      |
  24. // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
  25. // | Lukas Smith nor the names of his contributors may be used to endorse |
  26. // | or promote products derived from this software without specific prior|
  27. // | written permission.                                                  |
  28. // |                                                                      |
  29. // | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  |
  30. // | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT    |
  31. // | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS    |
  32. // | FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE      |
  33. // | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,          |
  34. // | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
  35. // | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS|
  36. // |  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED  |
  37. // | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT          |
  38. // | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY|
  39. // | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE          |
  40. // | POSSIBILITY OF SUCH DAMAGE.                                          |
  41. // +----------------------------------------------------------------------+
  42. // | Author: Lukas Smith <smith@pooteeweet.org>                           |
  43. // +----------------------------------------------------------------------+
  44. //
  45. // $Id: mysqli.php,v 1.59 2007/03/29 18:18:06 quipo Exp $
  46. //
  47.  
  48. require_once 'MDB2/Driver/Reverse/Common.php';
  49.  
  50. /**
  51.  * MDB2 MySQLi driver for the schema reverse engineering module
  52.  *
  53.  * @package MDB2
  54.  * @category Database
  55.  * @author  Lukas Smith <smith@pooteeweet.org>
  56.  * @author  Lorenzo Alberton <l.alberton@quipo.it>
  57.  */
  58. class MDB2_Driver_Reverse_mysqli extends MDB2_Driver_Reverse_Common
  59. {
  60.     /**
  61.      * Array for converting MYSQLI_*_FLAG constants to text values
  62.      * @var    array 
  63.      * @access public
  64.      */
  65.     var $flags = array(
  66.         MYSQLI_NOT_NULL_FLAG        => 'not_null',
  67.         MYSQLI_PRI_KEY_FLAG         => 'primary_key',
  68.         MYSQLI_UNIQUE_KEY_FLAG      => 'unique_key',
  69.         MYSQLI_MULTIPLE_KEY_FLAG    => 'multiple_key',
  70.         MYSQLI_BLOB_FLAG            => 'blob',
  71.         MYSQLI_UNSIGNED_FLAG        => 'unsigned',
  72.         MYSQLI_ZEROFILL_FLAG        => 'zerofill',
  73.         MYSQLI_AUTO_INCREMENT_FLAG  => 'auto_increment',
  74.         MYSQLI_TIMESTAMP_FLAG       => 'timestamp',
  75.         MYSQLI_SET_FLAG             => 'set',
  76.         // MYSQLI_NUM_FLAG             => 'numeric',  // unnecessary
  77.         // MYSQLI_PART_KEY_FLAG        => 'multiple_key',  // duplicatvie
  78.                 MYSQLI_GROUP_FLAG           => 'group_by'
  79.     );
  80.  
  81.     /**
  82.      * Array for converting MYSQLI_TYPE_* constants to text values
  83.      * @var    array 
  84.      * @access public
  85.      */
  86.     var $types = array(
  87.         MYSQLI_TYPE_DECIMAL     => 'decimal',
  88.         246                     => 'decimal',
  89.         MYSQLI_TYPE_TINY        => 'tinyint',
  90.         MYSQLI_TYPE_SHORT       => 'int',
  91.         MYSQLI_TYPE_LONG        => 'int',
  92.         MYSQLI_TYPE_FLOAT       => 'float',
  93.         MYSQLI_TYPE_DOUBLE      => 'double',
  94.         // MYSQLI_TYPE_NULL        => 'DEFAULT NULL',  // let flags handle it
  95.                 MYSQLI_TYPE_TIMESTAMP   => 'timestamp',
  96.         MYSQLI_TYPE_LONGLONG    => 'bigint',
  97.         MYSQLI_TYPE_INT24       => 'mediumint',
  98.         MYSQLI_TYPE_DATE        => 'date',
  99.         MYSQLI_TYPE_TIME        => 'time',
  100.         MYSQLI_TYPE_DATETIME    => 'datetime',
  101.         MYSQLI_TYPE_YEAR        => 'year',
  102.         MYSQLI_TYPE_NEWDATE     => 'date',
  103.         MYSQLI_TYPE_ENUM        => 'enum',
  104.         MYSQLI_TYPE_SET         => 'set',
  105.         MYSQLI_TYPE_TINY_BLOB   => 'tinyblob',
  106.         MYSQLI_TYPE_MEDIUM_BLOB => 'mediumblob',
  107.         MYSQLI_TYPE_LONG_BLOB   => 'longblob',
  108.         MYSQLI_TYPE_BLOB        => 'blob',
  109.         MYSQLI_TYPE_VAR_STRING  => 'varchar',
  110.         MYSQLI_TYPE_STRING      => 'char',
  111.         MYSQLI_TYPE_GEOMETRY    => 'geometry',
  112.     );
  113.  
  114.     // {{{ getTableFieldDefinition()
  115.  
  116.     
  117.     /**
  118.      * Get the structure of a field into an array
  119.      *
  120.      * @param string    $table       name of table that should be used in method
  121.      * @param string    $field_name  name of field that should be used in method
  122.      * @return mixed data array on success, a MDB2 error on failure
  123.      * @access public
  124.      */
  125.     function getTableFieldDefinition($table$field_name)
  126.     {
  127.         $db =$this->getDBInstance();
  128.         if (PEAR::isError($db)) {
  129.             return $db;
  130.         }
  131.  
  132.         $result $db->loadModule('Datatype'nulltrue);
  133.         if (PEAR::isError($result)) {
  134.             return $result;
  135.         }
  136.         $table $db->quoteIdentifier($tabletrue);
  137.         $query = "SHOW COLUMNS FROM $table LIKE ".$db->quote($field_name);
  138.         $columns $db->queryAll($querynullMDB2_FETCHMODE_ASSOC);
  139.         if (PEAR::isError($columns)) {
  140.             return $columns;
  141.         }
  142.         foreach ($columns as $column{
  143.             $column array_change_key_case($columnCASE_LOWER);
  144.             $column['name'$column['field'];
  145.             unset($column['field']);
  146.             if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  147.                 if ($db->options['field_case'== CASE_LOWER{
  148.                     $column['name'strtolower($column['name']);
  149.                 else {
  150.                     $column['name'strtoupper($column['name']);
  151.                 }
  152.             else {
  153.                 $column array_change_key_case($column$db->options['field_case']);
  154.             }
  155.             if ($field_name == $column['name']{
  156.                 $mapped_datatype $db->datatype->mapNativeDatatype($column);
  157.                 if (PEAR::IsError($mapped_datatype)) {
  158.                     return $mapped_datatype;
  159.                 }
  160.                 list($types$length$unsigned$fixed$mapped_datatype;
  161.                 $notnull = false;
  162.                 if (empty($column['null']|| $column['null'!== 'YES'{
  163.                     $notnull = true;
  164.                 }
  165.                 $default = false;
  166.                 if (array_key_exists('default'$column)) {
  167.                     $default $column['default'];
  168.                     if (is_null($default&& $notnull{
  169.                         $default '';
  170.                     }
  171.                 }
  172.                 $autoincrement = false;
  173.                 if (!empty($column['extra']&& $column['extra'== 'auto_increment'{
  174.                     $autoincrement = true;
  175.                 }
  176.  
  177.                 $definition[0= array(
  178.                     'notnull' => $notnull,
  179.                     'nativetype' => preg_replace('/^([a-z]+)[^a-z].*/i''\\1'$column['type'])
  180.                 );
  181.                 if (!is_null($length)) {
  182.                     $definition[0]['length'$length;
  183.                 }
  184.                 if (!is_null($unsigned)) {
  185.                     $definition[0]['unsigned'$unsigned;
  186.                 }
  187.                 if (!is_null($fixed)) {
  188.                     $definition[0]['fixed'$fixed;
  189.                 }
  190.                 if ($default !== false{
  191.                     $definition[0]['default'$default;
  192.                 }
  193.                 if ($autoincrement !== false{
  194.                     $definition[0]['autoincrement'$autoincrement;
  195.                 }
  196.                 foreach ($types as $key => $type{
  197.                     $definition[$key$definition[0];
  198.                     if ($type == 'clob' || $type == 'blob'{
  199.                         unset($definition[$key]['default']);
  200.                     }
  201.                     $definition[$key]['type'$type;
  202.                     $definition[$key]['mdb2type'$type;
  203.                 }
  204.                 return $definition;
  205.             }
  206.         }
  207.  
  208.         return $db->raiseError(MDB2_ERROR_NOT_FOUNDnullnull,
  209.             'it was not specified an existing table column'__FUNCTION__);
  210.     }
  211.  
  212.     // }}}
  213.     // {{{ getTableIndexDefinition()
  214.  
  215.     
  216.     /**
  217.      * Get the structure of an index into an array
  218.      *
  219.      * @param string    $table      name of table that should be used in method
  220.      * @param string    $index_name name of index that should be used in method
  221.      * @return mixed data array on success, a MDB2 error on failure
  222.      * @access public
  223.      */
  224.     function getTableIndexDefinition($table$index_name)
  225.     {
  226.         $db =$this->getDBInstance();
  227.         if (PEAR::isError($db)) {
  228.             return $db;
  229.         }
  230.  
  231.         $table $db->quoteIdentifier($tabletrue);
  232.         $query = "SHOW INDEX FROM $table /*!50002 WHERE Key_name = %s */";
  233.         $index_name_mdb2 $db->getIndexName($index_name);
  234.         $result $db->queryRow(sprintf($query$db->quote($index_name_mdb2)));
  235.         if (!PEAR::isError($result&& !is_null($result)) {
  236.             // apply 'idxname_format' only if the query succeeded, otherwise
  237.             // fallback to the given $index_name, without transformation
  238.             $index_name $index_name_mdb2;
  239.         }
  240.         $result $db->query(sprintf($query$db->quote($index_name)));
  241.         if (PEAR::isError($result)) {
  242.             return $result;
  243.         }
  244.         $colpos = 1;
  245.         $definition = array();
  246.         while (is_array($row $result->fetchRow(MDB2_FETCHMODE_ASSOC))) {
  247.             $row array_change_key_case($rowCASE_LOWER);
  248.             $key_name $row['key_name'];
  249.             if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  250.                 if ($db->options['field_case'== CASE_LOWER{
  251.                     $key_name strtolower($key_name);
  252.                 else {
  253.                     $key_name strtoupper($key_name);
  254.                 }
  255.             }
  256.             if ($index_name == $key_name{
  257.                 if (!$row['non_unique']{
  258.                     return $db->raiseError(MDB2_ERROR_NOT_FOUNDnullnull,
  259.                         'it was not specified an existing table index'__FUNCTION__);
  260.                 }
  261.                 $column_name $row['column_name'];
  262.                 if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  263.                     if ($db->options['field_case'== CASE_LOWER{
  264.                         $column_name strtolower($column_name);
  265.                     else {
  266.                         $column_name strtoupper($column_name);
  267.                     }
  268.                 }
  269.                 $definition['fields'][$column_name= array(
  270.                     'position' => $colpos++
  271.                 );
  272.                 if (!empty($row['collation'])) {
  273.                     $definition['fields'][$column_name]['sorting'($row['collation'== 'A'
  274.                         ? 'ascending' 'descending');
  275.                 }
  276.             }
  277.         }
  278.         $result->free();
  279.         if (empty($definition['fields'])) {
  280.             return $db->raiseError(MDB2_ERROR_NOT_FOUNDnullnull,
  281.                 'it was not specified an existing table index'__FUNCTION__);
  282.         }
  283.         return $definition;
  284.     }
  285.  
  286.     // }}}
  287.     // {{{ getTableConstraintDefinition()
  288.  
  289.     
  290.     /**
  291.      * Get the structure of a constraint into an array
  292.      *
  293.      * @param string    $table      name of table that should be used in method
  294.      * @param string    $constraint_name name of constraint that should be used in method
  295.      * @return mixed data array on success, a MDB2 error on failure
  296.      * @access public
  297.      */
  298.     function getTableConstraintDefinition($table$constraint_name)
  299.     {
  300.         $db =$this->getDBInstance();
  301.         if (PEAR::isError($db)) {
  302.             return $db;
  303.         }
  304.  
  305.         $table $db->quoteIdentifier($tabletrue);
  306.         $query = "SHOW INDEX FROM $table /*!50002 WHERE Key_name = %s */";
  307.         if (strtolower($constraint_name!= 'primary'{
  308.             $constraint_name_mdb2 $db->getIndexName($constraint_name);
  309.             $result $db->queryRow(sprintf($query$db->quote($constraint_name_mdb2)));
  310.             if (!PEAR::isError($result&& !is_null($result)) {
  311.                 // apply 'idxname_format' only if the query succeeded, otherwise
  312.                 // fallback to the given $index_name, without transformation
  313.                 $constraint_name $constraint_name_mdb2;
  314.             }
  315.         }
  316.         $result $db->query(sprintf($query$db->quote($constraint_name)));
  317.         if (PEAR::isError($result)) {
  318.             return $result;
  319.         }
  320.         $colpos = 1;
  321.         $definition = array();
  322.         while (is_array($row $result->fetchRow(MDB2_FETCHMODE_ASSOC))) {
  323.             $row array_change_key_case($rowCASE_LOWER);
  324.             $key_name $row['key_name'];
  325.             if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  326.                 if ($db->options['field_case'== CASE_LOWER{
  327.                     $key_name strtolower($key_name);
  328.                 else {
  329.                     $key_name strtoupper($key_name);
  330.                 }
  331.             }
  332.             if ($constraint_name == $key_name{
  333.                 if ($row['non_unique']{
  334.                     return $db->raiseError(MDB2_ERROR_NOT_FOUNDnullnull,
  335.                         $constraint_name ' is not an existing table constraint'__FUNCTION__);
  336.                 }
  337.                 if ($row['key_name'== 'PRIMARY'{
  338.                     $definition['primary'= true;
  339.                 else {
  340.                     $definition['unique'= true;
  341.                 }
  342.                 $column_name $row['column_name'];
  343.                 if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  344.                     if ($db->options['field_case'== CASE_LOWER{
  345.                         $column_name strtolower($column_name);
  346.                     else {
  347.                         $column_name strtoupper($column_name);
  348.                     }
  349.                 }
  350.                 $definition['fields'][$column_name= array(
  351.                     'position' => $colpos++
  352.                 );
  353.                 if (!empty($row['collation'])) {
  354.                     $definition['fields'][$column_name]['sorting'($row['collation'== 'A'
  355.                         ? 'ascending' 'descending');
  356.                 }
  357.             }
  358.         }
  359.         $result->free();
  360.         if (empty($definition['fields'])) {
  361.             return $db->raiseError(MDB2_ERROR_NOT_FOUNDnullnull,
  362.                 $constraint_name ' is not an existing table constraint'__FUNCTION__);
  363.         }
  364.         return $definition;
  365.     }
  366.  
  367.     // }}}
  368.     // {{{ getTriggerDefinition()
  369.  
  370.     
  371.     /**
  372.      * Get the structure of a trigger into an array
  373.      *
  374.      * EXPERIMENTAL
  375.      *
  376.      * WARNING: this function is experimental and may change the returned value
  377.      * at any time until labelled as non-experimental
  378.      *
  379.      * @param string    $trigger    name of trigger that should be used in method
  380.      * @return mixed data array on success, a MDB2 error on failure
  381.      * @access public
  382.      */
  383.     function getTriggerDefinition($trigger)
  384.     {
  385.         $db =$this->getDBInstance();
  386.         if (PEAR::isError($db)) {
  387.             return $db;
  388.         }
  389.  
  390.         $query 'SELECT trigger_name,
  391.                          event_object_table AS table_name,
  392.                          action_statement AS trigger_body,
  393.                          action_timing AS trigger_type,
  394.                          event_manipulation AS trigger_event
  395.                     FROM information_schema.triggers
  396.                    WHERE trigger_name = '$db->quote($trigger'text');
  397.         $types = array(
  398.             'trigger_name'    => 'text',
  399.             'table_name'      => 'text',
  400.             'trigger_body'    => 'text',
  401.             'trigger_type'    => 'text',
  402.             'trigger_event'   => 'text',
  403.         );
  404.         $def $db->queryRow($query$typesMDB2_FETCHMODE_ASSOC);
  405.         if (PEAR::isError($def)) {
  406.             return $def;
  407.         }
  408.         $def['trigger_comment''';
  409.         $def['trigger_enabled'= true;
  410.         return $def;
  411.     }
  412.  
  413.     // }}}
  414.     // {{{ tableInfo()
  415.  
  416.     
  417.     /**
  418.      * Returns information about a table or a result set
  419.      *
  420.      * @param object|string $result  MDB2_result object from a query or a
  421.      *                                  string containing the name of a table.
  422.      *                                  While this also accepts a query result
  423.      *                                  resource identifier, this behavior is
  424.      *                                  deprecated.
  425.      * @param int            $mode    a valid tableInfo mode
  426.      *
  427.      * @return array  an associative array with the information requested.
  428.      *                  A MDB2_Error object on failure.
  429.      *
  430.      * @see MDB2_Driver_Common::setOption()
  431.      */
  432.     function tableInfo($result$mode = null)
  433.     {
  434.         if (is_string($result)) {
  435.            return parent::tableInfo($result$mode);
  436.         }
  437.  
  438.         $db =$this->getDBInstance();
  439.         if (PEAR::isError($db)) {
  440.             return $db;
  441.         }
  442.  
  443.         $resource = MDB2::isResultCommon($result$result->getResource($result;
  444.         if (!is_object($resource)) {
  445.             return $db->raiseError(MDB2_ERROR_NEED_MORE_DATAnullnull,
  446.                 'Could not generate result resource'__FUNCTION__);
  447.         }
  448.  
  449.         if ($db->options['portability'MDB2_PORTABILITY_FIX_CASE{
  450.             if ($db->options['field_case'== CASE_LOWER{
  451.                 $case_func 'strtolower';
  452.             else {
  453.                 $case_func 'strtoupper';
  454.             }
  455.         else {
  456.             $case_func 'strval';
  457.         }
  458.  
  459.         $count @mysqli_num_fields($resource);
  460.         $res = array();
  461.         if ($mode{
  462.             $res['num_fields'$count;
  463.         }
  464.  
  465.         $db->loadModule('Datatype'nulltrue);
  466.         for ($i = 0; $i $count$i++{
  467.             $tmp @mysqli_fetch_field($resource);
  468.  
  469.             $flags '';
  470.             foreach ($this->flags as $const => $means{
  471.                 if ($tmp->flags $const{
  472.                     $flags.= $means ' ';
  473.                 }
  474.             }
  475.             if ($tmp->def{
  476.                 $flags.= 'default_' rawurlencode($tmp->def);
  477.             }
  478.             $flags trim($flags);
  479.  
  480.             $res[$i= array(
  481.                 'table'  => $case_func($tmp->table),
  482.                 'name'   => $case_func($tmp->name),
  483.                 'type'   => isset($this->types[$tmp->type])
  484.                     ? $this->types[$tmp->type'unknown',
  485.                 // http://bugs.php.net/?id=36579
  486.                 'length' => $tmp->length,
  487.                 'flags'  => $flags,
  488.             );
  489.             $mdb2type_info $db->datatype->mapNativeDatatype($res[$i]);
  490.             if (PEAR::isError($mdb2type_info)) {
  491.                return $mdb2type_info;
  492.             }
  493.             $res[$i]['mdb2type'$mdb2type_info[0][0];
  494.             if ($mode MDB2_TABLEINFO_ORDER{
  495.                 $res['order'][$res[$i]['name']] $i;
  496.             }
  497.             if ($mode MDB2_TABLEINFO_ORDERTABLE{
  498.                 $res['ordertable'][$res[$i]['table']][$res[$i]['name']] $i;
  499.             }
  500.         }
  501.  
  502.         return $res;
  503.     }
  504. }
  505. ?>

Documentation generated on Thu, 03 May 2007 15:02:03 -0400 by phpDocumentor 1.3.0. PEAR Logo Copyright © PHP Group 2004.