]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - extlib/DB/msql.php
no notice form on invites
[quix0rs-gnu-social.git] / extlib / DB / msql.php
1 <?php
2
3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
4
5 /**
6  * The PEAR DB driver for PHP's msql extension
7  * for interacting with Mini SQL databases
8  *
9  * PHP's mSQL extension did weird things with NULL values prior to PHP
10  * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
11  * those versions.
12  *
13  * PHP versions 4 and 5
14  *
15  * LICENSE: This source file is subject to version 3.0 of the PHP license
16  * that is available through the world-wide-web at the following URI:
17  * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
18  * the PHP License and are unable to obtain it through the web, please
19  * send a note to license@php.net so we can mail you a copy immediately.
20  *
21  * @category   Database
22  * @package    DB
23  * @author     Daniel Convissor <danielc@php.net>
24  * @copyright  1997-2007 The PHP Group
25  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
26  * @version    CVS: $Id: msql.php,v 1.64 2007/09/21 13:40:41 aharvey Exp $
27  * @link       http://pear.php.net/package/DB
28  */
29
30 /**
31  * Obtain the DB_common class so it can be extended from
32  */
33 require_once 'DB/common.php';
34
35 /**
36  * The methods PEAR DB uses to interact with PHP's msql extension
37  * for interacting with Mini SQL databases
38  *
39  * These methods overload the ones declared in DB_common.
40  *
41  * PHP's mSQL extension did weird things with NULL values prior to PHP
42  * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
43  * those versions.
44  *
45  * @category   Database
46  * @package    DB
47  * @author     Daniel Convissor <danielc@php.net>
48  * @copyright  1997-2007 The PHP Group
49  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
50  * @version    Release: 1.7.14RC1
51  * @link       http://pear.php.net/package/DB
52  * @since      Class not functional until Release 1.7.0
53  */
54 class DB_msql extends DB_common
55 {
56     // {{{ properties
57
58     /**
59      * The DB driver type (mysql, oci8, odbc, etc.)
60      * @var string
61      */
62     var $phptype = 'msql';
63
64     /**
65      * The database syntax variant to be used (db2, access, etc.), if any
66      * @var string
67      */
68     var $dbsyntax = 'msql';
69
70     /**
71      * The capabilities of this DB implementation
72      *
73      * The 'new_link' element contains the PHP version that first provided
74      * new_link support for this DBMS.  Contains false if it's unsupported.
75      *
76      * Meaning of the 'limit' element:
77      *   + 'emulate' = emulate with fetch row by number
78      *   + 'alter'   = alter the query
79      *   + false     = skip rows
80      *
81      * @var array
82      */
83     var $features = array(
84         'limit'         => 'emulate',
85         'new_link'      => false,
86         'numrows'       => true,
87         'pconnect'      => true,
88         'prepare'       => false,
89         'ssl'           => false,
90         'transactions'  => false,
91     );
92
93     /**
94      * A mapping of native error codes to DB error codes
95      * @var array
96      */
97     var $errorcode_map = array(
98     );
99
100     /**
101      * The raw database connection created by PHP
102      * @var resource
103      */
104     var $connection;
105
106     /**
107      * The DSN information for connecting to a database
108      * @var array
109      */
110     var $dsn = array();
111
112
113     /**
114      * The query result resource created by PHP
115      *
116      * Used to make affectedRows() work.  Only contains the result for
117      * data manipulation queries.  Contains false for other queries.
118      *
119      * @var resource
120      * @access private
121      */
122     var $_result;
123
124
125     // }}}
126     // {{{ constructor
127
128     /**
129      * This constructor calls <kbd>$this->DB_common()</kbd>
130      *
131      * @return void
132      */
133     function DB_msql()
134     {
135         $this->DB_common();
136     }
137
138     // }}}
139     // {{{ connect()
140
141     /**
142      * Connect to the database server, log in and open the database
143      *
144      * Don't call this method directly.  Use DB::connect() instead.
145      *
146      * Example of how to connect:
147      * <code>
148      * require_once 'DB.php';
149      * 
150      * // $dsn = 'msql://hostname/dbname';  // use a TCP connection
151      * $dsn = 'msql:///dbname';             // use a socket
152      * $options = array(
153      *     'portability' => DB_PORTABILITY_ALL,
154      * );
155      * 
156      * $db = DB::connect($dsn, $options);
157      * if (PEAR::isError($db)) {
158      *     die($db->getMessage());
159      * }
160      * </code>
161      *
162      * @param array $dsn         the data source name
163      * @param bool  $persistent  should the connection be persistent?
164      *
165      * @return int  DB_OK on success. A DB_Error object on failure.
166      */
167     function connect($dsn, $persistent = false)
168     {
169         if (!PEAR::loadExtension('msql')) {
170             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
171         }
172
173         $this->dsn = $dsn;
174         if ($dsn['dbsyntax']) {
175             $this->dbsyntax = $dsn['dbsyntax'];
176         }
177
178         $params = array();
179         if ($dsn['hostspec']) {
180             $params[] = $dsn['port']
181                         ? $dsn['hostspec'] . ',' . $dsn['port']
182                         : $dsn['hostspec'];
183         }
184
185         $connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';
186
187         $ini = ini_get('track_errors');
188         $php_errormsg = '';
189         if ($ini) {
190             $this->connection = @call_user_func_array($connect_function,
191                                                       $params);
192         } else {
193             @ini_set('track_errors', 1);
194             $this->connection = @call_user_func_array($connect_function,
195                                                       $params);
196             @ini_set('track_errors', $ini);
197         }
198
199         if (!$this->connection) {
200             if (($err = @msql_error()) != '') {
201                 return $this->raiseError(DB_ERROR_CONNECT_FAILED,
202                                          null, null, null,
203                                          $err);
204             } else {
205                 return $this->raiseError(DB_ERROR_CONNECT_FAILED,
206                                          null, null, null,
207                                          $php_errormsg);
208             }
209         }
210
211         if (!@msql_select_db($dsn['database'], $this->connection)) {
212             return $this->msqlRaiseError();
213         }
214         return DB_OK;
215     }
216
217     // }}}
218     // {{{ disconnect()
219
220     /**
221      * Disconnects from the database server
222      *
223      * @return bool  TRUE on success, FALSE on failure
224      */
225     function disconnect()
226     {
227         $ret = @msql_close($this->connection);
228         $this->connection = null;
229         return $ret;
230     }
231
232     // }}}
233     // {{{ simpleQuery()
234
235     /**
236      * Sends a query to the database server
237      *
238      * @param string  the SQL query string
239      *
240      * @return mixed  + a PHP result resrouce for successful SELECT queries
241      *                + the DB_OK constant for other successful queries
242      *                + a DB_Error object on failure
243      */
244     function simpleQuery($query)
245     {
246         $this->last_query = $query;
247         $query = $this->modifyQuery($query);
248         $result = @msql_query($query, $this->connection);
249         if (!$result) {
250             return $this->msqlRaiseError();
251         }
252         // Determine which queries that should return data, and which
253         // should return an error code only.
254         if ($this->_checkManip($query)) {
255             $this->_result = $result;
256             return DB_OK;
257         } else {
258             $this->_result = false;
259             return $result;
260         }
261     }
262
263
264     // }}}
265     // {{{ nextResult()
266
267     /**
268      * Move the internal msql result pointer to the next available result
269      *
270      * @param a valid fbsql result resource
271      *
272      * @access public
273      *
274      * @return true if a result is available otherwise return false
275      */
276     function nextResult($result)
277     {
278         return false;
279     }
280
281     // }}}
282     // {{{ fetchInto()
283
284     /**
285      * Places a row from the result set into the given array
286      *
287      * Formating of the array and the data therein are configurable.
288      * See DB_result::fetchInto() for more information.
289      *
290      * This method is not meant to be called directly.  Use
291      * DB_result::fetchInto() instead.  It can't be declared "protected"
292      * because DB_result is a separate object.
293      *
294      * PHP's mSQL extension did weird things with NULL values prior to PHP
295      * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
296      * those versions.
297      *
298      * @param resource $result    the query result resource
299      * @param array    $arr       the referenced array to put the data in
300      * @param int      $fetchmode how the resulting array should be indexed
301      * @param int      $rownum    the row number to fetch (0 = first row)
302      *
303      * @return mixed  DB_OK on success, NULL when the end of a result set is
304      *                 reached or on failure
305      *
306      * @see DB_result::fetchInto()
307      */
308     function fetchInto($result, &$arr, $fetchmode, $rownum = null)
309     {
310         if ($rownum !== null) {
311             if (!@msql_data_seek($result, $rownum)) {
312                 return null;
313             }
314         }
315         if ($fetchmode & DB_FETCHMODE_ASSOC) {
316             $arr = @msql_fetch_array($result, MSQL_ASSOC);
317             if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
318                 $arr = array_change_key_case($arr, CASE_LOWER);
319             }
320         } else {
321             $arr = @msql_fetch_row($result);
322         }
323         if (!$arr) {
324             return null;
325         }
326         if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
327             $this->_rtrimArrayValues($arr);
328         }
329         if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
330             $this->_convertNullArrayValuesToEmpty($arr);
331         }
332         return DB_OK;
333     }
334
335     // }}}
336     // {{{ freeResult()
337
338     /**
339      * Deletes the result set and frees the memory occupied by the result set
340      *
341      * This method is not meant to be called directly.  Use
342      * DB_result::free() instead.  It can't be declared "protected"
343      * because DB_result is a separate object.
344      *
345      * @param resource $result  PHP's query result resource
346      *
347      * @return bool  TRUE on success, FALSE if $result is invalid
348      *
349      * @see DB_result::free()
350      */
351     function freeResult($result)
352     {
353         return is_resource($result) ? msql_free_result($result) : false;
354     }
355
356     // }}}
357     // {{{ numCols()
358
359     /**
360      * Gets the number of columns in a result set
361      *
362      * This method is not meant to be called directly.  Use
363      * DB_result::numCols() instead.  It can't be declared "protected"
364      * because DB_result is a separate object.
365      *
366      * @param resource $result  PHP's query result resource
367      *
368      * @return int  the number of columns.  A DB_Error object on failure.
369      *
370      * @see DB_result::numCols()
371      */
372     function numCols($result)
373     {
374         $cols = @msql_num_fields($result);
375         if (!$cols) {
376             return $this->msqlRaiseError();
377         }
378         return $cols;
379     }
380
381     // }}}
382     // {{{ numRows()
383
384     /**
385      * Gets the number of rows in a result set
386      *
387      * This method is not meant to be called directly.  Use
388      * DB_result::numRows() instead.  It can't be declared "protected"
389      * because DB_result is a separate object.
390      *
391      * @param resource $result  PHP's query result resource
392      *
393      * @return int  the number of rows.  A DB_Error object on failure.
394      *
395      * @see DB_result::numRows()
396      */
397     function numRows($result)
398     {
399         $rows = @msql_num_rows($result);
400         if ($rows === false) {
401             return $this->msqlRaiseError();
402         }
403         return $rows;
404     }
405
406     // }}}
407     // {{{ affected()
408
409     /**
410      * Determines the number of rows affected by a data maniuplation query
411      *
412      * 0 is returned for queries that don't manipulate data.
413      *
414      * @return int  the number of rows.  A DB_Error object on failure.
415      */
416     function affectedRows()
417     {
418         if (!$this->_result) {
419             return 0;
420         }
421         return msql_affected_rows($this->_result);
422     }
423
424     // }}}
425     // {{{ nextId()
426
427     /**
428      * Returns the next free id in a sequence
429      *
430      * @param string  $seq_name  name of the sequence
431      * @param boolean $ondemand  when true, the seqence is automatically
432      *                            created if it does not exist
433      *
434      * @return int  the next id number in the sequence.
435      *               A DB_Error object on failure.
436      *
437      * @see DB_common::nextID(), DB_common::getSequenceName(),
438      *      DB_msql::createSequence(), DB_msql::dropSequence()
439      */
440     function nextId($seq_name, $ondemand = true)
441     {
442         $seqname = $this->getSequenceName($seq_name);
443         $repeat = false;
444         do {
445             $this->pushErrorHandling(PEAR_ERROR_RETURN);
446             $result = $this->query("SELECT _seq FROM ${seqname}");
447             $this->popErrorHandling();
448             if ($ondemand && DB::isError($result) &&
449                 $result->getCode() == DB_ERROR_NOSUCHTABLE) {
450                 $repeat = true;
451                 $this->pushErrorHandling(PEAR_ERROR_RETURN);
452                 $result = $this->createSequence($seq_name);
453                 $this->popErrorHandling();
454                 if (DB::isError($result)) {
455                     return $this->raiseError($result);
456                 }
457             } else {
458                 $repeat = false;
459             }
460         } while ($repeat);
461         if (DB::isError($result)) {
462             return $this->raiseError($result);
463         }
464         $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
465         $result->free();
466         return $arr[0];
467     }
468
469     // }}}
470     // {{{ createSequence()
471
472     /**
473      * Creates a new sequence
474      *
475      * Also creates a new table to associate the sequence with.  Uses
476      * a separate table to ensure portability with other drivers.
477      *
478      * @param string $seq_name  name of the new sequence
479      *
480      * @return int  DB_OK on success.  A DB_Error object on failure.
481      *
482      * @see DB_common::createSequence(), DB_common::getSequenceName(),
483      *      DB_msql::nextID(), DB_msql::dropSequence()
484      */
485     function createSequence($seq_name)
486     {
487         $seqname = $this->getSequenceName($seq_name);
488         $res = $this->query('CREATE TABLE ' . $seqname
489                             . ' (id INTEGER NOT NULL)');
490         if (DB::isError($res)) {
491             return $res;
492         }
493         $res = $this->query("CREATE SEQUENCE ON ${seqname}");
494         return $res;
495     }
496
497     // }}}
498     // {{{ dropSequence()
499
500     /**
501      * Deletes a sequence
502      *
503      * @param string $seq_name  name of the sequence to be deleted
504      *
505      * @return int  DB_OK on success.  A DB_Error object on failure.
506      *
507      * @see DB_common::dropSequence(), DB_common::getSequenceName(),
508      *      DB_msql::nextID(), DB_msql::createSequence()
509      */
510     function dropSequence($seq_name)
511     {
512         return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
513     }
514
515     // }}}
516     // {{{ quoteIdentifier()
517
518     /**
519      * mSQL does not support delimited identifiers
520      *
521      * @param string $str  the identifier name to be quoted
522      *
523      * @return object  a DB_Error object
524      *
525      * @see DB_common::quoteIdentifier()
526      * @since Method available since Release 1.7.0
527      */
528     function quoteIdentifier($str)
529     {
530         return $this->raiseError(DB_ERROR_UNSUPPORTED);
531     }
532
533     // }}}
534     // {{{ quoteFloat()
535
536     /**
537      * Formats a float value for use within a query in a locale-independent
538      * manner.
539      *
540      * @param float the float value to be quoted.
541      * @return string the quoted string.
542      * @see DB_common::quoteSmart()
543      * @since Method available since release 1.7.8.
544      */
545     function quoteFloat($float) {
546         return $this->escapeSimple(str_replace(',', '.', strval(floatval($float))));
547     }
548      
549     // }}}
550     // {{{ escapeSimple()
551
552     /**
553      * Escapes a string according to the current DBMS's standards
554      *
555      * @param string $str  the string to be escaped
556      *
557      * @return string  the escaped string
558      *
559      * @see DB_common::quoteSmart()
560      * @since Method available since Release 1.7.0
561      */
562     function escapeSimple($str)
563     {
564         return addslashes($str);
565     }
566
567     // }}}
568     // {{{ msqlRaiseError()
569
570     /**
571      * Produces a DB_Error object regarding the current problem
572      *
573      * @param int $errno  if the error is being manually raised pass a
574      *                     DB_ERROR* constant here.  If this isn't passed
575      *                     the error information gathered from the DBMS.
576      *
577      * @return object  the DB_Error object
578      *
579      * @see DB_common::raiseError(),
580      *      DB_msql::errorNative(), DB_msql::errorCode()
581      */
582     function msqlRaiseError($errno = null)
583     {
584         $native = $this->errorNative();
585         if ($errno === null) {
586             $errno = $this->errorCode($native);
587         }
588         return $this->raiseError($errno, null, null, null, $native);
589     }
590
591     // }}}
592     // {{{ errorNative()
593
594     /**
595      * Gets the DBMS' native error message produced by the last query
596      *
597      * @return string  the DBMS' error message
598      */
599     function errorNative()
600     {
601         return @msql_error();
602     }
603
604     // }}}
605     // {{{ errorCode()
606
607     /**
608      * Determines PEAR::DB error code from the database's text error message
609      *
610      * @param string $errormsg  the error message returned from the database
611      *
612      * @return integer  the error number from a DB_ERROR* constant
613      */
614     function errorCode($errormsg)
615     {
616         static $error_regexps;
617         
618         // PHP 5.2+ prepends the function name to $php_errormsg, so we need
619         // this hack to work around it, per bug #9599.
620         $errormsg = preg_replace('/^msql[a-z_]+\(\): /', '', $errormsg);
621
622         if (!isset($error_regexps)) {
623             $error_regexps = array(
624                 '/^Access to database denied/i'
625                     => DB_ERROR_ACCESS_VIOLATION,
626                 '/^Bad index name/i'
627                     => DB_ERROR_ALREADY_EXISTS,
628                 '/^Bad order field/i'
629                     => DB_ERROR_SYNTAX,
630                 '/^Bad type for comparison/i'
631                     => DB_ERROR_SYNTAX,
632                 '/^Can\'t perform LIKE on/i'
633                     => DB_ERROR_SYNTAX,
634                 '/^Can\'t use TEXT fields in LIKE comparison/i'
635                     => DB_ERROR_SYNTAX,
636                 '/^Couldn\'t create temporary table/i'
637                     => DB_ERROR_CANNOT_CREATE,
638                 '/^Error creating table file/i'
639                     => DB_ERROR_CANNOT_CREATE,
640                 '/^Field .* cannot be null$/i'
641                     => DB_ERROR_CONSTRAINT_NOT_NULL,
642                 '/^Index (field|condition) .* cannot be null$/i'
643                     => DB_ERROR_SYNTAX,
644                 '/^Invalid date format/i'
645                     => DB_ERROR_INVALID_DATE,
646                 '/^Invalid time format/i'
647                     => DB_ERROR_INVALID,
648                 '/^Literal value for .* is wrong type$/i'
649                     => DB_ERROR_INVALID_NUMBER,
650                 '/^No Database Selected/i'
651                     => DB_ERROR_NODBSELECTED,
652                 '/^No value specified for field/i'
653                     => DB_ERROR_VALUE_COUNT_ON_ROW,
654                 '/^Non unique value for unique index/i'
655                     => DB_ERROR_CONSTRAINT,
656                 '/^Out of memory for temporary table/i'
657                     => DB_ERROR_CANNOT_CREATE,
658                 '/^Permission denied/i'
659                     => DB_ERROR_ACCESS_VIOLATION,
660                 '/^Reference to un-selected table/i'
661                     => DB_ERROR_SYNTAX,
662                 '/^syntax error/i'
663                     => DB_ERROR_SYNTAX,
664                 '/^Table .* exists$/i'
665                     => DB_ERROR_ALREADY_EXISTS,
666                 '/^Unknown database/i'
667                     => DB_ERROR_NOSUCHDB,
668                 '/^Unknown field/i'
669                     => DB_ERROR_NOSUCHFIELD,
670                 '/^Unknown (index|system variable)/i'
671                     => DB_ERROR_NOT_FOUND,
672                 '/^Unknown table/i'
673                     => DB_ERROR_NOSUCHTABLE,
674                 '/^Unqualified field/i'
675                     => DB_ERROR_SYNTAX,
676             );
677         }
678
679         foreach ($error_regexps as $regexp => $code) {
680             if (preg_match($regexp, $errormsg)) {
681                 return $code;
682             }
683         }
684         return DB_ERROR;
685     }
686
687     // }}}
688     // {{{ tableInfo()
689
690     /**
691      * Returns information about a table or a result set
692      *
693      * @param object|string  $result  DB_result object from a query or a
694      *                                 string containing the name of a table.
695      *                                 While this also accepts a query result
696      *                                 resource identifier, this behavior is
697      *                                 deprecated.
698      * @param int            $mode    a valid tableInfo mode
699      *
700      * @return array  an associative array with the information requested.
701      *                 A DB_Error object on failure.
702      *
703      * @see DB_common::setOption()
704      */
705     function tableInfo($result, $mode = null)
706     {
707         if (is_string($result)) {
708             /*
709              * Probably received a table name.
710              * Create a result resource identifier.
711              */
712             $id = @msql_query("SELECT * FROM $result",
713                               $this->connection);
714             $got_string = true;
715         } elseif (isset($result->result)) {
716             /*
717              * Probably received a result object.
718              * Extract the result resource identifier.
719              */
720             $id = $result->result;
721             $got_string = false;
722         } else {
723             /*
724              * Probably received a result resource identifier.
725              * Copy it.
726              * Deprecated.  Here for compatibility only.
727              */
728             $id = $result;
729             $got_string = false;
730         }
731
732         if (!is_resource($id)) {
733             return $this->raiseError(DB_ERROR_NEED_MORE_DATA);
734         }
735
736         if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
737             $case_func = 'strtolower';
738         } else {
739             $case_func = 'strval';
740         }
741
742         $count = @msql_num_fields($id);
743         $res   = array();
744
745         if ($mode) {
746             $res['num_fields'] = $count;
747         }
748
749         for ($i = 0; $i < $count; $i++) {
750             $tmp = @msql_fetch_field($id);
751
752             $flags = '';
753             if ($tmp->not_null) {
754                 $flags .= 'not_null ';
755             }
756             if ($tmp->unique) {
757                 $flags .= 'unique_key ';
758             }
759             $flags = trim($flags);
760
761             $res[$i] = array(
762                 'table' => $case_func($tmp->table),
763                 'name'  => $case_func($tmp->name),
764                 'type'  => $tmp->type,
765                 'len'   => msql_field_len($id, $i),
766                 'flags' => $flags,
767             );
768
769             if ($mode & DB_TABLEINFO_ORDER) {
770                 $res['order'][$res[$i]['name']] = $i;
771             }
772             if ($mode & DB_TABLEINFO_ORDERTABLE) {
773                 $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
774             }
775         }
776
777         // free the result only if we were called on a table
778         if ($got_string) {
779             @msql_free_result($id);
780         }
781         return $res;
782     }
783
784     // }}}
785     // {{{ getSpecialQuery()
786
787     /**
788      * Obtain a list of a given type of objects
789      *
790      * @param string $type  the kind of objects you want to retrieve
791      *
792      * @return array  the array containing the list of objects requested
793      *
794      * @access protected
795      * @see DB_common::getListOf()
796      */
797     function getSpecialQuery($type)
798     {
799         switch ($type) {
800             case 'databases':
801                 $id = @msql_list_dbs($this->connection);
802                 break;
803             case 'tables':
804                 $id = @msql_list_tables($this->dsn['database'],
805                                         $this->connection);
806                 break;
807             default:
808                 return null;
809         }
810         if (!$id) {
811             return $this->msqlRaiseError();
812         }
813         $out = array();
814         while ($row = @msql_fetch_row($id)) {
815             $out[] = $row[0];
816         }
817         return $out;
818     }
819
820     // }}}
821
822 }
823
824 /*
825  * Local variables:
826  * tab-width: 4
827  * c-basic-offset: 4
828  * End:
829  */
830
831 ?>