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

Source for file Common.php

Documentation is available at Common.php

  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP versions 4 and 5                                                 |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1998-2007 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: Common.php 327310 2012-08-27 15:16:18Z danielc $
  46. //
  47.  
  48. /**
  49.  * @package MDB2
  50.  * @category Database
  51.  */
  52.  
  53. /**
  54.  * These are constants for the tableInfo-function
  55.  * they are bitwised or'ed. so if there are more constants to be defined
  56.  * in the future, adjust MDB2_TABLEINFO_FULL accordingly
  57.  */
  58.  
  59. define('MDB2_TABLEINFO_ORDER',      1);
  60. define('MDB2_TABLEINFO_ORDERTABLE'2);
  61. define('MDB2_TABLEINFO_FULL',       3);
  62.  
  63. /**
  64.  * Base class for the schema reverse engineering module that is extended by each MDB2 driver
  65.  *
  66.  * To load this module in the MDB2 object:
  67.  * $mdb->loadModule('Reverse');
  68.  *
  69.  * @package MDB2
  70.  * @category Database
  71.  * @author  Lukas Smith <smith@pooteeweet.org>
  72.  */
  73. {
  74.     // {{{ splitTableSchema()
  75.  
  76.     /**
  77.      * Split the "[owner|schema].table" notation into an array
  78.      *
  79.      * @param string $table [schema and] table name
  80.      *
  81.      * @return array array(schema, table)
  82.      * @access private
  83.      */
  84.     function splitTableSchema($table)
  85.     {
  86.         $ret = array();
  87.         if (strpos($table'.'!== false{
  88.             return explode('.'$table);
  89.         }
  90.         return array(null$table);
  91.     }
  92.  
  93.     // }}}
  94.     // {{{ getTableFieldDefinition()
  95.  
  96.     /**
  97.      * Get the structure of a field into an array
  98.      *
  99.      * @param string    $table     name of table that should be used in method
  100.      * @param string    $field     name of field that should be used in method
  101.      * @return mixed data array on success, a MDB2 error on failure.
  102.      *           The returned array contains an array for each field definition,
  103.      *           with all or some of these indices, depending on the field data type:
  104.      *           [notnull] [nativetype] [length] [fixed] [default] [type] [mdb2type]
  105.      * @access public
  106.      */
  107.     function getTableFieldDefinition($table$field)
  108.     {
  109.         $db $this->getDBInstance();
  110.         if (MDB2::isError($db)) {
  111.             return $db;
  112.         }
  113.  
  114.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  115.             'method not implemented'__FUNCTION__);
  116.     }
  117.  
  118.     // }}}
  119.     // {{{ getTableIndexDefinition()
  120.  
  121.     /**
  122.      * Get the structure of an index into an array
  123.      *
  124.      * @param string    $table      name of table that should be used in method
  125.      * @param string    $index      name of index that should be used in method
  126.      * @return mixed data array on success, a MDB2 error on failure
  127.      *           The returned array has this structure:
  128.      *           </pre>
  129.      *           array (
  130.      *               [fields] => array (
  131.      *                   [field1name] => array() // one entry per each field covered
  132.      *                   [field2name] => array() // by the index
  133.      *                   [field3name] => array(
  134.      *                       [sorting] => ascending
  135.      *                   )
  136.      *               )
  137.      *           );
  138.      *           </pre>
  139.      * @access public
  140.      */
  141.     function getTableIndexDefinition($table$index)
  142.     {
  143.         $db $this->getDBInstance();
  144.         if (MDB2::isError($db)) {
  145.             return $db;
  146.         }
  147.  
  148.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  149.             'method not implemented'__FUNCTION__);
  150.     }
  151.  
  152.     // }}}
  153.     // {{{ getTableConstraintDefinition()
  154.  
  155.     /**
  156.      * Get the structure of an constraints into an array
  157.      *
  158.      * @param string    $table      name of table that should be used in method
  159.      * @param string    $index      name of index that should be used in method
  160.      * @return mixed data array on success, a MDB2 error on failure
  161.      *           The returned array has this structure:
  162.      *           <pre>
  163.      *           array (
  164.      *               [primary] => 0
  165.      *               [unique]  => 0
  166.      *               [foreign] => 1
  167.      *               [check]   => 0
  168.      *               [fields] => array (
  169.      *                   [field1name] => array() // one entry per each field covered
  170.      *                   [field2name] => array() // by the index
  171.      *                   [field3name] => array(
  172.      *                       [sorting]  => ascending
  173.      *                       [position] => 3
  174.      *                   )
  175.      *               )
  176.      *               [references] => array(
  177.      *                   [table] => name
  178.      *                   [fields] => array(
  179.      *                       [field1name] => array(  //one entry per each referenced field
  180.      *                            [position] => 1
  181.      *                       )
  182.      *                   )
  183.      *               )
  184.      *               [deferrable] => 0
  185.      *               [initiallydeferred] => 0
  186.      *               [onupdate] => CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION
  187.      *               [ondelete] => CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION
  188.      *               [match] => SIMPLE|PARTIAL|FULL
  189.      *           );
  190.      *           </pre>
  191.      * @access public
  192.      */
  193.     function getTableConstraintDefinition($table$index)
  194.     {
  195.         $db $this->getDBInstance();
  196.         if (MDB2::isError($db)) {
  197.             return $db;
  198.         }
  199.  
  200.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  201.             'method not implemented'__FUNCTION__);
  202.     }
  203.  
  204.     // }}}
  205.     // {{{ getSequenceDefinition()
  206.  
  207.     /**
  208.      * Get the structure of a sequence into an array
  209.      *
  210.      * @param string    $sequence   name of sequence that should be used in method
  211.      * @return mixed data array on success, a MDB2 error on failure
  212.      *           The returned array has this structure:
  213.      *           <pre>
  214.      *           array (
  215.      *               [start] => n
  216.      *           );
  217.      *           </pre>
  218.      * @access public
  219.      */
  220.     function getSequenceDefinition($sequence)
  221.     {
  222.         $db $this->getDBInstance();
  223.         if (MDB2::isError($db)) {
  224.             return $db;
  225.         }
  226.  
  227.         $start $db->currId($sequence);
  228.         if (MDB2::isError($start)) {
  229.             return $start;
  230.         }
  231.         if ($db->supports('current_id')) {
  232.             $start++;
  233.         else {
  234.             $db->warnings['database does not support getting current
  235.                 sequence value, the sequence value was incremented';
  236.         }
  237.         $definition = array();
  238.         if ($start != 1{
  239.             $definition = array('start' => $start);
  240.         }
  241.         return $definition;
  242.     }
  243.  
  244.     // }}}
  245.     // {{{ getTriggerDefinition()
  246.  
  247.     /**
  248.      * Get the structure of a trigger into an array
  249.      *
  250.      * EXPERIMENTAL
  251.      *
  252.      * WARNING: this function is experimental and may change the returned value
  253.      * at any time until labelled as non-experimental
  254.      *
  255.      * @param string    $trigger    name of trigger that should be used in method
  256.      * @return mixed data array on success, a MDB2 error on failure
  257.      *           The returned array has this structure:
  258.      *           <pre>
  259.      *           array (
  260.      *               [trigger_name]    => 'trigger name',
  261.      *               [table_name]      => 'table name',
  262.      *               [trigger_body]    => 'trigger body definition',
  263.      *               [trigger_type]    => 'BEFORE' | 'AFTER',
  264.      *               [trigger_event]   => 'INSERT' | 'UPDATE' | 'DELETE'
  265.      *                   //or comma separated list of multiple events, when supported
  266.      *               [trigger_enabled] => true|false
  267.      *               [trigger_comment] => 'trigger comment',
  268.      *           );
  269.      *           </pre>
  270.      *           The oci8 driver also returns a [when_clause] index.
  271.      * @access public
  272.      */
  273.     function getTriggerDefinition($trigger)
  274.     {
  275.         $db $this->getDBInstance();
  276.         if (MDB2::isError($db)) {
  277.             return $db;
  278.         }
  279.  
  280.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  281.             'method not implemented'__FUNCTION__);
  282.     }
  283.  
  284.     // }}}
  285.     // {{{ tableInfo()
  286.  
  287.     /**
  288.      * Returns information about a table or a result set
  289.      *
  290.      * The format of the resulting array depends on which <var>$mode</var>
  291.      * you select.  The sample output below is based on this query:
  292.      * <pre>
  293.      *    SELECT tblFoo.fldID, tblFoo.fldPhone, tblBar.fldId
  294.      *    FROM tblFoo
  295.      *    JOIN tblBar ON tblFoo.fldId = tblBar.fldId
  296.      * </pre>
  297.      *
  298.      * <ul>
  299.      * <li>
  300.      *
  301.      * <kbd>null</kbd> (default)
  302.      *   <pre>
  303.      *   [0] => Array (
  304.      *       [table] => tblFoo
  305.      *       [name] => fldId
  306.      *       [type] => int
  307.      *       [len] => 11
  308.      *       [flags] => primary_key not_null
  309.      *   )
  310.      *   [1] => Array (
  311.      *       [table] => tblFoo
  312.      *       [name] => fldPhone
  313.      *       [type] => string
  314.      *       [len] => 20
  315.      *       [flags] =>
  316.      *   )
  317.      *   [2] => Array (
  318.      *       [table] => tblBar
  319.      *       [name] => fldId
  320.      *       [type] => int
  321.      *       [len] => 11
  322.      *       [flags] => primary_key not_null
  323.      *   )
  324.      *   </pre>
  325.      *
  326.      * </li><li>
  327.      *
  328.      * <kbd>MDB2_TABLEINFO_ORDER</kbd>
  329.      *
  330.      *   <p>In addition to the information found in the default output,
  331.      *   a notation of the number of columns is provided by the
  332.      *   <samp>num_fields</samp> element while the <samp>order</samp>
  333.      *   element provides an array with the column names as the keys and
  334.      *   their location index number (corresponding to the keys in the
  335.      *   the default output) as the values.</p>
  336.      *
  337.      *   <p>If a result set has identical field names, the last one is
  338.      *   used.</p>
  339.      *
  340.      *   <pre>
  341.      *   [num_fields] => 3
  342.      *   [order] => Array (
  343.      *       [fldId] => 2
  344.      *       [fldTrans] => 1
  345.      *   )
  346.      *   </pre>
  347.      *
  348.      * </li><li>
  349.      *
  350.      * <kbd>MDB2_TABLEINFO_ORDERTABLE</kbd>
  351.      *
  352.      *   <p>Similar to <kbd>MDB2_TABLEINFO_ORDER</kbd> but adds more
  353.      *   dimensions to the array in which the table names are keys and
  354.      *   the field names are sub-keys.  This is helpful for queries that
  355.      *   join tables which have identical field names.</p>
  356.      *
  357.      *   <pre>
  358.      *   [num_fields] => 3
  359.      *   [ordertable] => Array (
  360.      *       [tblFoo] => Array (
  361.      *           [fldId] => 0
  362.      *           [fldPhone] => 1
  363.      *       )
  364.      *       [tblBar] => Array (
  365.      *           [fldId] => 2
  366.      *       )
  367.      *   )
  368.      *   </pre>
  369.      *
  370.      * </li>
  371.      * </ul>
  372.      *
  373.      * The <samp>flags</samp> element contains a space separated list
  374.      * of extra information about the field.  This data is inconsistent
  375.      * between DBMS's due to the way each DBMS works.
  376.      *   + <samp>primary_key</samp>
  377.      *   + <samp>unique_key</samp>
  378.      *   + <samp>multiple_key</samp>
  379.      *   + <samp>not_null</samp>
  380.      *
  381.      * Most DBMS's only provide the <samp>table</samp> and <samp>flags</samp>
  382.      * elements if <var>$result</var> is a table name.  The following DBMS's
  383.      * provide full information from queries:
  384.      *   + fbsql
  385.      *   + mysql
  386.      *
  387.      * If the 'portability' option has <samp>MDB2_PORTABILITY_FIX_CASE</samp>
  388.      * turned on, the names of tables and fields will be lower or upper cased.
  389.      *
  390.      * @param object|string $result  MDB2_result object from a query or a
  391.      *                                 string containing the name of a table.
  392.      *                                 While this also accepts a query result
  393.      *                                 resource identifier, this behavior is
  394.      *                                 deprecated.
  395.      * @param int  $mode   either unused or one of the tableInfo modes:
  396.      *                      <kbd>MDB2_TABLEINFO_ORDERTABLE</kbd>,
  397.      *                      <kbd>MDB2_TABLEINFO_ORDER</kbd> or
  398.      *                      <kbd>MDB2_TABLEINFO_FULL</kbd> (which does both).
  399.      *                      These are bitwise, so the first two can be
  400.      *                      combined using <kbd>|</kbd>.
  401.      *
  402.      * @return array  an associative array with the information requested.
  403.      *                  A MDB2_Error object on failure.
  404.      *
  405.      * @see MDB2_Driver_Common::setOption()
  406.      */
  407.     function tableInfo($result$mode = null)
  408.     {
  409.         $db $this->getDBInstance();
  410.         if (MDB2::isError($db)) {
  411.             return $db;
  412.         }
  413.  
  414.         if (!is_string($result)) {
  415.             return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  416.                 'method not implemented'__FUNCTION__);
  417.         }
  418.  
  419.         $db->loadModule('Manager'nulltrue);
  420.         $fields $db->manager->listTableFields($result);
  421.         if (MDB2::isError($fields)) {
  422.             return $fields;
  423.         }
  424.  
  425.         $flags = array();
  426.  
  427.         $idxname_format $db->getOption('idxname_format');
  428.         $db->setOption('idxname_format''%s');
  429.  
  430.         $indexes $db->manager->listTableIndexes($result);
  431.         if (MDB2::isError($indexes)) {
  432.             $db->setOption('idxname_format'$idxname_format);
  433.             return $indexes;
  434.         }
  435.  
  436.         foreach ($indexes as $index{
  437.             $definition $this->getTableIndexDefinition($result$index);
  438.             if (MDB2::isError($definition)) {
  439.                 $db->setOption('idxname_format'$idxname_format);
  440.                 return $definition;
  441.             }
  442.             if (count($definition['fields']> 1{
  443.                 foreach ($definition['fields'as $field => $sort{
  444.                     $flags[$field'multiple_key';
  445.                 }
  446.             }
  447.         }
  448.  
  449.         $constraints $db->manager->listTableConstraints($result);
  450.         if (MDB2::isError($constraints)) {
  451.             return $constraints;
  452.         }
  453.  
  454.         foreach ($constraints as $constraint{
  455.             $definition $this->getTableConstraintDefinition($result$constraint);
  456.             if (MDB2::isError($definition)) {
  457.                 $db->setOption('idxname_format'$idxname_format);
  458.                 return $definition;
  459.             }
  460.             $flag !empty($definition['primary'])
  461.                 ? 'primary_key' (!empty($definition['unique'])
  462.                     ? 'unique_key' : false);
  463.             if ($flag{
  464.                 foreach ($definition['fields'as $field => $sort{
  465.                     if (empty($flags[$field]|| $flags[$field!= 'primary_key'{
  466.                         $flags[$field$flag;
  467.                     }
  468.                 }
  469.             }
  470.         }
  471.  
  472.         $res = array();
  473.  
  474.         if ($mode{
  475.             $res['num_fields'count($fields);
  476.         }
  477.  
  478.         foreach ($fields as $i => $field{
  479.             $definition $this->getTableFieldDefinition($result$field);
  480.             if (MDB2::isError($definition)) {
  481.                 $db->setOption('idxname_format'$idxname_format);
  482.                 return $definition;
  483.             }
  484.             $res[$i$definition[0];
  485.             $res[$i]['name'$field;
  486.             $res[$i]['table'$result;
  487.             $res[$i]['type'preg_replace('/^([a-z]+).*$/i''\\1'trim($definition[0]['nativetype']));
  488.             // 'primary_key', 'unique_key', 'multiple_key'
  489.             $res[$i]['flags'= empty($flags[$field]'' $flags[$field];
  490.             // not_null', 'unsigned', 'auto_increment', 'default_[rawencodedvalue]'
  491.             if (!empty($res[$i]['notnull'])) {
  492.                 $res[$i]['flags'].= ' not_null';
  493.             }
  494.             if (!empty($res[$i]['unsigned'])) {
  495.                 $res[$i]['flags'].= ' unsigned';
  496.             }
  497.             if (!empty($res[$i]['auto_increment'])) {
  498.                 $res[$i]['flags'].= ' autoincrement';
  499.             }
  500.             if (!empty($res[$i]['default'])) {
  501.                 $res[$i]['flags'].= ' default_'.rawurlencode($res[$i]['default']);
  502.             }
  503.  
  504.             if ($mode MDB2_TABLEINFO_ORDER{
  505.                 $res['order'][$res[$i]['name']] $i;
  506.             }
  507.             if ($mode MDB2_TABLEINFO_ORDERTABLE{
  508.                 $res['ordertable'][$res[$i]['table']][$res[$i]['name']] $i;
  509.             }
  510.         }
  511.  
  512.         $db->setOption('idxname_format'$idxname_format);
  513.         return $res;
  514.     }
  515. }
  516. ?>

Documentation generated on Mon, 29 Oct 2012 16:00:08 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.