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-2008 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. // | Authors: Lukas Smith <smith@pooteeweet.org>                          |
  43. // |          Lorenzo Alberton <l.alberton@quipo.it>                      |
  44. // +----------------------------------------------------------------------+
  45. //
  46. // $Id: Common.php 327310 2012-08-27 15:16:18Z danielc $
  47. //
  48.  
  49. /**
  50.  * @package  MDB2
  51.  * @category Database
  52.  * @author   Lukas Smith <smith@pooteeweet.org>
  53.  * @author   Lorenzo Alberton <l.alberton@quipo.it>
  54.  */
  55.  
  56. /**
  57.  * Base class for the management modules that is extended by each MDB2 driver
  58.  *
  59.  * To load this module in the MDB2 object:
  60.  * $mdb->loadModule('Manager');
  61.  *
  62.  * @package MDB2
  63.  * @category Database
  64.  * @author  Lukas Smith <smith@pooteeweet.org>
  65.  */
  66. {
  67.     // {{{ splitTableSchema()
  68.  
  69.     /**
  70.      * Split the "[owner|schema].table" notation into an array
  71.      *
  72.      * @param string $table [schema and] table name
  73.      *
  74.      * @return array array(schema, table)
  75.      * @access private
  76.      */
  77.     function splitTableSchema($table)
  78.     {
  79.         $ret = array();
  80.         if (strpos($table'.'!== false{
  81.             return explode('.'$table);
  82.         }
  83.         return array(null$table);
  84.     }
  85.  
  86.     // }}}
  87.     // {{{ getFieldDeclarationList()
  88.  
  89.     /**
  90.      * Get declaration of a number of field in bulk
  91.      *
  92.      * @param array $fields  a multidimensional associative array.
  93.      *       The first dimension determines the field name, while the second
  94.      *       dimension is keyed with the name of the properties
  95.      *       of the field being declared as array indexes. Currently, the types
  96.      *       of supported field properties are as follows:
  97.      *
  98.      *       default
  99.      *           Boolean value to be used as default for this field.
  100.      *
  101.      *       notnull
  102.      *           Boolean flag that indicates whether this field is constrained
  103.      *           to not be set to null.
  104.      *
  105.      * @return mixed string on success, a MDB2 error on failure
  106.      * @access public
  107.      */
  108.     function getFieldDeclarationList($fields)
  109.     {
  110.         $db $this->getDBInstance();
  111.         if (MDB2::isError($db)) {
  112.             return $db;
  113.         }
  114.  
  115.         if (!is_array($fields|| empty($fields)) {
  116.             return $db->raiseError(MDB2_ERROR_NEED_MORE_DATAnullnull,
  117.                 'missing any fields'__FUNCTION__);
  118.         }
  119.         foreach ($fields as $field_name => $field{
  120.             $query $db->getDeclaration($field['type']$field_name$field);
  121.             if (MDB2::isError($query)) {
  122.                 return $query;
  123.             }
  124.             $query_fields[$query;
  125.         }
  126.         return implode(', '$query_fields);
  127.     }
  128.  
  129.     // }}}
  130.     // {{{ _fixSequenceName()
  131.  
  132.     /**
  133.      * Removes any formatting in an sequence name using the 'seqname_format' option
  134.      *
  135.      * @param string $sqn string that containts name of a potential sequence
  136.      * @param bool $check if only formatted sequences should be returned
  137.      * @return string name of the sequence with possible formatting removed
  138.      * @access protected
  139.      */
  140.     function _fixSequenceName($sqn$check = false)
  141.     {
  142.         $db $this->getDBInstance();
  143.         if (MDB2::isError($db)) {
  144.             return $db;
  145.         }
  146.  
  147.         $seq_pattern '/^'.preg_replace('/%s/''([a-z0-9_]+)'$db->options['seqname_format']).'$/i';
  148.         $seq_name preg_replace($seq_pattern'\\1'$sqn);
  149.         if ($seq_name && !strcasecmp($sqn$db->getSequenceName($seq_name))) {
  150.             return $seq_name;
  151.         }
  152.         if ($check{
  153.             return false;
  154.         }
  155.         return $sqn;
  156.     }
  157.  
  158.     // }}}
  159.     // {{{ _fixIndexName()
  160.  
  161.     /**
  162.      * Removes any formatting in an index name using the 'idxname_format' option
  163.      *
  164.      * @param string $idx string that containts name of anl index
  165.      * @return string name of the index with eventual formatting removed
  166.      * @access protected
  167.      */
  168.     function _fixIndexName($idx)
  169.     {
  170.         $db $this->getDBInstance();
  171.         if (MDB2::isError($db)) {
  172.             return $db;
  173.         }
  174.  
  175.         $idx_pattern '/^'.preg_replace('/%s/''([a-z0-9_]+)'$db->options['idxname_format']).'$/i';
  176.         $idx_name preg_replace($idx_pattern'\\1'$idx);
  177.         if ($idx_name && !strcasecmp($idx$db->getIndexName($idx_name))) {
  178.             return $idx_name;
  179.         }
  180.         return $idx;
  181.     }
  182.  
  183.     // }}}
  184.     // {{{ createDatabase()
  185.  
  186.     /**
  187.      * create a new database
  188.      *
  189.      * @param string $name    name of the database that should be created
  190.      * @param array  $options array with charset, collation info
  191.      *
  192.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  193.      * @access public
  194.      */
  195.     function createDatabase($database$options = array())
  196.     {
  197.         $db $this->getDBInstance();
  198.         if (MDB2::isError($db)) {
  199.             return $db;
  200.         }
  201.  
  202.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  203.             'method not implemented'__FUNCTION__);
  204.     }
  205.  
  206.     // }}}
  207.     // {{{ alterDatabase()
  208.  
  209.     /**
  210.      * alter an existing database
  211.      *
  212.      * @param string $name    name of the database that should be created
  213.      * @param array  $options array with charset, collation info
  214.      *
  215.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  216.      * @access public
  217.      */
  218.     function alterDatabase($database$options = array())
  219.     {
  220.         $db $this->getDBInstance();
  221.         if (MDB2::isError($db)) {
  222.             return $db;
  223.         }
  224.  
  225.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  226.             'method not implemented'__FUNCTION__);
  227.     }
  228.  
  229.     // }}}
  230.     // {{{ dropDatabase()
  231.  
  232.     /**
  233.      * drop an existing database
  234.      *
  235.      * @param string $name name of the database that should be dropped
  236.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  237.      * @access public
  238.      */
  239.     function dropDatabase($database)
  240.     {
  241.         $db $this->getDBInstance();
  242.         if (MDB2::isError($db)) {
  243.             return $db;
  244.         }
  245.  
  246.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  247.             'method not implemented'__FUNCTION__);
  248.     }
  249.  
  250.     // }}}
  251.     // {{{ _getCreateTableQuery()
  252.  
  253.     /**
  254.      * Create a basic SQL query for a new table creation
  255.      *
  256.      * @param string $name    Name of the database that should be created
  257.      * @param array  $fields  Associative array that contains the definition of each field of the new table
  258.      * @param array  $options An associative array of table options
  259.      *
  260.      * @return mixed string (the SQL query) on success, a MDB2 error on failure
  261.      * @see createTable()
  262.      */
  263.     function _getCreateTableQuery($name$fields$options = array())
  264.     {
  265.         $db $this->getDBInstance();
  266.         if (MDB2::isError($db)) {
  267.             return $db;
  268.         }
  269.  
  270.         if (!$name{
  271.             return $db->raiseError(MDB2_ERROR_CANNOT_CREATEnullnull,
  272.                 'no valid table name specified'__FUNCTION__);
  273.         }
  274.         if (empty($fields)) {
  275.             return $db->raiseError(MDB2_ERROR_CANNOT_CREATEnullnull,
  276.                 'no fields specified for table "'.$name.'"'__FUNCTION__);
  277.         }
  278.         $query_fields $this->getFieldDeclarationList($fields);
  279.         if (MDB2::isError($query_fields)) {
  280.             return $query_fields;
  281.         }
  282.         if (!empty($options['primary'])) {
  283.             $query_fields.= ', PRIMARY KEY ('.implode(', 'array_keys($options['primary'])).')';
  284.         }
  285.  
  286.         $name $db->quoteIdentifier($nametrue);
  287.         $result 'CREATE ';
  288.         if (!empty($options['temporary'])) {
  289.             $result .= $this->_getTemporaryTableQuery();
  290.         }
  291.         $result .= " TABLE $name ($query_fields)";
  292.         return $result;
  293.     }
  294.  
  295.     // }}}
  296.     // {{{ _getTemporaryTableQuery()
  297.  
  298.     /**
  299.      * A method to return the required SQL string that fits between CREATE ... TABLE
  300.      * to create the table as a temporary table.
  301.      *
  302.      * Should be overridden in driver classes to return the correct string for the
  303.      * specific database type.
  304.      *
  305.      * The default is to return the string "TEMPORARY" - this will result in a
  306.      * SQL error for any database that does not support temporary tables, or that
  307.      * requires a different SQL command from "CREATE TEMPORARY TABLE".
  308.      *
  309.      * @return string The string required to be placed between "CREATE" and "TABLE"
  310.      *                 to generate a temporary table, if possible.
  311.      */
  312.     function _getTemporaryTableQuery()
  313.     {
  314.         return 'TEMPORARY';
  315.     }
  316.  
  317.     // }}}
  318.     // {{{ createTable()
  319.  
  320.     /**
  321.      * create a new table
  322.      *
  323.      * @param string $name   Name of the database that should be created
  324.      * @param array $fields  Associative array that contains the definition of each field of the new table
  325.      *                        The indexes of the array entries are the names of the fields of the table an
  326.      *                        the array entry values are associative arrays like those that are meant to be
  327.      *                        passed with the field definitions to get[Type]Declaration() functions.
  328.      *                           array(
  329.      *                               'id' => array(
  330.      *                                   'type' => 'integer',
  331.      *                                   'unsigned' => 1
  332.      *                                   'notnull' => 1
  333.      *                                   'default' => 0
  334.      *                               ),
  335.      *                               'name' => array(
  336.      *                                   'type' => 'text',
  337.      *                                   'length' => 12
  338.      *                               ),
  339.      *                               'password' => array(
  340.      *                                   'type' => 'text',
  341.      *                                   'length' => 12
  342.      *                               )
  343.      *                           );
  344.      * @param array $options  An associative array of table options:
  345.      *                           array(
  346.      *                               'comment' => 'Foo',
  347.      *                               'temporary' => true|false,
  348.      *                           );
  349.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  350.      * @access public
  351.      */
  352.     function createTable($name$fields$options = array())
  353.     {
  354.         $query $this->_getCreateTableQuery($name$fields$options);
  355.         if (MDB2::isError($query)) {
  356.             return $query;
  357.         }
  358.         $db $this->getDBInstance();
  359.         if (MDB2::isError($db)) {
  360.             return $db;
  361.         }
  362.         $result $db->exec($query);
  363.         if (MDB2::isError($result)) {
  364.             return $result;
  365.         }
  366.         return MDB2_OK;
  367.     }
  368.  
  369.     // }}}
  370.     // {{{ dropTable()
  371.  
  372.     /**
  373.      * drop an existing table
  374.      *
  375.      * @param string $name name of the table that should be dropped
  376.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  377.      * @access public
  378.      */
  379.     function dropTable($name)
  380.     {
  381.         $db $this->getDBInstance();
  382.         if (MDB2::isError($db)) {
  383.             return $db;
  384.         }
  385.  
  386.         $name $db->quoteIdentifier($nametrue);
  387.         $result $db->exec("DROP TABLE $name");
  388.         if (MDB2::isError($result)) {
  389.             return $result;
  390.         }
  391.         return MDB2_OK;
  392.     }
  393.  
  394.     // }}}
  395.     // {{{ truncateTable()
  396.  
  397.     /**
  398.      * Truncate an existing table (if the TRUNCATE TABLE syntax is not supported,
  399.      * it falls back to a DELETE FROM TABLE query)
  400.      *
  401.      * @param string $name name of the table that should be truncated
  402.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  403.      * @access public
  404.      */
  405.     function truncateTable($name)
  406.     {
  407.         $db $this->getDBInstance();
  408.         if (MDB2::isError($db)) {
  409.             return $db;
  410.         }
  411.  
  412.         $name $db->quoteIdentifier($nametrue);
  413.         $result $db->exec("DELETE FROM $name");
  414.         if (MDB2::isError($result)) {
  415.             return $result;
  416.         }
  417.         return MDB2_OK;
  418.     }
  419.  
  420.     // }}}
  421.     // {{{ vacuum()
  422.  
  423.     /**
  424.      * Optimize (vacuum) all the tables in the db (or only the specified table)
  425.      * and optionally run ANALYZE.
  426.      *
  427.      * @param string $table table name (all the tables if empty)
  428.      * @param array  $options an array with driver-specific options:
  429.      *                - timeout [int] (in seconds) [mssql-only]
  430.      *                - analyze [boolean] [pgsql and mysql]
  431.      *                - full [boolean] [pgsql-only]
  432.      *                - freeze [boolean] [pgsql-only]
  433.      *
  434.      * @return mixed MDB2_OK success, a MDB2 error on failure
  435.      * @access public
  436.      */
  437.     function vacuum($table = null$options = array())
  438.     {
  439.         $db $this->getDBInstance();
  440.         if (MDB2::isError($db)) {
  441.             return $db;
  442.         }
  443.  
  444.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  445.             'method not implemented'__FUNCTION__);
  446.     }
  447.  
  448.     // }}}
  449.     // {{{ alterTable()
  450.  
  451.     /**
  452.      * alter an existing table
  453.      *
  454.      * @param string $name         name of the table that is intended to be changed.
  455.      * @param array $changes     associative array that contains the details of each type
  456.      *                              of change that is intended to be performed. The types of
  457.      *                              changes that are currently supported are defined as follows:
  458.      *
  459.      *                              name
  460.      *
  461.      *                                 New name for the table.
  462.      *
  463.      *                             add
  464.      *
  465.      *                                 Associative array with the names of fields to be added as
  466.      *                                  indexes of the array. The value of each entry of the array
  467.      *                                  should be set to another associative array with the properties
  468.      *                                  of the fields to be added. The properties of the fields should
  469.      *                                  be the same as defined by the MDB2 parser.
  470.      *
  471.      *
  472.      *                             remove
  473.      *
  474.      *                                 Associative array with the names of fields to be removed as indexes
  475.      *                                  of the array. Currently the values assigned to each entry are ignored.
  476.      *                                  An empty array should be used for future compatibility.
  477.      *
  478.      *                             rename
  479.      *
  480.      *                                 Associative array with the names of fields to be renamed as indexes
  481.      *                                  of the array. The value of each entry of the array should be set to
  482.      *                                  another associative array with the entry named name with the new
  483.      *                                  field name and the entry named Declaration that is expected to contain
  484.      *                                  the portion of the field declaration already in DBMS specific SQL code
  485.      *                                  as it is used in the CREATE TABLE statement.
  486.      *
  487.      *                             change
  488.      *
  489.      *                                 Associative array with the names of the fields to be changed as indexes
  490.      *                                  of the array. Keep in mind that if it is intended to change either the
  491.      *                                  name of a field and any other properties, the change array entries
  492.      *                                  should have the new names of the fields as array indexes.
  493.      *
  494.      *                                 The value of each entry of the array should be set to another associative
  495.      *                                  array with the properties of the fields to that are meant to be changed as
  496.      *                                  array entries. These entries should be assigned to the new values of the
  497.      *                                  respective properties. The properties of the fields should be the same
  498.      *                                  as defined by the MDB2 parser.
  499.      *
  500.      *                             Example
  501.      *                                 array(
  502.      *                                     'name' => 'userlist',
  503.      *                                     'add' => array(
  504.      *                                         'quota' => array(
  505.      *                                             'type' => 'integer',
  506.      *                                             'unsigned' => 1
  507.      *                                         )
  508.      *                                     ),
  509.      *                                     'remove' => array(
  510.      *                                         'file_limit' => array(),
  511.      *                                         'time_limit' => array()
  512.      *                                     ),
  513.      *                                     'change' => array(
  514.      *                                         'name' => array(
  515.      *                                             'length' => '20',
  516.      *                                             'definition' => array(
  517.      *                                                 'type' => 'text',
  518.      *                                                 'length' => 20,
  519.      *                                             ),
  520.      *                                         )
  521.      *                                     ),
  522.      *                                     'rename' => array(
  523.      *                                         'sex' => array(
  524.      *                                             'name' => 'gender',
  525.      *                                             'definition' => array(
  526.      *                                                 'type' => 'text',
  527.      *                                                 'length' => 1,
  528.      *                                                 'default' => 'M',
  529.      *                                             ),
  530.      *                                         )
  531.      *                                     )
  532.      *                                 )
  533.      *
  534.      * @param boolean $check     indicates whether the function should just check if the DBMS driver
  535.      *                              can perform the requested table alterations if the value is true or
  536.      *                              actually perform them otherwise.
  537.      * @access public
  538.      *
  539.       * @return mixed MDB2_OK on success, a MDB2 error on failure
  540.      */
  541.     function alterTable($name$changes$check)
  542.     {
  543.         $db $this->getDBInstance();
  544.         if (MDB2::isError($db)) {
  545.             return $db;
  546.         }
  547.  
  548.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  549.             'method not implemented'__FUNCTION__);
  550.     }
  551.  
  552.     // }}}
  553.     // {{{ listDatabases()
  554.  
  555.     /**
  556.      * list all databases
  557.      *
  558.      * @return mixed array of database names on success, a MDB2 error on failure
  559.      * @access public
  560.      */
  561.     function listDatabases()
  562.     {
  563.         $db $this->getDBInstance();
  564.         if (MDB2::isError($db)) {
  565.             return $db;
  566.         }
  567.  
  568.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  569.             'method not implementedd'__FUNCTION__);
  570.     }
  571.  
  572.     // }}}
  573.     // {{{ listUsers()
  574.  
  575.     /**
  576.      * list all users
  577.      *
  578.      * @return mixed array of user names on success, a MDB2 error on failure
  579.      * @access public
  580.      */
  581.     function listUsers()
  582.     {
  583.         $db $this->getDBInstance();
  584.         if (MDB2::isError($db)) {
  585.             return $db;
  586.         }
  587.  
  588.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  589.             'method not implemented'__FUNCTION__);
  590.     }
  591.  
  592.     // }}}
  593.     // {{{ listViews()
  594.  
  595.     /**
  596.      * list all views in the current database
  597.      *
  598.      * @param string database, the current is default
  599.      *                NB: not all the drivers can get the view names from
  600.      *                a database other than the current one
  601.      * @return mixed array of view names on success, a MDB2 error on failure
  602.      * @access public
  603.      */
  604.     function listViews($database = null)
  605.     {
  606.         $db $this->getDBInstance();
  607.         if (MDB2::isError($db)) {
  608.             return $db;
  609.         }
  610.  
  611.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  612.             'method not implemented'__FUNCTION__);
  613.     }
  614.  
  615.     // }}}
  616.     // {{{ listTableViews()
  617.  
  618.     /**
  619.      * list the views in the database that reference a given table
  620.      *
  621.      * @param string table for which all referenced views should be found
  622.      * @return mixed array of view names on success, a MDB2 error on failure
  623.      * @access public
  624.      */
  625.     function listTableViews($table)
  626.     {
  627.         $db $this->getDBInstance();
  628.         if (MDB2::isError($db)) {
  629.             return $db;
  630.         }
  631.  
  632.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  633.             'method not implemented'__FUNCTION__);
  634.     }
  635.  
  636.     // }}}
  637.     // {{{ listTableTriggers()
  638.  
  639.     /**
  640.      * list all triggers in the database that reference a given table
  641.      *
  642.      * @param string table for which all referenced triggers should be found
  643.      * @return mixed array of trigger names on success, a MDB2 error on failure
  644.      * @access public
  645.      */
  646.     function listTableTriggers($table = null)
  647.     {
  648.         $db $this->getDBInstance();
  649.         if (MDB2::isError($db)) {
  650.             return $db;
  651.         }
  652.  
  653.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  654.             'method not implemented'__FUNCTION__);
  655.     }
  656.  
  657.     // }}}
  658.     // {{{ listFunctions()
  659.  
  660.     /**
  661.      * list all functions in the current database
  662.      *
  663.      * @return mixed array of function names on success, a MDB2 error on failure
  664.      * @access public
  665.      */
  666.     function listFunctions()
  667.     {
  668.         $db $this->getDBInstance();
  669.         if (MDB2::isError($db)) {
  670.             return $db;
  671.         }
  672.  
  673.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  674.             'method not implemented'__FUNCTION__);
  675.     }
  676.  
  677.     // }}}
  678.     // {{{ listTables()
  679.  
  680.     /**
  681.      * list all tables in the current database
  682.      *
  683.      * @param string database, the current is default.
  684.      *                NB: not all the drivers can get the table names from
  685.      *                a database other than the current one
  686.      * @return mixed array of table names on success, a MDB2 error on failure
  687.      * @access public
  688.      */
  689.     function listTables($database = null)
  690.     {
  691.         $db $this->getDBInstance();
  692.         if (MDB2::isError($db)) {
  693.             return $db;
  694.         }
  695.  
  696.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  697.             'method not implemented'__FUNCTION__);
  698.     }
  699.  
  700.     // }}}
  701.     // {{{ listTableFields()
  702.  
  703.     /**
  704.      * list all fields in a table in the current database
  705.      *
  706.      * @param string $table name of table that should be used in method
  707.      * @return mixed array of field names on success, a MDB2 error on failure
  708.      * @access public
  709.      */
  710.     function listTableFields($table)
  711.     {
  712.         $db $this->getDBInstance();
  713.         if (MDB2::isError($db)) {
  714.             return $db;
  715.         }
  716.  
  717.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  718.             'method not implemented'__FUNCTION__);
  719.     }
  720.  
  721.     // }}}
  722.     // {{{ createIndex()
  723.  
  724.     /**
  725.      * Get the stucture of a field into an array
  726.      *
  727.      * @param string    $table         name of the table on which the index is to be created
  728.      * @param string    $name         name of the index to be created
  729.      * @param array     $definition        associative array that defines properties of the index to be created.
  730.      *                                  Currently, only one property named FIELDS is supported. This property
  731.      *                                  is also an associative with the names of the index fields as array
  732.      *                                  indexes. Each entry of this array is set to another type of associative
  733.      *                                  array that specifies properties of the index that are specific to
  734.      *                                  each field.
  735.      *
  736.      *                                 Currently, only the sorting property is supported. It should be used
  737.      *                                  to define the sorting direction of the index. It may be set to either
  738.      *                                  ascending or descending.
  739.      *
  740.      *                                 Not all DBMS support index sorting direction configuration. The DBMS
  741.      *                                  drivers of those that do not support it ignore this property. Use the
  742.      *                                  function supports() to determine whether the DBMS driver can manage indexes.
  743.      *
  744.      *                                  Example
  745.      *                                     array(
  746.      *                                         'fields' => array(
  747.      *                                             'user_name' => array(
  748.      *                                                 'sorting' => 'ascending'
  749.      *                                             ),
  750.      *                                             'last_login' => array()
  751.      *                                         )
  752.      *                                     )
  753.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  754.      * @access public
  755.      */
  756.     function createIndex($table$name$definition)
  757.     {
  758.         $db $this->getDBInstance();
  759.         if (MDB2::isError($db)) {
  760.             return $db;
  761.         }
  762.  
  763.         $table $db->quoteIdentifier($tabletrue);
  764.         $name $db->quoteIdentifier($db->getIndexName($name)true);
  765.         $query = "CREATE INDEX $name ON $table";
  766.         $fields = array();
  767.         foreach (array_keys($definition['fields']as $field{
  768.             $fields[$db->quoteIdentifier($fieldtrue);
  769.         }
  770.         $query .= ' ('implode(', '$fields')';
  771.         $result $db->exec($query);
  772.         if (MDB2::isError($result)) {
  773.             return $result;
  774.         }
  775.         return MDB2_OK;
  776.     }
  777.  
  778.     // }}}
  779.     // {{{ dropIndex()
  780.  
  781.     /**
  782.      * drop existing index
  783.      *
  784.      * @param string    $table         name of table that should be used in method
  785.      * @param string    $name         name of the index to be dropped
  786.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  787.      * @access public
  788.      */
  789.     function dropIndex($table$name)
  790.     {
  791.         $db $this->getDBInstance();
  792.         if (MDB2::isError($db)) {
  793.             return $db;
  794.         }
  795.  
  796.         $name $db->quoteIdentifier($db->getIndexName($name)true);
  797.         $result $db->exec("DROP INDEX $name");
  798.         if (MDB2::isError($result)) {
  799.             return $result;
  800.         }
  801.         return MDB2_OK;
  802.     }
  803.  
  804.     // }}}
  805.     // {{{ listTableIndexes()
  806.  
  807.     /**
  808.      * list all indexes in a table
  809.      *
  810.      * @param string $table name of table that should be used in method
  811.      * @return mixed array of index names on success, a MDB2 error on failure
  812.      * @access public
  813.      */
  814.     function listTableIndexes($table)
  815.     {
  816.         $db $this->getDBInstance();
  817.         if (MDB2::isError($db)) {
  818.             return $db;
  819.         }
  820.  
  821.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  822.             'method not implemented'__FUNCTION__);
  823.     }
  824.  
  825.     // }}}
  826.     // {{{ _getAdvancedFKOptions()
  827.  
  828.     /**
  829.      * Return the FOREIGN KEY query section dealing with non-standard options
  830.      * as MATCH, INITIALLY DEFERRED, ON UPDATE, ...
  831.      *
  832.      * @param array $definition 
  833.      * @return string 
  834.      * @access protected
  835.      */
  836.     function _getAdvancedFKOptions($definition)
  837.     {
  838.         return '';
  839.     }
  840.  
  841.     // }}}
  842.     // {{{ createConstraint()
  843.  
  844.     /**
  845.      * create a constraint on a table
  846.      *
  847.      * @param string    $table       name of the table on which the constraint is to be created
  848.      * @param string    $name        name of the constraint to be created
  849.      * @param array     $definition  associative array that defines properties of the constraint to be created.
  850.      *                                The full structure of the array looks like this:
  851.      *           <pre>
  852.      *           array (
  853.      *               [primary] => 0
  854.      *               [unique]  => 0
  855.      *               [foreign] => 1
  856.      *               [check]   => 0
  857.      *               [fields] => array (
  858.      *                   [field1name] => array() // one entry per each field covered
  859.      *                   [field2name] => array() // by the index
  860.      *                   [field3name] => array(
  861.      *                       [sorting]  => ascending
  862.      *                       [position] => 3
  863.      *                   )
  864.      *               )
  865.      *               [references] => array(
  866.      *                   [table] => name
  867.      *                   [fields] => array(
  868.      *                       [field1name] => array(  //one entry per each referenced field
  869.      *                            [position] => 1
  870.      *                       )
  871.      *                   )
  872.      *               )
  873.      *               [deferrable] => 0
  874.      *               [initiallydeferred] => 0
  875.      *               [onupdate] => CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION
  876.      *               [ondelete] => CASCADE|RESTRICT|SET NULL|SET DEFAULT|NO ACTION
  877.      *               [match] => SIMPLE|PARTIAL|FULL
  878.      *           );
  879.      *           </pre>
  880.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  881.      * @access public
  882.      */
  883.     function createConstraint($table$name$definition)
  884.     {
  885.         $db $this->getDBInstance();
  886.         if (MDB2::isError($db)) {
  887.             return $db;
  888.         }
  889.         $table $db->quoteIdentifier($tabletrue);
  890.         $name $db->quoteIdentifier($db->getIndexName($name)true);
  891.         $query = "ALTER TABLE $table ADD CONSTRAINT $name";
  892.         if (!empty($definition['primary'])) {
  893.             $query.= ' PRIMARY KEY';
  894.         elseif (!empty($definition['unique'])) {
  895.             $query.= ' UNIQUE';
  896.         elseif (!empty($definition['foreign'])) {
  897.             $query.= ' FOREIGN KEY';
  898.         }
  899.         $fields = array();
  900.         foreach (array_keys($definition['fields']as $field{
  901.             $fields[$db->quoteIdentifier($fieldtrue);
  902.         }
  903.         $query .= ' ('implode(', '$fields')';
  904.         if (!empty($definition['foreign'])) {
  905.             $query.= ' REFERENCES ' $db->quoteIdentifier($definition['references']['table']true);
  906.             $referenced_fields = array();
  907.             foreach (array_keys($definition['references']['fields']as $field{
  908.                 $referenced_fields[$db->quoteIdentifier($fieldtrue);
  909.             }
  910.             $query .= ' ('implode(', '$referenced_fields')';
  911.             $query .= $this->_getAdvancedFKOptions($definition);
  912.         }
  913.         $result $db->exec($query);
  914.         if (MDB2::isError($result)) {
  915.             return $result;
  916.         }
  917.         return MDB2_OK;
  918.     }
  919.  
  920.     // }}}
  921.     // {{{ dropConstraint()
  922.  
  923.     /**
  924.      * drop existing constraint
  925.      *
  926.      * @param string    $table        name of table that should be used in method
  927.      * @param string    $name         name of the constraint to be dropped
  928.      * @param string    $primary      hint if the constraint is primary
  929.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  930.      * @access public
  931.      */
  932.     function dropConstraint($table$name$primary = false)
  933.     {
  934.         $db $this->getDBInstance();
  935.         if (MDB2::isError($db)) {
  936.             return $db;
  937.         }
  938.  
  939.         $table $db->quoteIdentifier($tabletrue);
  940.         $name $db->quoteIdentifier($db->getIndexName($name)true);
  941.         $result $db->exec("ALTER TABLE $table DROP CONSTRAINT $name");
  942.         if (MDB2::isError($result)) {
  943.             return $result;
  944.         }
  945.         return MDB2_OK;
  946.     }
  947.  
  948.     // }}}
  949.     // {{{ listTableConstraints()
  950.  
  951.     /**
  952.      * list all constraints in a table
  953.      *
  954.      * @param string $table name of table that should be used in method
  955.      * @return mixed array of constraint names on success, a MDB2 error on failure
  956.      * @access public
  957.      */
  958.     function listTableConstraints($table)
  959.     {
  960.         $db $this->getDBInstance();
  961.         if (MDB2::isError($db)) {
  962.             return $db;
  963.         }
  964.  
  965.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  966.             'method not implemented'__FUNCTION__);
  967.     }
  968.  
  969.     // }}}
  970.     // {{{ createSequence()
  971.  
  972.     /**
  973.      * create sequence
  974.      *
  975.      * @param string    $seq_name     name of the sequence to be created
  976.      * @param string    $start         start value of the sequence; default is 1
  977.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  978.      * @access public
  979.      */
  980.     function createSequence($seq_name$start = 1)
  981.     {
  982.         $db $this->getDBInstance();
  983.         if (MDB2::isError($db)) {
  984.             return $db;
  985.         }
  986.  
  987.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  988.             'method not implemented'__FUNCTION__);
  989.     }
  990.  
  991.     // }}}
  992.     // {{{ dropSequence()
  993.  
  994.     /**
  995.      * drop existing sequence
  996.      *
  997.      * @param string    $seq_name     name of the sequence to be dropped
  998.      * @return mixed MDB2_OK on success, a MDB2 error on failure
  999.      * @access public
  1000.      */
  1001.     function dropSequence($name)
  1002.     {
  1003.         $db $this->getDBInstance();
  1004.         if (MDB2::isError($db)) {
  1005.             return $db;
  1006.         }
  1007.  
  1008.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  1009.             'method not implemented'__FUNCTION__);
  1010.     }
  1011.  
  1012.     // }}}
  1013.     // {{{ listSequences()
  1014.  
  1015.     /**
  1016.      * list all sequences in the current database
  1017.      *
  1018.      * @param string database, the current is default
  1019.      *                NB: not all the drivers can get the sequence names from
  1020.      *                a database other than the current one
  1021.      * @return mixed array of sequence names on success, a MDB2 error on failure
  1022.      * @access public
  1023.      */
  1024.     function listSequences($database = null)
  1025.     {
  1026.         $db $this->getDBInstance();
  1027.         if (MDB2::isError($db)) {
  1028.             return $db;
  1029.         }
  1030.  
  1031.         return $db->raiseError(MDB2_ERROR_UNSUPPORTEDnullnull,
  1032.             'method not implemented'__FUNCTION__);
  1033.     }
  1034.  
  1035.     // }}}
  1036. }
  1037. ?>

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