Support Joomla!

Packages

Package: Joomla-Framework

License

Content on this site is copyright © 2005 - 2008 Open Source Matters Inc and can be used in accordance with the Joomla! Electronic Documentation License. Some parts of this website may be subject to other licenses.
Source code for file /joomla/database/database.php

Documentation is available at database.php

  1. <?php
  2. /**
  3. @version        $Id: database.php 12694 2009-09-11 21:03:02Z ian $
  4. @package        Joomla.Framework
  5. @subpackage    Database
  6. @copyright    Copyright (C) 2005 - 2008 Open Source Matters. All rights reserved.
  7. @license        GNU/GPL, see LICENSE.php
  8. *  Joomla! is free software. This version may have been modified pursuant
  9. *  to the GNU General Public License, and as distributed it includes or
  10. *  is derivative of works licensed under the GNU General Public License or
  11. *  other free or open source software licenses.
  12. *  See COPYRIGHT.php for copyright notices and details.
  13. */
  14.  
  15. // Check to ensure this file is within the rest of the framework
  16. defined('JPATH_BASE'or die();
  17.  
  18. /**
  19.  * Database connector class
  20.  *
  21.  * @abstract
  22.  * @package        Joomla.Framework
  23.  * @subpackage    Database
  24.  * @since        1.0
  25.  */
  26. class JDatabase extends JObject
  27. {
  28.     /**
  29.      * The database driver name
  30.      *
  31.      * @var string 
  32.      */
  33.     var $name            = '';
  34.  
  35.     /**
  36.      * The query sql string
  37.      *
  38.      * @var string 
  39.      ***/
  40.     var $_sql            = '';
  41.  
  42.     /**
  43.      * The database error number
  44.      *
  45.      * @var int 
  46.      ***/
  47.     var $_errorNum        = 0;
  48.  
  49.     /**
  50.      * The database error message
  51.      *
  52.      * @var string 
  53.      */
  54.     var $_errorMsg        = '';
  55.  
  56.     /**
  57.      * The prefix used on all database tables
  58.      *
  59.      * @var string 
  60.      */
  61.     var $_table_prefix    = '';
  62.  
  63.     /**
  64.      * The connector resource
  65.      *
  66.      * @var resource 
  67.      */
  68.     var $_resource        = '';
  69.  
  70.     /**
  71.      * The last query cursor
  72.      *
  73.      * @var resource 
  74.      */
  75.     var $_cursor        = null;
  76.  
  77.     /**
  78.      * Debug option
  79.      *
  80.      * @var boolean 
  81.      */
  82.     var $_debug            = 0;
  83.  
  84.     /**
  85.      * The limit for the query
  86.      *
  87.      * @var int 
  88.      */
  89.     var $_limit            = 0;
  90.  
  91.     /**
  92.      * The for offset for the limit
  93.      *
  94.      * @var int 
  95.      */
  96.     var $_offset        = 0;
  97.  
  98.     /**
  99.      * The number of queries performed by the object instance
  100.      *
  101.      * @var int 
  102.      */
  103.     var $_ticker        = 0;
  104.  
  105.     /**
  106.      * A log of queries
  107.      *
  108.      * @var array 
  109.      */
  110.     var $_log            = null;
  111.  
  112.     /**
  113.      * The null/zero date string
  114.      *
  115.      * @var string 
  116.      */
  117.     var $_nullDate        = null;
  118.  
  119.     /**
  120.      * Quote for named objects
  121.      *
  122.      * @var string 
  123.      */
  124.     var $_nameQuote        = null;
  125.  
  126.     /**
  127.      * UTF-8 support
  128.      *
  129.      * @var boolean 
  130.      * @since    1.5
  131.      */
  132.     var $_utf            = 0;
  133.  
  134.     /**
  135.      * The fields that are to be quote
  136.      *
  137.      * @var array 
  138.      * @since    1.5
  139.      */
  140.     var $_quoted    = null;
  141.  
  142.     /**
  143.      *  Legacy compatibility
  144.      *
  145.      * @var bool 
  146.      * @since    1.5
  147.      */
  148.     var $_hasQuoted    = null;
  149.  
  150.     /**
  151.     * Database object constructor
  152.     *
  153.     * @access    public
  154.     * @param    array    List of options used to configure the connection
  155.     * @since    1.5
  156.     */
  157.     function __construct$options )
  158.     {
  159.         $prefix        array_key_exists('prefix'$options)    $options['prefix']    'jos_';
  160.  
  161.         // Determine utf-8 support
  162.         $this->_utf = $this->hasUTF();
  163.  
  164.         //Set charactersets (needed for MySQL 4.1.2+)
  165.         if ($this->_utf){
  166.             $this->setUTF();
  167.         }
  168.  
  169.         $this->_table_prefix    = $prefix;
  170.         $this->_ticker            = 0;
  171.         $this->_errorNum        = 0;
  172.         $this->_log                = array();
  173.         $this->_quoted            = array();
  174.         $this->_hasQuoted        = false;
  175.  
  176.         // Register faked "destructor" in PHP4 to close all connections we might have made
  177.         if (version_compare(PHP_VERSION'5'== -1{
  178.             register_shutdown_function(array(&$this'__destruct'));
  179.         }
  180.     }
  181.  
  182.     /**
  183.      * Returns a reference to the global Database object, only creating it
  184.      * if it doesn't already exist.
  185.      *
  186.      * The 'driver' entry in the parameters array specifies the database driver
  187.      * to be used (defaults to 'mysql' if omitted). All other parameters are
  188.      * database driver dependent.
  189.      *
  190.      * @param array Parameters to be passed to the database driver
  191.      * @return JDatabase A database object
  192.      * @since 1.5
  193.     */
  194.     function &getInstance$options    array() )
  195.     {
  196.         static $instances;
  197.  
  198.         if (!isset$instances )) {
  199.             $instances array();
  200.         }
  201.  
  202.         $signature serialize$options );
  203.  
  204.         if (empty($instances[$signature]))
  205.         {
  206.             $driver        array_key_exists('driver'$options)         $options['driver']    'mysql';
  207.             $select        array_key_exists('select'$options)        $options['select']    true;
  208.             $database    array_key_exists('database'$options)    $options['database']    null;
  209.  
  210.             $driver preg_replace('/[^A-Z0-9_\.-]/i'''$driver);
  211.             $path    dirname(__FILE__).DS.'database'.DS.$driver.'.php';
  212.  
  213.             if (file_exists($path)) {
  214.                 require_once($path);
  215.             else {
  216.                 JError::setErrorHandling(E_ERROR'die')//force error type to die
  217.                 $error JError::raiseError500JTEXT::_('Unable to load Database Driver:'.$driver);
  218.                 return $error;
  219.             }
  220.  
  221.             $adapter    'JDatabase'.$driver;
  222.             $instance    new $adapter($options);
  223.  
  224.             if $error $instance->getErrorMsg() )
  225.             {
  226.                 JError::setErrorHandling(E_ERROR'ignore')//force error type to die
  227.                 $error JError::raiseError500JTEXT::_('Unable to connect to the database:'.$error);
  228.                 return $error;
  229.             }
  230.  
  231.  
  232.             $instances[$signature$instance;
  233.         }
  234.  
  235.         return $instances[$signature];
  236.     }
  237.  
  238.     /**
  239.      * Database object destructor
  240.      *
  241.      * @abstract
  242.      * @access private
  243.      * @return boolean 
  244.      * @since 1.5
  245.      */
  246.     function __destruct()
  247.     {
  248.         return true;
  249.     }
  250.  
  251.     /**
  252.      * Get the database connectors
  253.      *
  254.      * @access public
  255.      * @return array An array of available session handlers
  256.      */
  257.     function getConnectors()
  258.     {
  259.         jimport('joomla.filesystem.folder');
  260.         $handlers JFolder::files(dirname(__FILE__).DS.'database''.php$');
  261.  
  262.         $names array();
  263.         foreach($handlers as $handler)
  264.         {
  265.             $name substr($handler0strrpos($handler'.'));
  266.             $class 'JDatabase'.ucfirst($name);
  267.  
  268.             if(!class_exists($class)) {
  269.                 require_once(dirname(__FILE__).DS.'database'.DS.$name.'.php');
  270.             }
  271.  
  272.             if(call_user_func_arrayarraytrim($class)'test' )null)) {
  273.                 $names[$name;
  274.             }
  275.         }
  276.  
  277.         return $names;
  278.     }
  279.  
  280.     /**
  281.      * Test to see if the MySQLi connector is available
  282.      *
  283.      * @static
  284.      * @access public
  285.      * @return boolean  True on success, false otherwise.
  286.      */
  287.     function test()
  288.     {
  289.         return false;
  290.     }
  291.  
  292.     /**
  293.      * Determines if the connection to the server is active.
  294.      *
  295.      * @access      public
  296.      * @return      boolean 
  297.      * @since       1.5
  298.      */
  299.     function connected()
  300.     {
  301.         return false;
  302.     }
  303.  
  304.     /**
  305.      * Determines UTF support
  306.      *
  307.      * @abstract
  308.      * @access public
  309.      * @return boolean 
  310.      * @since 1.5
  311.      */
  312.     function hasUTF({
  313.         return false;
  314.     }
  315.  
  316.     /**
  317.      * Custom settings for UTF support
  318.      *
  319.      * @abstract
  320.      * @access public
  321.      * @since 1.5
  322.      */
  323.     function setUTF({
  324.     }
  325.  
  326.     /**
  327.      * Adds a field or array of field names to the list that are to be quoted
  328.      *
  329.      * @access public
  330.      * @param mixed Field name or array of names
  331.      * @since 1.5
  332.      */
  333.     function addQuoted$quoted )
  334.     {
  335.         if (is_string$quoted )) {
  336.             $this->_quoted[$quoted;
  337.         else {
  338.             $this->_quoted = array_merge$this->_quoted(array)$quoted );
  339.         }
  340.         $this->_hasQuoted = true;
  341.     }
  342.  
  343.     /**
  344.      * Splits a string of queries into an array of individual queries
  345.      *
  346.      * @access public
  347.      * @param string The queries to split
  348.      * @return array queries
  349.      */
  350.     function splitSql$queries )
  351.     {
  352.         $start 0;
  353.         $open false;
  354.         $open_char '';
  355.         $end strlen($queries);
  356.         $query_split array();
  357.         for($i=0;$i<$end;$i++{
  358.             $current substr($queries,$i,1);
  359.             if(($current == '"' || $current == '\'')) {
  360.                 $n 2;
  361.                 while(substr($queries,$i $n 11== '\\' && $n $i{
  362.                     $n ++;
  363.                 }
  364.                 if($n%2==0{
  365.                     if ($open{
  366.                         if($current == $open_char{
  367.                             $open false;
  368.                             $open_char '';
  369.                         }
  370.                     else {
  371.                         $open true;
  372.                         $open_char $current;
  373.                     }
  374.                 }
  375.             }
  376.             if(($current == ';' && !$open)|| $i == $end 1{
  377.                 $query_split[substr($queries$start($i $start 1));
  378.                 $start $i 1;
  379.             }
  380.         }
  381.  
  382.         return $query_split;
  383.     }
  384.  
  385.  
  386.  
  387.     /**
  388.      * Checks if field name needs to be quoted
  389.      *
  390.      * @access public
  391.      * @param string The field name
  392.      * @return bool 
  393.      */
  394.     function isQuoted$fieldName )
  395.     {
  396.         if ($this->_hasQuoted{
  397.             return in_array$fieldName$this->_quoted );
  398.         else {
  399.             return true;
  400.         }
  401.     }
  402.  
  403.     /**
  404.      * Sets the debug level on or off
  405.      *
  406.      * @access public
  407.      * @param int 0 = off, 1 = on
  408.      */
  409.     function debug$level {
  410.         $this->_debug = intval$level );
  411.     }
  412.  
  413.     /**
  414.      * Get the database UTF-8 support
  415.      *
  416.      * @access public
  417.      * @return boolean 
  418.      * @since 1.5
  419.      */
  420.     function getUTFSupport({
  421.         return $this->_utf;
  422.     }
  423.  
  424.     /**
  425.      * Get the error number
  426.      *
  427.      * @access public
  428.      * @return int The error number for the most recent query
  429.      */
  430.     function getErrorNum({
  431.         return $this->_errorNum;
  432.     }
  433.  
  434.  
  435.     /**
  436.      * Get the error message
  437.      *
  438.      * @access public
  439.      * @return string The error message for the most recent query
  440.      */
  441.     function getErrorMsg($escaped false)
  442.     {
  443.         if($escaped{
  444.             return addslashes($this->_errorMsg);
  445.         else {
  446.             return $this->_errorMsg;
  447.         }
  448.     }
  449.  
  450.     /**
  451.      * Get a database escaped string
  452.      *
  453.      * @param    string    The string to be escaped
  454.      * @param    boolean    Optional parameter to provide extra escaping
  455.      * @return    string 
  456.      * @access    public
  457.      * @abstract
  458.      */
  459.     function getEscaped$text$extra false )
  460.     {
  461.         return;
  462.     }
  463.  
  464.     /**
  465.      * Get a database error log
  466.      *
  467.      * @access public
  468.      * @return array 
  469.      */
  470.     function getLog)
  471.     {
  472.         return $this->_log;
  473.     }
  474.  
  475.     /**
  476.      * Get the total number of queries made
  477.      *
  478.      * @access public
  479.      * @return array 
  480.      */
  481.     function getTicker)
  482.     {
  483.         return $this->_ticker;
  484.     }
  485.  
  486.     /**
  487.      * Quote an identifier name (field, table, etc)
  488.      *
  489.      * @access    public
  490.      * @param    string    The name
  491.      * @return    string    The quoted name
  492.      */
  493.     function nameQuote$s )
  494.     {
  495.         // Only quote if the name is not using dot-notation
  496.         if (strpos$s'.' === false)
  497.         {
  498.             $q $this->_nameQuote;
  499.             if (strlen$q == 1{
  500.                 return $q $s $q;
  501.             else {
  502.                 return $q{0$s $q{1};
  503.             }
  504.         }
  505.         else {
  506.             return $s;
  507.         }
  508.     }
  509.     /**
  510.      * Get the database table prefix
  511.      *
  512.      * @access public
  513.      * @return string The database prefix
  514.      */
  515.     function getPrefix()
  516.     {
  517.         return $this->_table_prefix;
  518.     }
  519.  
  520.     /**
  521.      * Get the database null date
  522.      *
  523.      * @access public
  524.      * @return string Quoted null/zero date string
  525.      */
  526.     function getNullDate()
  527.     {
  528.         return $this->_nullDate;
  529.     }
  530.  
  531.     /**
  532.      * Sets the SQL query string for later execution.
  533.      *
  534.      * This function replaces a string identifier <var>$prefix</var> with the
  535.      * string held is the <var>_table_prefix</var> class variable.
  536.      *
  537.      * @access public
  538.      * @param string The SQL query
  539.      * @param string The offset to start selection
  540.      * @param string The number of results to return
  541.      * @param string The common table prefix
  542.      */
  543.     function setQuery$sql$offset 0$limit 0$prefix='#__' )
  544.     {
  545.         $this->_sql        = $this->replacePrefix$sql$prefix );
  546.         $this->_limit    = (int) $limit;
  547.         $this->_offset    = (int) $offset;
  548.     }
  549.  
  550.     /**
  551.      * This function replaces a string identifier <var>$prefix</var> with the
  552.      * string held is the <var>_table_prefix</var> class variable.
  553.      *
  554.      * @access public
  555.      * @param string The SQL query
  556.      * @param string The common table prefix
  557.      */
  558.     function replacePrefix$sql$prefix='#__' )
  559.     {
  560.         $sql trim$sql );
  561.  
  562.         $escaped false;
  563.         $quoteChar '';
  564.  
  565.         $n strlen$sql );
  566.  
  567.         $startPos 0;
  568.         $literal '';
  569.         while ($startPos $n{
  570.             $ip strpos($sql$prefix$startPos);
  571.             if ($ip === false{
  572.                 break;
  573.             }
  574.  
  575.             $j strpos$sql"'"$startPos );
  576.             $k strpos$sql'"'$startPos );
  577.             if (($k !== FALSE&& (($k $j|| ($j === FALSE))) {
  578.                 $quoteChar    '"';
  579.                 $j            $k;
  580.             else {
  581.                 $quoteChar    "'";
  582.             }
  583.  
  584.             if ($j === false{
  585.                 $j $n;
  586.             }
  587.  
  588.             $literal .= str_replace$prefix$this->_table_prefix,substr$sql$startPos$j $startPos ) );
  589.             $startPos $j;
  590.  
  591.             $j $startPos 1;
  592.  
  593.             if ($j >= $n{
  594.                 break;
  595.             }
  596.  
  597.             // quote comes first, find end of quote
  598.             while (TRUE{
  599.                 $k strpos$sql$quoteChar$j );
  600.                 $escaped false;
  601.                 if ($k === false{
  602.                     break;
  603.                 }
  604.                 $l $k 1;
  605.                 while ($l >= && $sql{$l== '\\'{
  606.                     $l--;
  607.                     $escaped !$escaped;
  608.                 }
  609.                 if ($escaped{
  610.                     $j    $k+1;
  611.                     continue;
  612.                 }
  613.                 break;
  614.             }
  615.             if ($k === FALSE{
  616.                 // error in the query - no end quote; ignore it
  617.                 break;
  618.             }
  619.             $literal .= substr$sql$startPos$k $startPos );
  620.             $startPos $k+1;
  621.         }
  622.         if ($startPos $n{
  623.             $literal .= substr$sql$startPos$n $startPos );
  624.         }
  625.         return $literal;
  626.     }
  627.  
  628.     /**
  629.      * Get the active query
  630.      *
  631.      * @access public
  632.      * @return string The current value of the internal SQL vairable
  633.      */
  634.     function getQuery()
  635.     {
  636.         return $this->_sql;
  637.     }
  638.  
  639.     /**
  640.      * Execute the query
  641.      *
  642.      * @abstract
  643.      * @access public
  644.      * @return mixed A database resource if successful, FALSE if not.
  645.      */
  646.     function query()
  647.     {
  648.         return;
  649.     }
  650.  
  651.     /**
  652.      * Get the affected rows by the most recent query
  653.      *
  654.      * @abstract
  655.      * @access public
  656.      * @return int The number of affected rows in the previous operation
  657.      * @since 1.0.5
  658.      */
  659.     function getAffectedRows()
  660.     {
  661.         return;
  662.     }
  663.  
  664.     /**
  665.     * Execute a batch query
  666.     *
  667.     * @abstract
  668.     * @access public
  669.     * @return mixed A database resource if successful, FALSE if not.
  670.     */
  671.     function queryBatch$abort_on_error=true$p_transaction_safe false)
  672.     {
  673.         return false;
  674.     }
  675.  
  676.     /**
  677.      * Diagnostic function
  678.      *
  679.      * @abstract
  680.      * @access public
  681.      */
  682.     function explain()
  683.     {
  684.         return;
  685.     }
  686.  
  687.     /**
  688.      * Get the number of rows returned by the most recent query
  689.      *
  690.      * @abstract
  691.      * @access public
  692.      * @param object Database resource
  693.      * @return int The number of rows
  694.      */
  695.     function getNumRows$cur=null )
  696.     {
  697.         return;
  698.     }
  699.  
  700.     /**
  701.      * This method loads the first field of the first row returned by the query.
  702.      *
  703.      * @abstract
  704.      * @access public
  705.      * @return The value returned in the query or null if the query failed.
  706.      */
  707.     function loadResult()
  708.     {
  709.         return;
  710.     }
  711.  
  712.     /**
  713.      * Load an array of single field results into an array
  714.      *
  715.      * @abstract
  716.      */
  717.     function loadResultArray($numinarray 0)
  718.     {
  719.         return;
  720.     }
  721.  
  722.     /**
  723.     * Fetch a result row as an associative array
  724.     *
  725.     * @abstract
  726.     */
  727.     function loadAssoc()
  728.     {
  729.         return;
  730.     }
  731.  
  732.     /**
  733.      * Load a associactive list of database rows
  734.      *
  735.      * @abstract
  736.      * @access public
  737.      * @param string The field name of a primary key
  738.      * @return array If key is empty as sequential list of returned records.
  739.      */
  740.     function loadAssocList$key='' )
  741.     {
  742.         return;
  743.     }
  744.  
  745.     /**
  746.      * This global function loads the first row of a query into an object
  747.      *
  748.      *
  749.      * @abstract
  750.      * @access public
  751.      * @param object 
  752.      */
  753.     function loadObject)
  754.     {
  755.         return;
  756.     }
  757.  
  758.     /**
  759.     * Load a list of database objects
  760.     *
  761.     * @abstract
  762.     * @access public
  763.     * @param string The field name of a primary key
  764.     * @return array If <var>key</var> is empty as sequential list of returned records.
  765.  
  766.     *  If <var>key</var> is not empty then the returned array is indexed by the value
  767.     *  the database key.  Returns <var>null</var> if the query fails.
  768.     */
  769.     function loadObjectList$key='' )
  770.     {
  771.         return;
  772.     }
  773.  
  774.     /**
  775.      * Load the first row returned by the query
  776.      *
  777.      * @abstract
  778.      * @access public
  779.      * @return The first row of the query.
  780.      */
  781.     function loadRow()
  782.     {
  783.         return;
  784.     }
  785.  
  786.     /**
  787.     * Load a list of database rows (numeric column indexing)
  788.     *
  789.     * If <var>key</var> is not empty then the returned array is indexed by the value
  790.     * the database key.  Returns <var>null</var> if the query fails.
  791.     *
  792.     * @abstract
  793.     * @access public
  794.     * @param string The field name of a primary key
  795.     * @return array 
  796.     */
  797.     function loadRowList$key='' )
  798.     {
  799.         return;
  800.     }
  801.  
  802.     /**
  803.      * Inserts a row into a table based on an objects properties
  804.      * @param    string    The name of the table
  805.      * @param    object    An object whose properties match table fields
  806.      * @param    string    The name of the primary key. If provided the object property is updated.
  807.      */
  808.     function insertObject$table&$object$keyName NULL )
  809.     {
  810.         return;
  811.     }
  812.  
  813.     /**
  814.      * Update an object in the database
  815.      *
  816.      * @abstract
  817.      * @access public
  818.      * @param string 
  819.      * @param object 
  820.      * @param string 
  821.      * @param boolean 
  822.      */
  823.     function updateObject$table&$object$keyName$updateNulls=true )
  824.     {
  825.         return;
  826.     }
  827.  
  828.     /**
  829.      * Print out an error statement
  830.      *
  831.      * @param boolean If TRUE, displays the last SQL statement sent to the database
  832.      * @return string A standised error message
  833.      */
  834.     function stderr$showSQL false )
  835.     {
  836.         if $this->_errorNum != {
  837.             return "DB function failed with error number $this->_errorNum"
  838.             ."<br /><font color=\"red\">$this->_errorMsg</font>"
  839.             .($showSQL "<br />SQL = <pre>$this->_sql</pre>'');
  840.         else {
  841.             return "DB function reports no errors";
  842.         }
  843.     }
  844.  
  845.     /**
  846.      * Get the ID generated from the previous INSERT operation
  847.      *
  848.      * @abstract
  849.      * @access public
  850.      * @return mixed 
  851.      */
  852.     function insertid()
  853.     {
  854.         return;
  855.     }
  856.  
  857.     /**
  858.      * Get the database collation
  859.      *
  860.      * @abstract
  861.      * @access public
  862.      * @return string Collation in use
  863.      */
  864.     function getCollation()
  865.     {
  866.         return;
  867.     }
  868.  
  869.     /**
  870.      * Get the version of the database connector
  871.      *
  872.      * @abstract
  873.      */
  874.     function getVersion()
  875.     {
  876.         return 'Not available for this connector';
  877.     }
  878.  
  879.     /**
  880.      * List tables in a database
  881.      *
  882.      * @abstract
  883.      * @access public
  884.      * @return array A list of all the tables in the database
  885.      */
  886.     function getTableList()
  887.     {
  888.         return;
  889.     }
  890.  
  891.     /**
  892.      * Shows the CREATE TABLE statement that creates the given tables
  893.      *
  894.      * @abstract
  895.      * @access    public
  896.      * @param     array|string    A table name or a list of table names
  897.      * @return     array A list the create SQL for the tables
  898.      */
  899.     function getTableCreate$tables )
  900.     {
  901.         return;
  902.     }
  903.  
  904.     /**
  905.      * Retrieves information about the given tables
  906.      *
  907.      * @abstract
  908.      * @access    public
  909.      * @param     array|string    A table name or a list of table names
  910.      * @param    boolean            Only return field types, default true
  911.      * @return    array An array of fields by table
  912.      */
  913.     function getTableFields$tables$typeonly true )
  914.     {
  915.         return;
  916.     }
  917.  
  918.     // ----
  919.     // ADODB Compatibility Functions
  920.     // ----
  921.  
  922.     
  923.     /**
  924.     * Get a quoted database escaped string
  925.     *
  926.     * @param    string    A string
  927.     * @param    boolean    Default true to escape string, false to leave the string unchanged
  928.     * @return    string 
  929.     * @access public
  930.     */
  931.     function Quote$text$escaped true )
  932.     {
  933.         return '\''.($escaped $this->getEscaped$text $text).'\'';
  934.     }
  935.  
  936.     /**
  937.      * ADODB compatability function
  938.      *
  939.      * @access    public
  940.      * @param    string SQL
  941.      * @since    1.5
  942.      */
  943.     function GetCol$query )
  944.     {
  945.         $this->setQuery$query );
  946.         return $this->loadResultArray();
  947.     }
  948.  
  949.     /**
  950.      * ADODB compatability function
  951.      *
  952.      * @access    public
  953.      * @param    string SQL
  954.      * @return    object 
  955.      * @since    1.5
  956.      */
  957.     function Execute$query )
  958.     {
  959.         jimport'joomla.database.recordset' );
  960.  
  961.         $query trim$query );
  962.         $this->setQuery$query );
  963.         if (preg_match('#^select#i'$query )) {
  964.             $result $this->loadRowList();
  965.             return new JRecordSet$result );
  966.         else {
  967.             $result $this->query();
  968.             if ($result === false{
  969.                 return false;
  970.             else {
  971.                 return new JRecordSetarray() );
  972.             }
  973.         }
  974.     }
  975.  
  976.     /**
  977.      * ADODB compatability function
  978.      *
  979.      * @access public
  980.      * @since 1.5
  981.      */
  982.     function SelectLimit$query$count$offset=)
  983.     {
  984.         jimport'joomla.database.recordset' );
  985.  
  986.         $this->setQuery$query$offset$count );
  987.         $result $this->loadRowList();
  988.         return new JRecordSet$result );
  989.     }
  990.  
  991.     /**
  992.      * ADODB compatability function
  993.      *
  994.      * @access public
  995.      * @since 1.5
  996.      */
  997.     function PageExecute$sql$nrows$page$inputarr=false$secs2cache=)
  998.     {
  999.         jimport'joomla.database.recordset' );
  1000.  
  1001.         $this->setQuery$sql$page*$nrows$nrows );
  1002.         $result $this->loadRowList();
  1003.         return new JRecordSet$result );
  1004.     }
  1005.     /**
  1006.      * ADODB compatability function
  1007.      *
  1008.      * @access public
  1009.      * @param string SQL
  1010.      * @return array 
  1011.      * @since 1.5
  1012.      */
  1013.     function GetRow$query )
  1014.     {
  1015.         $this->setQuery$query );
  1016.         $result $this->loadRowList();
  1017.         return $result[0];
  1018.     }
  1019.  
  1020.     /**
  1021.      * ADODB compatability function
  1022.      *
  1023.      * @access public
  1024.      * @param string SQL
  1025.      * @return mixed 
  1026.      * @since 1.5
  1027.      */
  1028.     function GetOne$query )
  1029.     {
  1030.         $this->setQuery$query );
  1031.         $result $this->loadResult();
  1032.         return $result;
  1033.     }
  1034.  
  1035.     /**
  1036.      * ADODB compatability function
  1037.      *
  1038.      * @since 1.5
  1039.      */
  1040.     function BeginTrans()
  1041.     {
  1042.     }
  1043.  
  1044.     /**
  1045.      * ADODB compatability function
  1046.      *
  1047.      * @since 1.5
  1048.      */
  1049.     function RollbackTrans()
  1050.     {
  1051.     }
  1052.  
  1053.     /**
  1054.      * ADODB compatability function
  1055.      *
  1056.      * @since 1.5
  1057.      */
  1058.     function CommitTrans()
  1059.     {
  1060.     }
  1061.  
  1062.     /**
  1063.      * ADODB compatability function
  1064.      *
  1065.      * @since 1.5
  1066.      */
  1067.     function ErrorMsg()
  1068.     {
  1069.         return $this->getErrorMsg();
  1070.     }
  1071.  
  1072.     /**
  1073.      * ADODB compatability function
  1074.      *
  1075.      * @since 1.5
  1076.      */
  1077.     function ErrorNo()
  1078.     {
  1079.         return $this->getErrorNum();
  1080.     }
  1081.  
  1082.     /**
  1083.      * ADODB compatability function
  1084.      *
  1085.      * @since 1.5
  1086.      */
  1087.     function GenID$foo1=null$foo2=null )
  1088.     {
  1089.         return '0';
  1090.     }
  1091. }

Documentation generated on Sat, 14 Nov 2009 11:12:04 +0000 by phpDocumentor 1.3.1