Peter M. Groen / knowledgetree

Commit affd3e45e87cfcc7beaf030688792a03086453ae

Authored by nbm 2004-11-27 06:44:43 +0000

PEAR DB from DB-1.6.8


git-svn-id: https://kt-dms.svn.sourceforge.net/svnroot/kt-dms/trunk@3009 c91229c3-7414-0410-bfa2-8a42b809f60b

Inline Side-by-side

Showing 16 changed files with 12611 additions and 0 deletions

pear/DB.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Authors: Stig Bakken <ssb@php.net> \|
		17	+// \| Tomas V.V.Cox <cox@idecnet.com> \|
		18	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		19	+// +----------------------------------------------------------------------+
		20	+//
		21	+// $Id$
		22	+//
		23	+// Database independent query interface.
		24	+
		25	+
		26	+require_once 'PEAR.php';
		27	+
		28	+// {{{ constants
		29	+// {{{ error codes
		30	+
		31	+/*
		32	+ * The method mapErrorCode in each DB_dbtype implementation maps
		33	+ * native error codes to one of these.
		34	+ *
		35	+ * If you add an error code here, make sure you also add a textual
		36	+ * version of it in DB::errorMessage().
		37	+ */
		38	+define('DB_OK', 1);
		39	+define('DB_ERROR', -1);
		40	+define('DB_ERROR_SYNTAX', -2);
		41	+define('DB_ERROR_CONSTRAINT', -3);
		42	+define('DB_ERROR_NOT_FOUND', -4);
		43	+define('DB_ERROR_ALREADY_EXISTS', -5);
		44	+define('DB_ERROR_UNSUPPORTED', -6);
		45	+define('DB_ERROR_MISMATCH', -7);
		46	+define('DB_ERROR_INVALID', -8);
		47	+define('DB_ERROR_NOT_CAPABLE', -9);
		48	+define('DB_ERROR_TRUNCATED', -10);
		49	+define('DB_ERROR_INVALID_NUMBER', -11);
		50	+define('DB_ERROR_INVALID_DATE', -12);
		51	+define('DB_ERROR_DIVZERO', -13);
		52	+define('DB_ERROR_NODBSELECTED', -14);
		53	+define('DB_ERROR_CANNOT_CREATE', -15);
		54	+define('DB_ERROR_CANNOT_DELETE', -16);
		55	+define('DB_ERROR_CANNOT_DROP', -17);
		56	+define('DB_ERROR_NOSUCHTABLE', -18);
		57	+define('DB_ERROR_NOSUCHFIELD', -19);
		58	+define('DB_ERROR_NEED_MORE_DATA', -20);
		59	+define('DB_ERROR_NOT_LOCKED', -21);
		60	+define('DB_ERROR_VALUE_COUNT_ON_ROW', -22);
		61	+define('DB_ERROR_INVALID_DSN', -23);
		62	+define('DB_ERROR_CONNECT_FAILED', -24);
		63	+define('DB_ERROR_EXTENSION_NOT_FOUND',-25);
		64	+define('DB_ERROR_ACCESS_VIOLATION', -26);
		65	+define('DB_ERROR_NOSUCHDB', -27);
		66	+define('DB_ERROR_CONSTRAINT_NOT_NULL',-29);
		67	+
		68	+
		69	+// }}}
		70	+// {{{ prepared statement-related
		71	+
		72	+
		73	+/*
		74	+ * These constants are used when storing information about prepared
		75	+ * statements (using the "prepare" method in DB_dbtype).
		76	+ *
		77	+ * The prepare/execute model in DB is mostly borrowed from the ODBC
		78	+ * extension, in a query the "?" character means a scalar parameter.
		79	+ * There are two extensions though, a "&" character means an opaque
		80	+ * parameter. An opaque parameter is simply a file name, the real
		81	+ * data are in that file (useful for putting uploaded files into your
		82	+ * database and such). The "!" char means a parameter that must be
		83	+ * left as it is.
		84	+ * They modify the quote behavoir:
		85	+ * DB_PARAM_SCALAR (?) => 'original string quoted'
		86	+ * DB_PARAM_OPAQUE (&) => 'string from file quoted'
		87	+ * DB_PARAM_MISC (!) => original string
		88	+ */
		89	+define('DB_PARAM_SCALAR', 1);
		90	+define('DB_PARAM_OPAQUE', 2);
		91	+define('DB_PARAM_MISC', 3);
		92	+
		93	+
		94	+// }}}
		95	+// {{{ binary data-related
		96	+
		97	+
		98	+/*
		99	+ * These constants define different ways of returning binary data
		100	+ * from queries. Again, this model has been borrowed from the ODBC
		101	+ * extension.
		102	+ *
		103	+ * DB_BINMODE_PASSTHRU sends the data directly through to the browser
		104	+ * when data is fetched from the database.
		105	+ * DB_BINMODE_RETURN lets you return data as usual.
		106	+ * DB_BINMODE_CONVERT returns data as well, only it is converted to
		107	+ * hex format, for example the string "123" would become "313233".
		108	+ */
		109	+define('DB_BINMODE_PASSTHRU', 1);
		110	+define('DB_BINMODE_RETURN', 2);
		111	+define('DB_BINMODE_CONVERT', 3);
		112	+
		113	+
		114	+// }}}
		115	+// {{{ fetch modes
		116	+
		117	+
		118	+/**
		119	+ * This is a special constant that tells DB the user hasn't specified
		120	+ * any particular get mode, so the default should be used.
		121	+ */
		122	+define('DB_FETCHMODE_DEFAULT', 0);
		123	+
		124	+/**
		125	+ * Column data indexed by numbers, ordered from 0 and up
		126	+ */
		127	+define('DB_FETCHMODE_ORDERED', 1);
		128	+
		129	+/**
		130	+ * Column data indexed by column names
		131	+ */
		132	+define('DB_FETCHMODE_ASSOC', 2);
		133	+
		134	+/**
		135	+ * Column data as object properties
		136	+ */
		137	+define('DB_FETCHMODE_OBJECT', 3);
		138	+
		139	+/**
		140	+ * For multi-dimensional results: normally the first level of arrays
		141	+ * is the row number, and the second level indexed by column number or name.
		142	+ * DB_FETCHMODE_FLIPPED switches this order, so the first level of arrays
		143	+ * is the column name, and the second level the row number.
		144	+ */
		145	+define('DB_FETCHMODE_FLIPPED', 4);
		146	+
		147	+/* for compatibility */
		148	+define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);
		149	+define('DB_GETMODE_ASSOC', DB_FETCHMODE_ASSOC);
		150	+define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);
		151	+
		152	+
		153	+// }}}
		154	+// {{{ tableInfo() && autoPrepare()-related
		155	+
		156	+
		157	+/**
		158	+ * these are constants for the tableInfo-function
		159	+ * they are bitwised or'ed. so if there are more constants to be defined
		160	+ * in the future, adjust DB_TABLEINFO_FULL accordingly
		161	+ */
		162	+define('DB_TABLEINFO_ORDER', 1);
		163	+define('DB_TABLEINFO_ORDERTABLE', 2);
		164	+define('DB_TABLEINFO_FULL', 3);
		165	+
		166	+/*
		167	+ * Used by autoPrepare()
		168	+ */
		169	+define('DB_AUTOQUERY_INSERT', 1);
		170	+define('DB_AUTOQUERY_UPDATE', 2);
		171	+
		172	+
		173	+// }}}
		174	+// {{{ portability modes
		175	+
		176	+
		177	+/**
		178	+ * Portability: turn off all portability features.
		179	+ * @see DB_common::setOption()
		180	+ */
		181	+define('DB_PORTABILITY_NONE', 0);
		182	+
		183	+/**
		184	+ * Portability: convert names of tables and fields to lower case
		185	+ * when using the get(), fetch() and tableInfo() methods.
		186	+ * @see DB_common::setOption()
		187	+ */
		188	+define('DB_PORTABILITY_LOWERCASE', 1);
		189	+
		190	+/**
		191	+ * Portability: right trim the data output by get() and fetch().
		192	+ * @see DB_common::setOption()
		193	+ */
		194	+define('DB_PORTABILITY_RTRIM', 2);
		195	+
		196	+/**
		197	+ * Portability: force reporting the number of rows deleted.
		198	+ * @see DB_common::setOption()
		199	+ */
		200	+define('DB_PORTABILITY_DELETE_COUNT', 4);
		201	+
		202	+/**
		203	+ * Portability: enable hack that makes numRows() work in Oracle.
		204	+ * @see DB_common::setOption()
		205	+ */
		206	+define('DB_PORTABILITY_NUMROWS', 8);
		207	+
		208	+/**
		209	+ * Portability: makes certain error messages in certain drivers compatible
		210	+ * with those from other DBMS's.
		211	+ *
		212	+ * + mysql, mysqli: change unique/primary key constraints
		213	+ * DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT
		214	+ *
		215	+ * + odbc(access): MS's ODBC driver reports 'no such field' as code
		216	+ * 07001, which means 'too few parameters.' When this option is on
		217	+ * that code gets mapped to DB_ERROR_NOSUCHFIELD.
		218	+ *
		219	+ * @see DB_common::setOption()
		220	+ */
		221	+define('DB_PORTABILITY_ERRORS', 16);
		222	+
		223	+/**
		224	+ * Portability: convert null values to empty strings in data output by
		225	+ * get() and fetch().
		226	+ * @see DB_common::setOption()
		227	+ */
		228	+define('DB_PORTABILITY_NULL_TO_EMPTY', 32);
		229	+
		230	+/**
		231	+ * Portability: turn on all portability features.
		232	+ * @see DB_common::setOption()
		233	+ */
		234	+define('DB_PORTABILITY_ALL', 63);
		235	+
		236	+// }}}
		237	+
		238	+
		239	+// }}}
		240	+// {{{ class DB
		241	+
		242	+/**
		243	+ * The main "DB" class is simply a container class with some static
		244	+ * methods for creating DB objects as well as some utility functions
		245	+ * common to all parts of DB.
		246	+ *
		247	+ * The object model of DB is as follows (indentation means inheritance):
		248	+ *
		249	+ * DB The main DB class. This is simply a utility class
		250	+ * with some "static" methods for creating DB objects as
		251	+ * well as common utility functions for other DB classes.
		252	+ *
		253	+ * DB_common The base for each DB implementation. Provides default
		254	+ * \| implementations (in OO lingo virtual methods) for
		255	+ * \| the actual DB implementations as well as a bunch of
		256	+ * \| query utility functions.
		257	+ * \|
		258	+ * +-DB_mysql The DB implementation for MySQL. Inherits DB_common.
		259	+ * When calling DB::factory or DB::connect for MySQL
		260	+ * connections, the object returned is an instance of this
		261	+ * class.
		262	+ *
		263	+ * @package DB
		264	+ * @author Stig Bakken <ssb@php.net>
		265	+ * @author Tomas V.V.Cox <cox@idecnet.com>
		266	+ * @since PHP 4.0
		267	+ * @version $Id$
		268	+ * @category Database
		269	+ */
		270	+class DB
		271	+{
		272	+ // {{{ &factory()
		273	+
		274	+ /**
		275	+ * Create a new DB object for the specified database type.
		276	+ *
		277	+ * Allows creation of a DB_<driver> object from which the object's
		278	+ * methods can be utilized without actually connecting to a database.
		279	+ *
		280	+ * @param string $type database type, for example "mysql"
		281	+ * @param array $options associative array of option names and values
		282	+ *
		283	+ * @return object a new DB object. On error, an error object.
		284	+ *
		285	+ * @see DB_common::setOption()
		286	+ * @access public
		287	+ */
		288	+ function &factory($type, $options = false)
		289	+ {
		290	+ if (!is_array($options)) {
		291	+ $options = array('persistent' => $options);
		292	+ }
		293	+
		294	+ if (isset($options['debug']) && $options['debug'] >= 2) {
		295	+ // expose php errors with sufficient debug level
		296	+ include_once "DB/{$type}.php";
		297	+ } else {
		298	+ @include_once "DB/{$type}.php";
		299	+ }
		300	+
		301	+ $classname = "DB_${type}";
		302	+
		303	+ if (!class_exists($classname)) {
		304	+ $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,
		305	+ "Unable to include the DB/{$type}.php file",
		306	+ 'DB_Error', true);
		307	+ return $tmp;
		308	+ }
		309	+
		310	+ @$obj =& new $classname;
		311	+
		312	+ foreach ($options as $option => $value) {
		313	+ $test = $obj->setOption($option, $value);
		314	+ if (DB::isError($test)) {
		315	+ return $test;
		316	+ }
		317	+ }
		318	+
		319	+ return $obj;
		320	+ }
		321	+
		322	+ // }}}
		323	+ // {{{ &connect()
		324	+
		325	+ /**
		326	+ * Create a new DB object and connect to the specified database.
		327	+ *
		328	+ * Example 1.
		329	+ * <code> <?php
		330	+ * require_once 'DB.php';
		331	+ *
		332	+ * $dsn = 'mysql://user:password@host/database'
		333	+ * $options = array(
		334	+ * 'debug' => 2,
		335	+ * 'portability' => DB_PORTABILITY_ALL,
		336	+ * );
		337	+ *
		338	+ * $dbh =& DB::connect($dsn, $options);
		339	+ * if (DB::isError($dbh)) {
		340	+ * die($dbh->getMessage());
		341	+ * }
		342	+ * ?></code>
		343	+ *
		344	+ * @param mixed $dsn string "data source name" or an array in the
		345	+ * format returned by DB::parseDSN()
		346	+ *
		347	+ * @param array $options an associative array of option names and
		348	+ * their values
		349	+ *
		350	+ * @return object a newly created DB connection object, or a DB
		351	+ * error object on error
		352	+ *
		353	+ * @see DB::parseDSN(), DB_common::setOption(), DB::isError()
		354	+ * @access public
		355	+ */
		356	+ function &connect($dsn, $options = array())
		357	+ {
		358	+ $dsninfo = DB::parseDSN($dsn);
		359	+ $type = $dsninfo['phptype'];
		360	+
		361	+ if (!is_array($options)) {
		362	+ /*
		363	+ * For backwards compatibility. $options used to be boolean,
		364	+ * indicating whether the connection should be persistent.
		365	+ */
		366	+ $options = array('persistent' => $options);
		367	+ }
		368	+
		369	+ if (isset($options['debug']) && $options['debug'] >= 2) {
		370	+ // expose php errors with sufficient debug level
		371	+ include_once "DB/${type}.php";
		372	+ } else {
		373	+ @include_once "DB/${type}.php";
		374	+ }
		375	+
		376	+ $classname = "DB_${type}";
		377	+ if (!class_exists($classname)) {
		378	+ $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,
		379	+ "Unable to include the DB/{$type}.php file for `$dsn'",
		380	+ 'DB_Error', true);
		381	+ return $tmp;
		382	+ }
		383	+
		384	+ @$obj =& new $classname;
		385	+
		386	+ foreach ($options as $option => $value) {
		387	+ $test = $obj->setOption($option, $value);
		388	+ if (DB::isError($test)) {
		389	+ return $test;
		390	+ }
		391	+ }
		392	+
		393	+ $err = $obj->connect($dsninfo, $obj->getOption('persistent'));
		394	+ if (DB::isError($err)) {
		395	+ $err->addUserInfo($dsn);
		396	+ return $err;
		397	+ }
		398	+
		399	+ return $obj;
		400	+ }
		401	+
		402	+ // }}}
		403	+ // {{{ apiVersion()
		404	+
		405	+ /**
		406	+ * Return the DB API version
		407	+ *
		408	+ * @return int the DB API version number
		409	+ *
		410	+ * @access public
		411	+ */
		412	+ function apiVersion()
		413	+ {
		414	+ return 2;
		415	+ }
		416	+
		417	+ // }}}
		418	+ // {{{ isError()
		419	+
		420	+ /**
		421	+ * Tell whether a result code from a DB method is an error
		422	+ *
		423	+ * @param int $value result code
		424	+ *
		425	+ * @return bool whether $value is an error
		426	+ *
		427	+ * @access public
		428	+ */
		429	+ function isError($value)
		430	+ {
		431	+ return is_a($value, 'DB_Error');
		432	+ }
		433	+
		434	+ // }}}
		435	+ // {{{ isConnection()
		436	+
		437	+ /**
		438	+ * Tell whether a value is a DB connection
		439	+ *
		440	+ * @param mixed $value value to test
		441	+ *
		442	+ * @return bool whether $value is a DB connection
		443	+ *
		444	+ * @access public
		445	+ */
		446	+ function isConnection($value)
		447	+ {
		448	+ return (is_object($value) &&
		449	+ is_subclass_of($value, 'db_common') &&
		450	+ method_exists($value, 'simpleQuery'));
		451	+ }
		452	+
		453	+ // }}}
		454	+ // {{{ isManip()
		455	+
		456	+ /**
		457	+ * Tell whether a query is a data manipulation query (insert,
		458	+ * update or delete) or a data definition query (create, drop,
		459	+ * alter, grant, revoke).
		460	+ *
		461	+ * @access public
		462	+ *
		463	+ * @param string $query the query
		464	+ *
		465	+ * @return boolean whether $query is a data manipulation query
		466	+ */
		467	+ function isManip($query)
		468	+ {
		469	+ $manips = 'INSERT\|UPDATE\|DELETE\|LOAD DATA\|'.'REPLACE\|CREATE\|DROP\|'.
		470	+ 'ALTER\|GRANT\|REVOKE\|'.'LOCK\|UNLOCK';
		471	+ if (preg_match('/^\s*"?('.$manips.')\s+/i', $query)) {
		472	+ return true;
		473	+ }
		474	+ return false;
		475	+ }
		476	+
		477	+ // }}}
		478	+ // {{{ errorMessage()
		479	+
		480	+ /**
		481	+ * Return a textual error message for a DB error code
		482	+ *
		483	+ * @param integer $value error code
		484	+ *
		485	+ * @return string error message, or false if the error code was
		486	+ * not recognized
		487	+ */
		488	+ function errorMessage($value)
		489	+ {
		490	+ static $errorMessages;
		491	+ if (!isset($errorMessages)) {
		492	+ $errorMessages = array(
		493	+ DB_ERROR => 'unknown error',
		494	+ DB_ERROR_ALREADY_EXISTS => 'already exists',
		495	+ DB_ERROR_CANNOT_CREATE => 'can not create',
		496	+ DB_ERROR_CANNOT_DELETE => 'can not delete',
		497	+ DB_ERROR_CANNOT_DROP => 'can not drop',
		498	+ DB_ERROR_CONSTRAINT => 'constraint violation',
		499	+ DB_ERROR_CONSTRAINT_NOT_NULL=> 'null value violates not-null constraint',
		500	+ DB_ERROR_DIVZERO => 'division by zero',
		501	+ DB_ERROR_INVALID => 'invalid',
		502	+ DB_ERROR_INVALID_DATE => 'invalid date or time',
		503	+ DB_ERROR_INVALID_NUMBER => 'invalid number',
		504	+ DB_ERROR_MISMATCH => 'mismatch',
		505	+ DB_ERROR_NODBSELECTED => 'no database selected',
		506	+ DB_ERROR_NOSUCHFIELD => 'no such field',
		507	+ DB_ERROR_NOSUCHTABLE => 'no such table',
		508	+ DB_ERROR_NOT_CAPABLE => 'DB backend not capable',
		509	+ DB_ERROR_NOT_FOUND => 'not found',
		510	+ DB_ERROR_NOT_LOCKED => 'not locked',
		511	+ DB_ERROR_SYNTAX => 'syntax error',
		512	+ DB_ERROR_UNSUPPORTED => 'not supported',
		513	+ DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',
		514	+ DB_ERROR_INVALID_DSN => 'invalid DSN',
		515	+ DB_ERROR_CONNECT_FAILED => 'connect failed',
		516	+ DB_OK => 'no error',
		517	+ DB_ERROR_NEED_MORE_DATA => 'insufficient data supplied',
		518	+ DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found',
		519	+ DB_ERROR_NOSUCHDB => 'no such database',
		520	+ DB_ERROR_ACCESS_VIOLATION => 'insufficient permissions',
		521	+ DB_ERROR_TRUNCATED => 'truncated'
		522	+ );
		523	+ }
		524	+
		525	+ if (DB::isError($value)) {
		526	+ $value = $value->getCode();
		527	+ }
		528	+
		529	+ return isset($errorMessages[$value]) ? $errorMessages[$value] : $errorMessages[DB_ERROR];
		530	+ }
		531	+
		532	+ // }}}
		533	+ // {{{ parseDSN()
		534	+
		535	+ /**
		536	+ * Parse a data source name.
		537	+ *
		538	+ * Additional keys can be added by appending a URI query string to the
		539	+ * end of the DSN.
		540	+ *
		541	+ * The format of the supplied DSN is in its fullest form:
		542	+ * <code>
		543	+ * phptype(dbsyntax)://username:password@protocol+hostspec/database?option=8&another=true
		544	+ * </code>
		545	+ *
		546	+ * Most variations are allowed:
		547	+ * <code>
		548	+ * phptype://username:password@protocol+hostspec:110//usr/db_file.db?mode=0644
		549	+ * phptype://username:password@hostspec/database_name
		550	+ * phptype://username:password@hostspec
		551	+ * phptype://username@hostspec
		552	+ * phptype://hostspec/database
		553	+ * phptype://hostspec
		554	+ * phptype(dbsyntax)
		555	+ * phptype
		556	+ * </code>
		557	+ *
		558	+ * @param string $dsn Data Source Name to be parsed
		559	+ *
		560	+ * @return array an associative array with the following keys:
		561	+ * + phptype: Database backend used in PHP (mysql, odbc etc.)
		562	+ * + dbsyntax: Database used with regards to SQL syntax etc.
		563	+ * + protocol: Communication protocol to use (tcp, unix etc.)
		564	+ * + hostspec: Host specification (hostname[:port])
		565	+ * + database: Database to use on the DBMS server
		566	+ * + username: User name for login
		567	+ * + password: Password for login
		568	+ *
		569	+ * @author Tomas V.V.Cox <cox@idecnet.com>
		570	+ */
		571	+ function parseDSN($dsn)
		572	+ {
		573	+ $parsed = array(
		574	+ 'phptype' => false,
		575	+ 'dbsyntax' => false,
		576	+ 'username' => false,
		577	+ 'password' => false,
		578	+ 'protocol' => false,
		579	+ 'hostspec' => false,
		580	+ 'port' => false,
		581	+ 'socket' => false,
		582	+ 'database' => false,
		583	+ );
		584	+
		585	+ if (is_array($dsn)) {
		586	+ $dsn = array_merge($parsed, $dsn);
		587	+ if (!$dsn['dbsyntax']) {
		588	+ $dsn['dbsyntax'] = $dsn['phptype'];
		589	+ }
		590	+ return $dsn;
		591	+ }
		592	+
		593	+ // Find phptype and dbsyntax
		594	+ if (($pos = strpos($dsn, '://')) !== false) {
		595	+ $str = substr($dsn, 0, $pos);
		596	+ $dsn = substr($dsn, $pos + 3);
		597	+ } else {
		598	+ $str = $dsn;
		599	+ $dsn = null;
		600	+ }
		601	+
		602	+ // Get phptype and dbsyntax
		603	+ // $str => phptype(dbsyntax)
		604	+ if (preg_match('\|^(.+?)$(.*?)$$\|', $str, $arr)) {
		605	+ $parsed['phptype'] = $arr[1];
		606	+ $parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2];
		607	+ } else {
		608	+ $parsed['phptype'] = $str;
		609	+ $parsed['dbsyntax'] = $str;
		610	+ }
		611	+
		612	+ if (!count($dsn)) {
		613	+ return $parsed;
		614	+ }
		615	+
		616	+ // Get (if found): username and password
		617	+ // $dsn => username:password@protocol+hostspec/database
		618	+ if (($at = strrpos($dsn,'@')) !== false) {
		619	+ $str = substr($dsn, 0, $at);
		620	+ $dsn = substr($dsn, $at + 1);
		621	+ if (($pos = strpos($str, ':')) !== false) {
		622	+ $parsed['username'] = rawurldecode(substr($str, 0, $pos));
		623	+ $parsed['password'] = rawurldecode(substr($str, $pos + 1));
		624	+ } else {
		625	+ $parsed['username'] = rawurldecode($str);
		626	+ }
		627	+ }
		628	+
		629	+ // Find protocol and hostspec
		630	+
		631	+ // $dsn => proto(proto_opts)/database
		632	+ if (preg_match('\|^([^(]+)$(.?)$/?(.?)$\|', $dsn, $match)) {
		633	+ $proto = $match[1];
		634	+ $proto_opts = $match[2] ? $match[2] : false;
		635	+ $dsn = $match[3];
		636	+
		637	+ // $dsn => protocol+hostspec/database (old format)
		638	+ } else {
		639	+ if (strpos($dsn, '+') !== false) {
		640	+ list($proto, $dsn) = explode('+', $dsn, 2);
		641	+ }
		642	+ if (strpos($dsn, '/') !== false) {
		643	+ list($proto_opts, $dsn) = explode('/', $dsn, 2);
		644	+ } else {
		645	+ $proto_opts = $dsn;
		646	+ $dsn = null;
		647	+ }
		648	+ }
		649	+
		650	+ // process the different protocol options
		651	+ $parsed['protocol'] = (!empty($proto)) ? $proto : 'tcp';
		652	+ $proto_opts = rawurldecode($proto_opts);
		653	+ if ($parsed['protocol'] == 'tcp') {
		654	+ if (strpos($proto_opts, ':') !== false) {
		655	+ list($parsed['hostspec'], $parsed['port']) = explode(':', $proto_opts);
		656	+ } else {
		657	+ $parsed['hostspec'] = $proto_opts;
		658	+ }
		659	+ } elseif ($parsed['protocol'] == 'unix') {
		660	+ $parsed['socket'] = $proto_opts;
		661	+ }
		662	+
		663	+ // Get dabase if any
		664	+ // $dsn => database
		665	+ if ($dsn) {
		666	+ // /database
		667	+ if (($pos = strpos($dsn, '?')) === false) {
		668	+ $parsed['database'] = rawurldecode($dsn);
		669	+ // /database?param1=value1&param2=value2
		670	+ } else {
		671	+ $parsed['database'] = rawurldecode(substr($dsn, 0, $pos));
		672	+ $dsn = substr($dsn, $pos + 1);
		673	+ if (strpos($dsn, '&') !== false) {
		674	+ $opts = explode('&', $dsn);
		675	+ } else { // database?param1=value1
		676	+ $opts = array($dsn);
		677	+ }
		678	+ foreach ($opts as $opt) {
		679	+ list($key, $value) = explode('=', $opt);
		680	+ if (!isset($parsed[$key])) {
		681	+ // don't allow params overwrite
		682	+ $parsed[$key] = rawurldecode($value);
		683	+ }
		684	+ }
		685	+ }
		686	+ }
		687	+
		688	+ return $parsed;
		689	+ }
		690	+
		691	+ // }}}
		692	+ // {{{ assertExtension()
		693	+
		694	+ /**
		695	+ * Load a PHP database extension if it is not loaded already.
		696	+ *
		697	+ * @access public
		698	+ *
		699	+ * @param string $name the base name of the extension (without the .so or
		700	+ * .dll suffix)
		701	+ *
		702	+ * @return boolean true if the extension was already or successfully
		703	+ * loaded, false if it could not be loaded
		704	+ */
		705	+ function assertExtension($name)
		706	+ {
		707	+ if (!extension_loaded($name)) {
		708	+ $dlext = OS_WINDOWS ? '.dll' : '.so';
		709	+ $dlprefix = OS_WINDOWS ? 'php_' : '';
		710	+ @dl($dlprefix . $name . $dlext);
		711	+ return extension_loaded($name);
		712	+ }
		713	+ return true;
		714	+ }
		715	+ // }}}
		716	+}
		717	+
		718	+// }}}
		719	+// {{{ class DB_Error
		720	+
		721	+/**
		722	+ * DB_Error implements a class for reporting portable database error
		723	+ * messages.
		724	+ *
		725	+ * @package DB
		726	+ * @author Stig Bakken <ssb@php.net>
		727	+ */
		728	+class DB_Error extends PEAR_Error
		729	+{
		730	+ // {{{ constructor
		731	+
		732	+ /**
		733	+ * DB_Error constructor.
		734	+ *
		735	+ * @param mixed $code DB error code, or string with error message.
		736	+ * @param integer $mode what "error mode" to operate in
		737	+ * @param integer $level what error level to use for $mode & PEAR_ERROR_TRIGGER
		738	+ * @param mixed $debuginfo additional debug info, such as the last query
		739	+ *
		740	+ * @access public
		741	+ *
		742	+ * @see PEAR_Error
		743	+ */
		744	+ function DB_Error($code = DB_ERROR, $mode = PEAR_ERROR_RETURN,
		745	+ $level = E_USER_NOTICE, $debuginfo = null)
		746	+ {
		747	+ if (is_int($code)) {
		748	+ $this->PEAR_Error('DB Error: ' . DB::errorMessage($code), $code, $mode, $level, $debuginfo);
		749	+ } else {
		750	+ $this->PEAR_Error("DB Error: $code", DB_ERROR, $mode, $level, $debuginfo);
		751	+ }
		752	+ }
		753	+ // }}}
		754	+}
		755	+
		756	+// }}}
		757	+// {{{ class DB_result
		758	+
		759	+/**
		760	+ * This class implements a wrapper for a DB result set.
		761	+ * A new instance of this class will be returned by the DB implementation
		762	+ * after processing a query that returns data.
		763	+ *
		764	+ * @package DB
		765	+ * @author Stig Bakken <ssb@php.net>
		766	+ */
		767	+class DB_result
		768	+{
		769	+ // {{{ properties
		770	+
		771	+ var $dbh;
		772	+ var $result;
		773	+ var $row_counter = null;
		774	+
		775	+ /**
		776	+ * for limit queries, the row to start fetching
		777	+ * @var integer
		778	+ */
		779	+ var $limit_from = null;
		780	+
		781	+ /**
		782	+ * for limit queries, the number of rows to fetch
		783	+ * @var integer
		784	+ */
		785	+ var $limit_count = null;
		786	+
		787	+ // }}}
		788	+ // {{{ constructor
		789	+
		790	+ /**
		791	+ * DB_result constructor.
		792	+ * @param resource &$dbh DB object reference
		793	+ * @param resource $result result resource id
		794	+ * @param array $options assoc array with optional result options
		795	+ */
		796	+ function DB_result(&$dbh, $result, $options = array())
		797	+ {
		798	+ $this->dbh = &$dbh;
		799	+ $this->result = $result;
		800	+ foreach ($options as $key => $value) {
		801	+ $this->setOption($key, $value);
		802	+ }
		803	+ $this->limit_type = $dbh->features['limit'];
		804	+ $this->autofree = $dbh->options['autofree'];
		805	+ $this->fetchmode = $dbh->fetchmode;
		806	+ $this->fetchmode_object_class = $dbh->fetchmode_object_class;
		807	+ }
		808	+
		809	+ function setOption($key, $value = null)
		810	+ {
		811	+ switch ($key) {
		812	+ case 'limit_from':
		813	+ $this->limit_from = $value; break;
		814	+ case 'limit_count':
		815	+ $this->limit_count = $value; break;
		816	+ }
		817	+ }
		818	+
		819	+ // }}}
		820	+ // {{{ fetchRow()
		821	+
		822	+ /**
		823	+ * Fetch a row of data and return it by reference into an array.
		824	+ *
		825	+ * The type of array returned can be controlled either by setting this
		826	+ * method's <var>$fetchmode</var> parameter or by changing the default
		827	+ * fetch mode setFetchMode() before calling this method.
		828	+ *
		829	+ * There are two options for standardizing the information returned
		830	+ * from databases, ensuring their values are consistent when changing
		831	+ * DBMS's. These portability options can be turned on when creating a
		832	+ * new DB object or by using setOption().
		833	+ *
		834	+ * + <samp>DB_PORTABILITY_LOWERCASE</samp>
		835	+ * convert names of fields to lower case
		836	+ *
		837	+ * + <samp>DB_PORTABILITY_RTRIM</samp>
		838	+ * right trim the data
		839	+ *
		840	+ * @param int $fetchmode how the resulting array should be indexed
		841	+ * @param int $rownum the row number to fetch
		842	+ *
		843	+ * @return array a row of data, null on no more rows or PEAR_Error
		844	+ * object on error
		845	+ *
		846	+ * @see DB_common::setOption(), DB_common::setFetchMode()
		847	+ * @access public
		848	+ */
		849	+ function &fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum=null)
		850	+ {
		851	+ if ($fetchmode === DB_FETCHMODE_DEFAULT) {
		852	+ $fetchmode = $this->fetchmode;
		853	+ }
		854	+ if ($fetchmode === DB_FETCHMODE_OBJECT) {
		855	+ $fetchmode = DB_FETCHMODE_ASSOC;
		856	+ $object_class = $this->fetchmode_object_class;
		857	+ }
		858	+ if ($this->limit_from !== null) {
		859	+ if ($this->row_counter === null) {
		860	+ $this->row_counter = $this->limit_from;
		861	+ // Skip rows
		862	+ if ($this->limit_type == false) {
		863	+ $i = 0;
		864	+ while ($i++ < $this->limit_from) {
		865	+ $this->dbh->fetchInto($this->result, $arr, $fetchmode);
		866	+ }
		867	+ }
		868	+ }
		869	+ if ($this->row_counter >= (
		870	+ $this->limit_from + $this->limit_count))
		871	+ {
		872	+ if ($this->autofree) {
		873	+ $this->free();
		874	+ }
		875	+ $tmp = null;
		876	+ return $tmp;
		877	+ }
		878	+ if ($this->limit_type == 'emulate') {
		879	+ $rownum = $this->row_counter;
		880	+ }
		881	+ $this->row_counter++;
		882	+ }
		883	+ $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
		884	+ if ($res === DB_OK) {
		885	+ if (isset($object_class)) {
		886	+ // default mode specified in DB_common::fetchmode_object_class property
		887	+ if ($object_class == 'stdClass') {
		888	+ $arr = (object) $arr;
		889	+ } else {
		890	+ $arr = &new $object_class($arr);
		891	+ }
		892	+ }
		893	+ return $arr;
		894	+ }
		895	+ if ($res == null && $this->autofree) {
		896	+ $this->free();
		897	+ }
		898	+ return $res;
		899	+ }
		900	+
		901	+ // }}}
		902	+ // {{{ fetchInto()
		903	+
		904	+ /**
		905	+ * Fetch a row of data into an array which is passed by reference.
		906	+ *
		907	+ * The type of array returned can be controlled either by setting this
		908	+ * method's <var>$fetchmode</var> parameter or by changing the default
		909	+ * fetch mode setFetchMode() before calling this method.
		910	+ *
		911	+ * There are two options for standardizing the information returned
		912	+ * from databases, ensuring their values are consistent when changing
		913	+ * DBMS's. These portability options can be turned on when creating a
		914	+ * new DB object or by using setOption().
		915	+ *
		916	+ * + <samp>DB_PORTABILITY_LOWERCASE</samp>
		917	+ * convert names of fields to lower case
		918	+ *
		919	+ * + <samp>DB_PORTABILITY_RTRIM</samp>
		920	+ * right trim the data
		921	+ *
		922	+ * @param array &$arr (reference) array where data from the row
		923	+ * should be placed
		924	+ * @param int $fetchmode how the resulting array should be indexed
		925	+ * @param int $rownum the row number to fetch
		926	+ *
		927	+ * @return mixed DB_OK on success, null on no more rows or
		928	+ * a DB_Error object on error
		929	+ *
		930	+ * @see DB_common::setOption(), DB_common::setFetchMode()
		931	+ * @access public
		932	+ */
		933	+ function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum=null)
		934	+ {
		935	+ if ($fetchmode === DB_FETCHMODE_DEFAULT) {
		936	+ $fetchmode = $this->fetchmode;
		937	+ }
		938	+ if ($fetchmode === DB_FETCHMODE_OBJECT) {
		939	+ $fetchmode = DB_FETCHMODE_ASSOC;
		940	+ $object_class = $this->fetchmode_object_class;
		941	+ }
		942	+ if ($this->limit_from !== null) {
		943	+ if ($this->row_counter === null) {
		944	+ $this->row_counter = $this->limit_from;
		945	+ // Skip rows
		946	+ if ($this->limit_type == false) {
		947	+ $i = 0;
		948	+ while ($i++ < $this->limit_from) {
		949	+ $this->dbh->fetchInto($this->result, $arr, $fetchmode);
		950	+ }
		951	+ }
		952	+ }
		953	+ if ($this->row_counter >= (
		954	+ $this->limit_from + $this->limit_count))
		955	+ {
		956	+ if ($this->autofree) {
		957	+ $this->free();
		958	+ }
		959	+ return null;
		960	+ }
		961	+ if ($this->limit_type == 'emulate') {
		962	+ $rownum = $this->row_counter;
		963	+ }
		964	+
		965	+ $this->row_counter++;
		966	+ }
		967	+ $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
		968	+ if ($res === DB_OK) {
		969	+ if (isset($object_class)) {
		970	+ // default mode specified in DB_common::fetchmode_object_class property
		971	+ if ($object_class == 'stdClass') {
		972	+ $arr = (object) $arr;
		973	+ } else {
		974	+ $arr = new $object_class($arr);
		975	+ }
		976	+ }
		977	+ return DB_OK;
		978	+ }
		979	+ if ($res == null && $this->autofree) {
		980	+ $this->free();
		981	+ }
		982	+ return $res;
		983	+ }
		984	+
		985	+ // }}}
		986	+ // {{{ numCols()
		987	+
		988	+ /**
		989	+ * Get the the number of columns in a result set.
		990	+ *
		991	+ * @return int the number of columns, or a DB error
		992	+ *
		993	+ * @access public
		994	+ */
		995	+ function numCols()
		996	+ {
		997	+ return $this->dbh->numCols($this->result);
		998	+ }
		999	+
		1000	+ // }}}
		1001	+ // {{{ numRows()
		1002	+
		1003	+ /**
		1004	+ * Get the number of rows in a result set.
		1005	+ *
		1006	+ * @return int the number of rows, or a DB error
		1007	+ *
		1008	+ * @access public
		1009	+ */
		1010	+ function numRows()
		1011	+ {
		1012	+ return $this->dbh->numRows($this->result);
		1013	+ }
		1014	+
		1015	+ // }}}
		1016	+ // {{{ nextResult()
		1017	+
		1018	+ /**
		1019	+ * Get the next result if a batch of queries was executed.
		1020	+ *
		1021	+ * @return bool true if a new result is available or false if not.
		1022	+ *
		1023	+ * @access public
		1024	+ */
		1025	+ function nextResult()
		1026	+ {
		1027	+ return $this->dbh->nextResult($this->result);
		1028	+ }
		1029	+
		1030	+ // }}}
		1031	+ // {{{ free()
		1032	+
		1033	+ /**
		1034	+ * Frees the resources allocated for this result set.
		1035	+ * @return int error code
		1036	+ *
		1037	+ * @access public
		1038	+ */
		1039	+ function free()
		1040	+ {
		1041	+ $err = $this->dbh->freeResult($this->result);
		1042	+ if (DB::isError($err)) {
		1043	+ return $err;
		1044	+ }
		1045	+ $this->result = false;
		1046	+ return true;
		1047	+ }
		1048	+
		1049	+ // }}}
		1050	+ // {{{ tableInfo()
		1051	+
		1052	+ /**
		1053	+ * @deprecated
		1054	+ * @internal
		1055	+ * @see DB_common::tableInfo()
		1056	+ */
		1057	+ function tableInfo($mode = null)
		1058	+ {
		1059	+ if (is_string($mode)) {
		1060	+ return $this->dbh->raiseError(DB_ERROR_NEED_MORE_DATA);
		1061	+ }
		1062	+ return $this->dbh->tableInfo($this, $mode);
		1063	+ }
		1064	+
		1065	+ // }}}
		1066	+ // {{{ getRowCounter()
		1067	+
		1068	+ /**
		1069	+ * returns the actual row number
		1070	+ * @return integer
		1071	+ */
		1072	+ function getRowCounter()
		1073	+ {
		1074	+ return $this->row_counter;
		1075	+ }
		1076	+ // }}}
		1077	+}
		1078	+
		1079	+// }}}
		1080	+// {{{ class DB_row
		1081	+
		1082	+/**
		1083	+ * Pear DB Row Object
		1084	+ * @see DB_common::setFetchMode()
		1085	+ */
		1086	+class DB_row
		1087	+{
		1088	+ // {{{ constructor
		1089	+
		1090	+ /**
		1091	+ * constructor
		1092	+ *
		1093	+ * @param resource row data as array
		1094	+ */
		1095	+ function DB_row(&$arr)
		1096	+ {
		1097	+ foreach ($arr as $key => $value) {
		1098	+ $this->$key = &$arr[$key];
		1099	+ }
		1100	+ }
		1101	+
		1102	+ // }}}
		1103	+}
		1104	+
		1105	+// }}}
		1106	+
		1107	+/*
		1108	+ * Local variables:
		1109	+ * tab-width: 4
		1110	+ * c-basic-offset: 4
		1111	+ * End:
		1112	+ */
		1113	+
		1114	+?>

pear/DB/common.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Stig Bakken <ssb@php.net> \|
		17	+// \| Tomas V.V.Cox <cox@idecnet.com> \|
		18	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		19	+// +----------------------------------------------------------------------+
		20	+//
		21	+// $Id$
		22	+
		23	+require_once 'PEAR.php';
		24	+
		25	+/**
		26	+ * DB_common is a base class for DB implementations, and must be
		27	+ * inherited by all such
		28	+ *
		29	+ * @package DB
		30	+ * @version $Id$
		31	+ * @category Database
		32	+ * @author Stig Bakken <ssb@php.net>
		33	+ * @author Tomas V.V.Cox <cox@idecnet.com>
		34	+ */
		35	+class DB_common extends PEAR
		36	+{
		37	+ // {{{ properties
		38	+
		39	+ /**
		40	+ * assoc of capabilities for this DB implementation
		41	+ * $features['limit'] => 'emulate' => emulate with fetch row by number
		42	+ * 'alter' => alter the query
		43	+ * false => skip rows
		44	+ * @var array
		45	+ */
		46	+ var $features = array();
		47	+
		48	+ /**
		49	+ * assoc mapping native error codes to DB ones
		50	+ * @var array
		51	+ */
		52	+ var $errorcode_map = array();
		53	+
		54	+ /**
		55	+ * DB type (mysql, oci8, odbc etc.)
		56	+ * @var string
		57	+ */
		58	+ var $phptype;
		59	+
		60	+ /**
		61	+ * @var string
		62	+ */
		63	+ var $prepare_tokens;
		64	+
		65	+ /**
		66	+ * @var string
		67	+ */
		68	+ var $prepare_types;
		69	+
		70	+ /**
		71	+ * @var string
		72	+ */
		73	+ var $prepared_queries;
		74	+
		75	+ /**
		76	+ * @var integer
		77	+ */
		78	+ var $prepare_maxstmt = 0;
		79	+
		80	+ /**
		81	+ * @var string
		82	+ */
		83	+ var $last_query = '';
		84	+
		85	+ /**
		86	+ * @var integer
		87	+ */
		88	+ var $fetchmode = DB_FETCHMODE_ORDERED;
		89	+
		90	+ /**
		91	+ * @var string
		92	+ */
		93	+ var $fetchmode_object_class = 'stdClass';
		94	+
		95	+ /**
		96	+ * Run-time configuration options.
		97	+ *
		98	+ * The 'optimize' option has been deprecated. Use the 'portability'
		99	+ * option instead.
		100	+ *
		101	+ * @see DB_common::setOption()
		102	+ * @var array
		103	+ */
		104	+ var $options = array(
		105	+ 'persistent' => false,
		106	+ 'ssl' => false,
		107	+ 'debug' => 0,
		108	+ 'seqname_format' => '%s_seq',
		109	+ 'autofree' => false,
		110	+ 'portability' => DB_PORTABILITY_NONE,
		111	+ 'optimize' => 'performance', // Deprecated. Use 'portability'.
		112	+ );
		113	+
		114	+ /**
		115	+ * DB handle
		116	+ * @var resource
		117	+ */
		118	+ var $dbh;
		119	+
		120	+ // }}}
		121	+ // {{{ toString()
		122	+
		123	+ /**
		124	+ * String conversation
		125	+ *
		126	+ * @return string
		127	+ * @access private
		128	+ */
		129	+ function toString()
		130	+ {
		131	+ $info = strtolower(get_class($this));
		132	+ $info .= ': (phptype=' . $this->phptype .
		133	+ ', dbsyntax=' . $this->dbsyntax .
		134	+ ')';
		135	+
		136	+ if ($this->connection) {
		137	+ $info .= ' [connected]';
		138	+ }
		139	+
		140	+ return $info;
		141	+ }
		142	+
		143	+ // }}}
		144	+ // {{{ constructor
		145	+
		146	+ /**
		147	+ * Constructor
		148	+ */
		149	+ function DB_common()
		150	+ {
		151	+ $this->PEAR('DB_Error');
		152	+ }
		153	+
		154	+ // }}}
		155	+ // {{{ quoteString()
		156	+
		157	+ /**
		158	+ * DEPRECATED: Quotes a string so it can be safely used within string
		159	+ * delimiters in a query
		160	+ *
		161	+ * @return string quoted string
		162	+ *
		163	+ * @see DB_common::quoteSmart(), DB_common::escapeSimple()
		164	+ * @deprecated Deprecated in release 1.2 or lower
		165	+ * @internal
		166	+ */
		167	+ function quoteString($string)
		168	+ {
		169	+ $string = $this->quote($string);
		170	+ if ($string{0} == "'") {
		171	+ return substr($string, 1, -1);
		172	+ }
		173	+ return $string;
		174	+ }
		175	+
		176	+ // }}}
		177	+ // {{{ quote()
		178	+
		179	+ /**
		180	+ * DEPRECATED: Quotes a string so it can be safely used in a query
		181	+ *
		182	+ * @param string $string the input string to quote
		183	+ *
		184	+ * @return string The NULL string or the string quotes
		185	+ * in magic_quote_sybase style
		186	+ *
		187	+ * @see DB_common::quoteSmart(), DB_common::escapeSimple()
		188	+ * @deprecated Deprecated in release 1.6.0
		189	+ * @internal
		190	+ */
		191	+ function quote($string = null)
		192	+ {
		193	+ return ($string === null) ? 'NULL' : "'".str_replace("'", "''", $string)."'";
		194	+ }
		195	+
		196	+ // }}}
		197	+ // {{{ quoteIdentifier()
		198	+
		199	+ /**
		200	+ * Quote a string so it can be safely used as a table or column name
		201	+ *
		202	+ * Delimiting style depends on which database driver is being used.
		203	+ *
		204	+ * NOTE: just because you CAN use delimited identifiers doesn't mean
		205	+ * you SHOULD use them. In general, they end up causing way more
		206	+ * problems than they solve.
		207	+ *
		208	+ * Portability is broken by using the following characters inside
		209	+ * delimited identifiers:
		210	+ * + backtick (<kbd>`</kbd>) -- due to MySQL
		211	+ * + double quote (<kbd>"</kbd>) -- due to Oracle
		212	+ * + brackets (<kbd>[</kbd> or <kbd>]</kbd>) -- due to Access
		213	+ *
		214	+ * Delimited identifiers are known to generally work correctly under
		215	+ * the following drivers:
		216	+ * + mssql
		217	+ * + mysql
		218	+ * + mysqli
		219	+ * + oci8
		220	+ * + odbc(access)
		221	+ * + odbc(db2)
		222	+ * + pgsql
		223	+ * + sqlite
		224	+ * + sybase
		225	+ *
		226	+ * InterBase doesn't seem to be able to use delimited identifiers
		227	+ * via PHP 4. They work fine under PHP 5.
		228	+ *
		229	+ * @param string $str identifier name to be quoted
		230	+ *
		231	+ * @return string quoted identifier string
		232	+ *
		233	+ * @since 1.6.0
		234	+ * @access public
		235	+ */
		236	+ function quoteIdentifier($str)
		237	+ {
		238	+ return '"' . str_replace('"', '""', $str) . '"';
		239	+ }
		240	+
		241	+ // }}}
		242	+ // {{{ quoteSmart()
		243	+
		244	+ /**
		245	+ * Format input so it can be safely used in a query
		246	+ *
		247	+ * The output depends on the PHP data type of input and the database
		248	+ * type being used.
		249	+ *
		250	+ * @param mixed $in data to be quoted
		251	+ *
		252	+ * @return mixed the format of the results depends on the input's
		253	+ * PHP type:
		254	+ *
		255	+ * <ul>
		256	+ * <li>
		257	+ * <kbd>input</kbd> -> <samp>returns</samp>
		258	+ * </li>
		259	+ * <li>
		260	+ * <kbd>null</kbd> -> the string <samp>NULL</samp>
		261	+ * </li>
		262	+ * <li>
		263	+ * <kbd>integer</kbd> or <kbd>double</kbd> -> the unquoted number
		264	+ * </li>
		265	+ * <li>
		266	+ * &type.bool; -> output depends on the driver in use
		267	+ * Most drivers return integers: <samp>1</samp> if
		268	+ * <kbd>true</kbd> or <samp>0</samp> if
		269	+ * <kbd>false</kbd>.
		270	+ * Some return strings: <samp>TRUE</samp> if
		271	+ * <kbd>true</kbd> or <samp>FALSE</samp> if
		272	+ * <kbd>false</kbd>.
		273	+ * Finally one returns strings: <samp>T</samp> if
		274	+ * <kbd>true</kbd> or <samp>F</samp> if
		275	+ * <kbd>false</kbd>. Here is a list of each DBMS,
		276	+ * the values returned and the suggested column type:
		277	+ * <ul>
		278	+ * <li>
		279	+ * <kbd>dbase</kbd> -> <samp>T/F</samp>
		280	+ * (<kbd>Logical</kbd>)
		281	+ * </li>
		282	+ * <li>
		283	+ * <kbd>fbase</kbd> -> <samp>TRUE/FALSE</samp>
		284	+ * (<kbd>BOOLEAN</kbd>)
		285	+ * </li>
		286	+ * <li>
		287	+ * <kbd>ibase</kbd> -> <samp>1/0</samp>
		288	+ * (<kbd>SMALLINT</kbd>) [1]
		289	+ * </li>
		290	+ * <li>
		291	+ * <kbd>ifx</kbd> -> <samp>1/0</samp>
		292	+ * (<kbd>SMALLINT</kbd>) [1]
		293	+ * </li>
		294	+ * <li>
		295	+ * <kbd>msql</kbd> -> <samp>1/0</samp>
		296	+ * (<kbd>INTEGER</kbd>)
		297	+ * </li>
		298	+ * <li>
		299	+ * <kbd>mssql</kbd> -> <samp>1/0</samp>
		300	+ * (<kbd>BIT</kbd>)
		301	+ * </li>
		302	+ * <li>
		303	+ * <kbd>mysql</kbd> -> <samp>1/0</samp>
		304	+ * (<kbd>TINYINT(1)</kbd>)
		305	+ * </li>
		306	+ * <li>
		307	+ * <kbd>mysqli</kbd> -> <samp>1/0</samp>
		308	+ * (<kbd>TINYINT(1)</kbd>)
		309	+ * </li>
		310	+ * <li>
		311	+ * <kbd>oci8</kbd> -> <samp>1/0</samp>
		312	+ * (<kbd>NUMBER(1)</kbd>)
		313	+ * </li>
		314	+ * <li>
		315	+ * <kbd>odbc</kbd> -> <samp>1/0</samp>
		316	+ * (<kbd>SMALLINT</kbd>) [1]
		317	+ * </li>
		318	+ * <li>
		319	+ * <kbd>pgsql</kbd> -> <samp>TRUE/FALSE</samp>
		320	+ * (<kbd>BOOLEAN</kbd>)
		321	+ * </li>
		322	+ * <li>
		323	+ * <kbd>sqlite</kbd> -> <samp>1/0</samp>
		324	+ * (<kbd>INTEGER</kbd>)
		325	+ * </li>
		326	+ * <li>
		327	+ * <kbd>sybase</kbd> -> <samp>1/0</samp>
		328	+ * (<kbd>TINYINT(1)</kbd>)
		329	+ * </li>
		330	+ * </ul>
		331	+ * [1] Accommodate the lowest common denominator because not all
		332	+ * versions of have <kbd>BOOLEAN</kbd>.
		333	+ * </li>
		334	+ * <li>
		335	+ * other (including strings and numeric strings) ->
		336	+ * the data with single quotes escaped by preceeding
		337	+ * single quotes, backslashes are escaped by preceeding
		338	+ * backslashes, then the whole string is encapsulated
		339	+ * between single quotes
		340	+ * </li>
		341	+ * </ul>
		342	+ *
		343	+ * @since 1.6.0
		344	+ * @see DB_common::escapeSimple()
		345	+ * @access public
		346	+ */
		347	+ function quoteSmart($in)
		348	+ {
		349	+ if (is_int($in) \|\| is_double($in)) {
		350	+ return $in;
		351	+ } elseif (is_bool($in)) {
		352	+ return $in ? 1 : 0;
		353	+ } elseif (is_null($in)) {
		354	+ return 'NULL';
		355	+ } else {
		356	+ return "'" . $this->escapeSimple($in) . "'";
		357	+ }
		358	+ }
		359	+
		360	+ // }}}
		361	+ // {{{ escapeSimple()
		362	+
		363	+ /**
		364	+ * Escape a string according to the current DBMS's standards
		365	+ *
		366	+ * In SQLite, this makes things safe for inserts/updates, but may
		367	+ * cause problems when performing text comparisons against columns
		368	+ * containing binary data. See the
		369	+ * {@link http://php.net/sqlite_escape_string PHP manual} for more info.
		370	+ *
		371	+ * @param string $str the string to be escaped
		372	+ *
		373	+ * @return string the escaped string
		374	+ *
		375	+ * @since 1.6.0
		376	+ * @see DB_common::quoteSmart()
		377	+ * @access public
		378	+ */
		379	+ function escapeSimple($str) {
		380	+ return str_replace("'", "''", $str);
		381	+ }
		382	+
		383	+ // }}}
		384	+ // {{{ provides()
		385	+
		386	+ /**
		387	+ * Tell whether a DB implementation or its backend extension
		388	+ * supports a given feature
		389	+ *
		390	+ * @param array $feature name of the feature (see the DB class doc)
		391	+ * @return bool whether this DB implementation supports $feature
		392	+ * @access public
		393	+ */
		394	+ function provides($feature)
		395	+ {
		396	+ return $this->features[$feature];
		397	+ }
		398	+
		399	+ // }}}
		400	+ // {{{ errorCode()
		401	+
		402	+ /**
		403	+ * Map native error codes to DB's portable ones
		404	+ *
		405	+ * Requires that the DB implementation's constructor fills
		406	+ * in the <var>$errorcode_map</var> property.
		407	+ *
		408	+ * @param mixed $nativecode the native error code, as returned by the
		409	+ * backend database extension (string or integer)
		410	+ *
		411	+ * @return int a portable DB error code, or DB_ERROR if this DB
		412	+ * implementation has no mapping for the given error code.
		413	+ *
		414	+ * @access public
		415	+ */
		416	+ function errorCode($nativecode)
		417	+ {
		418	+ if (isset($this->errorcode_map[$nativecode])) {
		419	+ return $this->errorcode_map[$nativecode];
		420	+ }
		421	+ // Fall back to DB_ERROR if there was no mapping.
		422	+ return DB_ERROR;
		423	+ }
		424	+
		425	+ // }}}
		426	+ // {{{ errorMessage()
		427	+
		428	+ /**
		429	+ * Map a DB error code to a textual message. This is actually
		430	+ * just a wrapper for DB::errorMessage()
		431	+ *
		432	+ * @param integer $dbcode the DB error code
		433	+ *
		434	+ * @return string the corresponding error message, of false
		435	+ * if the error code was unknown
		436	+ *
		437	+ * @access public
		438	+ */
		439	+ function errorMessage($dbcode)
		440	+ {
		441	+ return DB::errorMessage($this->errorcode_map[$dbcode]);
		442	+ }
		443	+
		444	+ // }}}
		445	+ // {{{ raiseError()
		446	+
		447	+ /**
		448	+ * Communicate an error and invoke error callbacks, etc
		449	+ *
		450	+ * Basically a wrapper for PEAR::raiseError without the message string.
		451	+ *
		452	+ * @param mixed integer error code, or a PEAR error object (all
		453	+ * other parameters are ignored if this parameter is
		454	+ * an object
		455	+ *
		456	+ * @param int error mode, see PEAR_Error docs
		457	+ *
		458	+ * @param mixed If error mode is PEAR_ERROR_TRIGGER, this is the
		459	+ * error level (E_USER_NOTICE etc). If error mode is
		460	+ * PEAR_ERROR_CALLBACK, this is the callback function,
		461	+ * either as a function name, or as an array of an
		462	+ * object and method name. For other error modes this
		463	+ * parameter is ignored.
		464	+ *
		465	+ * @param string Extra debug information. Defaults to the last
		466	+ * query and native error code.
		467	+ *
		468	+ * @param mixed Native error code, integer or string depending the
		469	+ * backend.
		470	+ *
		471	+ * @return object a PEAR error object
		472	+ *
		473	+ * @access public
		474	+ * @see PEAR_Error
		475	+ */
		476	+ function &raiseError($code = DB_ERROR, $mode = null, $options = null,
		477	+ $userinfo = null, $nativecode = null)
		478	+ {
		479	+ // The error is yet a DB error object
		480	+ if (is_object($code)) {
		481	+ // because we the static PEAR::raiseError, our global
		482	+ // handler should be used if it is set
		483	+ if ($mode === null && !empty($this->_default_error_mode)) {
		484	+ $mode = $this->_default_error_mode;
		485	+ $options = $this->_default_error_options;
		486	+ }
		487	+ $tmp = PEAR::raiseError($code, null, $mode, $options, null, null, true);
		488	+ return $tmp;
		489	+ }
		490	+
		491	+ if ($userinfo === null) {
		492	+ $userinfo = $this->last_query;
		493	+ }
		494	+
		495	+ if ($nativecode) {
		496	+ $userinfo .= ' [nativecode=' . trim($nativecode) . ']';
		497	+ }
		498	+
		499	+ $tmp = PEAR::raiseError(null, $code, $mode, $options, $userinfo,
		500	+ 'DB_Error', true);
		501	+ return $tmp;
		502	+ }
		503	+
		504	+ // }}}
		505	+ // {{{ setFetchMode()
		506	+
		507	+ /**
		508	+ * Sets which fetch mode should be used by default on queries
		509	+ * on this connection
		510	+ *
		511	+ * @param integer $fetchmode DB_FETCHMODE_ORDERED or
		512	+ * DB_FETCHMODE_ASSOC, possibly bit-wise OR'ed with
		513	+ * DB_FETCHMODE_FLIPPED.
		514	+ *
		515	+ * @param string $object_class The class of the object
		516	+ * to be returned by the fetch methods when
		517	+ * the DB_FETCHMODE_OBJECT mode is selected.
		518	+ * If no class is specified by default a cast
		519	+ * to object from the assoc array row will be done.
		520	+ * There is also the posibility to use and extend the
		521	+ * 'DB_row' class.
		522	+ *
		523	+ * @see DB_FETCHMODE_ORDERED
		524	+ * @see DB_FETCHMODE_ASSOC
		525	+ * @see DB_FETCHMODE_FLIPPED
		526	+ * @see DB_FETCHMODE_OBJECT
		527	+ * @see DB_row::DB_row()
		528	+ * @access public
		529	+ */
		530	+ function setFetchMode($fetchmode, $object_class = 'stdClass')
		531	+ {
		532	+ switch ($fetchmode) {
		533	+ case DB_FETCHMODE_OBJECT:
		534	+ $this->fetchmode_object_class = $object_class;
		535	+ case DB_FETCHMODE_ORDERED:
		536	+ case DB_FETCHMODE_ASSOC:
		537	+ $this->fetchmode = $fetchmode;
		538	+ break;
		539	+ default:
		540	+ return $this->raiseError('invalid fetchmode mode');
		541	+ }
		542	+ }
		543	+
		544	+ // }}}
		545	+ // {{{ setOption()
		546	+
		547	+ /**
		548	+ * Set run-time configuration options for PEAR DB
		549	+ *
		550	+ * Options, their data types, default values and description:
		551	+ * <ul>
		552	+ * <li>
		553	+ * <var>autofree</var> <kbd>boolean</kbd> = <samp>false</samp>
		554	+ * <br />should results be freed automatically when there are no
		555	+ * more rows?
		556	+ * </li><li>
		557	+ * <var>debug</var> <kbd>integer</kbd> = <samp>0</samp>
		558	+ * <br />debug level
		559	+ * </li><li>
		560	+ * <var>persistent</var> <kbd>boolean</kbd> = <samp>false</samp>
		561	+ * <br />should the connection be persistent?
		562	+ * </li><li>
		563	+ * <var>portability</var> <kbd>integer</kbd> = <samp>DB_PORTABILITY_NONE</samp>
		564	+ * <br />portability mode constant (see below)
		565	+ * </li><li>
		566	+ * <var>seqname_format</var> <kbd>string</kbd> = <samp>%s_seq</samp>
		567	+ * <br />the sprintf() format string used on sequence names. This
		568	+ * format is applied to sequence names passed to
		569	+ * createSequence(), nextID() and dropSequence().
		570	+ * </li><li>
		571	+ * <var>ssl</var> <kbd>boolean</kbd> = <samp>false</samp>
		572	+ * <br />use ssl to connect?
		573	+ * </li>
		574	+ * </ul>
		575	+ *
		576	+ * -----------------------------------------
		577	+ *
		578	+ * PORTABILITY MODES
		579	+ *
		580	+ * These modes are bitwised, so they can be combined using <kbd>\|</kbd>
		581	+ * and removed using <kbd>^</kbd>. See the examples section below on how
		582	+ * to do this.
		583	+ *
		584	+ * <samp>DB_PORTABILITY_NONE</samp>
		585	+ * turn off all portability features
		586	+ *
		587	+ * This mode gets automatically turned on if the deprecated
		588	+ * <var>optimize</var> option gets set to <samp>performance</samp>.
		589	+ *
		590	+ *
		591	+ * <samp>DB_PORTABILITY_LOWERCASE</samp>
		592	+ * convert names of tables and fields to lower case when using
		593	+ * <kbd>get()</kbd>, <kbd>fetch()</kbd> and <kbd>tableInfo()</kbd>
		594	+ *
		595	+ * This mode gets automatically turned on in the following databases
		596	+ * if the deprecated option <var>optimize</var> gets set to
		597	+ * <samp>portability</samp>:
		598	+ * + oci8
		599	+ *
		600	+ *
		601	+ * <samp>DB_PORTABILITY_RTRIM</samp>
		602	+ * right trim the data output by <kbd>get()</kbd> <kbd>fetch()</kbd>
		603	+ *
		604	+ *
		605	+ * <samp>DB_PORTABILITY_DELETE_COUNT</samp>
		606	+ * force reporting the number of rows deleted
		607	+ *
		608	+ * Some DBMS's don't count the number of rows deleted when performing
		609	+ * simple <kbd>DELETE FROM tablename</kbd> queries. This portability
		610	+ * mode tricks such DBMS's into telling the count by adding
		611	+ * <samp>WHERE 1=1</samp> to the end of <kbd>DELETE</kbd> queries.
		612	+ *
		613	+ * This mode gets automatically turned on in the following databases
		614	+ * if the deprecated option <var>optimize</var> gets set to
		615	+ * <samp>portability</samp>:
		616	+ * + fbsql
		617	+ * + mysql
		618	+ * + mysqli
		619	+ * + sqlite
		620	+ *
		621	+ *
		622	+ * <samp>DB_PORTABILITY_NUMROWS</samp>
		623	+ * enable hack that makes <kbd>numRows()</kbd> work in Oracle
		624	+ *
		625	+ * This mode gets automatically turned on in the following databases
		626	+ * if the deprecated option <var>optimize</var> gets set to
		627	+ * <samp>portability</samp>:
		628	+ * + oci8
		629	+ *
		630	+ *
		631	+ * <samp>DB_PORTABILITY_ERRORS</samp>
		632	+ * makes certain error messages in certain drivers compatible
		633	+ * with those from other DBMS's
		634	+ *
		635	+ * + mysql, mysqli: change unique/primary key constraints
		636	+ * DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT
		637	+ *
		638	+ * + odbc(access): MS's ODBC driver reports 'no such field' as code
		639	+ * 07001, which means 'too few parameters.' When this option is on
		640	+ * that code gets mapped to DB_ERROR_NOSUCHFIELD.
		641	+ * DB_ERROR_MISMATCH -> DB_ERROR_NOSUCHFIELD
		642	+ *
		643	+ *
		644	+ * <samp>DB_PORTABILITY_NULL_TO_EMPTY</samp>
		645	+ * convert null values to empty strings in data output by get*() and
		646	+ * fetch*(). Needed because Oracle considers empty strings to be null,
		647	+ * while most other DBMS's know the difference between empty and null.
		648	+ *
		649	+ *
		650	+ * <samp>DB_PORTABILITY_ALL</samp>
		651	+ * turn on all portability features
		652	+ *
		653	+ * -----------------------------------------
		654	+ *
		655	+ * Example 1. Simple setOption() example
		656	+ * <code> <?php
		657	+ * $dbh->setOption('autofree', true);
		658	+ * ?></code>
		659	+ *
		660	+ * Example 2. Portability for lowercasing and trimming
		661	+ * <code> <?php
		662	+ * $dbh->setOption('portability',
		663	+ * DB_PORTABILITY_LOWERCASE \| DB_PORTABILITY_RTRIM);
		664	+ * ?></code>
		665	+ *
		666	+ * Example 3. All portability options except trimming
		667	+ * <code> <?php
		668	+ * $dbh->setOption('portability',
		669	+ * DB_PORTABILITY_ALL ^ DB_PORTABILITY_RTRIM);
		670	+ * ?></code>
		671	+ *
		672	+ * @param string $option option name
		673	+ * @param mixed $value value for the option
		674	+ *
		675	+ * @return int DB_OK on success. DB_Error object on failure.
		676	+ *
		677	+ * @see DB_common::$options
		678	+ */
		679	+ function setOption($option, $value)
		680	+ {
		681	+ if (isset($this->options[$option])) {
		682	+ $this->options[$option] = $value;
		683	+
		684	+ /*
		685	+ * Backwards compatibility check for the deprecated 'optimize'
		686	+ * option. Done here in case settings change after connecting.
		687	+ */
		688	+ if ($option == 'optimize') {
		689	+ if ($value == 'portability') {
		690	+ switch ($this->phptype) {
		691	+ case 'oci8':
		692	+ $this->options['portability'] =
		693	+ DB_PORTABILITY_LOWERCASE \|
		694	+ DB_PORTABILITY_NUMROWS;
		695	+ break;
		696	+ case 'fbsql':
		697	+ case 'mysql':
		698	+ case 'mysqli':
		699	+ case 'sqlite':
		700	+ $this->options['portability'] =
		701	+ DB_PORTABILITY_DELETE_COUNT;
		702	+ break;
		703	+ }
		704	+ } else {
		705	+ $this->options['portability'] = DB_PORTABILITY_NONE;
		706	+ }
		707	+ }
		708	+
		709	+ return DB_OK;
		710	+ }
		711	+ return $this->raiseError("unknown option $option");
		712	+ }
		713	+
		714	+ // }}}
		715	+ // {{{ getOption()
		716	+
		717	+ /**
		718	+ * Returns the value of an option
		719	+ *
		720	+ * @param string $option option name
		721	+ *
		722	+ * @return mixed the option value
		723	+ */
		724	+ function getOption($option)
		725	+ {
		726	+ if (isset($this->options[$option])) {
		727	+ return $this->options[$option];
		728	+ }
		729	+ return $this->raiseError("unknown option $option");
		730	+ }
		731	+
		732	+ // }}}
		733	+ // {{{ prepare()
		734	+
		735	+ /**
		736	+ * Prepares a query for multiple execution with execute()
		737	+ *
		738	+ * Creates a query that can be run multiple times. Each time it is run,
		739	+ * the placeholders, if any, will be replaced by the contents of
		740	+ * execute()'s $data argument.
		741	+ *
		742	+ * Three types of placeholders can be used:
		743	+ * + <kbd>?</kbd> scalar value (i.e. strings, integers). The system
		744	+ * will automatically quote and escape the data.
		745	+ * + <kbd>!</kbd> value is inserted 'as is'
		746	+ * + <kbd>&</kbd> requires a file name. The file's contents get
		747	+ * inserted into the query (i.e. saving binary
		748	+ * data in a db)
		749	+ *
		750	+ * Example 1.
		751	+ * <code> <?php
		752	+ * $sth = $dbh->prepare('INSERT INTO tbl (a, b, c) VALUES (?, !, &)');
		753	+ * $data = array(
		754	+ * "John's text",
		755	+ * "'it''s good'",
		756	+ * 'filename.txt'
		757	+ * );
		758	+ * $res = $dbh->execute($sth, $data);
		759	+ * ?></code>
		760	+ *
		761	+ * Use backslashes to escape placeholder characters if you don't want
		762	+ * them to be interpreted as placeholders:
		763	+ * <pre>
		764	+ * "UPDATE foo SET col=? WHERE col='over \& under'"
		765	+ * </pre>
		766	+ *
		767	+ * With some database backends, this is emulated.
		768	+ *
		769	+ * {@internal ibase and oci8 have their own prepare() methods.}}
		770	+ *
		771	+ * @param string $query query to be prepared
		772	+ *
		773	+ * @return mixed DB statement resource on success. DB_Error on failure.
		774	+ *
		775	+ * @see DB_common::execute()
		776	+ * @access public
		777	+ */
		778	+ function prepare($query)
		779	+ {
		780	+ $tokens = preg_split('/((?<!\\\)[&?!])/', $query, -1,
		781	+ PREG_SPLIT_DELIM_CAPTURE);
		782	+ $token = 0;
		783	+ $types = array();
		784	+ $newtokens = array();
		785	+
		786	+ foreach ($tokens as $val) {
		787	+ switch ($val) {
		788	+ case '?':
		789	+ $types[$token++] = DB_PARAM_SCALAR;
		790	+ break;
		791	+ case '&':
		792	+ $types[$token++] = DB_PARAM_OPAQUE;
		793	+ break;
		794	+ case '!':
		795	+ $types[$token++] = DB_PARAM_MISC;
		796	+ break;
		797	+ default:
		798	+ $newtokens[] = preg_replace('/\\\([&?!])/', "\\1", $val);
		799	+ }
		800	+ }
		801	+
		802	+ $this->prepare_tokens[] = &$newtokens;
		803	+ end($this->prepare_tokens);
		804	+
		805	+ $k = key($this->prepare_tokens);
		806	+ $this->prepare_types[$k] = $types;
		807	+ $this->prepared_queries[$k] = implode(' ', $newtokens);
		808	+
		809	+ return $k;
		810	+ }
		811	+
		812	+ // }}}
		813	+ // {{{ autoPrepare()
		814	+
		815	+ /**
		816	+ * Automaticaly generate an insert or update query and pass it to prepare()
		817	+ *
		818	+ * @param string $table name of the table
		819	+ * @param array $table_fields ordered array containing the fields names
		820	+ * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)
		821	+ * @param string $where in case of update queries, this string will be put after the sql WHERE statement
		822	+ * @return resource handle for the query
		823	+ * @see DB_common::prepare(), DB_common::buildManipSQL()
		824	+ * @access public
		825	+ */
		826	+ function autoPrepare($table, $table_fields, $mode = DB_AUTOQUERY_INSERT, $where = false)
		827	+ {
		828	+ $query = $this->buildManipSQL($table, $table_fields, $mode, $where);
		829	+ return $this->prepare($query);
		830	+ }
		831	+
		832	+ // }}}
		833	+ // {{{ autoExecute()
		834	+
		835	+ /**
		836	+ * Automaticaly generate an insert or update query and call prepare()
		837	+ * and execute() with it
		838	+ *
		839	+ * @param string $table name of the table
		840	+ * @param array $fields_values assoc ($key=>$value) where $key is a field name and $value its value
		841	+ * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)
		842	+ * @param string $where in case of update queries, this string will be put after the sql WHERE statement
		843	+ * @return mixed a new DB_Result or a DB_Error when fail
		844	+ * @see DB_common::autoPrepare(), DB_common::buildManipSQL()
		845	+ * @access public
		846	+ */
		847	+ function autoExecute($table, $fields_values, $mode = DB_AUTOQUERY_INSERT, $where = false)
		848	+ {
		849	+ $sth = $this->autoPrepare($table, array_keys($fields_values), $mode, $where);
		850	+ $ret =& $this->execute($sth, array_values($fields_values));
		851	+ $this->freePrepared($sth);
		852	+ return $ret;
		853	+
		854	+ }
		855	+
		856	+ // }}}
		857	+ // {{{ buildManipSQL()
		858	+
		859	+ /**
		860	+ * Make automaticaly an sql query for prepare()
		861	+ *
		862	+ * Example : buildManipSQL('table_sql', array('field1', 'field2', 'field3'), DB_AUTOQUERY_INSERT)
		863	+ * will return the string : INSERT INTO table_sql (field1,field2,field3) VALUES (?,?,?)
		864	+ * NB : - This belongs more to a SQL Builder class, but this is a simple facility
		865	+ * - Be carefull ! If you don't give a $where param with an UPDATE query, all
		866	+ * the records of the table will be updated !
		867	+ *
		868	+ * @param string $table name of the table
		869	+ * @param array $table_fields ordered array containing the fields names
		870	+ * @param int $mode type of query to make (DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE)
		871	+ * @param string $where in case of update queries, this string will be put after the sql WHERE statement
		872	+ * @return string sql query for prepare()
		873	+ * @access public
		874	+ */
		875	+ function buildManipSQL($table, $table_fields, $mode, $where = false)
		876	+ {
		877	+ if (count($table_fields) == 0) {
		878	+ $this->raiseError(DB_ERROR_NEED_MORE_DATA);
		879	+ }
		880	+ $first = true;
		881	+ switch ($mode) {
		882	+ case DB_AUTOQUERY_INSERT:
		883	+ $values = '';
		884	+ $names = '';
		885	+ foreach ($table_fields as $value) {
		886	+ if ($first) {
		887	+ $first = false;
		888	+ } else {
		889	+ $names .= ',';
		890	+ $values .= ',';
		891	+ }
		892	+ $names .= $value;
		893	+ $values .= '?';
		894	+ }
		895	+ return "INSERT INTO $table ($names) VALUES ($values)";
		896	+ case DB_AUTOQUERY_UPDATE:
		897	+ $set = '';
		898	+ foreach ($table_fields as $value) {
		899	+ if ($first) {
		900	+ $first = false;
		901	+ } else {
		902	+ $set .= ',';
		903	+ }
		904	+ $set .= "$value = ?";
		905	+ }
		906	+ $sql = "UPDATE $table SET $set";
		907	+ if ($where) {
		908	+ $sql .= " WHERE $where";
		909	+ }
		910	+ return $sql;
		911	+ default:
		912	+ $this->raiseError(DB_ERROR_SYNTAX);
		913	+ }
		914	+ }
		915	+
		916	+ // }}}
		917	+ // {{{ execute()
		918	+
		919	+ /**
		920	+ * Executes a DB statement prepared with prepare()
		921	+ *
		922	+ * Example 1.
		923	+ * <code> <?php
		924	+ * $sth = $dbh->prepare('INSERT INTO tbl (a, b, c) VALUES (?, !, &)');
		925	+ * $data = array(
		926	+ * "John's text",
		927	+ * "'it''s good'",
		928	+ * 'filename.txt'
		929	+ * );
		930	+ * $res =& $dbh->execute($sth, $data);
		931	+ * ?></code>
		932	+ *
		933	+ * @param resource $stmt a DB statement resource returned from prepare()
		934	+ * @param mixed $data array, string or numeric data to be used in
		935	+ * execution of the statement. Quantity of items
		936	+ * passed must match quantity of placeholders in
		937	+ * query: meaning 1 placeholder for non-array
		938	+ * parameters or 1 placeholder per array element.
		939	+ *
		940	+ * @return object a new DB_Result or a DB_Error when fail
		941	+ *
		942	+ * {@internal ibase and oci8 have their own execute() methods.}}
		943	+ *
		944	+ * @see DB_common::prepare()
		945	+ * @access public
		946	+ */
		947	+ function &execute($stmt, $data = array())
		948	+ {
		949	+ $realquery = $this->executeEmulateQuery($stmt, $data);
		950	+ if (DB::isError($realquery)) {
		951	+ return $realquery;
		952	+ }
		953	+ $result = $this->simpleQuery($realquery);
		954	+
		955	+ if (DB::isError($result) \|\| $result === DB_OK) {
		956	+ return $result;
		957	+ } else {
		958	+ $tmp =& new DB_result($this, $result);
		959	+ return $tmp;
		960	+ }
		961	+ }
		962	+
		963	+ // }}}
		964	+ // {{{ executeEmulateQuery()
		965	+
		966	+ /**
		967	+ * Emulates the execute statement, when not supported
		968	+ *
		969	+ * @param resource $stmt a DB statement resource returned from execute()
		970	+ * @param mixed $data array, string or numeric data to be used in
		971	+ * execution of the statement. Quantity of items
		972	+ * passed must match quantity of placeholders in
		973	+ * query: meaning 1 placeholder for non-array
		974	+ * parameters or 1 placeholder per array element.
		975	+ *
		976	+ * @return mixed a string containing the real query run when emulating
		977	+ * prepare/execute. A DB error code is returned on failure.
		978	+ *
		979	+ * @see DB_common::execute()
		980	+ * @access private
		981	+ */
		982	+ function executeEmulateQuery($stmt, $data = array())
		983	+ {
		984	+ $stmt = (int)$stmt;
		985	+ if (!is_array($data)) {
		986	+ $data = array($data);
		987	+ }
		988	+
		989	+ if (count($this->prepare_types[$stmt]) != count($data)) {
		990	+ $this->last_query = $this->prepared_queries[$stmt];
		991	+ return $this->raiseError(DB_ERROR_MISMATCH);
		992	+ }
		993	+
		994	+ $realquery = $this->prepare_tokens[$stmt][0];
		995	+
		996	+ $i = 0;
		997	+ foreach ($data as $value) {
		998	+ if ($this->prepare_types[$stmt][$i] == DB_PARAM_SCALAR) {
		999	+ $realquery .= $this->quoteSmart($value);
		1000	+ } elseif ($this->prepare_types[$stmt][$i] == DB_PARAM_OPAQUE) {
		1001	+ $fp = @fopen($value, 'rb');
		1002	+ if (!$fp) {
		1003	+ return $this->raiseError(DB_ERROR_ACCESS_VIOLATION);
		1004	+ }
		1005	+ $realquery .= $this->quoteSmart(fread($fp, filesize($value)));
		1006	+ fclose($fp);
		1007	+ } else {
		1008	+ $realquery .= $value;
		1009	+ }
		1010	+
		1011	+ $realquery .= $this->prepare_tokens[$stmt][++$i];
		1012	+ }
		1013	+
		1014	+ return $realquery;
		1015	+ }
		1016	+
		1017	+ // }}}
		1018	+ // {{{ executeMultiple()
		1019	+
		1020	+ /**
		1021	+ * This function does several execute() calls on the same
		1022	+ * statement handle
		1023	+ *
		1024	+ * $data must be an array indexed numerically
		1025	+ * from 0, one execute call is done for every "row" in the array.
		1026	+ *
		1027	+ * If an error occurs during execute(), executeMultiple() does not
		1028	+ * execute the unfinished rows, but rather returns that error.
		1029	+ *
		1030	+ * @param resource $stmt query handle from prepare()
		1031	+ * @param array $data numeric array containing the
		1032	+ * data to insert into the query
		1033	+ *
		1034	+ * @return mixed DB_OK or DB_Error
		1035	+ *
		1036	+ * @see DB_common::prepare(), DB_common::execute()
		1037	+ * @access public
		1038	+ */
		1039	+ function executeMultiple($stmt, $data)
		1040	+ {
		1041	+ foreach ($data as $value) {
		1042	+ $res =& $this->execute($stmt, $value);
		1043	+ if (DB::isError($res)) {
		1044	+ return $res;
		1045	+ }
		1046	+ }
		1047	+ return DB_OK;
		1048	+ }
		1049	+
		1050	+ // }}}
		1051	+ // {{{ freePrepared()
		1052	+
		1053	+ /**
		1054	+ * Free the resource used in a prepared query
		1055	+ *
		1056	+ * @param $stmt The resurce returned by the prepare() function
		1057	+ * @see DB_common::prepare()
		1058	+ */
		1059	+ function freePrepared($stmt)
		1060	+ {
		1061	+ $stmt = (int)$stmt;
		1062	+ // Free the internal prepared vars
		1063	+ if (isset($this->prepare_tokens[$stmt])) {
		1064	+ unset($this->prepare_tokens[$stmt]);
		1065	+ unset($this->prepare_types[$stmt]);
		1066	+ unset($this->prepared_queries[$stmt]);
		1067	+ return true;
		1068	+ }
		1069	+ return false;
		1070	+ }
		1071	+
		1072	+ // }}}
		1073	+ // {{{ modifyQuery()
		1074	+
		1075	+ /**
		1076	+ * This method is used by backends to alter queries for various
		1077	+ * reasons
		1078	+ *
		1079	+ * It is defined here to assure that all implementations
		1080	+ * have this method defined.
		1081	+ *
		1082	+ * @param string $query query to modify
		1083	+ *
		1084	+ * @return the new (modified) query
		1085	+ *
		1086	+ * @access private
		1087	+ */
		1088	+ function modifyQuery($query) {
		1089	+ return $query;
		1090	+ }
		1091	+
		1092	+ // }}}
		1093	+ // {{{ modifyLimitQuery()
		1094	+
		1095	+ /**
		1096	+ * This method is used by backends to alter limited queries
		1097	+ *
		1098	+ * @param string $query query to modify
		1099	+ * @param integer $from the row to start to fetching
		1100	+ * @param integer $count the numbers of rows to fetch
		1101	+ *
		1102	+ * @return the new (modified) query
		1103	+ *
		1104	+ * @access private
		1105	+ */
		1106	+ function modifyLimitQuery($query, $from, $count, $params = array())
		1107	+ {
		1108	+ return $query;
		1109	+ }
		1110	+
		1111	+ // }}}
		1112	+ // {{{ query()
		1113	+
		1114	+ /**
		1115	+ * Send a query to the database and return any results with a
		1116	+ * DB_result object
		1117	+ *
		1118	+ * The query string can be either a normal statement to be sent directly
		1119	+ * to the server OR if <var>$params</var> are passed the query can have
		1120	+ * placeholders and it will be passed through prepare() and execute().
		1121	+ *
		1122	+ * @param string $query the SQL query or the statement to prepare
		1123	+ * @param mixed $params array, string or numeric data to be used in
		1124	+ * execution of the statement. Quantity of items
		1125	+ * passed must match quantity of placeholders in
		1126	+ * query: meaning 1 placeholder for non-array
		1127	+ * parameters or 1 placeholder per array element.
		1128	+ *
		1129	+ * @return mixed a DB_result object or DB_OK on success, a DB
		1130	+ * error on failure
		1131	+ *
		1132	+ * @see DB_result, DB_common::prepare(), DB_common::execute()
		1133	+ * @access public
		1134	+ */
		1135	+ function &query($query, $params = array())
		1136	+ {
		1137	+ if (sizeof($params) > 0) {
		1138	+ $sth = $this->prepare($query);
		1139	+ if (DB::isError($sth)) {
		1140	+ return $sth;
		1141	+ }
		1142	+ $ret =& $this->execute($sth, $params);
		1143	+ $this->freePrepared($sth);
		1144	+ return $ret;
		1145	+ } else {
		1146	+ $result = $this->simpleQuery($query);
		1147	+ if (DB::isError($result) \|\| $result === DB_OK) {
		1148	+ return $result;
		1149	+ } else {
		1150	+ $tmp =& new DB_result($this, $result);
		1151	+ return $tmp;
		1152	+ }
		1153	+ }
		1154	+ }
		1155	+
		1156	+ // }}}
		1157	+ // {{{ limitQuery()
		1158	+
		1159	+ /**
		1160	+ * Generates a limited query
		1161	+ *
		1162	+ * @param string $query query
		1163	+ * @param integer $from the row to start to fetching
		1164	+ * @param integer $count the numbers of rows to fetch
		1165	+ * @param mixed $params array, string or numeric data to be used in
		1166	+ * execution of the statement. Quantity of items
		1167	+ * passed must match quantity of placeholders in
		1168	+ * query: meaning 1 placeholder for non-array
		1169	+ * parameters or 1 placeholder per array element.
		1170	+ *
		1171	+ * @return mixed a DB_Result object, DB_OK or a DB_Error
		1172	+ *
		1173	+ * @access public
		1174	+ */
		1175	+ function &limitQuery($query, $from, $count, $params = array())
		1176	+ {
		1177	+ $query = $this->modifyLimitQuery($query, $from, $count, $params);
		1178	+ if (DB::isError($query)){
		1179	+ return $query;
		1180	+ }
		1181	+ $result =& $this->query($query, $params);
		1182	+ if (is_a($result, 'DB_result')) {
		1183	+ $result->setOption('limit_from', $from);
		1184	+ $result->setOption('limit_count', $count);
		1185	+ }
		1186	+ return $result;
		1187	+ }
		1188	+
		1189	+ // }}}
		1190	+ // {{{ getOne()
		1191	+
		1192	+ /**
		1193	+ * Fetch the first column of the first row of data returned from
		1194	+ * a query
		1195	+ *
		1196	+ * Takes care of doing the query and freeing the results when finished.
		1197	+ *
		1198	+ * @param string $query the SQL query
		1199	+ * @param mixed $params array, string or numeric data to be used in
		1200	+ * execution of the statement. Quantity of items
		1201	+ * passed must match quantity of placeholders in
		1202	+ * query: meaning 1 placeholder for non-array
		1203	+ * parameters or 1 placeholder per array element.
		1204	+ *
		1205	+ * @return mixed the returned value of the query. DB_Error on failure.
		1206	+ *
		1207	+ * @access public
		1208	+ */
		1209	+ function &getOne($query, $params = array())
		1210	+ {
		1211	+ settype($params, 'array');
		1212	+ if (sizeof($params) > 0) {
		1213	+ $sth = $this->prepare($query);
		1214	+ if (DB::isError($sth)) {
		1215	+ return $sth;
		1216	+ }
		1217	+ $res =& $this->execute($sth, $params);
		1218	+ $this->freePrepared($sth);
		1219	+ } else {
		1220	+ $res =& $this->query($query);
		1221	+ }
		1222	+
		1223	+ if (DB::isError($res)) {
		1224	+ return $res;
		1225	+ }
		1226	+
		1227	+ $err = $res->fetchInto($row, DB_FETCHMODE_ORDERED);
		1228	+ $res->free();
		1229	+
		1230	+ if ($err !== DB_OK) {
		1231	+ return $err;
		1232	+ }
		1233	+
		1234	+ return $row[0];
		1235	+ }
		1236	+
		1237	+ // }}}
		1238	+ // {{{ getRow()
		1239	+
		1240	+ /**
		1241	+ * Fetch the first row of data returned from a query
		1242	+ *
		1243	+ * Takes care of doing the query and freeing the results when finished.
		1244	+ *
		1245	+ * @param string $query the SQL query
		1246	+ * @param array $params array to be used in execution of the statement.
		1247	+ * Quantity of array elements must match quantity
		1248	+ * of placeholders in query. This function does
		1249	+ * NOT support scalars.
		1250	+ * @param int $fetchmode the fetch mode to use
		1251	+ *
		1252	+ * @return array the first row of results as an array indexed from
		1253	+ * 0, or a DB error code.
		1254	+ *
		1255	+ * @access public
		1256	+ */
		1257	+ function &getRow($query,
		1258	+ $params = array(),
		1259	+ $fetchmode = DB_FETCHMODE_DEFAULT)
		1260	+ {
		1261	+ // compat check, the params and fetchmode parameters used to
		1262	+ // have the opposite order
		1263	+ if (!is_array($params)) {
		1264	+ if (is_array($fetchmode)) {
		1265	+ if ($params === null) {
		1266	+ $tmp = DB_FETCHMODE_DEFAULT;
		1267	+ } else {
		1268	+ $tmp = $params;
		1269	+ }
		1270	+ $params = $fetchmode;
		1271	+ $fetchmode = $tmp;
		1272	+ } elseif ($params !== null) {
		1273	+ $fetchmode = $params;
		1274	+ $params = array();
		1275	+ }
		1276	+ }
		1277	+
		1278	+ if (sizeof($params) > 0) {
		1279	+ $sth = $this->prepare($query);
		1280	+ if (DB::isError($sth)) {
		1281	+ return $sth;
		1282	+ }
		1283	+ $res =& $this->execute($sth, $params);
		1284	+ $this->freePrepared($sth);
		1285	+ } else {
		1286	+ $res =& $this->query($query);
		1287	+ }
		1288	+
		1289	+ if (DB::isError($res)) {
		1290	+ return $res;
		1291	+ }
		1292	+
		1293	+ $err = $res->fetchInto($row, $fetchmode);
		1294	+
		1295	+ $res->free();
		1296	+
		1297	+ if ($err !== DB_OK) {
		1298	+ return $err;
		1299	+ }
		1300	+
		1301	+ return $row;
		1302	+ }
		1303	+
		1304	+ // }}}
		1305	+ // {{{ getCol()
		1306	+
		1307	+ /**
		1308	+ * Fetch a single column from a result set and return it as an
		1309	+ * indexed array
		1310	+ *
		1311	+ * @param string $query the SQL query
		1312	+ * @param mixed $col which column to return (integer [column number,
		1313	+ * starting at 0] or string [column name])
		1314	+ * @param mixed $params array, string or numeric data to be used in
		1315	+ * execution of the statement. Quantity of items
		1316	+ * passed must match quantity of placeholders in
		1317	+ * query: meaning 1 placeholder for non-array
		1318	+ * parameters or 1 placeholder per array element.
		1319	+ *
		1320	+ * @return array an indexed array with the data from the first
		1321	+ * row at index 0, or a DB error code
		1322	+ *
		1323	+ * @see DB_common::query()
		1324	+ * @access public
		1325	+ */
		1326	+ function &getCol($query, $col = 0, $params = array())
		1327	+ {
		1328	+ settype($params, 'array');
		1329	+ if (sizeof($params) > 0) {
		1330	+ $sth = $this->prepare($query);
		1331	+
		1332	+ if (DB::isError($sth)) {
		1333	+ return $sth;
		1334	+ }
		1335	+
		1336	+ $res =& $this->execute($sth, $params);
		1337	+ $this->freePrepared($sth);
		1338	+ } else {
		1339	+ $res =& $this->query($query);
		1340	+ }
		1341	+
		1342	+ if (DB::isError($res)) {
		1343	+ return $res;
		1344	+ }
		1345	+
		1346	+ $fetchmode = is_int($col) ? DB_FETCHMODE_ORDERED : DB_FETCHMODE_ASSOC;
		1347	+
		1348	+ if (!is_array($row = $res->fetchRow($fetchmode))) {
		1349	+ $ret = array();
		1350	+ } else {
		1351	+ if (!array_key_exists($col, $row)) {
		1352	+ $ret =& $this->raiseError(DB_ERROR_NOSUCHFIELD);
		1353	+ } else {
		1354	+ $ret = array($row[$col]);
		1355	+ while (is_array($row = $res->fetchRow($fetchmode))) {
		1356	+ $ret[] = $row[$col];
		1357	+ }
		1358	+ }
		1359	+ }
		1360	+
		1361	+ $res->free();
		1362	+
		1363	+ if (DB::isError($row)) {
		1364	+ $ret = $row;
		1365	+ }
		1366	+
		1367	+ return $ret;
		1368	+ }
		1369	+
		1370	+ // }}}
		1371	+ // {{{ getAssoc()
		1372	+
		1373	+ /**
		1374	+ * Fetch the entire result set of a query and return it as an
		1375	+ * associative array using the first column as the key
		1376	+ *
		1377	+ * If the result set contains more than two columns, the value
		1378	+ * will be an array of the values from column 2-n. If the result
		1379	+ * set contains only two columns, the returned value will be a
		1380	+ * scalar with the value of the second column (unless forced to an
		1381	+ * array with the $force_array parameter). A DB error code is
		1382	+ * returned on errors. If the result set contains fewer than two
		1383	+ * columns, a DB_ERROR_TRUNCATED error is returned.
		1384	+ *
		1385	+ * For example, if the table "mytable" contains:
		1386	+ *
		1387	+ * <pre>
		1388	+ * ID TEXT DATE
		1389	+ * --------------------------------
		1390	+ * 1 'one' 944679408
		1391	+ * 2 'two' 944679408
		1392	+ * 3 'three' 944679408
		1393	+ * </pre>
		1394	+ *
		1395	+ * Then the call getAssoc('SELECT id,text FROM mytable') returns:
		1396	+ * <pre>
		1397	+ * array(
		1398	+ * '1' => 'one',
		1399	+ * '2' => 'two',
		1400	+ * '3' => 'three',
		1401	+ * )
		1402	+ * </pre>
		1403	+ *
		1404	+ * ...while the call getAssoc('SELECT id,text,date FROM mytable') returns:
		1405	+ * <pre>
		1406	+ * array(
		1407	+ * '1' => array('one', '944679408'),
		1408	+ * '2' => array('two', '944679408'),
		1409	+ * '3' => array('three', '944679408')
		1410	+ * )
		1411	+ * </pre>
		1412	+ *
		1413	+ * If the more than one row occurs with the same value in the
		1414	+ * first column, the last row overwrites all previous ones by
		1415	+ * default. Use the $group parameter if you don't want to
		1416	+ * overwrite like this. Example:
		1417	+ *
		1418	+ * <pre>
		1419	+ * getAssoc('SELECT category,id,name FROM mytable', false, null,
		1420	+ * DB_FETCHMODE_ASSOC, true) returns:
		1421	+ *
		1422	+ * array(
		1423	+ * '1' => array(array('id' => '4', 'name' => 'number four'),
		1424	+ * array('id' => '6', 'name' => 'number six')
		1425	+ * ),
		1426	+ * '9' => array(array('id' => '4', 'name' => 'number four'),
		1427	+ * array('id' => '6', 'name' => 'number six')
		1428	+ * )
		1429	+ * )
		1430	+ * </pre>
		1431	+ *
		1432	+ * Keep in mind that database functions in PHP usually return string
		1433	+ * values for results regardless of the database's internal type.
		1434	+ *
		1435	+ * @param string $query the SQL query
		1436	+ * @param boolean $force_array used only when the query returns
		1437	+ * exactly two columns. If true, the values
		1438	+ * of the returned array will be one-element
		1439	+ * arrays instead of scalars.
		1440	+ * @param mixed $params array, string or numeric data to be used in
		1441	+ * execution of the statement. Quantity of items
		1442	+ * passed must match quantity of placeholders in
		1443	+ * query: meaning 1 placeholder for non-array
		1444	+ * parameters or 1 placeholder per array element.
		1445	+ * @param int $fetchmode the fetch mode to use
		1446	+ * @param boolean $group if true, the values of the returned array
		1447	+ * is wrapped in another array. If the same
		1448	+ * key value (in the first column) repeats
		1449	+ * itself, the values will be appended to
		1450	+ * this array instead of overwriting the
		1451	+ * existing values.
		1452	+ *
		1453	+ * @return array associative array with results from the query.
		1454	+ * DB Error on failure.
		1455	+ *
		1456	+ * @access public
		1457	+ */
		1458	+ function &getAssoc($query, $force_array = false, $params = array(),
		1459	+ $fetchmode = DB_FETCHMODE_DEFAULT, $group = false)
		1460	+ {
		1461	+ settype($params, 'array');
		1462	+ if (sizeof($params) > 0) {
		1463	+ $sth = $this->prepare($query);
		1464	+
		1465	+ if (DB::isError($sth)) {
		1466	+ return $sth;
		1467	+ }
		1468	+
		1469	+ $res =& $this->execute($sth, $params);
		1470	+ $this->freePrepared($sth);
		1471	+ } else {
		1472	+ $res =& $this->query($query);
		1473	+ }
		1474	+
		1475	+ if (DB::isError($res)) {
		1476	+ return $res;
		1477	+ }
		1478	+ if ($fetchmode == DB_FETCHMODE_DEFAULT) {
		1479	+ $fetchmode = $this->fetchmode;
		1480	+ }
		1481	+ $cols = $res->numCols();
		1482	+
		1483	+ if ($cols < 2) {
		1484	+ $tmp =& $this->raiseError(DB_ERROR_TRUNCATED);
		1485	+ return $tmp;
		1486	+ }
		1487	+
		1488	+ $results = array();
		1489	+
		1490	+ if ($cols > 2 \|\| $force_array) {
		1491	+ // return array values
		1492	+ // XXX this part can be optimized
		1493	+ if ($fetchmode == DB_FETCHMODE_ASSOC) {
		1494	+ while (is_array($row = $res->fetchRow(DB_FETCHMODE_ASSOC))) {
		1495	+ reset($row);
		1496	+ $key = current($row);
		1497	+ unset($row[key($row)]);
		1498	+ if ($group) {
		1499	+ $results[$key][] = $row;
		1500	+ } else {
		1501	+ $results[$key] = $row;
		1502	+ }
		1503	+ }
		1504	+ } elseif ($fetchmode == DB_FETCHMODE_OBJECT) {
		1505	+ while ($row = $res->fetchRow(DB_FETCHMODE_OBJECT)) {
		1506	+ $arr = get_object_vars($row);
		1507	+ $key = current($arr);
		1508	+ if ($group) {
		1509	+ $results[$key][] = $row;
		1510	+ } else {
		1511	+ $results[$key] = $row;
		1512	+ }
		1513	+ }
		1514	+ } else {
		1515	+ while (is_array($row = $res->fetchRow(DB_FETCHMODE_ORDERED))) {
		1516	+ // we shift away the first element to get
		1517	+ // indices running from 0 again
		1518	+ $key = array_shift($row);
		1519	+ if ($group) {
		1520	+ $results[$key][] = $row;
		1521	+ } else {
		1522	+ $results[$key] = $row;
		1523	+ }
		1524	+ }
		1525	+ }
		1526	+ if (DB::isError($row)) {
		1527	+ $results = $row;
		1528	+ }
		1529	+ } else {
		1530	+ // return scalar values
		1531	+ while (is_array($row = $res->fetchRow(DB_FETCHMODE_ORDERED))) {
		1532	+ if ($group) {
		1533	+ $results[$row[0]][] = $row[1];
		1534	+ } else {
		1535	+ $results[$row[0]] = $row[1];
		1536	+ }
		1537	+ }
		1538	+ if (DB::isError($row)) {
		1539	+ $results = $row;
		1540	+ }
		1541	+ }
		1542	+
		1543	+ $res->free();
		1544	+
		1545	+ return $results;
		1546	+ }
		1547	+
		1548	+ // }}}
		1549	+ // {{{ getAll()
		1550	+
		1551	+ /**
		1552	+ * Fetch all the rows returned from a query
		1553	+ *
		1554	+ * @param string $query the SQL query
		1555	+ * @param array $params array to be used in execution of the statement.
		1556	+ * Quantity of array elements must match quantity
		1557	+ * of placeholders in query. This function does
		1558	+ * NOT support scalars.
		1559	+ * @param int $fetchmode the fetch mode to use
		1560	+ *
		1561	+ * @return array an nested array. DB error on failure.
		1562	+ *
		1563	+ * @access public
		1564	+ */
		1565	+ function &getAll($query,
		1566	+ $params = array(),
		1567	+ $fetchmode = DB_FETCHMODE_DEFAULT)
		1568	+ {
		1569	+ // compat check, the params and fetchmode parameters used to
		1570	+ // have the opposite order
		1571	+ if (!is_array($params)) {
		1572	+ if (is_array($fetchmode)) {
		1573	+ if ($params === null) {
		1574	+ $tmp = DB_FETCHMODE_DEFAULT;
		1575	+ } else {
		1576	+ $tmp = $params;
		1577	+ }
		1578	+ $params = $fetchmode;
		1579	+ $fetchmode = $tmp;
		1580	+ } elseif ($params !== null) {
		1581	+ $fetchmode = $params;
		1582	+ $params = array();
		1583	+ }
		1584	+ }
		1585	+
		1586	+ if (sizeof($params) > 0) {
		1587	+ $sth = $this->prepare($query);
		1588	+
		1589	+ if (DB::isError($sth)) {
		1590	+ return $sth;
		1591	+ }
		1592	+
		1593	+ $res =& $this->execute($sth, $params);
		1594	+ $this->freePrepared($sth);
		1595	+ } else {
		1596	+ $res =& $this->query($query);
		1597	+ }
		1598	+
		1599	+ if (DB::isError($res) \|\| $res === DB_OK) {
		1600	+ return $res;
		1601	+ }
		1602	+
		1603	+ $results = array();
		1604	+ while (DB_OK === $res->fetchInto($row, $fetchmode)) {
		1605	+ if ($fetchmode & DB_FETCHMODE_FLIPPED) {
		1606	+ foreach ($row as $key => $val) {
		1607	+ $results[$key][] = $val;
		1608	+ }
		1609	+ } else {
		1610	+ $results[] = $row;
		1611	+ }
		1612	+ }
		1613	+
		1614	+ $res->free();
		1615	+
		1616	+ if (DB::isError($row)) {
		1617	+ $tmp =& $this->raiseError($row);
		1618	+ return $tmp;
		1619	+ }
		1620	+ return $results;
		1621	+ }
		1622	+
		1623	+ // }}}
		1624	+ // {{{ autoCommit()
		1625	+
		1626	+ /**
		1627	+ * enable automatic Commit
		1628	+ *
		1629	+ * @param boolean $onoff
		1630	+ * @return mixed DB_Error
		1631	+ *
		1632	+ * @access public
		1633	+ */
		1634	+ function autoCommit($onoff=false)
		1635	+ {
		1636	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1637	+ }
		1638	+
		1639	+ // }}}
		1640	+ // {{{ commit()
		1641	+
		1642	+ /**
		1643	+ * starts a Commit
		1644	+ *
		1645	+ * @return mixed DB_Error
		1646	+ *
		1647	+ * @access public
		1648	+ */
		1649	+ function commit()
		1650	+ {
		1651	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1652	+ }
		1653	+
		1654	+ // }}}
		1655	+ // {{{ rollback()
		1656	+
		1657	+ /**
		1658	+ * starts a rollback
		1659	+ *
		1660	+ * @return mixed DB_Error
		1661	+ *
		1662	+ * @access public
		1663	+ */
		1664	+ function rollback()
		1665	+ {
		1666	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1667	+ }
		1668	+
		1669	+ // }}}
		1670	+ // {{{ numRows()
		1671	+
		1672	+ /**
		1673	+ * Returns the number of rows in a result object
		1674	+ *
		1675	+ * @param object DB_Result the result object to check
		1676	+ *
		1677	+ * @return mixed DB_Error or the number of rows
		1678	+ *
		1679	+ * @access public
		1680	+ */
		1681	+ function numRows($result)
		1682	+ {
		1683	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1684	+ }
		1685	+
		1686	+ // }}}
		1687	+ // {{{ affectedRows()
		1688	+
		1689	+ /**
		1690	+ * Returns the affected rows of a query
		1691	+ *
		1692	+ * @return mixed DB_Error or number of rows
		1693	+ *
		1694	+ * @access public
		1695	+ */
		1696	+ function affectedRows()
		1697	+ {
		1698	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1699	+ }
		1700	+
		1701	+ // }}}
		1702	+ // {{{ errorNative()
		1703	+
		1704	+ /**
		1705	+ * Returns an errormessage, provides by the database
		1706	+ *
		1707	+ * @return mixed DB_Error or message
		1708	+ *
		1709	+ * @access public
		1710	+ */
		1711	+ function errorNative()
		1712	+ {
		1713	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1714	+ }
		1715	+
		1716	+ // }}}
		1717	+ // {{{ getSequenceName()
		1718	+
		1719	+ /**
		1720	+ * Generate the name used inside the database for a sequence
		1721	+ *
		1722	+ * The createSequence() docblock contains notes about storing sequence
		1723	+ * names.
		1724	+ *
		1725	+ * @param string $sqn the sequence's public name
		1726	+ *
		1727	+ * @return string the sequence's name in the backend
		1728	+ *
		1729	+ * @see DB_common::createSequence(), DB_common::dropSequence(),
		1730	+ * DB_common::nextID(), DB_common::setOption()
		1731	+ * @access private
		1732	+ */
		1733	+ function getSequenceName($sqn)
		1734	+ {
		1735	+ return sprintf($this->getOption('seqname_format'),
		1736	+ preg_replace('/[^a-z0-9_.]/i', '_', $sqn));
		1737	+ }
		1738	+
		1739	+ // }}}
		1740	+ // {{{ nextId()
		1741	+
		1742	+ /**
		1743	+ * Returns the next free id in a sequence
		1744	+ *
		1745	+ * @param string $seq_name name of the sequence
		1746	+ * @param boolean $ondemand when true, the seqence is automatically
		1747	+ * created if it does not exist
		1748	+ *
		1749	+ * @return int the next id number in the sequence. DB_Error if problem.
		1750	+ *
		1751	+ * @see DB_common::createSequence(), DB_common::dropSequence(),
		1752	+ * DB_common::getSequenceName()
		1753	+ * @access public
		1754	+ */
		1755	+ function nextId($seq_name, $ondemand = true)
		1756	+ {
		1757	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1758	+ }
		1759	+
		1760	+ // }}}
		1761	+ // {{{ createSequence()
		1762	+
		1763	+ /**
		1764	+ * Creates a new sequence
		1765	+ *
		1766	+ * The name of a given sequence is determined by passing the string
		1767	+ * provided in the <var>$seq_name</var> argument through PHP's sprintf()
		1768	+ * function using the value from the <var>seqname_format</var> option as
		1769	+ * the sprintf()'s format argument.
		1770	+ *
		1771	+ * <var>seqname_format</var> is set via setOption().
		1772	+ *
		1773	+ * @param string $seq_name name of the new sequence
		1774	+ *
		1775	+ * @return int DB_OK on success. A DB_Error object is returned if
		1776	+ * problems arise.
		1777	+ *
		1778	+ * @see DB_common::dropSequence(), DB_common::getSequenceName(),
		1779	+ * DB_common::nextID()
		1780	+ * @access public
		1781	+ */
		1782	+ function createSequence($seq_name)
		1783	+ {
		1784	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1785	+ }
		1786	+
		1787	+ // }}}
		1788	+ // {{{ dropSequence()
		1789	+
		1790	+ /**
		1791	+ * Deletes a sequence
		1792	+ *
		1793	+ * @param string $seq_name name of the sequence to be deleted
		1794	+ *
		1795	+ * @return int DB_OK on success. DB_Error if problems.
		1796	+ *
		1797	+ * @see DB_common::createSequence(), DB_common::getSequenceName(),
		1798	+ * DB_common::nextID()
		1799	+ * @access public
		1800	+ */
		1801	+ function dropSequence($seq_name)
		1802	+ {
		1803	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1804	+ }
		1805	+
		1806	+ // }}}
		1807	+ // {{{ tableInfo()
		1808	+
		1809	+ /**
		1810	+ * Returns information about a table or a result set
		1811	+ *
		1812	+ * The format of the resulting array depends on which <var>$mode</var>
		1813	+ * you select. The sample output below is based on this query:
		1814	+ * <pre>
		1815	+ * SELECT tblFoo.fldID, tblFoo.fldPhone, tblBar.fldId
		1816	+ * FROM tblFoo
		1817	+ * JOIN tblBar ON tblFoo.fldId = tblBar.fldId
		1818	+ * </pre>
		1819	+ *
		1820	+ * <ul>
		1821	+ * <li>
		1822	+ *
		1823	+ * <kbd>null</kbd> (default)
		1824	+ * <pre>
		1825	+ * [0] => Array (
		1826	+ * [table] => tblFoo
		1827	+ * [name] => fldId
		1828	+ * [type] => int
		1829	+ * [len] => 11
		1830	+ * [flags] => primary_key not_null
		1831	+ * )
		1832	+ * [1] => Array (
		1833	+ * [table] => tblFoo
		1834	+ * [name] => fldPhone
		1835	+ * [type] => string
		1836	+ * [len] => 20
		1837	+ * [flags] =>
		1838	+ * )
		1839	+ * [2] => Array (
		1840	+ * [table] => tblBar
		1841	+ * [name] => fldId
		1842	+ * [type] => int
		1843	+ * [len] => 11
		1844	+ * [flags] => primary_key not_null
		1845	+ * )
		1846	+ * </pre>
		1847	+ *
		1848	+ * </li><li>
		1849	+ *
		1850	+ * <kbd>DB_TABLEINFO_ORDER</kbd>
		1851	+ *
		1852	+ * <p>In addition to the information found in the default output,
		1853	+ * a notation of the number of columns is provided by the
		1854	+ * <samp>num_fields</samp> element while the <samp>order</samp>
		1855	+ * element provides an array with the column names as the keys and
		1856	+ * their location index number (corresponding to the keys in the
		1857	+ * the default output) as the values.</p>
		1858	+ *
		1859	+ * <p>If a result set has identical field names, the last one is
		1860	+ * used.</p>
		1861	+ *
		1862	+ * <pre>
		1863	+ * [num_fields] => 3
		1864	+ * [order] => Array (
		1865	+ * [fldId] => 2
		1866	+ * [fldTrans] => 1
		1867	+ * )
		1868	+ * </pre>
		1869	+ *
		1870	+ * </li><li>
		1871	+ *
		1872	+ * <kbd>DB_TABLEINFO_ORDERTABLE</kbd>
		1873	+ *
		1874	+ * <p>Similar to <kbd>DB_TABLEINFO_ORDER</kbd> but adds more
		1875	+ * dimensions to the array in which the table names are keys and
		1876	+ * the field names are sub-keys. This is helpful for queries that
		1877	+ * join tables which have identical field names.</p>
		1878	+ *
		1879	+ * <pre>
		1880	+ * [num_fields] => 3
		1881	+ * [ordertable] => Array (
		1882	+ * [tblFoo] => Array (
		1883	+ * [fldId] => 0
		1884	+ * [fldPhone] => 1
		1885	+ * )
		1886	+ * [tblBar] => Array (
		1887	+ * [fldId] => 2
		1888	+ * )
		1889	+ * )
		1890	+ * </pre>
		1891	+ *
		1892	+ * </li>
		1893	+ * </ul>
		1894	+ *
		1895	+ * The <samp>flags</samp> element contains a space separated list
		1896	+ * of extra information about the field. This data is inconsistent
		1897	+ * between DBMS's due to the way each DBMS works.
		1898	+ * + <samp>primary_key</samp>
		1899	+ * + <samp>unique_key</samp>
		1900	+ * + <samp>multiple_key</samp>
		1901	+ * + <samp>not_null</samp>
		1902	+ *
		1903	+ * Most DBMS's only provide the <samp>table</samp> and <samp>flags</samp>
		1904	+ * elements if <var>$result</var> is a table name. The following DBMS's
		1905	+ * provide full information from queries:
		1906	+ * + fbsql
		1907	+ * + mysql
		1908	+ *
		1909	+ * If the 'portability' option has <samp>DB_PORTABILITY_LOWERCASE</samp>
		1910	+ * turned on, the names of tables and fields will be lowercased.
		1911	+ *
		1912	+ * @param object\|string $result DB_result object from a query or a
		1913	+ * string containing the name of a table.
		1914	+ * While this also accepts a query result
		1915	+ * resource identifier, this behavior is
		1916	+ * deprecated.
		1917	+ * @param int $mode either unused or one of the tableInfo modes:
		1918	+ * <kbd>DB_TABLEINFO_ORDERTABLE</kbd>,
		1919	+ * <kbd>DB_TABLEINFO_ORDER</kbd> or
		1920	+ * <kbd>DB_TABLEINFO_FULL</kbd> (which does both).
		1921	+ * These are bitwise, so the first two can be
		1922	+ * combined using <kbd>\|</kbd>.
		1923	+ * @return array an associative array with the information requested.
		1924	+ * If something goes wrong an error object is returned.
		1925	+ *
		1926	+ * @see DB_common::setOption()
		1927	+ * @access public
		1928	+ */
		1929	+ function tableInfo($result, $mode = null)
		1930	+ {
		1931	+ /*
		1932	+ * If the DB_<driver> class has a tableInfo() method, that one
		1933	+ * overrides this one. But, if the driver doesn't have one,
		1934	+ * this method runs and tells users about that fact.
		1935	+ */
		1936	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		1937	+ }
		1938	+
		1939	+ // }}}
		1940	+ // {{{ getTables()
		1941	+
		1942	+ /**
		1943	+ * @deprecated Deprecated in release 1.2 or lower
		1944	+ */
		1945	+ function getTables()
		1946	+ {
		1947	+ return $this->getListOf('tables');
		1948	+ }
		1949	+
		1950	+ // }}}
		1951	+ // {{{ getListOf()
		1952	+
		1953	+ /**
		1954	+ * list internal DB info
		1955	+ * valid values for $type are db dependent,
		1956	+ * often: databases, users, view, functions
		1957	+ *
		1958	+ * @param string $type type of requested info
		1959	+ *
		1960	+ * @return mixed DB_Error or the requested data
		1961	+ *
		1962	+ * @access public
		1963	+ */
		1964	+ function getListOf($type)
		1965	+ {
		1966	+ $sql = $this->getSpecialQuery($type);
		1967	+ if ($sql === null) { // No support
		1968	+ return $this->raiseError(DB_ERROR_UNSUPPORTED);
		1969	+ } elseif (is_int($sql) \|\| DB::isError($sql)) { // Previous error
		1970	+ return $this->raiseError($sql);
		1971	+ } elseif (is_array($sql)) { // Already the result
		1972	+ return $sql;
		1973	+ }
		1974	+ return $this->getCol($sql); // Launch this query
		1975	+ }
		1976	+
		1977	+ // }}}
		1978	+ // {{{ getSpecialQuery()
		1979	+
		1980	+ /**
		1981	+ * Returns the query needed to get some backend info
		1982	+ *
		1983	+ * @param string $type What kind of info you want to retrieve
		1984	+ *
		1985	+ * @return string The SQL query string
		1986	+ *
		1987	+ * @access public
		1988	+ */
		1989	+ function getSpecialQuery($type)
		1990	+ {
		1991	+ return $this->raiseError(DB_ERROR_UNSUPPORTED);
		1992	+ }
		1993	+
		1994	+ // }}}
		1995	+ // {{{ _rtrimArrayValues()
		1996	+
		1997	+ /**
		1998	+ * Right trim all strings in an array
		1999	+ *
		2000	+ * @param array $array the array to be trimmed (passed by reference)
		2001	+ * @return void
		2002	+ * @access private
		2003	+ */
		2004	+ function _rtrimArrayValues(&$array)
		2005	+ {
		2006	+ foreach ($array as $key => $value) {
		2007	+ if (is_string($value)) {
		2008	+ $array[$key] = rtrim($value);
		2009	+ }
		2010	+ }
		2011	+ }
		2012	+
		2013	+ // }}}
		2014	+ // {{{ _convertNullArrayValuesToEmpty()
		2015	+
		2016	+ /**
		2017	+ * Convert all null values in an array to empty strings
		2018	+ *
		2019	+ * @param array $array the array to be de-nullified (passed by reference)
		2020	+ * @return void
		2021	+ * @access private
		2022	+ */
		2023	+ function _convertNullArrayValuesToEmpty(&$array)
		2024	+ {
		2025	+ foreach ($array as $key => $value) {
		2026	+ if (is_null($value)) {
		2027	+ $array[$key] = '';
		2028	+ }
		2029	+ }
		2030	+ }
		2031	+
		2032	+ // }}}
		2033	+}
		2034	+
		2035	+/*
		2036	+ * Local variables:
		2037	+ * tab-width: 4
		2038	+ * c-basic-offset: 4
		2039	+ * End:
		2040	+ */
		2041	+
		2042	+?>

pear/DB/dbase.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Tomas V.V.Cox <cox@idecnet.com> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// XXX legend:
		24	+// You have to compile your PHP with the --enable-dbase option
		25	+
		26	+
		27	+require_once 'DB/common.php';
		28	+
		29	+/**
		30	+ * Database independent query interface definition for PHP's dbase
		31	+ * extension.
		32	+ *
		33	+ * @package DB
		34	+ * @version $Id$
		35	+ * @category Database
		36	+ * @author Stig Bakken <ssb@php.net>
		37	+ */
		38	+class DB_dbase extends DB_common
		39	+{
		40	+ // {{{ properties
		41	+
		42	+ var $connection;
		43	+ var $phptype, $dbsyntax;
		44	+ var $prepare_tokens = array();
		45	+ var $prepare_types = array();
		46	+ var $res_row = array();
		47	+ var $result = 0;
		48	+
		49	+ // }}}
		50	+ // {{{ constructor
		51	+
		52	+ /**
		53	+ * DB_mysql constructor.
		54	+ *
		55	+ * @access public
		56	+ */
		57	+ function DB_dbase()
		58	+ {
		59	+ $this->DB_common();
		60	+ $this->phptype = 'dbase';
		61	+ $this->dbsyntax = 'dbase';
		62	+ $this->features = array(
		63	+ 'prepare' => false,
		64	+ 'pconnect' => false,
		65	+ 'transactions' => false,
		66	+ 'limit' => false
		67	+ );
		68	+ $this->errorcode_map = array();
		69	+ }
		70	+
		71	+ // }}}
		72	+ // {{{ connect()
		73	+
		74	+ function connect($dsninfo, $persistent = false)
		75	+ {
		76	+ if (!DB::assertExtension('dbase')) {
		77	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		78	+ }
		79	+ $this->dsn = $dsninfo;
		80	+
		81	+ $ini = ini_get('track_errors');
		82	+ if ($ini) {
		83	+ $conn = @dbase_open($dsninfo['database'], 0);
		84	+ } else {
		85	+ ini_set('track_errors', 1);
		86	+ $conn = @dbase_open($dsninfo['database'], 0);
		87	+ ini_set('track_errors', $ini);
		88	+ }
		89	+ if (!$conn) {
		90	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null,
		91	+ null, null, strip_tags($php_errormsg));
		92	+ }
		93	+ $this->connection = $conn;
		94	+ return DB_OK;
		95	+ }
		96	+
		97	+ // }}}
		98	+ // {{{ disconnect()
		99	+
		100	+ function disconnect()
		101	+ {
		102	+ $ret = @dbase_close($this->connection);
		103	+ $this->connection = null;
		104	+ return $ret;
		105	+ }
		106	+
		107	+ // }}}
		108	+ // {{{ &query()
		109	+
		110	+ function &query($query = null)
		111	+ {
		112	+ // emulate result resources
		113	+ $this->res_row[(int)$this->result] = 0;
		114	+ $tmp =& new DB_result($this, $this->result++);
		115	+ return $tmp;
		116	+ }
		117	+
		118	+ // }}}
		119	+ // {{{ fetchInto()
		120	+
		121	+ /**
		122	+ * Fetch a row and insert the data into an existing array.
		123	+ *
		124	+ * Formating of the array and the data therein are configurable.
		125	+ * See DB_result::fetchInto() for more information.
		126	+ *
		127	+ * @param resource $result query result identifier
		128	+ * @param array $arr (reference) array where data from the row
		129	+ * should be placed
		130	+ * @param int $fetchmode how the resulting array should be indexed
		131	+ * @param int $rownum the row number to fetch
		132	+ *
		133	+ * @return mixed DB_OK on success, null when end of result set is
		134	+ * reached or on failure
		135	+ *
		136	+ * @see DB_result::fetchInto()
		137	+ * @access private
		138	+ */
		139	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		140	+ {
		141	+ if ($rownum === null) {
		142	+ $rownum = $this->res_row[(int)$result]++;
		143	+ }
		144	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		145	+ $arr = @dbase_get_record_with_names($this->connection, $rownum);
		146	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		147	+ $arr = array_change_key_case($arr, CASE_LOWER);
		148	+ }
		149	+ } else {
		150	+ $arr = @dbase_get_record($this->connection, $rownum);
		151	+ }
		152	+ if (!$arr) {
		153	+ return null;
		154	+ }
		155	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		156	+ $this->_rtrimArrayValues($arr);
		157	+ }
		158	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		159	+ $this->_convertNullArrayValuesToEmpty($arr);
		160	+ }
		161	+ return DB_OK;
		162	+ }
		163	+
		164	+ // }}}
		165	+ // {{{ numCols()
		166	+
		167	+ function numCols($foo)
		168	+ {
		169	+ return @dbase_numfields($this->connection);
		170	+ }
		171	+
		172	+ // }}}
		173	+ // {{{ numRows()
		174	+
		175	+ function numRows($foo)
		176	+ {
		177	+ return @dbase_numrecords($this->connection);
		178	+ }
		179	+
		180	+ // }}}
		181	+ // {{{ quoteSmart()
		182	+
		183	+ /**
		184	+ * Format input so it can be safely used in a query
		185	+ *
		186	+ * @param mixed $in data to be quoted
		187	+ *
		188	+ * @return mixed Submitted variable's type = returned value:
		189	+ * + null = the string <samp>NULL</samp>
		190	+ * + boolean = <samp>T</samp> if true or
		191	+ * <samp>F</samp> if false. Use the <kbd>Logical</kbd>
		192	+ * data type.
		193	+ * + integer or double = the unquoted number
		194	+ * + other (including strings and numeric strings) =
		195	+ * the data with single quotes escaped by preceeding
		196	+ * single quotes then the whole string is encapsulated
		197	+ * between single quotes
		198	+ *
		199	+ * @internal
		200	+ */
		201	+ function quoteSmart($in)
		202	+ {
		203	+ if (is_int($in) \|\| is_double($in)) {
		204	+ return $in;
		205	+ } elseif (is_bool($in)) {
		206	+ return $in ? 'T' : 'F';
		207	+ } elseif (is_null($in)) {
		208	+ return 'NULL';
		209	+ } else {
		210	+ return "'" . $this->escapeSimple($in) . "'";
		211	+ }
		212	+ }
		213	+
		214	+ // }}}
		215	+
		216	+}
		217	+
		218	+/*
		219	+ * Local variables:
		220	+ * tab-width: 4
		221	+ * c-basic-offset: 4
		222	+ * End:
		223	+ */
		224	+
		225	+?>

pear/DB/fbsql.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Frank M. Kromann <frank@frontbase.com> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// XXX legend:
		24	+//
		25	+// XXX ERRORMSG: The error message from the fbsql function should
		26	+// be registered here.
		27	+//
		28	+// TODO/wishlist:
		29	+// longReadlen
		30	+// binmode
		31	+
		32	+
		33	+require_once 'DB/common.php';
		34	+
		35	+/**
		36	+ * Database independent query interface definition for PHP's FrontBase
		37	+ * extension.
		38	+ *
		39	+ * @package DB
		40	+ * @version $Id$
		41	+ * @category Database
		42	+ * @author Frank M. Kromann <frank@frontbase.com>
		43	+ */
		44	+class DB_fbsql extends DB_common
		45	+{
		46	+ // {{{ properties
		47	+
		48	+ var $connection;
		49	+ var $phptype, $dbsyntax;
		50	+ var $prepare_tokens = array();
		51	+ var $prepare_types = array();
		52	+ var $num_rows = array();
		53	+ var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */
		54	+
		55	+ // }}}
		56	+ // {{{ constructor
		57	+
		58	+ /**
		59	+ * DB_fbsql constructor.
		60	+ *
		61	+ * @access public
		62	+ */
		63	+ function DB_fbsql()
		64	+ {
		65	+ $this->DB_common();
		66	+ $this->phptype = 'fbsql';
		67	+ $this->dbsyntax = 'fbsql';
		68	+ $this->features = array(
		69	+ 'prepare' => false,
		70	+ 'pconnect' => true,
		71	+ 'transactions' => true,
		72	+ 'limit' => 'emulate'
		73	+ );
		74	+ $this->errorcode_map = array(
		75	+ 1004 => DB_ERROR_CANNOT_CREATE,
		76	+ 1005 => DB_ERROR_CANNOT_CREATE,
		77	+ 1006 => DB_ERROR_CANNOT_CREATE,
		78	+ 1007 => DB_ERROR_ALREADY_EXISTS,
		79	+ 1008 => DB_ERROR_CANNOT_DROP,
		80	+ 1046 => DB_ERROR_NODBSELECTED,
		81	+ 1050 => DB_ERROR_ALREADY_EXISTS,
		82	+ 1051 => DB_ERROR_NOSUCHTABLE,
		83	+ 1054 => DB_ERROR_NOSUCHFIELD,
		84	+ 1062 => DB_ERROR_ALREADY_EXISTS,
		85	+ 1064 => DB_ERROR_SYNTAX,
		86	+ 1100 => DB_ERROR_NOT_LOCKED,
		87	+ 1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
		88	+ 1146 => DB_ERROR_NOSUCHTABLE,
		89	+ );
		90	+ }
		91	+
		92	+ // }}}
		93	+ // {{{ connect()
		94	+
		95	+ /**
		96	+ * Connect to a database and log in as the specified user.
		97	+ *
		98	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		99	+ * @param $persistent (optional) whether the connection should
		100	+ * be persistent
		101	+ * @access public
		102	+ * @return int DB_OK on success, a DB error on failure
		103	+ */
		104	+ function connect($dsninfo, $persistent = false)
		105	+ {
		106	+ if (!DB::assertExtension('fbsql')) {
		107	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		108	+ }
		109	+
		110	+ $this->dsn = $dsninfo;
		111	+ $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
		112	+
		113	+ $php_errormsg = '';
		114	+ $connect_function = $persistent ? 'fbsql_pconnect' : 'fbsql_connect';
		115	+
		116	+ if ($dbhost && $dsninfo['username'] && $dsninfo['password']) {
		117	+ $conn = @$connect_function($dbhost, $dsninfo['username'],
		118	+ $dsninfo['password']);
		119	+ } elseif ($dbhost && $dsninfo['username']) {
		120	+ $conn = @$connect_function($dbhost, $dsninfo['username']);
		121	+ } elseif ($dbhost) {
		122	+ $conn = @$connect_function($dbhost);
		123	+ } else {
		124	+ $conn = false;
		125	+ }
		126	+ if (!$conn) {
		127	+ if (empty($php_errormsg)) {
		128	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED);
		129	+ } else {
		130	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		131	+ null, $php_errormsg);
		132	+ }
		133	+ }
		134	+
		135	+ if ($dsninfo['database']) {
		136	+ if (!fbsql_select_db($dsninfo['database'], $conn)) {
		137	+ return $this->fbsqlRaiseError();
		138	+ }
		139	+ }
		140	+
		141	+ $this->connection = $conn;
		142	+ return DB_OK;
		143	+ }
		144	+
		145	+ // }}}
		146	+ // {{{ disconnect()
		147	+
		148	+ /**
		149	+ * Log out and disconnect from the database.
		150	+ *
		151	+ * @access public
		152	+ *
		153	+ * @return bool true on success, false if not connected.
		154	+ */
		155	+ function disconnect()
		156	+ {
		157	+ $ret = @fbsql_close($this->connection);
		158	+ $this->connection = null;
		159	+ return $ret;
		160	+ }
		161	+
		162	+ // }}}
		163	+ // {{{ simpleQuery()
		164	+
		165	+ /**
		166	+ * Send a query to fbsql and return the results as a fbsql resource
		167	+ * identifier.
		168	+ *
		169	+ * @param the SQL query
		170	+ *
		171	+ * @access public
		172	+ *
		173	+ * @return mixed returns a valid fbsql result for successful SELECT
		174	+ * queries, DB_OK for other successful queries. A DB error is
		175	+ * returned on failure.
		176	+ */
		177	+ function simpleQuery($query)
		178	+ {
		179	+ $this->last_query = $query;
		180	+ $query = $this->modifyQuery($query);
		181	+ $result = @fbsql_query("$query;", $this->connection);
		182	+ if (!$result) {
		183	+ return $this->fbsqlRaiseError();
		184	+ }
		185	+ // Determine which queries that should return data, and which
		186	+ // should return an error code only.
		187	+ if (DB::isManip($query)) {
		188	+ return DB_OK;
		189	+ }
		190	+ $numrows = $this->numrows($result);
		191	+ if (is_object($numrows)) {
		192	+ return $numrows;
		193	+ }
		194	+ $this->num_rows[(int)$result] = $numrows;
		195	+ return $result;
		196	+ }
		197	+
		198	+ // }}}
		199	+ // {{{ nextResult()
		200	+
		201	+ /**
		202	+ * Move the internal fbsql result pointer to the next available result
		203	+ *
		204	+ * @param a valid fbsql result resource
		205	+ *
		206	+ * @access public
		207	+ *
		208	+ * @return true if a result is available otherwise return false
		209	+ */
		210	+ function nextResult($result)
		211	+ {
		212	+ return @fbsql_next_result($result);
		213	+ }
		214	+
		215	+ // }}}
		216	+ // {{{ fetchInto()
		217	+
		218	+ /**
		219	+ * Fetch a row and insert the data into an existing array.
		220	+ *
		221	+ * Formating of the array and the data therein are configurable.
		222	+ * See DB_result::fetchInto() for more information.
		223	+ *
		224	+ * @param resource $result query result identifier
		225	+ * @param array $arr (reference) array where data from the row
		226	+ * should be placed
		227	+ * @param int $fetchmode how the resulting array should be indexed
		228	+ * @param int $rownum the row number to fetch
		229	+ *
		230	+ * @return mixed DB_OK on success, null when end of result set is
		231	+ * reached or on failure
		232	+ *
		233	+ * @see DB_result::fetchInto()
		234	+ * @access private
		235	+ */
		236	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		237	+ {
		238	+ if ($rownum !== null) {
		239	+ if (!@fbsql_data_seek($result, $rownum)) {
		240	+ return null;
		241	+ }
		242	+ }
		243	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		244	+ $arr = @fbsql_fetch_array($result, FBSQL_ASSOC);
		245	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		246	+ $arr = array_change_key_case($arr, CASE_LOWER);
		247	+ }
		248	+ } else {
		249	+ $arr = @fbsql_fetch_row($result);
		250	+ }
		251	+ if (!$arr) {
		252	+ $errno = @fbsql_errno($this->connection);
		253	+ if (!$errno) {
		254	+ return null;
		255	+ }
		256	+ return $this->fbsqlRaiseError($errno);
		257	+ }
		258	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		259	+ $this->_rtrimArrayValues($arr);
		260	+ }
		261	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		262	+ $this->_convertNullArrayValuesToEmpty($arr);
		263	+ }
		264	+ return DB_OK;
		265	+ }
		266	+
		267	+ // }}}
		268	+ // {{{ freeResult()
		269	+
		270	+ /**
		271	+ * Free the internal resources associated with $result.
		272	+ *
		273	+ * @param $result fbsql result identifier
		274	+ *
		275	+ * @access public
		276	+ *
		277	+ * @return bool true on success, false if $result is invalid
		278	+ */
		279	+ function freeResult($result)
		280	+ {
		281	+ return @fbsql_free_result($result);
		282	+ }
		283	+
		284	+ // }}}
		285	+ // {{{ autoCommit()
		286	+
		287	+ function autoCommit($onoff=false)
		288	+ {
		289	+ if ($onoff) {
		290	+ $this->query("SET COMMIT TRUE");
		291	+ } else {
		292	+ $this->query("SET COMMIT FALSE");
		293	+ }
		294	+ }
		295	+
		296	+ // }}}
		297	+ // {{{ commit()
		298	+
		299	+ function commit()
		300	+ {
		301	+ @fbsql_commit();
		302	+ }
		303	+
		304	+ // }}}
		305	+ // {{{ rollback()
		306	+
		307	+ function rollback()
		308	+ {
		309	+ @fbsql_rollback();
		310	+ }
		311	+
		312	+ // }}}
		313	+ // {{{ numCols()
		314	+
		315	+ /**
		316	+ * Get the number of columns in a result set.
		317	+ *
		318	+ * @param $result fbsql result identifier
		319	+ *
		320	+ * @access public
		321	+ *
		322	+ * @return int the number of columns per row in $result
		323	+ */
		324	+ function numCols($result)
		325	+ {
		326	+ $cols = @fbsql_num_fields($result);
		327	+
		328	+ if (!$cols) {
		329	+ return $this->fbsqlRaiseError();
		330	+ }
		331	+
		332	+ return $cols;
		333	+ }
		334	+
		335	+ // }}}
		336	+ // {{{ numRows()
		337	+
		338	+ /**
		339	+ * Get the number of rows in a result set.
		340	+ *
		341	+ * @param $result fbsql result identifier
		342	+ *
		343	+ * @access public
		344	+ *
		345	+ * @return int the number of rows in $result
		346	+ */
		347	+ function numRows($result)
		348	+ {
		349	+ $rows = @fbsql_num_rows($result);
		350	+ if ($rows === null) {
		351	+ return $this->fbsqlRaiseError();
		352	+ }
		353	+ return $rows;
		354	+ }
		355	+
		356	+ // }}}
		357	+ // {{{ affectedRows()
		358	+
		359	+ /**
		360	+ * Gets the number of rows affected by the data manipulation
		361	+ * query. For other queries, this function returns 0.
		362	+ *
		363	+ * @return number of rows affected by the last query
		364	+ */
		365	+ function affectedRows()
		366	+ {
		367	+ if (DB::isManip($this->last_query)) {
		368	+ $result = @fbsql_affected_rows($this->connection);
		369	+ } else {
		370	+ $result = 0;
		371	+ }
		372	+ return $result;
		373	+ }
		374	+
		375	+ // }}}
		376	+ // {{{ errorNative()
		377	+
		378	+ /**
		379	+ * Get the native error code of the last error (if any) that
		380	+ * occured on the current connection.
		381	+ *
		382	+ * @access public
		383	+ *
		384	+ * @return int native fbsql error code
		385	+ */
		386	+ function errorNative()
		387	+ {
		388	+ return @fbsql_errno($this->connection);
		389	+ }
		390	+
		391	+ // }}}
		392	+ // {{{ nextId()
		393	+
		394	+ /**
		395	+ * Returns the next free id in a sequence
		396	+ *
		397	+ * @param string $seq_name name of the sequence
		398	+ * @param boolean $ondemand when true, the seqence is automatically
		399	+ * created if it does not exist
		400	+ *
		401	+ * @return int the next id number in the sequence. DB_Error if problem.
		402	+ *
		403	+ * @internal
		404	+ * @see DB_common::nextID()
		405	+ * @access public
		406	+ */
		407	+ function nextId($seq_name, $ondemand = true)
		408	+ {
		409	+ $seqname = $this->getSequenceName($seq_name);
		410	+ $repeat = 0;
		411	+ do {
		412	+ $result = $this->query("INSERT INTO ${seqname} (id) VALUES (NULL)");
		413	+ if ($ondemand && DB::isError($result) &&
		414	+ $result->getCode() == DB_ERROR_NOSUCHTABLE) {
		415	+ $repeat = 1;
		416	+ $result = $this->createSequence($seq_name);
		417	+ if (DB::isError($result)) {
		418	+ return $result;
		419	+ }
		420	+ } else {
		421	+ $repeat = 0;
		422	+ }
		423	+ } while ($repeat);
		424	+ if (DB::isError($result)) {
		425	+ return $result;
		426	+ }
		427	+ return @fbsql_insert_id($this->connection);
		428	+ }
		429	+
		430	+ /**
		431	+ * Creates a new sequence
		432	+ *
		433	+ * @param string $seq_name name of the new sequence
		434	+ *
		435	+ * @return int DB_OK on success. A DB_Error object is returned if
		436	+ * problems arise.
		437	+ *
		438	+ * @internal
		439	+ * @see DB_common::createSequence()
		440	+ * @access public
		441	+ */
		442	+ function createSequence($seq_name)
		443	+ {
		444	+ $seqname = $this->getSequenceName($seq_name);
		445	+ return $this->query("CREATE TABLE ${seqname} ".
		446	+ '(id INTEGER UNSIGNED AUTO_INCREMENT NOT NULL,'.
		447	+ ' PRIMARY KEY(id))');
		448	+ }
		449	+
		450	+ // }}}
		451	+ // {{{ dropSequence()
		452	+
		453	+ /**
		454	+ * Deletes a sequence
		455	+ *
		456	+ * @param string $seq_name name of the sequence to be deleted
		457	+ *
		458	+ * @return int DB_OK on success. DB_Error if problems.
		459	+ *
		460	+ * @internal
		461	+ * @see DB_common::dropSequence()
		462	+ * @access public
		463	+ */
		464	+ function dropSequence($seq_name)
		465	+ {
		466	+ $seqname = $this->getSequenceName($seq_name);
		467	+ return $this->query("DROP TABLE ${seqname} RESTRICT");
		468	+ }
		469	+
		470	+ // }}}
		471	+ // {{{ modifyQuery()
		472	+
		473	+ function modifyQuery($query)
		474	+ {
		475	+ if ($this->options['portability'] & DB_PORTABILITY_DELETE_COUNT) {
		476	+ // "DELETE FROM table" gives 0 affected rows in fbsql.
		477	+ // This little hack lets you know how many rows were deleted.
		478	+ if (preg_match('/^\sDELETE\s+FROM\s+(\S+)\s$/i', $query)) {
		479	+ $query = preg_replace('/^\sDELETE\s+FROM\s+(\S+)\s$/',
		480	+ 'DELETE FROM \1 WHERE 1=1', $query);
		481	+ }
		482	+ }
		483	+ return $query;
		484	+ }
		485	+
		486	+ // }}}
		487	+ // {{{ quoteSmart()
		488	+
		489	+ /**
		490	+ * Format input so it can be safely used in a query
		491	+ *
		492	+ * @param mixed $in data to be quoted
		493	+ *
		494	+ * @return mixed Submitted variable's type = returned value:
		495	+ * + null = the string <samp>NULL</samp>
		496	+ * + boolean = string <samp>TRUE</samp> or <samp>FALSE</samp>
		497	+ * + integer or double = the unquoted number
		498	+ * + other (including strings and numeric strings) =
		499	+ * the data escaped according to MySQL's settings
		500	+ * then encapsulated between single quotes
		501	+ *
		502	+ * @internal
		503	+ */
		504	+ function quoteSmart($in)
		505	+ {
		506	+ if (is_int($in) \|\| is_double($in)) {
		507	+ return $in;
		508	+ } elseif (is_bool($in)) {
		509	+ return $in ? 'TRUE' : 'FALSE';
		510	+ } elseif (is_null($in)) {
		511	+ return 'NULL';
		512	+ } else {
		513	+ return "'" . $this->escapeSimple($in) . "'";
		514	+ }
		515	+ }
		516	+
		517	+ // }}}
		518	+ // {{{ fbsqlRaiseError()
		519	+
		520	+ /**
		521	+ * Gather information about an error, then use that info to create a
		522	+ * DB error object and finally return that object.
		523	+ *
		524	+ * @param integer $errno PEAR error number (usually a DB constant) if
		525	+ * manually raising an error
		526	+ * @return object DB error object
		527	+ * @see DB_common::errorCode()
		528	+ * @see DB_common::raiseError()
		529	+ */
		530	+ function fbsqlRaiseError($errno = null)
		531	+ {
		532	+ if ($errno === null) {
		533	+ $errno = $this->errorCode(fbsql_errno($this->connection));
		534	+ }
		535	+ return $this->raiseError($errno, null, null, null,
		536	+ @fbsql_error($this->connection));
		537	+ }
		538	+
		539	+ // }}}
		540	+ // {{{ tableInfo()
		541	+
		542	+ /**
		543	+ * Returns information about a table or a result set.
		544	+ *
		545	+ * @param object\|string $result DB_result object from a query or a
		546	+ * string containing the name of a table
		547	+ * @param int $mode a valid tableInfo mode
		548	+ * @return array an associative array with the information requested
		549	+ * or an error object if something is wrong
		550	+ * @access public
		551	+ * @internal
		552	+ * @see DB_common::tableInfo()
		553	+ */
		554	+ function tableInfo($result, $mode = null) {
		555	+ if (isset($result->result)) {
		556	+ /*
		557	+ * Probably received a result object.
		558	+ * Extract the result resource identifier.
		559	+ */
		560	+ $id = $result->result;
		561	+ $got_string = false;
		562	+ } elseif (is_string($result)) {
		563	+ /*
		564	+ * Probably received a table name.
		565	+ * Create a result resource identifier.
		566	+ */
		567	+ $id = @fbsql_list_fields($this->dsn['database'],
		568	+ $result, $this->connection);
		569	+ $got_string = true;
		570	+ } else {
		571	+ /*
		572	+ * Probably received a result resource identifier.
		573	+ * Copy it.
		574	+ * Deprecated. Here for compatibility only.
		575	+ */
		576	+ $id = $result;
		577	+ $got_string = false;
		578	+ }
		579	+
		580	+ if (!is_resource($id)) {
		581	+ return $this->fbsqlRaiseError(DB_ERROR_NEED_MORE_DATA);
		582	+ }
		583	+
		584	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		585	+ $case_func = 'strtolower';
		586	+ } else {
		587	+ $case_func = 'strval';
		588	+ }
		589	+
		590	+ $count = @fbsql_num_fields($id);
		591	+
		592	+ // made this IF due to performance (one if is faster than $count if's)
		593	+ if (!$mode) {
		594	+ for ($i=0; $i<$count; $i++) {
		595	+ $res[$i]['table'] = $case_func(@fbsql_field_table($id, $i));
		596	+ $res[$i]['name'] = $case_func(@fbsql_field_name($id, $i));
		597	+ $res[$i]['type'] = @fbsql_field_type($id, $i);
		598	+ $res[$i]['len'] = @fbsql_field_len($id, $i);
		599	+ $res[$i]['flags'] = @fbsql_field_flags($id, $i);
		600	+ }
		601	+ } else { // full
		602	+ $res["num_fields"]= $count;
		603	+
		604	+ for ($i=0; $i<$count; $i++) {
		605	+ $res[$i]['table'] = $case_func(@fbsql_field_table($id, $i));
		606	+ $res[$i]['name'] = $case_func(@fbsql_field_name($id, $i));
		607	+ $res[$i]['type'] = @fbsql_field_type($id, $i);
		608	+ $res[$i]['len'] = @fbsql_field_len($id, $i);
		609	+ $res[$i]['flags'] = @fbsql_field_flags($id, $i);
		610	+
		611	+ if ($mode & DB_TABLEINFO_ORDER) {
		612	+ $res['order'][$res[$i]['name']] = $i;
		613	+ }
		614	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		615	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		616	+ }
		617	+ }
		618	+ }
		619	+
		620	+ // free the result only if we were called on a table
		621	+ if ($got_string) {
		622	+ @fbsql_free_result($id);
		623	+ }
		624	+ return $res;
		625	+ }
		626	+
		627	+ // }}}
		628	+ // {{{ getSpecialQuery()
		629	+
		630	+ /**
		631	+ * Returns the query needed to get some backend info
		632	+ * @param string $type What kind of info you want to retrieve
		633	+ * @return string The SQL query string
		634	+ */
		635	+ function getSpecialQuery($type)
		636	+ {
		637	+ switch ($type) {
		638	+ case 'tables':
		639	+ return 'select "table_name" from information_schema.tables';
		640	+ default:
		641	+ return null;
		642	+ }
		643	+ }
		644	+
		645	+ // }}}
		646	+}
		647	+
		648	+/*
		649	+ * Local variables:
		650	+ * tab-width: 4
		651	+ * c-basic-offset: 4
		652	+ * End:
		653	+ */
		654	+
		655	+?>

pear/DB/ibase.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Sterling Hughes <sterling@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// Bugs:
		24	+// - If dbsyntax is not firebird, the limitQuery may fail
		25	+
		26	+
		27	+require_once 'DB/common.php';
		28	+
		29	+/**
		30	+ * Database independent query interface definition for PHP's Interbase
		31	+ * extension.
		32	+ *
		33	+ * @package DB
		34	+ * @version $Id$
		35	+ * @category Database
		36	+ * @author Sterling Hughes <sterling@php.net>
		37	+ */
		38	+class DB_ibase extends DB_common
		39	+{
		40	+
		41	+ // {{{ properties
		42	+
		43	+ var $connection;
		44	+ var $phptype, $dbsyntax;
		45	+ var $autocommit = 1;
		46	+ var $manip_query = array();
		47	+
		48	+ // }}}
		49	+ // {{{ constructor
		50	+
		51	+ function DB_ibase()
		52	+ {
		53	+ $this->DB_common();
		54	+ $this->phptype = 'ibase';
		55	+ $this->dbsyntax = 'ibase';
		56	+ $this->features = array(
		57	+ 'prepare' => true,
		58	+ 'pconnect' => true,
		59	+ 'transactions' => true,
		60	+ 'limit' => false
		61	+ );
		62	+ // just a few of the tons of Interbase error codes listed in the
		63	+ // Language Reference section of the Interbase manual
		64	+ $this->errorcode_map = array(
		65	+ -104 => DB_ERROR_SYNTAX,
		66	+ -150 => DB_ERROR_ACCESS_VIOLATION,
		67	+ -151 => DB_ERROR_ACCESS_VIOLATION,
		68	+ -155 => DB_ERROR_NOSUCHTABLE,
		69	+ 88 => DB_ERROR_NOSUCHTABLE,
		70	+ -157 => DB_ERROR_NOSUCHFIELD,
		71	+ -158 => DB_ERROR_VALUE_COUNT_ON_ROW,
		72	+ -170 => DB_ERROR_MISMATCH,
		73	+ -171 => DB_ERROR_MISMATCH,
		74	+ -172 => DB_ERROR_INVALID,
		75	+ -204 => DB_ERROR_INVALID,
		76	+ -205 => DB_ERROR_NOSUCHFIELD,
		77	+ -206 => DB_ERROR_NOSUCHFIELD,
		78	+ -208 => DB_ERROR_INVALID,
		79	+ -219 => DB_ERROR_NOSUCHTABLE,
		80	+ -297 => DB_ERROR_CONSTRAINT,
		81	+ -530 => DB_ERROR_CONSTRAINT,
		82	+ -607 => DB_ERROR_NOSUCHTABLE,
		83	+ -803 => DB_ERROR_CONSTRAINT,
		84	+ -551 => DB_ERROR_ACCESS_VIOLATION,
		85	+ -552 => DB_ERROR_ACCESS_VIOLATION,
		86	+ -922 => DB_ERROR_NOSUCHDB,
		87	+ -923 => DB_ERROR_CONNECT_FAILED,
		88	+ -924 => DB_ERROR_CONNECT_FAILED
		89	+ );
		90	+ }
		91	+
		92	+ // }}}
		93	+ // {{{ connect()
		94	+
		95	+ function connect($dsninfo, $persistent = false)
		96	+ {
		97	+ if (!DB::assertExtension('interbase')) {
		98	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		99	+ }
		100	+ $this->dsn = $dsninfo;
		101	+ $dbhost = $dsninfo['hostspec'] ?
		102	+ ($dsninfo['hostspec'] . ':' . $dsninfo['database']) :
		103	+ $dsninfo['database'];
		104	+
		105	+ $connect_function = $persistent ? 'ibase_pconnect' : 'ibase_connect';
		106	+
		107	+ $params = array();
		108	+ $params[] = $dbhost;
		109	+ $params[] = $dsninfo['username'] ? $dsninfo['username'] : null;
		110	+ $params[] = $dsninfo['password'] ? $dsninfo['password'] : null;
		111	+ $params[] = isset($dsninfo['charset']) ? $dsninfo['charset'] : null;
		112	+ $params[] = isset($dsninfo['buffers']) ? $dsninfo['buffers'] : null;
		113	+ $params[] = isset($dsninfo['dialect']) ? $dsninfo['dialect'] : null;
		114	+ $params[] = isset($dsninfo['role']) ? $dsninfo['role'] : null;
		115	+
		116	+ $conn = @call_user_func_array($connect_function, $params);
		117	+ if (!$conn) {
		118	+ return $this->ibaseRaiseError(DB_ERROR_CONNECT_FAILED);
		119	+ }
		120	+ $this->connection = $conn;
		121	+ if ($this->dsn['dbsyntax'] == 'firebird') {
		122	+ $this->features['limit'] = 'alter';
		123	+ }
		124	+ return DB_OK;
		125	+ }
		126	+
		127	+ // }}}
		128	+ // {{{ disconnect()
		129	+
		130	+ function disconnect()
		131	+ {
		132	+ $ret = @ibase_close($this->connection);
		133	+ $this->connection = null;
		134	+ return $ret;
		135	+ }
		136	+
		137	+ // }}}
		138	+ // {{{ simpleQuery()
		139	+
		140	+ function simpleQuery($query)
		141	+ {
		142	+ $ismanip = DB::isManip($query);
		143	+ $this->last_query = $query;
		144	+ $query = $this->modifyQuery($query);
		145	+ $result = @ibase_query($this->connection, $query);
		146	+ if (!$result) {
		147	+ return $this->ibaseRaiseError();
		148	+ }
		149	+ if ($this->autocommit && $ismanip) {
		150	+ @ibase_commit($this->connection);
		151	+ }
		152	+ // Determine which queries that should return data, and which
		153	+ // should return an error code only.
		154	+ return $ismanip ? DB_OK : $result;
		155	+ }
		156	+
		157	+ // }}}
		158	+ // {{{ modifyLimitQuery()
		159	+
		160	+ /**
		161	+ * This method is used by backends to alter limited queries
		162	+ * Uses the new FIRST n SKIP n Firebird 1.0 syntax, so it is
		163	+ * only compatible with Firebird 1.x
		164	+ *
		165	+ * @param string $query query to modify
		166	+ * @param integer $from the row to start to fetching
		167	+ * @param integer $count the numbers of rows to fetch
		168	+ *
		169	+ * @return the new (modified) query
		170	+ * @author Ludovico Magnocavallo <ludo@sumatrasolutions.com>
		171	+ * @access private
		172	+ */
		173	+ function modifyLimitQuery($query, $from, $count, $params = array())
		174	+ {
		175	+ if ($this->dsn['dbsyntax'] == 'firebird') {
		176	+ //$from++; // SKIP starts from 1, ie SKIP 1 starts from the first record
		177	+ // (cox) Seems that SKIP starts in 0
		178	+ $query = preg_replace('/^\sselect\s(.)$/is',
		179	+ "SELECT FIRST $count SKIP $from $1", $query);
		180	+ }
		181	+ return $query;
		182	+ }
		183	+
		184	+ // }}}
		185	+ // {{{ nextResult()
		186	+
		187	+ /**
		188	+ * Move the internal ibase result pointer to the next available result
		189	+ *
		190	+ * @param a valid fbsql result resource
		191	+ *
		192	+ * @access public
		193	+ *
		194	+ * @return true if a result is available otherwise return false
		195	+ */
		196	+ function nextResult($result)
		197	+ {
		198	+ return false;
		199	+ }
		200	+
		201	+ // }}}
		202	+ // {{{ fetchInto()
		203	+
		204	+ /**
		205	+ * Fetch a row and insert the data into an existing array.
		206	+ *
		207	+ * Formating of the array and the data therein are configurable.
		208	+ * See DB_result::fetchInto() for more information.
		209	+ *
		210	+ * @param resource $result query result identifier
		211	+ * @param array $arr (reference) array where data from the row
		212	+ * should be placed
		213	+ * @param int $fetchmode how the resulting array should be indexed
		214	+ * @param int $rownum the row number to fetch
		215	+ *
		216	+ * @return mixed DB_OK on success, null when end of result set is
		217	+ * reached or on failure
		218	+ *
		219	+ * @see DB_result::fetchInto()
		220	+ * @access private
		221	+ */
		222	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		223	+ {
		224	+ if ($rownum !== null) {
		225	+ return $this->ibaseRaiseError(DB_ERROR_NOT_CAPABLE);
		226	+ }
		227	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		228	+ if (function_exists('ibase_fetch_assoc')) {
		229	+ $arr = @ibase_fetch_assoc($result);
		230	+ } else {
		231	+ $arr = get_object_vars(ibase_fetch_object($result));
		232	+ }
		233	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		234	+ $arr = array_change_key_case($arr, CASE_LOWER);
		235	+ }
		236	+ } else {
		237	+ $arr = @ibase_fetch_row($result);
		238	+ }
		239	+ if (!$arr) {
		240	+ if ($errmsg = @ibase_errmsg()) {
		241	+ return $this->ibaseRaiseError(null, $errmsg);
		242	+ } else {
		243	+ return null;
		244	+ }
		245	+ }
		246	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		247	+ $this->_rtrimArrayValues($arr);
		248	+ }
		249	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		250	+ $this->_convertNullArrayValuesToEmpty($arr);
		251	+ }
		252	+ return DB_OK;
		253	+ }
		254	+
		255	+ // }}}
		256	+ // {{{ freeResult()
		257	+
		258	+ function freeResult($result)
		259	+ {
		260	+ return @ibase_free_result($result);
		261	+ }
		262	+
		263	+ // }}}
		264	+ // {{{ freeQuery()
		265	+
		266	+ function freeQuery($query)
		267	+ {
		268	+ @ibase_free_query($query);
		269	+ return true;
		270	+ }
		271	+
		272	+ // }}}
		273	+ // {{{ numCols()
		274	+
		275	+ function numCols($result)
		276	+ {
		277	+ $cols = @ibase_num_fields($result);
		278	+ if (!$cols) {
		279	+ return $this->ibaseRaiseError();
		280	+ }
		281	+ return $cols;
		282	+ }
		283	+
		284	+ // }}}
		285	+ // {{{ prepare()
		286	+
		287	+ /**
		288	+ * Prepares a query for multiple execution with execute().
		289	+ *
		290	+ * prepare() requires a generic query as string like <code>
		291	+ * INSERT INTO numbers VALUES (?, ?, ?)
		292	+ * </code>. The <kbd>?</kbd> characters are placeholders.
		293	+ *
		294	+ * Three types of placeholders can be used:
		295	+ * + <kbd>?</kbd> a quoted scalar value, i.e. strings, integers
		296	+ * + <kbd>!</kbd> value is inserted 'as is'
		297	+ * + <kbd>&</kbd> requires a file name. The file's contents get
		298	+ * inserted into the query (i.e. saving binary
		299	+ * data in a db)
		300	+ *
		301	+ * Use backslashes to escape placeholder characters if you don't want
		302	+ * them to be interpreted as placeholders. Example: <code>
		303	+ * "UPDATE foo SET col=? WHERE col='over \& under'"
		304	+ * </code>
		305	+ *
		306	+ * @param string $query query to be prepared
		307	+ * @return mixed DB statement resource on success. DB_Error on failure.
		308	+ */
		309	+ function prepare($query)
		310	+ {
		311	+ $tokens = preg_split('/((?<!\\\)[&?!])/', $query, -1,
		312	+ PREG_SPLIT_DELIM_CAPTURE);
		313	+ $token = 0;
		314	+ $types = array();
		315	+ $newquery = '';
		316	+
		317	+ foreach ($tokens as $key => $val) {
		318	+ switch ($val) {
		319	+ case '?':
		320	+ $types[$token++] = DB_PARAM_SCALAR;
		321	+ break;
		322	+ case '&':
		323	+ $types[$token++] = DB_PARAM_OPAQUE;
		324	+ break;
		325	+ case '!':
		326	+ $types[$token++] = DB_PARAM_MISC;
		327	+ break;
		328	+ default:
		329	+ $tokens[$key] = preg_replace('/\\\([&?!])/', "\\1", $val);
		330	+ $newquery .= $tokens[$key] . '?';
		331	+ }
		332	+ }
		333	+
		334	+ $newquery = substr($newquery, 0, -1);
		335	+ $this->last_query = $query;
		336	+ $newquery = $this->modifyQuery($newquery);
		337	+ $stmt = @ibase_prepare($this->connection, $newquery);
		338	+ $this->prepare_types[(int)$stmt] = $types;
		339	+ $this->manip_query[(int)$stmt] = DB::isManip($query);
		340	+ return $stmt;
		341	+ }
		342	+
		343	+ // }}}
		344	+ // {{{ execute()
		345	+
		346	+ /**
		347	+ * Executes a DB statement prepared with prepare().
		348	+ *
		349	+ * @param resource $stmt a DB statement resource returned from prepare()
		350	+ * @param mixed $data array, string or numeric data to be used in
		351	+ * execution of the statement. Quantity of items
		352	+ * passed must match quantity of placeholders in
		353	+ * query: meaning 1 for non-array items or the
		354	+ * quantity of elements in the array.
		355	+ * @return object a new DB_Result or a DB_Error when fail
		356	+ * @see DB_ibase::prepare()
		357	+ * @access public
		358	+ */
		359	+ function &execute($stmt, $data = array())
		360	+ {
		361	+ if (!is_array($data)) {
		362	+ $data = array($data);
		363	+ }
		364	+
		365	+ $types =& $this->prepare_types[(int)$stmt];
		366	+ if (count($types) != count($data)) {
		367	+ $tmp =& $this->raiseError(DB_ERROR_MISMATCH);
		368	+ return $tmp;
		369	+ }
		370	+
		371	+ $i = 0;
		372	+ foreach ($data as $key => $value) {
		373	+ if ($types[$i] == DB_PARAM_MISC) {
		374	+ /*
		375	+ * ibase doesn't seem to have the ability to pass a
		376	+ * parameter along unchanged, so strip off quotes from start
		377	+ * and end, plus turn two single quotes to one single quote,
		378	+ * in order to avoid the quotes getting escaped by
		379	+ * ibase and ending up in the database.
		380	+ */
		381	+ $data[$key] = preg_replace("/^'(.*)'$/", "\\1", $data[$key]);
		382	+ $data[$key] = str_replace("''", "'", $data[$key]);
		383	+ } elseif ($types[$i] == DB_PARAM_OPAQUE) {
		384	+ $fp = @fopen($data[$key], 'rb');
		385	+ if (!$fp) {
		386	+ $tmp =& $this->raiseError(DB_ERROR_ACCESS_VIOLATION);
		387	+ return $tmp;
		388	+ }
		389	+ $data[$key] = fread($fp, filesize($data[$key]));
		390	+ fclose($fp);
		391	+ }
		392	+ $i++;
		393	+ }
		394	+
		395	+ array_unshift($data, $stmt);
		396	+
		397	+ $res = call_user_func_array('ibase_execute', $data);
		398	+ if (!$res) {
		399	+ $tmp =& $this->ibaseRaiseError();
		400	+ return $tmp;
		401	+ }
		402	+ /* XXX need this?
		403	+ if ($this->autocommit && $this->manip_query[(int)$stmt]) {
		404	+ @ibase_commit($this->connection);
		405	+ }*/
		406	+ if ($this->manip_query[(int)$stmt]) {
		407	+ $tmp = DB_OK;
		408	+ } else {
		409	+ $tmp =& new DB_result($this, $res);
		410	+ }
		411	+ return $tmp;
		412	+ }
		413	+
		414	+ /**
		415	+ * Free the internal resources associated with a prepared query.
		416	+ *
		417	+ * @param $stmt The interbase_query resource type
		418	+ *
		419	+ * @return bool true on success, false if $result is invalid
		420	+ */
		421	+ function freePrepared($stmt)
		422	+ {
		423	+ if (!is_resource($stmt)) {
		424	+ return false;
		425	+ }
		426	+ @ibase_free_query($stmt);
		427	+ unset($this->prepare_tokens[(int)$stmt]);
		428	+ unset($this->prepare_types[(int)$stmt]);
		429	+ unset($this->manip_query[(int)$stmt]);
		430	+ return true;
		431	+ }
		432	+
		433	+ // }}}
		434	+ // {{{ autoCommit()
		435	+
		436	+ function autoCommit($onoff = false)
		437	+ {
		438	+ $this->autocommit = $onoff ? 1 : 0;
		439	+ return DB_OK;
		440	+ }
		441	+
		442	+ // }}}
		443	+ // {{{ commit()
		444	+
		445	+ function commit()
		446	+ {
		447	+ return @ibase_commit($this->connection);
		448	+ }
		449	+
		450	+ // }}}
		451	+ // {{{ rollback()
		452	+
		453	+ function rollback()
		454	+ {
		455	+ return @ibase_rollback($this->connection);
		456	+ }
		457	+
		458	+ // }}}
		459	+ // {{{ transactionInit()
		460	+
		461	+ function transactionInit($trans_args = 0)
		462	+ {
		463	+ return $trans_args ? @ibase_trans($trans_args, $this->connection) : @ibase_trans();
		464	+ }
		465	+
		466	+ // }}}
		467	+ // {{{ nextId()
		468	+
		469	+ /**
		470	+ * Returns the next free id in a sequence
		471	+ *
		472	+ * @param string $seq_name name of the sequence
		473	+ * @param boolean $ondemand when true, the seqence is automatically
		474	+ * created if it does not exist
		475	+ *
		476	+ * @return int the next id number in the sequence. DB_Error if problem.
		477	+ *
		478	+ * @internal
		479	+ * @see DB_common::nextID()
		480	+ * @access public
		481	+ */
		482	+ function nextId($seq_name, $ondemand = true)
		483	+ {
		484	+ $sqn = strtoupper($this->getSequenceName($seq_name));
		485	+ $repeat = 0;
		486	+ do {
		487	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		488	+ $result =& $this->query("SELECT GEN_ID(${sqn}, 1) "
		489	+ . 'FROM RDB$GENERATORS '
		490	+ . "WHERE RDB\$GENERATOR_NAME='${sqn}'");
		491	+ $this->popErrorHandling();
		492	+ if ($ondemand && DB::isError($result)) {
		493	+ $repeat = 1;
		494	+ $result = $this->createSequence($seq_name);
		495	+ if (DB::isError($result)) {
		496	+ return $result;
		497	+ }
		498	+ } else {
		499	+ $repeat = 0;
		500	+ }
		501	+ } while ($repeat);
		502	+ if (DB::isError($result)) {
		503	+ return $this->raiseError($result);
		504	+ }
		505	+ $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
		506	+ $result->free();
		507	+ return $arr[0];
		508	+ }
		509	+
		510	+ // }}}
		511	+ // {{{ createSequence()
		512	+
		513	+ /**
		514	+ * Create the sequence
		515	+ *
		516	+ * @param string $seq_name the name of the sequence
		517	+ * @return mixed DB_OK on success or DB error on error
		518	+ * @access public
		519	+ */
		520	+ function createSequence($seq_name)
		521	+ {
		522	+ $sqn = strtoupper($this->getSequenceName($seq_name));
		523	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		524	+ $result = $this->query("CREATE GENERATOR ${sqn}");
		525	+ $this->popErrorHandling();
		526	+
		527	+ return $result;
		528	+ }
		529	+
		530	+ // }}}
		531	+ // {{{ dropSequence()
		532	+
		533	+ /**
		534	+ * Drop a sequence
		535	+ *
		536	+ * @param string $seq_name the name of the sequence
		537	+ * @return mixed DB_OK on success or DB error on error
		538	+ * @access public
		539	+ */
		540	+ function dropSequence($seq_name)
		541	+ {
		542	+ $sqn = strtoupper($this->getSequenceName($seq_name));
		543	+ return $this->query('DELETE FROM RDB$GENERATORS '
		544	+ . "WHERE RDB\$GENERATOR_NAME='${sqn}'");
		545	+ }
		546	+
		547	+ // }}}
		548	+ // {{{ _ibaseFieldFlags()
		549	+
		550	+ /**
		551	+ * get the Flags of a Field
		552	+ *
		553	+ * @param string $field_name the name of the field
		554	+ * @param string $table_name the name of the table
		555	+ *
		556	+ * @return string The flags of the field ("primary_key", "unique_key", "not_null"
		557	+ * "default", "computed" and "blob" are supported)
		558	+ * @access private
		559	+ */
		560	+ function _ibaseFieldFlags($field_name, $table_name)
		561	+ {
		562	+ $sql = 'SELECT R.RDB$CONSTRAINT_TYPE CTYPE'
		563	+ .' FROM RDB$INDEX_SEGMENTS I'
		564	+ .' JOIN RDB$RELATION_CONSTRAINTS R ON I.RDB$INDEX_NAME=R.RDB$INDEX_NAME'
		565	+ .' WHERE I.RDB$FIELD_NAME=\'' . $field_name . '\''
		566	+ .' AND UPPER(R.RDB$RELATION_NAME)=\'' . strtoupper($table_name) . '\'';
		567	+
		568	+ $result = @ibase_query($this->connection, $sql);
		569	+ if (!$result) {
		570	+ return $this->ibaseRaiseError();
		571	+ }
		572	+
		573	+ $flags = '';
		574	+ if ($obj = @ibase_fetch_object($result)) {
		575	+ @ibase_free_result($result);
		576	+ if (isset($obj->CTYPE) && trim($obj->CTYPE) == 'PRIMARY KEY') {
		577	+ $flags .= 'primary_key ';
		578	+ }
		579	+ if (isset($obj->CTYPE) && trim($obj->CTYPE) == 'UNIQUE') {
		580	+ $flags .= 'unique_key ';
		581	+ }
		582	+ }
		583	+
		584	+ $sql = 'SELECT R.RDB$NULL_FLAG AS NFLAG,'
		585	+ .' R.RDB$DEFAULT_SOURCE AS DSOURCE,'
		586	+ .' F.RDB$FIELD_TYPE AS FTYPE,'
		587	+ .' F.RDB$COMPUTED_SOURCE AS CSOURCE'
		588	+ .' FROM RDB$RELATION_FIELDS R '
		589	+ .' JOIN RDB$FIELDS F ON R.RDB$FIELD_SOURCE=F.RDB$FIELD_NAME'
		590	+ .' WHERE UPPER(R.RDB$RELATION_NAME)=\'' . strtoupper($table_name) . '\''
		591	+ .' AND R.RDB$FIELD_NAME=\'' . $field_name . '\'';
		592	+
		593	+ $result = @ibase_query($this->connection, $sql);
		594	+ if (!$result) {
		595	+ return $this->ibaseRaiseError();
		596	+ }
		597	+ if ($obj = @ibase_fetch_object($result)) {
		598	+ @ibase_free_result($result);
		599	+ if (isset($obj->NFLAG)) {
		600	+ $flags .= 'not_null ';
		601	+ }
		602	+ if (isset($obj->DSOURCE)) {
		603	+ $flags .= 'default ';
		604	+ }
		605	+ if (isset($obj->CSOURCE)) {
		606	+ $flags .= 'computed ';
		607	+ }
		608	+ if (isset($obj->FTYPE) && $obj->FTYPE == 261) {
		609	+ $flags .= 'blob ';
		610	+ }
		611	+ }
		612	+
		613	+ return trim($flags);
		614	+ }
		615	+
		616	+ // }}}
		617	+ // {{{ tableInfo()
		618	+
		619	+ /**
		620	+ * Returns information about a table or a result set.
		621	+ *
		622	+ * NOTE: only supports 'table' and 'flags' if <var>$result</var>
		623	+ * is a table name.
		624	+ *
		625	+ * @param object\|string $result DB_result object from a query or a
		626	+ * string containing the name of a table
		627	+ * @param int $mode a valid tableInfo mode
		628	+ * @return array an associative array with the information requested
		629	+ * or an error object if something is wrong
		630	+ * @access public
		631	+ * @internal
		632	+ * @see DB_common::tableInfo()
		633	+ */
		634	+ function tableInfo($result, $mode = null)
		635	+ {
		636	+ if (isset($result->result)) {
		637	+ /*
		638	+ * Probably received a result object.
		639	+ * Extract the result resource identifier.
		640	+ */
		641	+ $id = $result->result;
		642	+ $got_string = false;
		643	+ } elseif (is_string($result)) {
		644	+ /*
		645	+ * Probably received a table name.
		646	+ * Create a result resource identifier.
		647	+ */
		648	+ $id = @ibase_query($this->connection,
		649	+ "SELECT * FROM $result WHERE 1=0");
		650	+ $got_string = true;
		651	+ } else {
		652	+ /*
		653	+ * Probably received a result resource identifier.
		654	+ * Copy it.
		655	+ * Deprecated. Here for compatibility only.
		656	+ */
		657	+ $id = $result;
		658	+ $got_string = false;
		659	+ }
		660	+
		661	+ if (!is_resource($id)) {
		662	+ return $this->ibaseRaiseError(DB_ERROR_NEED_MORE_DATA);
		663	+ }
		664	+
		665	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		666	+ $case_func = 'strtolower';
		667	+ } else {
		668	+ $case_func = 'strval';
		669	+ }
		670	+
		671	+ $count = @ibase_num_fields($id);
		672	+
		673	+ // made this IF due to performance (one if is faster than $count if's)
		674	+ if (!$mode) {
		675	+ for ($i=0; $i<$count; $i++) {
		676	+ $info = @ibase_field_info($id, $i);
		677	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		678	+ $res[$i]['name'] = $case_func($info['name']);
		679	+ $res[$i]['type'] = $info['type'];
		680	+ $res[$i]['len'] = $info['length'];
		681	+ $res[$i]['flags'] = ($got_string) ? $this->_ibaseFieldFlags($info['name'], $result) : '';
		682	+ }
		683	+ } else { // full
		684	+ $res['num_fields']= $count;
		685	+
		686	+ for ($i=0; $i<$count; $i++) {
		687	+ $info = @ibase_field_info($id, $i);
		688	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		689	+ $res[$i]['name'] = $case_func($info['name']);
		690	+ $res[$i]['type'] = $info['type'];
		691	+ $res[$i]['len'] = $info['length'];
		692	+ $res[$i]['flags'] = ($got_string) ? $this->_ibaseFieldFlags($info['name'], $result) : '';
		693	+
		694	+ if ($mode & DB_TABLEINFO_ORDER) {
		695	+ $res['order'][$res[$i]['name']] = $i;
		696	+ }
		697	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		698	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		699	+ }
		700	+ }
		701	+ }
		702	+
		703	+ // free the result only if we were called on a table
		704	+ if ($got_string) {
		705	+ @ibase_free_result($id);
		706	+ }
		707	+ return $res;
		708	+ }
		709	+
		710	+ // }}}
		711	+ // {{{ ibaseRaiseError()
		712	+
		713	+ /**
		714	+ * Gather information about an error, then use that info to create a
		715	+ * DB error object and finally return that object.
		716	+ *
		717	+ * @param integer $db_errno PEAR error number (usually a DB constant) if
		718	+ * manually raising an error
		719	+ * @param string $native_errmsg text of error message if known
		720	+ * @return object DB error object
		721	+ * @see DB_common::errorCode()
		722	+ * @see DB_common::raiseError()
		723	+ */
		724	+ function &ibaseRaiseError($db_errno = null, $native_errmsg = null)
		725	+ {
		726	+ if ($native_errmsg === null) {
		727	+ $native_errmsg = @ibase_errmsg();
		728	+ }
		729	+ // memo for the interbase php module hackers: we need something similar
		730	+ // to mysql_errno() to retrieve error codes instead of this ugly hack
		731	+ if (preg_match('/^([^0-9\-]+)([0-9\-]+)\s+(.*)$/', $native_errmsg, $m)) {
		732	+ $native_errno = (int)$m[2];
		733	+ } else {
		734	+ $native_errno = null;
		735	+ }
		736	+ // try to map the native error to the DB one
		737	+ if ($db_errno === null) {
		738	+ if ($native_errno) {
		739	+ // try to interpret Interbase error code (that's why we need ibase_errno()
		740	+ // in the interbase module to return the real error code)
		741	+ switch ($native_errno) {
		742	+ case -204:
		743	+ if (is_int(strpos($m[3], 'Table unknown'))) {
		744	+ $db_errno = DB_ERROR_NOSUCHTABLE;
		745	+ }
		746	+ break;
		747	+ default:
		748	+ $db_errno = $this->errorCode($native_errno);
		749	+ }
		750	+ } else {
		751	+ $error_regexps = array(
		752	+ '/[tT]able not found/' => DB_ERROR_NOSUCHTABLE,
		753	+ '/[tT]able .* already exists/' => DB_ERROR_ALREADY_EXISTS,
		754	+ '/validation error for column .* value "\\\* null/' => DB_ERROR_CONSTRAINT_NOT_NULL,
		755	+ '/violation of [\w ]+ constraint/' => DB_ERROR_CONSTRAINT,
		756	+ '/conversion error from string/' => DB_ERROR_INVALID_NUMBER,
		757	+ '/no permission for/' => DB_ERROR_ACCESS_VIOLATION,
		758	+ '/arithmetic exception, numeric overflow, or string truncation/' => DB_ERROR_DIVZERO
		759	+ );
		760	+ foreach ($error_regexps as $regexp => $code) {
		761	+ if (preg_match($regexp, $native_errmsg)) {
		762	+ $db_errno = $code;
		763	+ $native_errno = null;
		764	+ break;
		765	+ }
		766	+ }
		767	+ }
		768	+ }
		769	+ $tmp =& $this->raiseError($db_errno, null, null, null, $native_errmsg);
		770	+ return $tmp;
		771	+ }
		772	+
		773	+ // }}}
		774	+
		775	+}
		776	+
		777	+/*
		778	+ * Local variables:
		779	+ * tab-width: 4
		780	+ * c-basic-offset: 4
		781	+ * End:
		782	+ */
		783	+
		784	+?>

pear/DB/ifx.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Tomas V.V.Cox <cox@idecnet.com> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// Legend:
		24	+// For more info on Informix errors see:
		25	+// http://www.informix.com/answers/english/ierrors.htm
		26	+//
		27	+// TODO:
		28	+// - set needed env Informix vars on connect
		29	+// - implement native prepare/execute
		30	+
		31	+
		32	+require_once 'DB/common.php';
		33	+
		34	+/**
		35	+ * Database independent query interface definition for PHP's Informix
		36	+ * extension.
		37	+ *
		38	+ * @package DB
		39	+ * @version $Id$
		40	+ * @category Database
		41	+ * @author Tomas V.V.Cox <cox@idecnet.com>
		42	+ */
		43	+class DB_ifx extends DB_common
		44	+{
		45	+ // {{{ properties
		46	+
		47	+ var $connection;
		48	+ var $affected = 0;
		49	+ var $dsn = array();
		50	+ var $transaction_opcount = 0;
		51	+ var $autocommit = true;
		52	+ var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */
		53	+
		54	+ // }}}
		55	+ // {{{ constructor
		56	+
		57	+ function DB_ifx()
		58	+ {
		59	+ $this->phptype = 'ifx';
		60	+ $this->dbsyntax = 'ifx';
		61	+ $this->features = array(
		62	+ 'prepare' => false,
		63	+ 'pconnect' => true,
		64	+ 'transactions' => true,
		65	+ 'limit' => 'emulate'
		66	+ );
		67	+ $this->errorcode_map = array(
		68	+ '-201' => DB_ERROR_SYNTAX,
		69	+ '-206' => DB_ERROR_NOSUCHTABLE,
		70	+ '-217' => DB_ERROR_NOSUCHFIELD,
		71	+ '-239' => DB_ERROR_CONSTRAINT,
		72	+ '-253' => DB_ERROR_SYNTAX,
		73	+ '-292' => DB_ERROR_CONSTRAINT_NOT_NULL,
		74	+ '-310' => DB_ERROR_ALREADY_EXISTS,
		75	+ '-329' => DB_ERROR_NODBSELECTED,
		76	+ '-346' => DB_ERROR_CONSTRAINT,
		77	+ '-386' => DB_ERROR_CONSTRAINT_NOT_NULL,
		78	+ '-391' => DB_ERROR_CONSTRAINT_NOT_NULL,
		79	+ '-554' => DB_ERROR_SYNTAX,
		80	+ '-691' => DB_ERROR_CONSTRAINT,
		81	+ '-703' => DB_ERROR_CONSTRAINT_NOT_NULL,
		82	+ '-1204' => DB_ERROR_INVALID_DATE,
		83	+ '-1205' => DB_ERROR_INVALID_DATE,
		84	+ '-1206' => DB_ERROR_INVALID_DATE,
		85	+ '-1209' => DB_ERROR_INVALID_DATE,
		86	+ '-1210' => DB_ERROR_INVALID_DATE,
		87	+ '-1212' => DB_ERROR_INVALID_DATE,
		88	+ '-1213' => DB_ERROR_INVALID_NUMBER,
		89	+ );
		90	+ }
		91	+
		92	+ // }}}
		93	+ // {{{ connect()
		94	+
		95	+ /**
		96	+ * Connect to a database and log in as the specified user.
		97	+ *
		98	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		99	+ * @param $persistent (optional) whether the connection should
		100	+ * be persistent
		101	+ *
		102	+ * @return int DB_OK on success, a DB error code on failure
		103	+ */
		104	+ function connect($dsninfo, $persistent = false)
		105	+ {
		106	+ if (!DB::assertExtension('informix') &&
		107	+ !DB::assertExtension('Informix'))
		108	+ {
		109	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		110	+ }
		111	+ $this->dsn = $dsninfo;
		112	+ $dbhost = $dsninfo['hostspec'] ? '@' . $dsninfo['hostspec'] : '';
		113	+ $dbname = $dsninfo['database'] ? $dsninfo['database'] . $dbhost : '';
		114	+ $user = $dsninfo['username'] ? $dsninfo['username'] : '';
		115	+ $pw = $dsninfo['password'] ? $dsninfo['password'] : '';
		116	+
		117	+ $connect_function = $persistent ? 'ifx_pconnect' : 'ifx_connect';
		118	+
		119	+ $this->connection = @$connect_function($dbname, $user, $pw);
		120	+ if (!is_resource($this->connection)) {
		121	+ return $this->ifxraiseError(DB_ERROR_CONNECT_FAILED);
		122	+ }
		123	+ return DB_OK;
		124	+ }
		125	+
		126	+ // }}}
		127	+ // {{{ disconnect()
		128	+
		129	+ /**
		130	+ * Log out and disconnect from the database.
		131	+ *
		132	+ * @return bool true on success, false if not connected.
		133	+ */
		134	+ function disconnect()
		135	+ {
		136	+ $ret = @ifx_close($this->connection);
		137	+ $this->connection = null;
		138	+ return $ret;
		139	+ }
		140	+
		141	+ // }}}
		142	+ // {{{ simpleQuery()
		143	+
		144	+ /**
		145	+ * Send a query to Informix and return the results as a
		146	+ * Informix resource identifier.
		147	+ *
		148	+ * @param $query the SQL query
		149	+ *
		150	+ * @return int returns a valid Informix result for successful SELECT
		151	+ * queries, DB_OK for other successful queries. A DB error code
		152	+ * is returned on failure.
		153	+ */
		154	+ function simpleQuery($query)
		155	+ {
		156	+ $ismanip = DB::isManip($query);
		157	+ $this->last_query = $query;
		158	+ $this->affected = null;
		159	+ if (preg_match('/(SELECT)/i', $query)) { //TESTME: Use !DB::isManip()?
		160	+ // the scroll is needed for fetching absolute row numbers
		161	+ // in a select query result
		162	+ $result = @ifx_query($query, $this->connection, IFX_SCROLL);
		163	+ } else {
		164	+ if (!$this->autocommit && $ismanip) {
		165	+ if ($this->transaction_opcount == 0) {
		166	+ $result = @ifx_query('BEGIN WORK', $this->connection);
		167	+ if (!$result) {
		168	+ return $this->ifxraiseError();
		169	+ }
		170	+ }
		171	+ $this->transaction_opcount++;
		172	+ }
		173	+ $result = @ifx_query($query, $this->connection);
		174	+ }
		175	+ if (!$result) {
		176	+ return $this->ifxraiseError();
		177	+ }
		178	+ $this->affected = @ifx_affected_rows($result);
		179	+ // Determine which queries should return data, and which
		180	+ // should return an error code only.
		181	+ if (preg_match('/(SELECT)/i', $query)) {
		182	+ return $result;
		183	+ }
		184	+ // XXX Testme: free results inside a transaction
		185	+ // may cause to stop it and commit the work?
		186	+
		187	+ // Result has to be freed even with a insert or update
		188	+ @ifx_free_result($result);
		189	+
		190	+ return DB_OK;
		191	+ }
		192	+
		193	+ // }}}
		194	+ // {{{ nextResult()
		195	+
		196	+ /**
		197	+ * Move the internal ifx result pointer to the next available result
		198	+ *
		199	+ * @param a valid fbsql result resource
		200	+ *
		201	+ * @access public
		202	+ *
		203	+ * @return true if a result is available otherwise return false
		204	+ */
		205	+ function nextResult($result)
		206	+ {
		207	+ return false;
		208	+ }
		209	+
		210	+ // }}}
		211	+ // {{{ affectedRows()
		212	+
		213	+ /**
		214	+ * Gets the number of rows affected by the last query.
		215	+ * if the last query was a select, returns 0.
		216	+ *
		217	+ * @return number of rows affected by the last query
		218	+ */
		219	+ function affectedRows()
		220	+ {
		221	+ if (DB::isManip($this->last_query)) {
		222	+ return $this->affected;
		223	+ } else {
		224	+ return 0;
		225	+ }
		226	+
		227	+ }
		228	+
		229	+ // }}}
		230	+ // {{{ fetchInto()
		231	+
		232	+ /**
		233	+ * Fetch a row and insert the data into an existing array.
		234	+ *
		235	+ * Formating of the array and the data therein are configurable.
		236	+ * See DB_result::fetchInto() for more information.
		237	+ *
		238	+ * @param resource $result query result identifier
		239	+ * @param array $arr (reference) array where data from the row
		240	+ * should be placed
		241	+ * @param int $fetchmode how the resulting array should be indexed
		242	+ * @param int $rownum the row number to fetch
		243	+ *
		244	+ * @return mixed DB_OK on success, null when end of result set is
		245	+ * reached or on failure
		246	+ *
		247	+ * @see DB_result::fetchInto()
		248	+ * @access private
		249	+ */
		250	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		251	+ {
		252	+ if (($rownum !== null) && ($rownum < 0)) {
		253	+ return null;
		254	+ }
		255	+ if ($rownum === null) {
		256	+ /*
		257	+ * Even though fetch_row() should return the next row if
		258	+ * $rownum is null, it doesn't in all cases. Bug 598.
		259	+ */
		260	+ $rownum = 'NEXT';
		261	+ } else {
		262	+ // Index starts at row 1, unlike most DBMS's starting at 0.
		263	+ $rownum++;
		264	+ }
		265	+ if (!$arr = @ifx_fetch_row($result, $rownum)) {
		266	+ return null;
		267	+ }
		268	+ if ($fetchmode !== DB_FETCHMODE_ASSOC) {
		269	+ $i=0;
		270	+ $order = array();
		271	+ foreach ($arr as $val) {
		272	+ $order[$i++] = $val;
		273	+ }
		274	+ $arr = $order;
		275	+ } elseif ($fetchmode == DB_FETCHMODE_ASSOC &&
		276	+ $this->options['portability'] & DB_PORTABILITY_LOWERCASE)
		277	+ {
		278	+ $arr = array_change_key_case($arr, CASE_LOWER);
		279	+ }
		280	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		281	+ $this->_rtrimArrayValues($arr);
		282	+ }
		283	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		284	+ $this->_convertNullArrayValuesToEmpty($arr);
		285	+ }
		286	+ return DB_OK;
		287	+ }
		288	+
		289	+ // }}}
		290	+ // {{{ numRows()
		291	+
		292	+ function numRows($result)
		293	+ {
		294	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		295	+ }
		296	+
		297	+ // }}}
		298	+ // {{{ numCols()
		299	+
		300	+ /**
		301	+ * Get the number of columns in a result set.
		302	+ *
		303	+ * @param $result Informix result identifier
		304	+ *
		305	+ * @return int the number of columns per row in $result
		306	+ */
		307	+ function numCols($result)
		308	+ {
		309	+ if (!$cols = @ifx_num_fields($result)) {
		310	+ return $this->ifxraiseError();
		311	+ }
		312	+ return $cols;
		313	+ }
		314	+
		315	+ // }}}
		316	+ // {{{ freeResult()
		317	+
		318	+ /**
		319	+ * Free the internal resources associated with $result.
		320	+ *
		321	+ * @param $result Informix result identifier
		322	+ *
		323	+ * @return bool true on success, false if $result is invalid
		324	+ */
		325	+ function freeResult($result)
		326	+ {
		327	+ return @ifx_free_result($result);
		328	+ }
		329	+
		330	+ // }}}
		331	+ // {{{ autoCommit()
		332	+
		333	+ /**
		334	+ * Enable/disable automatic commits
		335	+ */
		336	+ function autoCommit($onoff = true)
		337	+ {
		338	+ // XXX if $this->transaction_opcount > 0, we should probably
		339	+ // issue a warning here.
		340	+ $this->autocommit = $onoff ? true : false;
		341	+ return DB_OK;
		342	+ }
		343	+
		344	+ // }}}
		345	+ // {{{ commit()
		346	+
		347	+ /**
		348	+ * Commit the current transaction.
		349	+ */
		350	+ function commit()
		351	+ {
		352	+ if ($this->transaction_opcount > 0) {
		353	+ $result = @ifx_query('COMMIT WORK', $this->connection);
		354	+ $this->transaction_opcount = 0;
		355	+ if (!$result) {
		356	+ return $this->ifxRaiseError();
		357	+ }
		358	+ }
		359	+ return DB_OK;
		360	+ }
		361	+
		362	+ // }}}
		363	+ // {{{ rollback()
		364	+
		365	+ /**
		366	+ * Roll back (undo) the current transaction.
		367	+ */
		368	+ function rollback()
		369	+ {
		370	+ if ($this->transaction_opcount > 0) {
		371	+ $result = @ifx_query('ROLLBACK WORK', $this->connection);
		372	+ $this->transaction_opcount = 0;
		373	+ if (!$result) {
		374	+ return $this->ifxRaiseError();
		375	+ }
		376	+ }
		377	+ return DB_OK;
		378	+ }
		379	+
		380	+ // }}}
		381	+ // {{{ ifxraiseError()
		382	+
		383	+ /**
		384	+ * Gather information about an error, then use that info to create a
		385	+ * DB error object and finally return that object.
		386	+ *
		387	+ * @param integer $errno PEAR error number (usually a DB constant) if
		388	+ * manually raising an error
		389	+ * @return object DB error object
		390	+ * @see errorNative()
		391	+ * @see errorCode()
		392	+ * @see DB_common::raiseError()
		393	+ */
		394	+ function ifxraiseError($errno = null)
		395	+ {
		396	+ if ($errno === null) {
		397	+ $errno = $this->errorCode(ifx_error());
		398	+ }
		399	+
		400	+ return $this->raiseError($errno, null, null, null,
		401	+ $this->errorNative());
		402	+ }
		403	+
		404	+ // }}}
		405	+ // {{{ errorCode()
		406	+
		407	+ /**
		408	+ * Map native error codes to DB's portable ones.
		409	+ *
		410	+ * Requires that the DB implementation's constructor fills
		411	+ * in the <var>$errorcode_map</var> property.
		412	+ *
		413	+ * @param string $nativecode error code returned by the database
		414	+ * @return int a portable DB error code, or DB_ERROR if this DB
		415	+ * implementation has no mapping for the given error code.
		416	+ */
		417	+ function errorCode($nativecode)
		418	+ {
		419	+ if (ereg('SQLCODE=(.*)]', $nativecode, $match)) {
		420	+ $code = $match[1];
		421	+ if (isset($this->errorcode_map[$code])) {
		422	+ return $this->errorcode_map[$code];
		423	+ }
		424	+ }
		425	+ return DB_ERROR;
		426	+ }
		427	+
		428	+ // }}}
		429	+ // {{{ errorNative()
		430	+
		431	+ /**
		432	+ * Get the native error message of the last error (if any) that
		433	+ * occured on the current connection.
		434	+ *
		435	+ * @return int native Informix error code
		436	+ */
		437	+ function errorNative()
		438	+ {
		439	+ return @ifx_error() . ' ' . @ifx_errormsg();
		440	+ }
		441	+
		442	+ // }}}
		443	+ // {{{ getSpecialQuery()
		444	+
		445	+ /**
		446	+ * Returns the query needed to get some backend info
		447	+ * @param string $type What kind of info you want to retrieve
		448	+ * @return string The SQL query string
		449	+ */
		450	+ function getSpecialQuery($type)
		451	+ {
		452	+ switch ($type) {
		453	+ case 'tables':
		454	+ return 'select tabname from systables where tabid >= 100';
		455	+ default:
		456	+ return null;
		457	+ }
		458	+ }
		459	+
		460	+ // }}}
		461	+ // {{{ tableInfo()
		462	+
		463	+ /**
		464	+ * Returns information about a table or a result set.
		465	+ *
		466	+ * NOTE: only supports 'table' if <var>$result</var> is a table name.
		467	+ *
		468	+ * If analyzing a query result and the result has duplicate field names,
		469	+ * an error will be raised saying
		470	+ * <samp>can't distinguish duplicate field names</samp>.
		471	+ *
		472	+ * @param object\|string $result DB_result object from a query or a
		473	+ * string containing the name of a table
		474	+ * @param int $mode a valid tableInfo mode
		475	+ * @return array an associative array with the information requested
		476	+ * or an error object if something is wrong
		477	+ * @access public
		478	+ * @internal
		479	+ * @since 1.6.0
		480	+ * @see DB_common::tableInfo()
		481	+ */
		482	+ function tableInfo($result, $mode = null)
		483	+ {
		484	+ if (isset($result->result)) {
		485	+ /*
		486	+ * Probably received a result object.
		487	+ * Extract the result resource identifier.
		488	+ */
		489	+ $id = $result->result;
		490	+ $got_string = false;
		491	+ } elseif (is_string($result)) {
		492	+ /*
		493	+ * Probably received a table name.
		494	+ * Create a result resource identifier.
		495	+ */
		496	+ $id = @ifx_query("SELECT * FROM $result WHERE 1=0",
		497	+ $this->connection);
		498	+ $got_string = true;
		499	+ } else {
		500	+ /*
		501	+ * Probably received a result resource identifier.
		502	+ * Copy it.
		503	+ */
		504	+ $id = $result;
		505	+ $got_string = false;
		506	+ }
		507	+
		508	+ if (!is_resource($id)) {
		509	+ return $this->ifxRaiseError(DB_ERROR_NEED_MORE_DATA);
		510	+ }
		511	+
		512	+ $flds = @ifx_fieldproperties($id);
		513	+ $count = @ifx_num_fields($id);
		514	+
		515	+ if (count($flds) != $count) {
		516	+ return $this->raiseError("can't distinguish duplicate field names");
		517	+ }
		518	+
		519	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		520	+ $case_func = 'strtolower';
		521	+ } else {
		522	+ $case_func = 'strval';
		523	+ }
		524	+
		525	+ $i = 0;
		526	+ // made this IF due to performance (one if is faster than $count if's)
		527	+ if (!$mode) {
		528	+ foreach ($flds as $key => $value) {
		529	+ $props = explode(';', $value);
		530	+
		531	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		532	+ $res[$i]['name'] = $case_func($key);
		533	+ $res[$i]['type'] = $props[0];
		534	+ $res[$i]['len'] = $props[1];
		535	+ $res[$i]['flags'] = $props[4] == 'N' ? 'not_null' : '';
		536	+ $i++;
		537	+ }
		538	+
		539	+ } else { // full
		540	+ $res['num_fields'] = $count;
		541	+
		542	+ foreach ($flds as $key => $value) {
		543	+ $props = explode(';', $value);
		544	+
		545	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		546	+ $res[$i]['name'] = $case_func($key);
		547	+ $res[$i]['type'] = $props[0];
		548	+ $res[$i]['len'] = $props[1];
		549	+ $res[$i]['flags'] = $props[4] == 'N' ? 'not_null' : '';
		550	+
		551	+ if ($mode & DB_TABLEINFO_ORDER) {
		552	+ $res['order'][$res[$i]['name']] = $i;
		553	+ }
		554	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		555	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		556	+ }
		557	+ $i++;
		558	+ }
		559	+ }
		560	+
		561	+ // free the result only if we were called on a table
		562	+ if ($got_string) {
		563	+ @ifx_free_result($id);
		564	+ }
		565	+ return $res;
		566	+ }
		567	+
		568	+ // }}}
		569	+
		570	+}
		571	+
		572	+/*
		573	+ * Local variables:
		574	+ * tab-width: 4
		575	+ * c-basic-offset: 4
		576	+ * End:
		577	+ */
		578	+
		579	+?>

pear/DB/msql.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Sterling Hughes <sterling@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+require_once 'DB/common.php';
		23	+
		24	+/**
		25	+ * Database independent query interface definition for PHP's Mini-SQL
		26	+ * extension.
		27	+ *
		28	+ * @package DB
		29	+ * @version $Id$
		30	+ * @category Database
		31	+ * @author Sterling Hughes <sterling@php.net>
		32	+ */
		33	+class DB_msql extends DB_common
		34	+{
		35	+ // {{{ properties
		36	+
		37	+ var $connection;
		38	+ var $phptype, $dbsyntax;
		39	+ var $prepare_tokens = array();
		40	+ var $prepare_types = array();
		41	+
		42	+ // }}}
		43	+ // {{{ constructor
		44	+
		45	+ function DB_msql()
		46	+ {
		47	+ $this->DB_common();
		48	+ $this->phptype = 'msql';
		49	+ $this->dbsyntax = 'msql';
		50	+ $this->features = array(
		51	+ 'prepare' => false,
		52	+ 'pconnect' => true,
		53	+ 'transactions' => false,
		54	+ 'limit' => 'emulate'
		55	+ );
		56	+ }
		57	+
		58	+ // }}}
		59	+ // {{{ connect()
		60	+
		61	+ function connect($dsninfo, $persistent = false)
		62	+ {
		63	+ if (!DB::assertExtension('msql')) {
		64	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		65	+ }
		66	+
		67	+ $this->dsn = $dsninfo;
		68	+ $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
		69	+
		70	+ $connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';
		71	+
		72	+ if ($dbhost && $dsninfo['username'] && $dsninfo['password']) {
		73	+ $conn = $connect_function($dbhost, $dsninfo['username'],
		74	+ $dsninfo['password']);
		75	+ } elseif ($dbhost && $dsninfo['username']) {
		76	+ $conn = $connect_function($dbhost, $dsninfo['username']);
		77	+ } else {
		78	+ $conn = $connect_function($dbhost);
		79	+ }
		80	+ if (!$conn) {
		81	+ $this->raiseError(DB_ERROR_CONNECT_FAILED);
		82	+ }
		83	+ if (!@msql_select_db($dsninfo['database'], $conn)){
		84	+ return $this->raiseError(DB_ERROR_NODBSELECTED);
		85	+ }
		86	+ $this->connection = $conn;
		87	+ return DB_OK;
		88	+ }
		89	+
		90	+ // }}}
		91	+ // {{{ disconnect()
		92	+
		93	+ function disconnect()
		94	+ {
		95	+ $ret = @msql_close($this->connection);
		96	+ $this->connection = null;
		97	+ return $ret;
		98	+ }
		99	+
		100	+ // }}}
		101	+ // {{{ simpleQuery()
		102	+
		103	+ function simpleQuery($query)
		104	+ {
		105	+ $this->last_query = $query;
		106	+ $query = $this->modifyQuery($query);
		107	+ $result = @msql_query($query, $this->connection);
		108	+ if (!$result) {
		109	+ return $this->raiseError();
		110	+ }
		111	+ // Determine which queries that should return data, and which
		112	+ // should return an error code only.
		113	+ return DB::isManip($query) ? DB_OK : $result;
		114	+ }
		115	+
		116	+
		117	+ // }}}
		118	+ // {{{ nextResult()
		119	+
		120	+ /**
		121	+ * Move the internal msql result pointer to the next available result
		122	+ *
		123	+ * @param a valid fbsql result resource
		124	+ *
		125	+ * @access public
		126	+ *
		127	+ * @return true if a result is available otherwise return false
		128	+ */
		129	+ function nextResult($result)
		130	+ {
		131	+ return false;
		132	+ }
		133	+
		134	+ // }}}
		135	+ // {{{ fetchInto()
		136	+
		137	+ /**
		138	+ * Fetch a row and insert the data into an existing array.
		139	+ *
		140	+ * Formating of the array and the data therein are configurable.
		141	+ * See DB_result::fetchInto() for more information.
		142	+ *
		143	+ * @param resource $result query result identifier
		144	+ * @param array $arr (reference) array where data from the row
		145	+ * should be placed
		146	+ * @param int $fetchmode how the resulting array should be indexed
		147	+ * @param int $rownum the row number to fetch
		148	+ *
		149	+ * @return mixed DB_OK on success, null when end of result set is
		150	+ * reached or on failure
		151	+ *
		152	+ * @see DB_result::fetchInto()
		153	+ * @access private
		154	+ */
		155	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		156	+ {
		157	+ if ($rownum !== null) {
		158	+ if (!@msql_data_seek($result, $rownum)) {
		159	+ return null;
		160	+ }
		161	+ }
		162	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		163	+ $arr = @msql_fetch_array($result, MSQL_ASSOC);
		164	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		165	+ $arr = array_change_key_case($arr, CASE_LOWER);
		166	+ }
		167	+ } else {
		168	+ $arr = @msql_fetch_row($result);
		169	+ }
		170	+ if (!$arr) {
		171	+ if ($error = @msql_error()) {
		172	+ return $this->raiseError($error);
		173	+ } else {
		174	+ return null;
		175	+ }
		176	+ }
		177	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		178	+ $this->_rtrimArrayValues($arr);
		179	+ }
		180	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		181	+ $this->_convertNullArrayValuesToEmpty($arr);
		182	+ }
		183	+ return DB_OK;
		184	+ }
		185	+
		186	+ // }}}
		187	+ // {{{ freeResult()
		188	+
		189	+ function freeResult($result)
		190	+ {
		191	+ return @msql_free_result($result);
		192	+ }
		193	+
		194	+ // }}}
		195	+ // {{{ numCols()
		196	+
		197	+ function numCols($result)
		198	+ {
		199	+ $cols = @msql_num_fields($result);
		200	+ if (!$cols) {
		201	+ return $this->raiseError();
		202	+ }
		203	+ return $cols;
		204	+ }
		205	+
		206	+ // }}}
		207	+ // {{{ numRows()
		208	+
		209	+ function numRows($result)
		210	+ {
		211	+ $rows = @msql_num_rows($result);
		212	+ if (!$rows) {
		213	+ return $this->raiseError();
		214	+ }
		215	+ return $rows;
		216	+ }
		217	+
		218	+ // }}}
		219	+ // {{{ affected()
		220	+
		221	+ /**
		222	+ * Gets the number of rows affected by a query.
		223	+ *
		224	+ * @return number of rows affected by the last query
		225	+ */
		226	+ function affectedRows()
		227	+ {
		228	+ return @msql_affected_rows($this->connection);
		229	+ }
		230	+
		231	+ // }}}
		232	+
		233	+}
		234	+
		235	+/*
		236	+ * Local variables:
		237	+ * tab-width: 4
		238	+ * c-basic-offset: 4
		239	+ * End:
		240	+ */
		241	+
		242	+?>

pear/DB/mssql.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Sterling Hughes <sterling@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+require_once 'DB/common.php';
		23	+
		24	+/**
		25	+ * Database independent query interface definition for PHP's Microsoft SQL Server
		26	+ * extension.
		27	+ *
		28	+ * @package DB
		29	+ * @version $Id$
		30	+ * @category Database
		31	+ * @author Sterling Hughes <sterling@php.net>
		32	+ */
		33	+class DB_mssql extends DB_common
		34	+{
		35	+ // {{{ properties
		36	+
		37	+ var $connection;
		38	+ var $phptype, $dbsyntax;
		39	+ var $prepare_tokens = array();
		40	+ var $prepare_types = array();
		41	+ var $transaction_opcount = 0;
		42	+ var $autocommit = true;
		43	+ var $_db = null;
		44	+
		45	+ // }}}
		46	+ // {{{ constructor
		47	+
		48	+ function DB_mssql()
		49	+ {
		50	+ $this->DB_common();
		51	+ $this->phptype = 'mssql';
		52	+ $this->dbsyntax = 'mssql';
		53	+ $this->features = array(
		54	+ 'prepare' => false,
		55	+ 'pconnect' => true,
		56	+ 'transactions' => true,
		57	+ 'limit' => 'emulate'
		58	+ );
		59	+ // XXX Add here error codes ie: 'S100E' => DB_ERROR_SYNTAX
		60	+ $this->errorcode_map = array(
		61	+ 170 => DB_ERROR_SYNTAX,
		62	+ 207 => DB_ERROR_NOSUCHFIELD,
		63	+ 208 => DB_ERROR_NOSUCHTABLE,
		64	+ 245 => DB_ERROR_INVALID_NUMBER,
		65	+ 515 => DB_ERROR_CONSTRAINT_NOT_NULL,
		66	+ 547 => DB_ERROR_CONSTRAINT,
		67	+ 2627 => DB_ERROR_CONSTRAINT,
		68	+ 2714 => DB_ERROR_ALREADY_EXISTS,
		69	+ 3701 => DB_ERROR_NOSUCHTABLE,
		70	+ 8134 => DB_ERROR_DIVZERO,
		71	+ );
		72	+ }
		73	+
		74	+ // }}}
		75	+ // {{{ connect()
		76	+
		77	+ function connect($dsninfo, $persistent = false)
		78	+ {
		79	+ if (!DB::assertExtension('mssql') && !DB::assertExtension('sybase')
		80	+ && !DB::assertExtension('sybase_ct'))
		81	+ {
		82	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		83	+ }
		84	+ $this->dsn = $dsninfo;
		85	+ $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
		86	+ $dbhost .= $dsninfo['port'] ? ',' . $dsninfo['port'] : '';
		87	+
		88	+ $connect_function = $persistent ? 'mssql_pconnect' : 'mssql_connect';
		89	+
		90	+ if ($dbhost && $dsninfo['username'] && $dsninfo['password']) {
		91	+ $conn = @$connect_function($dbhost, $dsninfo['username'],
		92	+ $dsninfo['password']);
		93	+ } elseif ($dbhost && $dsninfo['username']) {
		94	+ $conn = @$connect_function($dbhost, $dsninfo['username']);
		95	+ } else {
		96	+ $conn = @$connect_function($dbhost);
		97	+ }
		98	+ if (!$conn) {
		99	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		100	+ null, @mssql_get_last_message());
		101	+ }
		102	+ if ($dsninfo['database']) {
		103	+ if (!@mssql_select_db($dsninfo['database'], $conn)) {
		104	+ return $this->raiseError(DB_ERROR_NODBSELECTED, null, null,
		105	+ null, @mssql_get_last_message());
		106	+ }
		107	+ $this->_db = $dsninfo['database'];
		108	+ }
		109	+ $this->connection = $conn;
		110	+ return DB_OK;
		111	+ }
		112	+
		113	+ // }}}
		114	+ // {{{ disconnect()
		115	+
		116	+ function disconnect()
		117	+ {
		118	+ $ret = @mssql_close($this->connection);
		119	+ $this->connection = null;
		120	+ return $ret;
		121	+ }
		122	+
		123	+ // }}}
		124	+ // {{{ simpleQuery()
		125	+
		126	+ function simpleQuery($query)
		127	+ {
		128	+ $ismanip = DB::isManip($query);
		129	+ $this->last_query = $query;
		130	+ if (!@mssql_select_db($this->_db, $this->connection)) {
		131	+ return $this->mssqlRaiseError(DB_ERROR_NODBSELECTED);
		132	+ }
		133	+ $query = $this->modifyQuery($query);
		134	+ if (!$this->autocommit && $ismanip) {
		135	+ if ($this->transaction_opcount == 0) {
		136	+ $result = @mssql_query('BEGIN TRAN', $this->connection);
		137	+ if (!$result) {
		138	+ return $this->mssqlRaiseError();
		139	+ }
		140	+ }
		141	+ $this->transaction_opcount++;
		142	+ }
		143	+ $result = @mssql_query($query, $this->connection);
		144	+ if (!$result) {
		145	+ return $this->mssqlRaiseError();
		146	+ }
		147	+ // Determine which queries that should return data, and which
		148	+ // should return an error code only.
		149	+ return $ismanip ? DB_OK : $result;
		150	+ }
		151	+
		152	+ // }}}
		153	+ // {{{ nextResult()
		154	+
		155	+ /**
		156	+ * Move the internal mssql result pointer to the next available result
		157	+ *
		158	+ * @param a valid fbsql result resource
		159	+ *
		160	+ * @access public
		161	+ *
		162	+ * @return true if a result is available otherwise return false
		163	+ */
		164	+ function nextResult($result)
		165	+ {
		166	+ return @mssql_next_result($result);
		167	+ }
		168	+
		169	+ // }}}
		170	+ // {{{ fetchInto()
		171	+
		172	+ /**
		173	+ * Fetch a row and insert the data into an existing array.
		174	+ *
		175	+ * Formating of the array and the data therein are configurable.
		176	+ * See DB_result::fetchInto() for more information.
		177	+ *
		178	+ * @param resource $result query result identifier
		179	+ * @param array $arr (reference) array where data from the row
		180	+ * should be placed
		181	+ * @param int $fetchmode how the resulting array should be indexed
		182	+ * @param int $rownum the row number to fetch
		183	+ *
		184	+ * @return mixed DB_OK on success, null when end of result set is
		185	+ * reached or on failure
		186	+ *
		187	+ * @see DB_result::fetchInto()
		188	+ * @access private
		189	+ */
		190	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		191	+ {
		192	+ if ($rownum !== null) {
		193	+ if (!@mssql_data_seek($result, $rownum)) {
		194	+ return null;
		195	+ }
		196	+ }
		197	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		198	+ $arr = @mssql_fetch_array($result, MSSQL_ASSOC);
		199	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		200	+ $arr = array_change_key_case($arr, CASE_LOWER);
		201	+ }
		202	+ } else {
		203	+ $arr = @mssql_fetch_row($result);
		204	+ }
		205	+ if (!$arr) {
		206	+ /* This throws informative error messages,
		207	+ don't use it for now
		208	+ if ($msg = @mssql_get_last_message()) {
		209	+ return $this->raiseError($msg);
		210	+ }
		211	+ */
		212	+ return null;
		213	+ }
		214	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		215	+ $this->_rtrimArrayValues($arr);
		216	+ }
		217	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		218	+ $this->_convertNullArrayValuesToEmpty($arr);
		219	+ }
		220	+ return DB_OK;
		221	+ }
		222	+
		223	+ // }}}
		224	+ // {{{ freeResult()
		225	+
		226	+ function freeResult($result)
		227	+ {
		228	+ return @mssql_free_result($result);
		229	+ }
		230	+
		231	+ // }}}
		232	+ // {{{ numCols()
		233	+
		234	+ function numCols($result)
		235	+ {
		236	+ $cols = @mssql_num_fields($result);
		237	+ if (!$cols) {
		238	+ return $this->mssqlRaiseError();
		239	+ }
		240	+ return $cols;
		241	+ }
		242	+
		243	+ // }}}
		244	+ // {{{ numRows()
		245	+
		246	+ function numRows($result)
		247	+ {
		248	+ $rows = @mssql_num_rows($result);
		249	+ if ($rows === false) {
		250	+ return $this->mssqlRaiseError();
		251	+ }
		252	+ return $rows;
		253	+ }
		254	+
		255	+ // }}}
		256	+ // {{{ autoCommit()
		257	+
		258	+ /**
		259	+ * Enable/disable automatic commits
		260	+ */
		261	+ function autoCommit($onoff = false)
		262	+ {
		263	+ // XXX if $this->transaction_opcount > 0, we should probably
		264	+ // issue a warning here.
		265	+ $this->autocommit = $onoff ? true : false;
		266	+ return DB_OK;
		267	+ }
		268	+
		269	+ // }}}
		270	+ // {{{ commit()
		271	+
		272	+ /**
		273	+ * Commit the current transaction.
		274	+ */
		275	+ function commit()
		276	+ {
		277	+ if ($this->transaction_opcount > 0) {
		278	+ if (!@mssql_select_db($this->_db, $this->connection)) {
		279	+ return $this->mssqlRaiseError(DB_ERROR_NODBSELECTED);
		280	+ }
		281	+ $result = @mssql_query('COMMIT TRAN', $this->connection);
		282	+ $this->transaction_opcount = 0;
		283	+ if (!$result) {
		284	+ return $this->mssqlRaiseError();
		285	+ }
		286	+ }
		287	+ return DB_OK;
		288	+ }
		289	+
		290	+ // }}}
		291	+ // {{{ rollback()
		292	+
		293	+ /**
		294	+ * Roll back (undo) the current transaction.
		295	+ */
		296	+ function rollback()
		297	+ {
		298	+ if ($this->transaction_opcount > 0) {
		299	+ if (!@mssql_select_db($this->_db, $this->connection)) {
		300	+ return $this->mssqlRaiseError(DB_ERROR_NODBSELECTED);
		301	+ }
		302	+ $result = @mssql_query('ROLLBACK TRAN', $this->connection);
		303	+ $this->transaction_opcount = 0;
		304	+ if (!$result) {
		305	+ return $this->mssqlRaiseError();
		306	+ }
		307	+ }
		308	+ return DB_OK;
		309	+ }
		310	+
		311	+ // }}}
		312	+ // {{{ affectedRows()
		313	+
		314	+ /**
		315	+ * Gets the number of rows affected by the last query.
		316	+ * if the last query was a select, returns 0.
		317	+ *
		318	+ * @return number of rows affected by the last query or DB_ERROR
		319	+ */
		320	+ function affectedRows()
		321	+ {
		322	+ if (DB::isManip($this->last_query)) {
		323	+ $res = @mssql_query('select @@rowcount', $this->connection);
		324	+ if (!$res) {
		325	+ return $this->mssqlRaiseError();
		326	+ }
		327	+ $ar = @mssql_fetch_row($res);
		328	+ if (!$ar) {
		329	+ $result = 0;
		330	+ } else {
		331	+ @mssql_free_result($res);
		332	+ $result = $ar[0];
		333	+ }
		334	+ } else {
		335	+ $result = 0;
		336	+ }
		337	+ return $result;
		338	+ }
		339	+
		340	+ // }}}
		341	+ // {{{ nextId()
		342	+
		343	+ /**
		344	+ * Returns the next free id in a sequence
		345	+ *
		346	+ * @param string $seq_name name of the sequence
		347	+ * @param boolean $ondemand when true, the seqence is automatically
		348	+ * created if it does not exist
		349	+ *
		350	+ * @return int the next id number in the sequence. DB_Error if problem.
		351	+ *
		352	+ * @internal
		353	+ * @see DB_common::nextID()
		354	+ * @access public
		355	+ */
		356	+ function nextId($seq_name, $ondemand = true)
		357	+ {
		358	+ $seqname = $this->getSequenceName($seq_name);
		359	+ if (!@mssql_select_db($this->_db, $this->connection)) {
		360	+ return $this->mssqlRaiseError(DB_ERROR_NODBSELECTED);
		361	+ }
		362	+ $repeat = 0;
		363	+ do {
		364	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		365	+ $result = $this->query("INSERT INTO $seqname (vapor) VALUES (0)");
		366	+ $this->popErrorHandling();
		367	+ if ($ondemand && DB::isError($result) &&
		368	+ ($result->getCode() == DB_ERROR \|\| $result->getCode() == DB_ERROR_NOSUCHTABLE))
		369	+ {
		370	+ $repeat = 1;
		371	+ $result = $this->createSequence($seq_name);
		372	+ if (DB::isError($result)) {
		373	+ return $this->raiseError($result);
		374	+ }
		375	+ } elseif (!DB::isError($result)) {
		376	+ $result =& $this->query("SELECT @@IDENTITY FROM $seqname");
		377	+ $repeat = 0;
		378	+ } else {
		379	+ $repeat = false;
		380	+ }
		381	+ } while ($repeat);
		382	+ if (DB::isError($result)) {
		383	+ return $this->raiseError($result);
		384	+ }
		385	+ $result = $result->fetchRow(DB_FETCHMODE_ORDERED);
		386	+ return $result[0];
		387	+ }
		388	+
		389	+ /**
		390	+ * Creates a new sequence
		391	+ *
		392	+ * @param string $seq_name name of the new sequence
		393	+ *
		394	+ * @return int DB_OK on success. A DB_Error object is returned if
		395	+ * problems arise.
		396	+ *
		397	+ * @internal
		398	+ * @see DB_common::createSequence()
		399	+ * @access public
		400	+ */
		401	+ function createSequence($seq_name)
		402	+ {
		403	+ $seqname = $this->getSequenceName($seq_name);
		404	+ return $this->query("CREATE TABLE $seqname ".
		405	+ '([id] [int] IDENTITY (1, 1) NOT NULL ,' .
		406	+ '[vapor] [int] NULL)');
		407	+ }
		408	+
		409	+ // }}}
		410	+ // {{{ dropSequence()
		411	+
		412	+ /**
		413	+ * Deletes a sequence
		414	+ *
		415	+ * @param string $seq_name name of the sequence to be deleted
		416	+ *
		417	+ * @return int DB_OK on success. DB_Error if problems.
		418	+ *
		419	+ * @internal
		420	+ * @see DB_common::dropSequence()
		421	+ * @access public
		422	+ */
		423	+ function dropSequence($seq_name)
		424	+ {
		425	+ $seqname = $this->getSequenceName($seq_name);
		426	+ return $this->query("DROP TABLE $seqname");
		427	+ }
		428	+
		429	+ // }}}
		430	+ // {{{ errorNative()
		431	+
		432	+ /**
		433	+ * Determine MS SQL Server error code by querying @@ERROR.
		434	+ *
		435	+ * @return mixed mssql's native error code or DB_ERROR if unknown.
		436	+ */
		437	+ function errorNative()
		438	+ {
		439	+ $res = @mssql_query('select @@ERROR as ErrorCode', $this->connection);
		440	+ if (!$res) {
		441	+ return DB_ERROR;
		442	+ }
		443	+ $row = @mssql_fetch_row($res);
		444	+ return $row[0];
		445	+ }
		446	+
		447	+ // }}}
		448	+ // {{{ errorCode()
		449	+
		450	+ /**
		451	+ * Determine PEAR::DB error code from mssql's native codes.
		452	+ *
		453	+ * If <var>$nativecode</var> isn't known yet, it will be looked up.
		454	+ *
		455	+ * @param mixed $nativecode mssql error code, if known
		456	+ * @return integer an error number from a DB error constant
		457	+ * @see errorNative()
		458	+ */
		459	+ function errorCode($nativecode = null)
		460	+ {
		461	+ if (!$nativecode) {
		462	+ $nativecode = $this->errorNative();
		463	+ }
		464	+ if (isset($this->errorcode_map[$nativecode])) {
		465	+ return $this->errorcode_map[$nativecode];
		466	+ } else {
		467	+ return DB_ERROR;
		468	+ }
		469	+ }
		470	+
		471	+ // }}}
		472	+ // {{{ mssqlRaiseError()
		473	+
		474	+ /**
		475	+ * Gather information about an error, then use that info to create a
		476	+ * DB error object and finally return that object.
		477	+ *
		478	+ * @param integer $code PEAR error number (usually a DB constant) if
		479	+ * manually raising an error
		480	+ * @return object DB error object
		481	+ * @see errorCode()
		482	+ * @see errorNative()
		483	+ * @see DB_common::raiseError()
		484	+ */
		485	+ function mssqlRaiseError($code = null)
		486	+ {
		487	+ $message = @mssql_get_last_message();
		488	+ if (!$code) {
		489	+ $code = $this->errorNative();
		490	+ }
		491	+ return $this->raiseError($this->errorCode($code), null, null, null,
		492	+ "$code - $message");
		493	+ }
		494	+
		495	+ // }}}
		496	+ // {{{ tableInfo()
		497	+
		498	+ /**
		499	+ * Returns information about a table or a result set.
		500	+ *
		501	+ * NOTE: only supports 'table' and 'flags' if <var>$result</var>
		502	+ * is a table name.
		503	+ *
		504	+ * @param object\|string $result DB_result object from a query or a
		505	+ * string containing the name of a table
		506	+ * @param int $mode a valid tableInfo mode
		507	+ * @return array an associative array with the information requested
		508	+ * or an error object if something is wrong
		509	+ * @access public
		510	+ * @internal
		511	+ * @see DB_common::tableInfo()
		512	+ */
		513	+ function tableInfo($result, $mode = null)
		514	+ {
		515	+ if (isset($result->result)) {
		516	+ /*
		517	+ * Probably received a result object.
		518	+ * Extract the result resource identifier.
		519	+ */
		520	+ $id = $result->result;
		521	+ $got_string = false;
		522	+ } elseif (is_string($result)) {
		523	+ /*
		524	+ * Probably received a table name.
		525	+ * Create a result resource identifier.
		526	+ */
		527	+ if (!@mssql_select_db($this->_db, $this->connection)) {
		528	+ return $this->mssqlRaiseError(DB_ERROR_NODBSELECTED);
		529	+ }
		530	+ $id = @mssql_query("SELECT * FROM $result WHERE 1=0",
		531	+ $this->connection);
		532	+ $got_string = true;
		533	+ } else {
		534	+ /*
		535	+ * Probably received a result resource identifier.
		536	+ * Copy it.
		537	+ * Deprecated. Here for compatibility only.
		538	+ */
		539	+ $id = $result;
		540	+ $got_string = false;
		541	+ }
		542	+
		543	+ if (!is_resource($id)) {
		544	+ return $this->mssqlRaiseError(DB_ERROR_NEED_MORE_DATA);
		545	+ }
		546	+
		547	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		548	+ $case_func = 'strtolower';
		549	+ } else {
		550	+ $case_func = 'strval';
		551	+ }
		552	+
		553	+ $count = @mssql_num_fields($id);
		554	+
		555	+ // made this IF due to performance (one if is faster than $count if's)
		556	+ if (!$mode) {
		557	+ for ($i=0; $i<$count; $i++) {
		558	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		559	+ $res[$i]['name'] = $case_func(@mssql_field_name($id, $i));
		560	+ $res[$i]['type'] = @mssql_field_type($id, $i);
		561	+ $res[$i]['len'] = @mssql_field_length($id, $i);
		562	+ // We only support flags for tables
		563	+ $res[$i]['flags'] = $got_string ? $this->_mssql_field_flags($result, $res[$i]['name']) : '';
		564	+ }
		565	+
		566	+ } else { // full
		567	+ $res['num_fields']= $count;
		568	+
		569	+ for ($i=0; $i<$count; $i++) {
		570	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		571	+ $res[$i]['name'] = $case_func(@mssql_field_name($id, $i));
		572	+ $res[$i]['type'] = @mssql_field_type($id, $i);
		573	+ $res[$i]['len'] = @mssql_field_length($id, $i);
		574	+ // We only support flags for tables
		575	+ $res[$i]['flags'] = $got_string ? $this->_mssql_field_flags($result, $res[$i]['name']) : '';
		576	+
		577	+ if ($mode & DB_TABLEINFO_ORDER) {
		578	+ $res['order'][$res[$i]['name']] = $i;
		579	+ }
		580	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		581	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		582	+ }
		583	+ }
		584	+ }
		585	+
		586	+ // free the result only if we were called on a table
		587	+ if ($got_string) {
		588	+ @mssql_free_result($id);
		589	+ }
		590	+ return $res;
		591	+ }
		592	+
		593	+ // }}}
		594	+ // {{{ getSpecialQuery()
		595	+
		596	+ /**
		597	+ * Returns the query needed to get some backend info
		598	+ * @param string $type What kind of info you want to retrieve
		599	+ * @return string The SQL query string
		600	+ */
		601	+ function getSpecialQuery($type)
		602	+ {
		603	+ switch ($type) {
		604	+ case 'tables':
		605	+ return "select name from sysobjects where type = 'U' order by name";
		606	+ case 'views':
		607	+ return "select name from sysobjects where type = 'V'";
		608	+ default:
		609	+ return null;
		610	+ }
		611	+ }
		612	+
		613	+ // }}}
		614	+ // {{{ _mssql_field_flags()
		615	+
		616	+ /**
		617	+ * Get the flags for a field, currently supports "not_null", "primary_key",
		618	+ * "auto_increment" (mssql identity), "timestamp" (mssql timestamp),
		619	+ * "unique_key" (mssql unique index, unique check or primary_key) and
		620	+ * "multiple_key" (multikey index)
		621	+ *
		622	+ * mssql timestamp is NOT similar to the mysql timestamp so this is maybe
		623	+ * not useful at all - is the behaviour of mysql_field_flags that primary
		624	+ * keys are alway unique? is the interpretation of multiple_key correct?
		625	+ *
		626	+ * @param string The table name
		627	+ * @param string The field
		628	+ * @author Joern Barthel <j_barthel@web.de>
		629	+ * @access private
		630	+ */
		631	+ function _mssql_field_flags($table, $column)
		632	+ {
		633	+ static $tableName = null;
		634	+ static $flags = array();
		635	+
		636	+ if ($table != $tableName) {
		637	+
		638	+ $flags = array();
		639	+ $tableName = $table;
		640	+
		641	+ // get unique and primary keys
		642	+ $res = $this->getAll("EXEC SP_HELPINDEX[$table]", DB_FETCHMODE_ASSOC);
		643	+
		644	+ foreach ($res as $val) {
		645	+ $keys = explode(', ', $val['index_keys']);
		646	+
		647	+ if (sizeof($keys) > 1) {
		648	+ foreach ($keys as $key) {
		649	+ $this->_add_flag($flags[$key], 'multiple_key');
		650	+ }
		651	+ }
		652	+
		653	+ if (strpos($val['index_description'], 'primary key')) {
		654	+ foreach ($keys as $key) {
		655	+ $this->_add_flag($flags[$key], 'primary_key');
		656	+ }
		657	+ } elseif (strpos($val['index_description'], 'unique')) {
		658	+ foreach ($keys as $key) {
		659	+ $this->_add_flag($flags[$key], 'unique_key');
		660	+ }
		661	+ }
		662	+ }
		663	+
		664	+ // get auto_increment, not_null and timestamp
		665	+ $res = $this->getAll("EXEC SP_COLUMNS[$table]", DB_FETCHMODE_ASSOC);
		666	+
		667	+ foreach ($res as $val) {
		668	+ $val = array_change_key_case($val, CASE_LOWER);
		669	+ if ($val['nullable'] == '0') {
		670	+ $this->_add_flag($flags[$val['column_name']], 'not_null');
		671	+ }
		672	+ if (strpos($val['type_name'], 'identity')) {
		673	+ $this->_add_flag($flags[$val['column_name']], 'auto_increment');
		674	+ }
		675	+ if (strpos($val['type_name'], 'timestamp')) {
		676	+ $this->_add_flag($flags[$val['column_name']], 'timestamp');
		677	+ }
		678	+ }
		679	+ }
		680	+
		681	+ if (array_key_exists($column, $flags)) {
		682	+ return(implode(' ', $flags[$column]));
		683	+ }
		684	+ return '';
		685	+ }
		686	+
		687	+ // }}}
		688	+ // {{{ _add_flag()
		689	+
		690	+ /**
		691	+ * Adds a string to the flags array if the flag is not yet in there
		692	+ * - if there is no flag present the array is created.
		693	+ *
		694	+ * @param reference Reference to the flag-array
		695	+ * @param value The flag value
		696	+ * @access private
		697	+ * @author Joern Barthel <j_barthel@web.de>
		698	+ */
		699	+ function _add_flag(&$array, $value)
		700	+ {
		701	+ if (!is_array($array)) {
		702	+ $array = array($value);
		703	+ } elseif (!in_array($value, $array)) {
		704	+ array_push($array, $value);
		705	+ }
		706	+ }
		707	+
		708	+ // }}}
		709	+ // {{{ quoteIdentifier()
		710	+
		711	+ /**
		712	+ * Quote a string so it can be safely used as a table / column name
		713	+ *
		714	+ * Quoting style depends on which database driver is being used.
		715	+ *
		716	+ * @param string $str identifier name to be quoted
		717	+ *
		718	+ * @return string quoted identifier string
		719	+ *
		720	+ * @since 1.6.0
		721	+ * @access public
		722	+ */
		723	+ function quoteIdentifier($str)
		724	+ {
		725	+ return '[' . str_replace(']', ']]', $str) . ']';
		726	+ }
		727	+
		728	+ // }}}
		729	+}
		730	+
		731	+/*
		732	+ * Local variables:
		733	+ * tab-width: 4
		734	+ * c-basic-offset: 4
		735	+ * End:
		736	+ */
		737	+
		738	+?>

pear/DB/mysql.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Stig Bakken <ssb@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// XXX legend:
		24	+//
		25	+// XXX ERRORMSG: The error message from the mysql function should
		26	+// be registered here.
		27	+//
		28	+// TODO/wishlist:
		29	+// longReadlen
		30	+// binmode
		31	+
		32	+
		33	+require_once 'DB/common.php';
		34	+
		35	+/**
		36	+ * Database independent query interface definition for PHP's MySQL
		37	+ * extension.
		38	+ *
		39	+ * This is for MySQL versions 4.0 and below.
		40	+ *
		41	+ * @package DB
		42	+ * @version $Id$
		43	+ * @category Database
		44	+ * @author Stig Bakken <ssb@php.net>
		45	+ */
		46	+class DB_mysql extends DB_common
		47	+{
		48	+ // {{{ properties
		49	+
		50	+ var $connection;
		51	+ var $phptype, $dbsyntax;
		52	+ var $prepare_tokens = array();
		53	+ var $prepare_types = array();
		54	+ var $num_rows = array();
		55	+ var $transaction_opcount = 0;
		56	+ var $autocommit = true;
		57	+ var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */
		58	+ var $_db = false;
		59	+
		60	+ // }}}
		61	+ // {{{ constructor
		62	+
		63	+ /**
		64	+ * DB_mysql constructor.
		65	+ *
		66	+ * @access public
		67	+ */
		68	+ function DB_mysql()
		69	+ {
		70	+ $this->DB_common();
		71	+ $this->phptype = 'mysql';
		72	+ $this->dbsyntax = 'mysql';
		73	+ $this->features = array(
		74	+ 'prepare' => false,
		75	+ 'pconnect' => true,
		76	+ 'transactions' => true,
		77	+ 'limit' => 'alter'
		78	+ );
		79	+ $this->errorcode_map = array(
		80	+ 1004 => DB_ERROR_CANNOT_CREATE,
		81	+ 1005 => DB_ERROR_CANNOT_CREATE,
		82	+ 1006 => DB_ERROR_CANNOT_CREATE,
		83	+ 1007 => DB_ERROR_ALREADY_EXISTS,
		84	+ 1008 => DB_ERROR_CANNOT_DROP,
		85	+ 1022 => DB_ERROR_ALREADY_EXISTS,
		86	+ 1046 => DB_ERROR_NODBSELECTED,
		87	+ 1048 => DB_ERROR_CONSTRAINT,
		88	+ 1050 => DB_ERROR_ALREADY_EXISTS,
		89	+ 1051 => DB_ERROR_NOSUCHTABLE,
		90	+ 1054 => DB_ERROR_NOSUCHFIELD,
		91	+ 1062 => DB_ERROR_ALREADY_EXISTS,
		92	+ 1064 => DB_ERROR_SYNTAX,
		93	+ 1100 => DB_ERROR_NOT_LOCKED,
		94	+ 1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
		95	+ 1146 => DB_ERROR_NOSUCHTABLE,
		96	+ 1216 => DB_ERROR_CONSTRAINT,
		97	+ 1217 => DB_ERROR_CONSTRAINT,
		98	+ );
		99	+ }
		100	+
		101	+ // }}}
		102	+ // {{{ connect()
		103	+
		104	+ /**
		105	+ * Connect to a database and log in as the specified user.
		106	+ *
		107	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		108	+ * @param $persistent (optional) whether the connection should
		109	+ * be persistent
		110	+ * @access public
		111	+ * @return int DB_OK on success, a DB error on failure
		112	+ */
		113	+ function connect($dsninfo, $persistent = false)
		114	+ {
		115	+ if (!DB::assertExtension('mysql')) {
		116	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		117	+ }
		118	+ $this->dsn = $dsninfo;
		119	+ if ($dsninfo['protocol'] && $dsninfo['protocol'] == 'unix') {
		120	+ $dbhost = ':' . $dsninfo['socket'];
		121	+ } else {
		122	+ $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
		123	+ if ($dsninfo['port']) {
		124	+ $dbhost .= ':' . $dsninfo['port'];
		125	+ }
		126	+ }
		127	+
		128	+ $connect_function = $persistent ? 'mysql_pconnect' : 'mysql_connect';
		129	+
		130	+ if ($dbhost && $dsninfo['username'] && isset($dsninfo['password'])) {
		131	+ $conn = @$connect_function($dbhost, $dsninfo['username'],
		132	+ $dsninfo['password']);
		133	+ } elseif ($dbhost && $dsninfo['username']) {
		134	+ $conn = @$connect_function($dbhost, $dsninfo['username']);
		135	+ } elseif ($dbhost) {
		136	+ $conn = @$connect_function($dbhost);
		137	+ } else {
		138	+ $conn = false;
		139	+ }
		140	+ if (!$conn) {
		141	+ if (($err = @mysql_error()) != '') {
		142	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		143	+ null, $err);
		144	+ } elseif (empty($php_errormsg)) {
		145	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED);
		146	+ } else {
		147	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		148	+ null, $php_errormsg);
		149	+ }
		150	+ }
		151	+
		152	+ if ($dsninfo['database']) {
		153	+ if (!@mysql_select_db($dsninfo['database'], $conn)) {
		154	+ switch(mysql_errno($conn)) {
		155	+ case 1049:
		156	+ return $this->raiseError(DB_ERROR_NOSUCHDB, null, null,
		157	+ null, @mysql_error($conn));
		158	+ case 1044:
		159	+ return $this->raiseError(DB_ERROR_ACCESS_VIOLATION, null, null,
		160	+ null, @mysql_error($conn));
		161	+ default:
		162	+ return $this->raiseError(DB_ERROR, null, null,
		163	+ null, @mysql_error($conn));
		164	+ }
		165	+ }
		166	+ // fix to allow calls to different databases in the same script
		167	+ $this->_db = $dsninfo['database'];
		168	+ }
		169	+
		170	+ $this->connection = $conn;
		171	+ return DB_OK;
		172	+ }
		173	+
		174	+ // }}}
		175	+ // {{{ disconnect()
		176	+
		177	+ /**
		178	+ * Log out and disconnect from the database.
		179	+ *
		180	+ * @access public
		181	+ *
		182	+ * @return bool true on success, false if not connected.
		183	+ */
		184	+ function disconnect()
		185	+ {
		186	+ $ret = @mysql_close($this->connection);
		187	+ $this->connection = null;
		188	+ return $ret;
		189	+ }
		190	+
		191	+ // }}}
		192	+ // {{{ simpleQuery()
		193	+
		194	+ /**
		195	+ * Send a query to MySQL and return the results as a MySQL resource
		196	+ * identifier.
		197	+ *
		198	+ * @param the SQL query
		199	+ *
		200	+ * @access public
		201	+ *
		202	+ * @return mixed returns a valid MySQL result for successful SELECT
		203	+ * queries, DB_OK for other successful queries. A DB error is
		204	+ * returned on failure.
		205	+ */
		206	+ function simpleQuery($query)
		207	+ {
		208	+ $ismanip = DB::isManip($query);
		209	+ $this->last_query = $query;
		210	+ $query = $this->modifyQuery($query);
		211	+ if ($this->_db) {
		212	+ if (!@mysql_select_db($this->_db, $this->connection)) {
		213	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		214	+ }
		215	+ }
		216	+ if (!$this->autocommit && $ismanip) {
		217	+ if ($this->transaction_opcount == 0) {
		218	+ $result = @mysql_query('SET AUTOCOMMIT=0', $this->connection);
		219	+ $result = @mysql_query('BEGIN', $this->connection);
		220	+ if (!$result) {
		221	+ return $this->mysqlRaiseError();
		222	+ }
		223	+ }
		224	+ $this->transaction_opcount++;
		225	+ }
		226	+ $result = @mysql_query($query, $this->connection);
		227	+ if (!$result) {
		228	+ return $this->mysqlRaiseError();
		229	+ }
		230	+ if (is_resource($result)) {
		231	+ $numrows = $this->numrows($result);
		232	+ if (is_object($numrows)) {
		233	+ return $numrows;
		234	+ }
		235	+ $this->num_rows[(int)$result] = $numrows;
		236	+ return $result;
		237	+ }
		238	+ return DB_OK;
		239	+ }
		240	+
		241	+ // }}}
		242	+ // {{{ nextResult()
		243	+
		244	+ /**
		245	+ * Move the internal mysql result pointer to the next available result
		246	+ *
		247	+ * This method has not been implemented yet.
		248	+ *
		249	+ * @param a valid sql result resource
		250	+ *
		251	+ * @access public
		252	+ *
		253	+ * @return false
		254	+ */
		255	+ function nextResult($result)
		256	+ {
		257	+ return false;
		258	+ }
		259	+
		260	+ // }}}
		261	+ // {{{ fetchInto()
		262	+
		263	+ /**
		264	+ * Fetch a row and insert the data into an existing array.
		265	+ *
		266	+ * Formating of the array and the data therein are configurable.
		267	+ * See DB_result::fetchInto() for more information.
		268	+ *
		269	+ * @param resource $result query result identifier
		270	+ * @param array $arr (reference) array where data from the row
		271	+ * should be placed
		272	+ * @param int $fetchmode how the resulting array should be indexed
		273	+ * @param int $rownum the row number to fetch
		274	+ *
		275	+ * @return mixed DB_OK on success, null when end of result set is
		276	+ * reached or on failure
		277	+ *
		278	+ * @see DB_result::fetchInto()
		279	+ * @access private
		280	+ */
		281	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		282	+ {
		283	+ if ($rownum !== null) {
		284	+ if (!@mysql_data_seek($result, $rownum)) {
		285	+ return null;
		286	+ }
		287	+ }
		288	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		289	+ $arr = @mysql_fetch_array($result, MYSQL_ASSOC);
		290	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		291	+ $arr = array_change_key_case($arr, CASE_LOWER);
		292	+ }
		293	+ } else {
		294	+ $arr = @mysql_fetch_row($result);
		295	+ }
		296	+ if (!$arr) {
		297	+ // See: http://bugs.php.net/bug.php?id=22328
		298	+ // for why we can't check errors on fetching
		299	+ return null;
		300	+ /*
		301	+ $errno = @mysql_errno($this->connection);
		302	+ if (!$errno) {
		303	+ return null;
		304	+ }
		305	+ return $this->mysqlRaiseError($errno);
		306	+ */
		307	+ }
		308	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		309	+ /*
		310	+ * Even though this DBMS already trims output, we do this because
		311	+ * a field might have intentional whitespace at the end that
		312	+ * gets removed by DB_PORTABILITY_RTRIM under another driver.
		313	+ */
		314	+ $this->_rtrimArrayValues($arr);
		315	+ }
		316	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		317	+ $this->_convertNullArrayValuesToEmpty($arr);
		318	+ }
		319	+ return DB_OK;
		320	+ }
		321	+
		322	+ // }}}
		323	+ // {{{ freeResult()
		324	+
		325	+ /**
		326	+ * Free the internal resources associated with $result.
		327	+ *
		328	+ * @param $result MySQL result identifier
		329	+ *
		330	+ * @access public
		331	+ *
		332	+ * @return bool true on success, false if $result is invalid
		333	+ */
		334	+ function freeResult($result)
		335	+ {
		336	+ unset($this->num_rows[(int)$result]);
		337	+ return @mysql_free_result($result);
		338	+ }
		339	+
		340	+ // }}}
		341	+ // {{{ numCols()
		342	+
		343	+ /**
		344	+ * Get the number of columns in a result set.
		345	+ *
		346	+ * @param $result MySQL result identifier
		347	+ *
		348	+ * @access public
		349	+ *
		350	+ * @return int the number of columns per row in $result
		351	+ */
		352	+ function numCols($result)
		353	+ {
		354	+ $cols = @mysql_num_fields($result);
		355	+
		356	+ if (!$cols) {
		357	+ return $this->mysqlRaiseError();
		358	+ }
		359	+
		360	+ return $cols;
		361	+ }
		362	+
		363	+ // }}}
		364	+ // {{{ numRows()
		365	+
		366	+ /**
		367	+ * Get the number of rows in a result set.
		368	+ *
		369	+ * @param $result MySQL result identifier
		370	+ *
		371	+ * @access public
		372	+ *
		373	+ * @return int the number of rows in $result
		374	+ */
		375	+ function numRows($result)
		376	+ {
		377	+ $rows = @mysql_num_rows($result);
		378	+ if ($rows === null) {
		379	+ return $this->mysqlRaiseError();
		380	+ }
		381	+ return $rows;
		382	+ }
		383	+
		384	+ // }}}
		385	+ // {{{ autoCommit()
		386	+
		387	+ /**
		388	+ * Enable/disable automatic commits
		389	+ */
		390	+ function autoCommit($onoff = false)
		391	+ {
		392	+ // XXX if $this->transaction_opcount > 0, we should probably
		393	+ // issue a warning here.
		394	+ $this->autocommit = $onoff ? true : false;
		395	+ return DB_OK;
		396	+ }
		397	+
		398	+ // }}}
		399	+ // {{{ commit()
		400	+
		401	+ /**
		402	+ * Commit the current transaction.
		403	+ */
		404	+ function commit()
		405	+ {
		406	+ if ($this->transaction_opcount > 0) {
		407	+ if ($this->_db) {
		408	+ if (!@mysql_select_db($this->_db, $this->connection)) {
		409	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		410	+ }
		411	+ }
		412	+ $result = @mysql_query('COMMIT', $this->connection);
		413	+ $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);
		414	+ $this->transaction_opcount = 0;
		415	+ if (!$result) {
		416	+ return $this->mysqlRaiseError();
		417	+ }
		418	+ }
		419	+ return DB_OK;
		420	+ }
		421	+
		422	+ // }}}
		423	+ // {{{ rollback()
		424	+
		425	+ /**
		426	+ * Roll back (undo) the current transaction.
		427	+ */
		428	+ function rollback()
		429	+ {
		430	+ if ($this->transaction_opcount > 0) {
		431	+ if ($this->_db) {
		432	+ if (!@mysql_select_db($this->_db, $this->connection)) {
		433	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		434	+ }
		435	+ }
		436	+ $result = @mysql_query('ROLLBACK', $this->connection);
		437	+ $result = @mysql_query('SET AUTOCOMMIT=1', $this->connection);
		438	+ $this->transaction_opcount = 0;
		439	+ if (!$result) {
		440	+ return $this->mysqlRaiseError();
		441	+ }
		442	+ }
		443	+ return DB_OK;
		444	+ }
		445	+
		446	+ // }}}
		447	+ // {{{ affectedRows()
		448	+
		449	+ /**
		450	+ * Gets the number of rows affected by the data manipulation
		451	+ * query. For other queries, this function returns 0.
		452	+ *
		453	+ * @return number of rows affected by the last query
		454	+ */
		455	+ function affectedRows()
		456	+ {
		457	+ if (DB::isManip($this->last_query)) {
		458	+ return @mysql_affected_rows($this->connection);
		459	+ } else {
		460	+ return 0;
		461	+ }
		462	+ }
		463	+
		464	+ // }}}
		465	+ // {{{ errorNative()
		466	+
		467	+ /**
		468	+ * Get the native error code of the last error (if any) that
		469	+ * occured on the current connection.
		470	+ *
		471	+ * @access public
		472	+ *
		473	+ * @return int native MySQL error code
		474	+ */
		475	+ function errorNative()
		476	+ {
		477	+ return @mysql_errno($this->connection);
		478	+ }
		479	+
		480	+ // }}}
		481	+ // {{{ nextId()
		482	+
		483	+ /**
		484	+ * Returns the next free id in a sequence
		485	+ *
		486	+ * @param string $seq_name name of the sequence
		487	+ * @param boolean $ondemand when true, the seqence is automatically
		488	+ * created if it does not exist
		489	+ *
		490	+ * @return int the next id number in the sequence. DB_Error if problem.
		491	+ *
		492	+ * @internal
		493	+ * @see DB_common::nextID()
		494	+ * @access public
		495	+ */
		496	+ function nextId($seq_name, $ondemand = true)
		497	+ {
		498	+ $seqname = $this->getSequenceName($seq_name);
		499	+ do {
		500	+ $repeat = 0;
		501	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		502	+ $result = $this->query("UPDATE ${seqname} ".
		503	+ 'SET id=LAST_INSERT_ID(id+1)');
		504	+ $this->popErrorHandling();
		505	+ if ($result === DB_OK) {
		506	+ / COMMON CASE /
		507	+ $id = @mysql_insert_id($this->connection);
		508	+ if ($id != 0) {
		509	+ return $id;
		510	+ }
		511	+ / EMPTY SEQ TABLE /
		512	+ // Sequence table must be empty for some reason, so fill it and return 1
		513	+ // Obtain a user-level lock
		514	+ $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
		515	+ if (DB::isError($result)) {
		516	+ return $this->raiseError($result);
		517	+ }
		518	+ if ($result == 0) {
		519	+ // Failed to get the lock, bail with a DB_ERROR_NOT_LOCKED error
		520	+ return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
		521	+ }
		522	+
		523	+ // add the default value
		524	+ $result = $this->query("REPLACE INTO ${seqname} (id) VALUES (0)");
		525	+ if (DB::isError($result)) {
		526	+ return $this->raiseError($result);
		527	+ }
		528	+
		529	+ // Release the lock
		530	+ $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
		531	+ if (DB::isError($result)) {
		532	+ return $this->raiseError($result);
		533	+ }
		534	+ // We know what the result will be, so no need to try again
		535	+ return 1;
		536	+
		537	+ / ONDEMAND TABLE CREATION /
		538	+ } elseif ($ondemand && DB::isError($result) &&
		539	+ $result->getCode() == DB_ERROR_NOSUCHTABLE)
		540	+ {
		541	+ $result = $this->createSequence($seq_name);
		542	+ if (DB::isError($result)) {
		543	+ return $this->raiseError($result);
		544	+ } else {
		545	+ $repeat = 1;
		546	+ }
		547	+
		548	+ / BACKWARDS COMPAT /
		549	+ } elseif (DB::isError($result) &&
		550	+ $result->getCode() == DB_ERROR_ALREADY_EXISTS)
		551	+ {
		552	+ // see _BCsequence() comment
		553	+ $result = $this->_BCsequence($seqname);
		554	+ if (DB::isError($result)) {
		555	+ return $this->raiseError($result);
		556	+ }
		557	+ $repeat = 1;
		558	+ }
		559	+ } while ($repeat);
		560	+
		561	+ return $this->raiseError($result);
		562	+ }
		563	+
		564	+ // }}}
		565	+ // {{{ createSequence()
		566	+
		567	+ /**
		568	+ * Creates a new sequence
		569	+ *
		570	+ * @param string $seq_name name of the new sequence
		571	+ *
		572	+ * @return int DB_OK on success. A DB_Error object is returned if
		573	+ * problems arise.
		574	+ *
		575	+ * @internal
		576	+ * @see DB_common::createSequence()
		577	+ * @access public
		578	+ */
		579	+ function createSequence($seq_name)
		580	+ {
		581	+ $seqname = $this->getSequenceName($seq_name);
		582	+ $res = $this->query("CREATE TABLE ${seqname} ".
		583	+ '(id INTEGER UNSIGNED AUTO_INCREMENT NOT NULL,'.
		584	+ ' PRIMARY KEY(id))');
		585	+ if (DB::isError($res)) {
		586	+ return $res;
		587	+ }
		588	+ // insert yields value 1, nextId call will generate ID 2
		589	+ $res = $this->query("INSERT INTO ${seqname} (id) VALUES (0)");
		590	+ if (DB::isError($res)) {
		591	+ return $res;
		592	+ }
		593	+ // so reset to zero
		594	+ return $this->query("UPDATE ${seqname} SET id = 0;");
		595	+ }
		596	+
		597	+ // }}}
		598	+ // {{{ dropSequence()
		599	+
		600	+ /**
		601	+ * Deletes a sequence
		602	+ *
		603	+ * @param string $seq_name name of the sequence to be deleted
		604	+ *
		605	+ * @return int DB_OK on success. DB_Error if problems.
		606	+ *
		607	+ * @internal
		608	+ * @see DB_common::dropSequence()
		609	+ * @access public
		610	+ */
		611	+ function dropSequence($seq_name)
		612	+ {
		613	+ return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
		614	+ }
		615	+
		616	+ // }}}
		617	+ // {{{ _BCsequence()
		618	+
		619	+ /**
		620	+ * Backwards compatibility with old sequence emulation implementation
		621	+ * (clean up the dupes)
		622	+ *
		623	+ * @param string $seqname The sequence name to clean up
		624	+ * @return mixed DB_Error or true
		625	+ */
		626	+ function _BCsequence($seqname)
		627	+ {
		628	+ // Obtain a user-level lock... this will release any previous
		629	+ // application locks, but unlike LOCK TABLES, it does not abort
		630	+ // the current transaction and is much less frequently used.
		631	+ $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
		632	+ if (DB::isError($result)) {
		633	+ return $result;
		634	+ }
		635	+ if ($result == 0) {
		636	+ // Failed to get the lock, can't do the conversion, bail
		637	+ // with a DB_ERROR_NOT_LOCKED error
		638	+ return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
		639	+ }
		640	+
		641	+ $highest_id = $this->getOne("SELECT MAX(id) FROM ${seqname}");
		642	+ if (DB::isError($highest_id)) {
		643	+ return $highest_id;
		644	+ }
		645	+ // This should kill all rows except the highest
		646	+ // We should probably do something if $highest_id isn't
		647	+ // numeric, but I'm at a loss as how to handle that...
		648	+ $result = $this->query("DELETE FROM ${seqname} WHERE id <> $highest_id");
		649	+ if (DB::isError($result)) {
		650	+ return $result;
		651	+ }
		652	+
		653	+ // If another thread has been waiting for this lock,
		654	+ // it will go thru the above procedure, but will have no
		655	+ // real effect
		656	+ $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
		657	+ if (DB::isError($result)) {
		658	+ return $result;
		659	+ }
		660	+ return true;
		661	+ }
		662	+
		663	+ // }}}
		664	+ // {{{ quoteIdentifier()
		665	+
		666	+ /**
		667	+ * Quote a string so it can be safely used as a table or column name
		668	+ *
		669	+ * Quoting style depends on which database driver is being used.
		670	+ *
		671	+ * MySQL can't handle the backtick character (<kbd>`</kbd>) in
		672	+ * table or column names.
		673	+ *
		674	+ * @param string $str identifier name to be quoted
		675	+ *
		676	+ * @return string quoted identifier string
		677	+ *
		678	+ * @since 1.6.0
		679	+ * @access public
		680	+ * @internal
		681	+ */
		682	+ function quoteIdentifier($str)
		683	+ {
		684	+ return '`' . $str . '`';
		685	+ }
		686	+
		687	+ // }}}
		688	+ // {{{ quote()
		689	+
		690	+ /**
		691	+ * @deprecated Deprecated in release 1.6.0
		692	+ * @internal
		693	+ */
		694	+ function quote($str) {
		695	+ return $this->quoteSmart($str);
		696	+ }
		697	+
		698	+ // }}}
		699	+ // {{{ escapeSimple()
		700	+
		701	+ /**
		702	+ * Escape a string according to the current DBMS's standards
		703	+ *
		704	+ * @param string $str the string to be escaped
		705	+ *
		706	+ * @return string the escaped string
		707	+ *
		708	+ * @internal
		709	+ */
		710	+ function escapeSimple($str) {
		711	+ if (function_exists('mysql_real_escape_string')) {
		712	+ return @mysql_real_escape_string($str, $this->connection);
		713	+ } else {
		714	+ return @mysql_escape_string($str);
		715	+ }
		716	+ }
		717	+
		718	+ // }}}
		719	+ // {{{ modifyQuery()
		720	+
		721	+ function modifyQuery($query)
		722	+ {
		723	+ if ($this->options['portability'] & DB_PORTABILITY_DELETE_COUNT) {
		724	+ // "DELETE FROM table" gives 0 affected rows in MySQL.
		725	+ // This little hack lets you know how many rows were deleted.
		726	+ if (preg_match('/^\sDELETE\s+FROM\s+(\S+)\s$/i', $query)) {
		727	+ $query = preg_replace('/^\sDELETE\s+FROM\s+(\S+)\s$/',
		728	+ 'DELETE FROM \1 WHERE 1=1', $query);
		729	+ }
		730	+ }
		731	+ return $query;
		732	+ }
		733	+
		734	+ // }}}
		735	+ // {{{ modifyLimitQuery()
		736	+
		737	+ function modifyLimitQuery($query, $from, $count, $params = array())
		738	+ {
		739	+ if (DB::isManip($query)) {
		740	+ return $query . " LIMIT $count";
		741	+ } else {
		742	+ return $query . " LIMIT $from, $count";
		743	+ }
		744	+ }
		745	+
		746	+ // }}}
		747	+ // {{{ mysqlRaiseError()
		748	+
		749	+ /**
		750	+ * Gather information about an error, then use that info to create a
		751	+ * DB error object and finally return that object.
		752	+ *
		753	+ * @param integer $errno PEAR error number (usually a DB constant) if
		754	+ * manually raising an error
		755	+ * @return object DB error object
		756	+ * @see DB_common::errorCode()
		757	+ * @see DB_common::raiseError()
		758	+ */
		759	+ function mysqlRaiseError($errno = null)
		760	+ {
		761	+ if ($errno === null) {
		762	+ if ($this->options['portability'] & DB_PORTABILITY_ERRORS) {
		763	+ $this->errorcode_map[1022] = DB_ERROR_CONSTRAINT;
		764	+ $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT_NOT_NULL;
		765	+ $this->errorcode_map[1062] = DB_ERROR_CONSTRAINT;
		766	+ } else {
		767	+ // Doing this in case mode changes during runtime.
		768	+ $this->errorcode_map[1022] = DB_ERROR_ALREADY_EXISTS;
		769	+ $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT;
		770	+ $this->errorcode_map[1062] = DB_ERROR_ALREADY_EXISTS;
		771	+ }
		772	+ $errno = $this->errorCode(mysql_errno($this->connection));
		773	+ }
		774	+ return $this->raiseError($errno, null, null, null,
		775	+ @mysql_errno($this->connection) . ' ** ' .
		776	+ @mysql_error($this->connection));
		777	+ }
		778	+
		779	+ // }}}
		780	+ // {{{ tableInfo()
		781	+
		782	+ /**
		783	+ * Returns information about a table or a result set.
		784	+ *
		785	+ * @param object\|string $result DB_result object from a query or a
		786	+ * string containing the name of a table
		787	+ * @param int $mode a valid tableInfo mode
		788	+ * @return array an associative array with the information requested
		789	+ * or an error object if something is wrong
		790	+ * @access public
		791	+ * @internal
		792	+ * @see DB_common::tableInfo()
		793	+ */
		794	+ function tableInfo($result, $mode = null) {
		795	+ if (isset($result->result)) {
		796	+ /*
		797	+ * Probably received a result object.
		798	+ * Extract the result resource identifier.
		799	+ */
		800	+ $id = $result->result;
		801	+ $got_string = false;
		802	+ } elseif (is_string($result)) {
		803	+ /*
		804	+ * Probably received a table name.
		805	+ * Create a result resource identifier.
		806	+ */
		807	+ $id = @mysql_list_fields($this->dsn['database'],
		808	+ $result, $this->connection);
		809	+ $got_string = true;
		810	+ } else {
		811	+ /*
		812	+ * Probably received a result resource identifier.
		813	+ * Copy it.
		814	+ * Deprecated. Here for compatibility only.
		815	+ */
		816	+ $id = $result;
		817	+ $got_string = false;
		818	+ }
		819	+
		820	+ if (!is_resource($id)) {
		821	+ return $this->mysqlRaiseError(DB_ERROR_NEED_MORE_DATA);
		822	+ }
		823	+
		824	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		825	+ $case_func = 'strtolower';
		826	+ } else {
		827	+ $case_func = 'strval';
		828	+ }
		829	+
		830	+ $count = @mysql_num_fields($id);
		831	+
		832	+ // made this IF due to performance (one if is faster than $count if's)
		833	+ if (!$mode) {
		834	+ for ($i=0; $i<$count; $i++) {
		835	+ $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));
		836	+ $res[$i]['name'] = $case_func(@mysql_field_name($id, $i));
		837	+ $res[$i]['type'] = @mysql_field_type($id, $i);
		838	+ $res[$i]['len'] = @mysql_field_len($id, $i);
		839	+ $res[$i]['flags'] = @mysql_field_flags($id, $i);
		840	+ }
		841	+ } else { // full
		842	+ $res['num_fields']= $count;
		843	+
		844	+ for ($i=0; $i<$count; $i++) {
		845	+ $res[$i]['table'] = $case_func(@mysql_field_table($id, $i));
		846	+ $res[$i]['name'] = $case_func(@mysql_field_name($id, $i));
		847	+ $res[$i]['type'] = @mysql_field_type($id, $i);
		848	+ $res[$i]['len'] = @mysql_field_len($id, $i);
		849	+ $res[$i]['flags'] = @mysql_field_flags($id, $i);
		850	+
		851	+ if ($mode & DB_TABLEINFO_ORDER) {
		852	+ $res['order'][$res[$i]['name']] = $i;
		853	+ }
		854	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		855	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		856	+ }
		857	+ }
		858	+ }
		859	+
		860	+ // free the result only if we were called on a table
		861	+ if ($got_string) {
		862	+ @mysql_free_result($id);
		863	+ }
		864	+ return $res;
		865	+ }
		866	+
		867	+ // }}}
		868	+ // {{{ getSpecialQuery()
		869	+
		870	+ /**
		871	+ * Returns the query needed to get some backend info
		872	+ * @param string $type What kind of info you want to retrieve
		873	+ * @return string The SQL query string
		874	+ */
		875	+ function getSpecialQuery($type)
		876	+ {
		877	+ switch ($type) {
		878	+ case 'tables':
		879	+ return 'SHOW TABLES';
		880	+ case 'views':
		881	+ return DB_ERROR_NOT_CAPABLE;
		882	+ case 'users':
		883	+ $sql = 'select distinct User from user';
		884	+ if ($this->dsn['database'] != 'mysql') {
		885	+ $dsn = $this->dsn;
		886	+ $dsn['database'] = 'mysql';
		887	+ if (DB::isError($db = DB::connect($dsn))) {
		888	+ return $db;
		889	+ }
		890	+ $sql = $db->getCol($sql);
		891	+ $db->disconnect();
		892	+ // XXX Fixme the mysql driver should take care of this
		893	+ if (!@mysql_select_db($this->dsn['database'], $this->connection)) {
		894	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		895	+ }
		896	+ }
		897	+ return $sql;
		898	+ case 'databases':
		899	+ return 'SHOW DATABASES';
		900	+ default:
		901	+ return null;
		902	+ }
		903	+ }
		904	+
		905	+ // }}}
		906	+
		907	+}
		908	+
		909	+/*
		910	+ * Local variables:
		911	+ * tab-width: 4
		912	+ * c-basic-offset: 4
		913	+ * End:
		914	+ */
		915	+
		916	+?>

pear/DB/mysqli.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Daniel Convissor <danielc@php.net> \|
		17	+// +----------------------------------------------------------------------+
		18	+//
		19	+// $Id$
		20	+
		21	+
		22	+// EXPERIMENTAL
		23	+
		24	+
		25	+require_once 'DB/common.php';
		26	+
		27	+/**
		28	+ * Database independent query interface definition for PHP's mysqli
		29	+ * extension.
		30	+ *
		31	+ * This is for MySQL versions 4.1 and above. Requires PHP 5.
		32	+ *
		33	+ * Note that persistent connections no longer exist.
		34	+ *
		35	+ * @package DB
		36	+ * @version $Id$
		37	+ * @category Database
		38	+ * @author Daniel Convissor <danielc@php.net>
		39	+ * @since Class functional since Release 1.6.3
		40	+ */
		41	+class DB_mysqli extends DB_common
		42	+{
		43	+ // {{{ properties
		44	+
		45	+ var $connection;
		46	+ var $phptype, $dbsyntax;
		47	+ var $prepare_tokens = array();
		48	+ var $prepare_types = array();
		49	+ var $num_rows = array();
		50	+ var $transaction_opcount = 0;
		51	+ var $autocommit = true;
		52	+ var $fetchmode = DB_FETCHMODE_ORDERED; /* Default fetch mode */
		53	+ var $_db = false;
		54	+
		55	+ /**
		56	+ * Array for converting MYSQLI_*_FLAG constants to text values
		57	+ * @var array
		58	+ * @access public
		59	+ * @since Property available since Release 1.6.5
		60	+ */
		61	+ var $mysqli_flags = array(
		62	+ MYSQLI_NOT_NULL_FLAG => 'not_null',
		63	+ MYSQLI_PRI_KEY_FLAG => 'primary_key',
		64	+ MYSQLI_UNIQUE_KEY_FLAG => 'unique_key',
		65	+ MYSQLI_MULTIPLE_KEY_FLAG => 'multiple_key',
		66	+ MYSQLI_BLOB_FLAG => 'blob',
		67	+ MYSQLI_UNSIGNED_FLAG => 'unsigned',
		68	+ MYSQLI_ZEROFILL_FLAG => 'zerofill',
		69	+ MYSQLI_AUTO_INCREMENT_FLAG => 'auto_increment',
		70	+ MYSQLI_TIMESTAMP_FLAG => 'timestamp',
		71	+ MYSQLI_SET_FLAG => 'set',
		72	+ // MYSQLI_NUM_FLAG => 'numeric', // unnecessary
		73	+ // MYSQLI_PART_KEY_FLAG => 'multiple_key', // duplicatvie
		74	+ MYSQLI_GROUP_FLAG => 'group_by'
		75	+ );
		76	+
		77	+ /**
		78	+ * Array for converting MYSQLI_TYPE_* constants to text values
		79	+ * @var array
		80	+ * @access public
		81	+ * @since Property available since Release 1.6.5
		82	+ */
		83	+ var $mysqli_types = array(
		84	+ MYSQLI_TYPE_DECIMAL => 'decimal',
		85	+ MYSQLI_TYPE_TINY => 'tinyint',
		86	+ MYSQLI_TYPE_SHORT => 'int',
		87	+ MYSQLI_TYPE_LONG => 'int',
		88	+ MYSQLI_TYPE_FLOAT => 'float',
		89	+ MYSQLI_TYPE_DOUBLE => 'double',
		90	+ // MYSQLI_TYPE_NULL => 'DEFAULT NULL', // let flags handle it
		91	+ MYSQLI_TYPE_TIMESTAMP => 'timestamp',
		92	+ MYSQLI_TYPE_LONGLONG => 'bigint',
		93	+ MYSQLI_TYPE_INT24 => 'mediumint',
		94	+ MYSQLI_TYPE_DATE => 'date',
		95	+ MYSQLI_TYPE_TIME => 'time',
		96	+ MYSQLI_TYPE_DATETIME => 'datetime',
		97	+ MYSQLI_TYPE_YEAR => 'year',
		98	+ MYSQLI_TYPE_NEWDATE => 'date',
		99	+ MYSQLI_TYPE_ENUM => 'enum',
		100	+ MYSQLI_TYPE_SET => 'set',
		101	+ MYSQLI_TYPE_TINY_BLOB => 'tinyblob',
		102	+ MYSQLI_TYPE_MEDIUM_BLOB => 'mediumblob',
		103	+ MYSQLI_TYPE_LONG_BLOB => 'longblob',
		104	+ MYSQLI_TYPE_BLOB => 'blob',
		105	+ MYSQLI_TYPE_VAR_STRING => 'varchar',
		106	+ MYSQLI_TYPE_STRING => 'char',
		107	+ MYSQLI_TYPE_GEOMETRY => 'geometry',
		108	+ );
		109	+
		110	+ // }}}
		111	+ // {{{ constructor
		112	+
		113	+ /**
		114	+ * DB_mysql constructor.
		115	+ *
		116	+ * @access public
		117	+ */
		118	+ function DB_mysqli()
		119	+ {
		120	+ $this->DB_common();
		121	+ $this->phptype = 'mysqli';
		122	+ $this->dbsyntax = 'mysqli';
		123	+ $this->features = array(
		124	+ 'prepare' => false,
		125	+ 'ssl' => true,
		126	+ 'transactions' => true,
		127	+ 'limit' => 'alter'
		128	+ );
		129	+ $this->errorcode_map = array(
		130	+ 1004 => DB_ERROR_CANNOT_CREATE,
		131	+ 1005 => DB_ERROR_CANNOT_CREATE,
		132	+ 1006 => DB_ERROR_CANNOT_CREATE,
		133	+ 1007 => DB_ERROR_ALREADY_EXISTS,
		134	+ 1008 => DB_ERROR_CANNOT_DROP,
		135	+ 1022 => DB_ERROR_ALREADY_EXISTS,
		136	+ 1046 => DB_ERROR_NODBSELECTED,
		137	+ 1048 => DB_ERROR_CONSTRAINT,
		138	+ 1050 => DB_ERROR_ALREADY_EXISTS,
		139	+ 1051 => DB_ERROR_NOSUCHTABLE,
		140	+ 1054 => DB_ERROR_NOSUCHFIELD,
		141	+ 1062 => DB_ERROR_ALREADY_EXISTS,
		142	+ 1064 => DB_ERROR_SYNTAX,
		143	+ 1100 => DB_ERROR_NOT_LOCKED,
		144	+ 1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
		145	+ 1146 => DB_ERROR_NOSUCHTABLE,
		146	+ 1216 => DB_ERROR_CONSTRAINT,
		147	+ 1217 => DB_ERROR_CONSTRAINT,
		148	+ );
		149	+ }
		150	+
		151	+ // }}}
		152	+ // {{{ connect()
		153	+
		154	+ /**
		155	+ * Connect to a database and log in as the specified user.
		156	+ *
		157	+ * @param string $dsn the data source name (see DB::parseDSN for syntax)
		158	+ * @param boolean $persistent (optional) whether the connection should
		159	+ * be persistent
		160	+ * @return mixed DB_OK on success, a DB error on failure
		161	+ * @access public
		162	+ */
		163	+ function connect($dsninfo, $persistent = false)
		164	+ {
		165	+ if (!DB::assertExtension('mysqli')) {
		166	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		167	+ }
		168	+
		169	+ $this->dsn = $dsninfo;
		170	+ $conn = false;
		171	+ @ini_set('track_errors', true);
		172	+
		173	+ if ($this->getOption('ssl') === true) {
		174	+ $init = mysqli_init();
		175	+ mysqli_ssl_set(
		176	+ $init,
		177	+ empty($dsninfo['key']) ? null : $dsninfo['key'],
		178	+ empty($dsninfo['cert']) ? null : $dsninfo['cert'],
		179	+ empty($dsninfo['ca']) ? null : $dsninfo['ca'],
		180	+ empty($dsninfo['capath']) ? null : $dsninfo['capath'],
		181	+ empty($dsninfo['cipher']) ? null : $dsninfo['cipher']
		182	+ );
		183	+ if ($conn = @mysqli_real_connect($init,
		184	+ $dsninfo['hostspec'],
		185	+ $dsninfo['username'],
		186	+ $dsninfo['password'],
		187	+ $dsninfo['database'],
		188	+ $dsninfo['port'],
		189	+ $dsninfo['socket']))
		190	+ {
		191	+ $conn = $init;
		192	+ }
		193	+ } else {
		194	+ $conn = @mysqli_connect(
		195	+ $dsninfo['hostspec'],
		196	+ $dsninfo['username'],
		197	+ $dsninfo['password'],
		198	+ $dsninfo['database'],
		199	+ $dsninfo['port'],
		200	+ $dsninfo['socket']
		201	+ );
		202	+ }
		203	+
		204	+ @ini_restore('track_errors');
		205	+
		206	+ if (!$conn) {
		207	+ if (($err = @mysqli_connect_error()) != '') {
		208	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		209	+ null, $err);
		210	+ } elseif (empty($php_errormsg)) {
		211	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED);
		212	+ } else {
		213	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		214	+ null, $php_errormsg);
		215	+ }
		216	+ }
		217	+
		218	+ if ($dsninfo['database']) {
		219	+ $this->_db = $dsninfo['database'];
		220	+ }
		221	+
		222	+ $this->connection = $conn;
		223	+ return DB_OK;
		224	+ }
		225	+
		226	+ // }}}
		227	+ // {{{ disconnect()
		228	+
		229	+ /**
		230	+ * Log out and disconnect from the database.
		231	+ *
		232	+ * @return boolean true on success, false if not connected
		233	+ * @access public
		234	+ */
		235	+ function disconnect()
		236	+ {
		237	+ $ret = @mysqli_close($this->connection);
		238	+ $this->connection = null;
		239	+ return $ret;
		240	+ }
		241	+
		242	+ // }}}
		243	+ // {{{ simpleQuery()
		244	+
		245	+ /**
		246	+ * Send a query to MySQL and return the results as a MySQL resource
		247	+ * identifier.
		248	+ *
		249	+ * @param string $query the SQL query
		250	+ * @return mixed a valid MySQL result for successful SELECT
		251	+ * queries, DB_OK for other successful queries.
		252	+ * A DB error is returned on failure.
		253	+ * @access public
		254	+ */
		255	+ function simpleQuery($query)
		256	+ {
		257	+ $ismanip = DB::isManip($query);
		258	+ $this->last_query = $query;
		259	+ $query = $this->modifyQuery($query);
		260	+ if ($this->_db) {
		261	+ if (!@mysqli_select_db($this->connection, $this->_db)) {
		262	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		263	+ }
		264	+ }
		265	+ if (!$this->autocommit && $ismanip) {
		266	+ if ($this->transaction_opcount == 0) {
		267	+ $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=0');
		268	+ $result = @mysqli_query($this->connection, 'BEGIN');
		269	+ if (!$result) {
		270	+ return $this->mysqlRaiseError();
		271	+ }
		272	+ }
		273	+ $this->transaction_opcount++;
		274	+ }
		275	+ $result = @mysqli_query($this->connection, $query);
		276	+ if (!$result) {
		277	+ return $this->mysqlRaiseError();
		278	+ }
		279	+# this next block is still sketchy..
		280	+ if (is_object($result)) {
		281	+ $numrows = $this->numrows($result);
		282	+ if (is_object($numrows)) {
		283	+ return $numrows;
		284	+ }
		285	+# need to come up with different means for next line
		286	+# since $result is object (int)$result won't fly...
		287	+// $this->num_rows[(int)$result] = $numrows;
		288	+ return $result;
		289	+ }
		290	+ return DB_OK;
		291	+ }
		292	+
		293	+ // }}}
		294	+ // {{{ nextResult()
		295	+
		296	+ /**
		297	+ * Move the internal mysql result pointer to the next available result.
		298	+ *
		299	+ * This method has not been implemented yet.
		300	+ *
		301	+ * @param resource $result a valid sql result resource
		302	+ * @return false
		303	+ * @access public
		304	+ */
		305	+ function nextResult($result)
		306	+ {
		307	+ return false;
		308	+ }
		309	+
		310	+ // }}}
		311	+ // {{{ fetchInto()
		312	+
		313	+ /**
		314	+ * Fetch a row and insert the data into an existing array.
		315	+ *
		316	+ * Formating of the array and the data therein are configurable.
		317	+ * See DB_result::fetchInto() for more information.
		318	+ *
		319	+ * @param resource $result query result identifier
		320	+ * @param array $arr (reference) array where data from the row
		321	+ * should be placed
		322	+ * @param int $fetchmode how the resulting array should be indexed
		323	+ * @param int $rownum the row number to fetch
		324	+ *
		325	+ * @return mixed DB_OK on success, null when end of result set is
		326	+ * reached or on failure
		327	+ *
		328	+ * @see DB_result::fetchInto()
		329	+ * @access private
		330	+ */
		331	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		332	+ {
		333	+ if ($rownum !== null) {
		334	+ if (!@mysqli_data_seek($result, $rownum)) {
		335	+ return null;
		336	+ }
		337	+ }
		338	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		339	+ $arr = @mysqli_fetch_array($result, MYSQLI_ASSOC);
		340	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		341	+ $arr = array_change_key_case($arr, CASE_LOWER);
		342	+ }
		343	+ } else {
		344	+ $arr = @mysqli_fetch_row($result);
		345	+ }
		346	+ if (!$arr) {
		347	+ $errno = @mysqli_errno($this->connection);
		348	+ if (!$errno) {
		349	+ return null;
		350	+ }
		351	+ return $this->mysqlRaiseError($errno);
		352	+ }
		353	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		354	+ /*
		355	+ * Even though this DBMS already trims output, we do this because
		356	+ * a field might have intentional whitespace at the end that
		357	+ * gets removed by DB_PORTABILITY_RTRIM under another driver.
		358	+ */
		359	+ $this->_rtrimArrayValues($arr);
		360	+ }
		361	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		362	+ $this->_convertNullArrayValuesToEmpty($arr);
		363	+ }
		364	+ return DB_OK;
		365	+ }
		366	+
		367	+ // }}}
		368	+ // {{{ freeResult()
		369	+
		370	+ /**
		371	+ * Free the internal resources associated with $result.
		372	+ *
		373	+ * @param resource $result MySQL result identifier
		374	+ * @return bool true on success, false if $result is invalid
		375	+ * @access public
		376	+ */
		377	+ function freeResult($result)
		378	+ {
		379	+# need to come up with different means for next line
		380	+# since $result is object (int)$result won't fly...
		381	+// unset($this->num_rows[(int)$result]);
		382	+ return @mysqli_free_result($result);
		383	+ }
		384	+
		385	+ // }}}
		386	+ // {{{ numCols()
		387	+
		388	+ /**
		389	+ * Get the number of columns in a result set.
		390	+ *
		391	+ * @param $result MySQL result identifier
		392	+ *
		393	+ * @access public
		394	+ *
		395	+ * @return int the number of columns per row in $result
		396	+ */
		397	+ function numCols($result)
		398	+ {
		399	+ $cols = @mysqli_num_fields($result);
		400	+
		401	+ if (!$cols) {
		402	+ return $this->mysqlRaiseError();
		403	+ }
		404	+
		405	+ return $cols;
		406	+ }
		407	+
		408	+ // }}}
		409	+ // {{{ numRows()
		410	+
		411	+ /**
		412	+ * Get the number of rows in a result set.
		413	+ *
		414	+ * @param resource $result MySQL result identifier
		415	+ * @return int the number of rows in $result
		416	+ * @access public
		417	+ */
		418	+ function numRows($result)
		419	+ {
		420	+ $rows = @mysqli_num_rows($result);
		421	+ if ($rows === null) {
		422	+ return $this->mysqlRaiseError();
		423	+ }
		424	+ return $rows;
		425	+ }
		426	+
		427	+ // }}}
		428	+ // {{{ autoCommit()
		429	+
		430	+ /**
		431	+ * Enable/disable automatic commits.
		432	+ */
		433	+ function autoCommit($onoff = false)
		434	+ {
		435	+ // XXX if $this->transaction_opcount > 0, we should probably
		436	+ // issue a warning here.
		437	+ $this->autocommit = $onoff ? true : false;
		438	+ return DB_OK;
		439	+ }
		440	+
		441	+ // }}}
		442	+ // {{{ commit()
		443	+
		444	+ /**
		445	+ * Commit the current transaction.
		446	+ */
		447	+ function commit()
		448	+ {
		449	+ if ($this->transaction_opcount > 0) {
		450	+ if ($this->_db) {
		451	+ if (!@mysqli_select_db($this->connection, $this->_db)) {
		452	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		453	+ }
		454	+ }
		455	+ $result = @mysqli_query($this->connection, 'COMMIT');
		456	+ $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=1');
		457	+ $this->transaction_opcount = 0;
		458	+ if (!$result) {
		459	+ return $this->mysqlRaiseError();
		460	+ }
		461	+ }
		462	+ return DB_OK;
		463	+ }
		464	+
		465	+ // }}}
		466	+ // {{{ rollback()
		467	+
		468	+ /**
		469	+ * Roll back (undo) the current transaction.
		470	+ */
		471	+ function rollback()
		472	+ {
		473	+ if ($this->transaction_opcount > 0) {
		474	+ if ($this->_db) {
		475	+ if (!@mysqli_select_db($this->connection, $this->_db)) {
		476	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		477	+ }
		478	+ }
		479	+ $result = @mysqli_query($this->connection, 'ROLLBACK');
		480	+ $result = @mysqli_query($this->connection, 'SET AUTOCOMMIT=1');
		481	+ $this->transaction_opcount = 0;
		482	+ if (!$result) {
		483	+ return $this->mysqlRaiseError();
		484	+ }
		485	+ }
		486	+ return DB_OK;
		487	+ }
		488	+
		489	+ // }}}
		490	+ // {{{ affectedRows()
		491	+
		492	+ /**
		493	+ * Gets the number of rows affected by the data manipulation
		494	+ * query. For other queries, this function returns 0.
		495	+ *
		496	+ * @return integer number of rows affected by the last query
		497	+ */
		498	+ function affectedRows()
		499	+ {
		500	+ if (DB::isManip($this->last_query)) {
		501	+ return @mysqli_affected_rows($this->connection);
		502	+ } else {
		503	+ return 0;
		504	+ }
		505	+ }
		506	+
		507	+ // }}}
		508	+ // {{{ errorNative()
		509	+
		510	+ /**
		511	+ * Get the native error code of the last error (if any) that
		512	+ * occured on the current connection.
		513	+ *
		514	+ * @return int native MySQL error code
		515	+ * @access public
		516	+ */
		517	+ function errorNative()
		518	+ {
		519	+ return @mysqli_errno($this->connection);
		520	+ }
		521	+
		522	+ // }}}
		523	+ // {{{ nextId()
		524	+
		525	+ /**
		526	+ * Returns the next free id in a sequence
		527	+ *
		528	+ * @param string $seq_name name of the sequence
		529	+ * @param boolean $ondemand when true, the seqence is automatically
		530	+ * created if it does not exist
		531	+ *
		532	+ * @return int the next id number in the sequence. DB_Error if problem.
		533	+ *
		534	+ * @internal
		535	+ * @see DB_common::nextID()
		536	+ * @access public
		537	+ */
		538	+ function nextId($seq_name, $ondemand = true)
		539	+ {
		540	+ $seqname = $this->getSequenceName($seq_name);
		541	+ do {
		542	+ $repeat = 0;
		543	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		544	+ $result = $this->query("UPDATE ${seqname} ".
		545	+ 'SET id=LAST_INSERT_ID(id+1)');
		546	+ $this->popErrorHandling();
		547	+ if ($result === DB_OK) {
		548	+ / COMMON CASE /
		549	+ $id = @mysqli_insert_id($this->connection);
		550	+ if ($id != 0) {
		551	+ return $id;
		552	+ }
		553	+ / EMPTY SEQ TABLE /
		554	+ // Sequence table must be empty for some reason, so fill it and return 1
		555	+ // Obtain a user-level lock
		556	+ $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
		557	+ if (DB::isError($result)) {
		558	+ return $this->raiseError($result);
		559	+ }
		560	+ if ($result == 0) {
		561	+ // Failed to get the lock, bail with a DB_ERROR_NOT_LOCKED error
		562	+ return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
		563	+ }
		564	+
		565	+ // add the default value
		566	+ $result = $this->query("REPLACE INTO ${seqname} (id) VALUES (0)");
		567	+ if (DB::isError($result)) {
		568	+ return $this->raiseError($result);
		569	+ }
		570	+
		571	+ // Release the lock
		572	+ $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
		573	+ if (DB::isError($result)) {
		574	+ return $this->raiseError($result);
		575	+ }
		576	+ // We know what the result will be, so no need to try again
		577	+ return 1;
		578	+
		579	+ / ONDEMAND TABLE CREATION /
		580	+ } elseif ($ondemand && DB::isError($result) &&
		581	+ $result->getCode() == DB_ERROR_NOSUCHTABLE)
		582	+ {
		583	+ $result = $this->createSequence($seq_name);
		584	+ // Since createSequence initializes the ID to be 1,
		585	+ // we do not need to retrieve the ID again (or we will get 2)
		586	+ if (DB::isError($result)) {
		587	+ return $this->raiseError($result);
		588	+ } else {
		589	+ // First ID of a newly created sequence is 1
		590	+ return 1;
		591	+ }
		592	+
		593	+ / BACKWARDS COMPAT /
		594	+ } elseif (DB::isError($result) &&
		595	+ $result->getCode() == DB_ERROR_ALREADY_EXISTS)
		596	+ {
		597	+ // see _BCsequence() comment
		598	+ $result = $this->_BCsequence($seqname);
		599	+ if (DB::isError($result)) {
		600	+ return $this->raiseError($result);
		601	+ }
		602	+ $repeat = 1;
		603	+ }
		604	+ } while ($repeat);
		605	+
		606	+ return $this->raiseError($result);
		607	+ }
		608	+
		609	+ /**
		610	+ * Creates a new sequence
		611	+ *
		612	+ * @param string $seq_name name of the new sequence
		613	+ *
		614	+ * @return int DB_OK on success. A DB_Error object is returned if
		615	+ * problems arise.
		616	+ *
		617	+ * @internal
		618	+ * @see DB_common::createSequence()
		619	+ * @access public
		620	+ */
		621	+ function createSequence($seq_name)
		622	+ {
		623	+ $seqname = $this->getSequenceName($seq_name);
		624	+ $res = $this->query("CREATE TABLE ${seqname} ".
		625	+ '(id INTEGER UNSIGNED AUTO_INCREMENT NOT NULL,'.
		626	+ ' PRIMARY KEY(id))');
		627	+ if (DB::isError($res)) {
		628	+ return $res;
		629	+ }
		630	+ // insert yields value 1, nextId call will generate ID 2
		631	+ return $this->query("INSERT INTO ${seqname} (id) VALUES (0)");
		632	+ }
		633	+
		634	+ // }}}
		635	+ // {{{ dropSequence()
		636	+
		637	+ /**
		638	+ * Deletes a sequence
		639	+ *
		640	+ * @param string $seq_name name of the sequence to be deleted
		641	+ *
		642	+ * @return int DB_OK on success. DB_Error if problems.
		643	+ *
		644	+ * @internal
		645	+ * @see DB_common::dropSequence()
		646	+ * @access public
		647	+ */
		648	+ function dropSequence($seq_name)
		649	+ {
		650	+ return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
		651	+ }
		652	+
		653	+ // }}}
		654	+ // {{{ _BCsequence()
		655	+
		656	+ /**
		657	+ * Backwards compatibility with old sequence emulation implementation
		658	+ * (clean up the dupes).
		659	+ *
		660	+ * @param string $seqname The sequence name to clean up
		661	+ * @return mixed DB_Error or true
		662	+ */
		663	+ function _BCsequence($seqname)
		664	+ {
		665	+ // Obtain a user-level lock... this will release any previous
		666	+ // application locks, but unlike LOCK TABLES, it does not abort
		667	+ // the current transaction and is much less frequently used.
		668	+ $result = $this->getOne("SELECT GET_LOCK('${seqname}_lock',10)");
		669	+ if (DB::isError($result)) {
		670	+ return $result;
		671	+ }
		672	+ if ($result == 0) {
		673	+ // Failed to get the lock, can't do the conversion, bail
		674	+ // with a DB_ERROR_NOT_LOCKED error
		675	+ return $this->mysqlRaiseError(DB_ERROR_NOT_LOCKED);
		676	+ }
		677	+
		678	+ $highest_id = $this->getOne("SELECT MAX(id) FROM ${seqname}");
		679	+ if (DB::isError($highest_id)) {
		680	+ return $highest_id;
		681	+ }
		682	+ // This should kill all rows except the highest
		683	+ // We should probably do something if $highest_id isn't
		684	+ // numeric, but I'm at a loss as how to handle that...
		685	+ $result = $this->query("DELETE FROM ${seqname} WHERE id <> $highest_id");
		686	+ if (DB::isError($result)) {
		687	+ return $result;
		688	+ }
		689	+
		690	+ // If another thread has been waiting for this lock,
		691	+ // it will go thru the above procedure, but will have no
		692	+ // real effect
		693	+ $result = $this->getOne("SELECT RELEASE_LOCK('${seqname}_lock')");
		694	+ if (DB::isError($result)) {
		695	+ return $result;
		696	+ }
		697	+ return true;
		698	+ }
		699	+
		700	+ // }}}
		701	+ // {{{ quoteIdentifier()
		702	+
		703	+ /**
		704	+ * Quote a string so it can be safely used as a table or column name
		705	+ *
		706	+ * Quoting style depends on which database driver is being used.
		707	+ *
		708	+ * MySQL can't handle the backtick character (<kbd>`</kbd>) in
		709	+ * table or column names.
		710	+ *
		711	+ * @param string $str identifier name to be quoted
		712	+ *
		713	+ * @return string quoted identifier string
		714	+ *
		715	+ * @since 1.6.0
		716	+ * @access public
		717	+ * @internal
		718	+ */
		719	+ function quoteIdentifier($str)
		720	+ {
		721	+ return '`' . $str . '`';
		722	+ }
		723	+
		724	+ // }}}
		725	+ // {{{ escapeSimple()
		726	+
		727	+ /**
		728	+ * Escape a string according to the current DBMS's standards
		729	+ *
		730	+ * @param string $str the string to be escaped
		731	+ *
		732	+ * @return string the escaped string
		733	+ *
		734	+ * @internal
		735	+ */
		736	+ function escapeSimple($str) {
		737	+ return @mysqli_real_escape_string($this->connection, $str);
		738	+ }
		739	+
		740	+ // }}}
		741	+ // {{{ modifyQuery()
		742	+
		743	+ function modifyQuery($query)
		744	+ {
		745	+ return $query;
		746	+ }
		747	+
		748	+ // }}}
		749	+ // {{{ modifyLimitQuery()
		750	+
		751	+ function modifyLimitQuery($query, $from, $count, $params = array())
		752	+ {
		753	+ if (DB::isManip($query)) {
		754	+ return $query . " LIMIT $count";
		755	+ } else {
		756	+ return $query . " LIMIT $from, $count";
		757	+ }
		758	+ }
		759	+
		760	+ // }}}
		761	+ // {{{ mysqlRaiseError()
		762	+
		763	+ /**
		764	+ * Gather information about an error, then use that info to create a
		765	+ * DB error object and finally return that object.
		766	+ *
		767	+ * @param integer $errno PEAR error number (usually a DB constant) if
		768	+ * manually raising an error
		769	+ * @return object DB error object
		770	+ * @see DB_common::errorCode()
		771	+ * @see DB_common::raiseError()
		772	+ */
		773	+ function mysqlRaiseError($errno = null)
		774	+ {
		775	+ if ($errno === null) {
		776	+ if ($this->options['portability'] & DB_PORTABILITY_ERRORS) {
		777	+ $this->errorcode_map[1022] = DB_ERROR_CONSTRAINT;
		778	+ $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT_NOT_NULL;
		779	+ $this->errorcode_map[1062] = DB_ERROR_CONSTRAINT;
		780	+ } else {
		781	+ // Doing this in case mode changes during runtime.
		782	+ $this->errorcode_map[1022] = DB_ERROR_ALREADY_EXISTS;
		783	+ $this->errorcode_map[1048] = DB_ERROR_CONSTRAINT;
		784	+ $this->errorcode_map[1062] = DB_ERROR_ALREADY_EXISTS;
		785	+ }
		786	+ $errno = $this->errorCode(mysqli_errno($this->connection));
		787	+ }
		788	+ return $this->raiseError($errno, null, null, null,
		789	+ @mysqli_errno($this->connection) . ' ** ' .
		790	+ @mysqli_error($this->connection));
		791	+ }
		792	+
		793	+ // }}}
		794	+ // {{{ tableInfo()
		795	+
		796	+ /**
		797	+ * Returns information about a table or a result set.
		798	+ *
		799	+ * WARNING: this method will probably not work because the mysqli_*()
		800	+ * functions it relies upon may not exist.
		801	+ *
		802	+ * @param object\|string $result DB_result object from a query or a
		803	+ * string containing the name of a table
		804	+ * @param int $mode a valid tableInfo mode
		805	+ * @return array an associative array with the information requested
		806	+ * or an error object if something is wrong
		807	+ * @access public
		808	+ * @internal
		809	+ * @see DB_common::tableInfo()
		810	+ */
		811	+ function tableInfo($result, $mode = null) {
		812	+ if (isset($result->result)) {
		813	+ /*
		814	+ * Probably received a result object.
		815	+ * Extract the result resource identifier.
		816	+ */
		817	+ $id = $result->result;
		818	+ $got_string = false;
		819	+ } elseif (is_string($result)) {
		820	+ /*
		821	+ * Probably received a table name.
		822	+ * Create a result resource identifier.
		823	+ */
		824	+ $id = @mysqli_query($this->connection,
		825	+ "SELECT * FROM $result LIMIT 0");
		826	+ $got_string = true;
		827	+ } else {
		828	+ /*
		829	+ * Probably received a result resource identifier.
		830	+ * Copy it.
		831	+ * Deprecated. Here for compatibility only.
		832	+ */
		833	+ $id = $result;
		834	+ $got_string = false;
		835	+ }
		836	+
		837	+ if (!is_a($id, 'mysqli_result')) {
		838	+ return $this->mysqlRaiseError(DB_ERROR_NEED_MORE_DATA);
		839	+ }
		840	+
		841	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		842	+ $case_func = 'strtolower';
		843	+ } else {
		844	+ $case_func = 'strval';
		845	+ }
		846	+
		847	+ $count = @mysqli_num_fields($id);
		848	+
		849	+ // made this IF due to performance (one if is faster than $count if's)
		850	+ if (!$mode) {
		851	+ for ($i=0; $i<$count; $i++) {
		852	+ $tmp = @mysqli_fetch_field($id);
		853	+ $res[$i]['table'] = $case_func($tmp->table);
		854	+ $res[$i]['name'] = $case_func($tmp->name);
		855	+ $res[$i]['type'] = isset($this->mysqli_types[$tmp->type]) ?
		856	+ $this->mysqli_types[$tmp->type] :
		857	+ 'unknown';
		858	+ $res[$i]['len'] = $tmp->max_length;
		859	+
		860	+ $res[$i]['flags'] = '';
		861	+ foreach ($this->mysqli_flags as $const => $means) {
		862	+ if ($tmp->flags & $const) {
		863	+ $res[$i]['flags'] .= $means . ' ';
		864	+ }
		865	+ }
		866	+ if ($tmp->def) {
		867	+ $res[$i]['flags'] .= 'default_' . rawurlencode($tmp->def);
		868	+ }
		869	+ $res[$i]['flags'] = trim($res[$i]['flags']);
		870	+ }
		871	+ } else { // full
		872	+ $res['num_fields']= $count;
		873	+
		874	+ for ($i=0; $i<$count; $i++) {
		875	+ $tmp = @mysqli_fetch_field($id);
		876	+ $res[$i]['table'] = $case_func($tmp->table);
		877	+ $res[$i]['name'] = $case_func($tmp->name);
		878	+ $res[$i]['type'] = isset($this->mysqli_types[$tmp->type]) ?
		879	+ $this->mysqli_types[$tmp->type] :
		880	+ 'unknown';
		881	+ $res[$i]['len'] = $tmp->max_length;
		882	+
		883	+ $res[$i]['flags'] = '';
		884	+ foreach ($this->mysqli_flags as $const => $means) {
		885	+ if ($tmp->flags & $const) {
		886	+ $res[$i]['flags'] .= $means . ' ';
		887	+ }
		888	+ }
		889	+ if ($tmp->def) {
		890	+ $res[$i]['flags'] .= 'default_' . rawurlencode($tmp->def);
		891	+ }
		892	+ $res[$i]['flags'] = trim($res[$i]['flags']);
		893	+
		894	+ if ($mode & DB_TABLEINFO_ORDER) {
		895	+ $res['order'][$res[$i]['name']] = $i;
		896	+ }
		897	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		898	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		899	+ }
		900	+ }
		901	+ }
		902	+
		903	+ // free the result only if we were called on a table
		904	+ if ($got_string) {
		905	+ @mysqli_free_result($id);
		906	+ }
		907	+ return $res;
		908	+ }
		909	+
		910	+ // }}}
		911	+ // {{{ getSpecialQuery()
		912	+
		913	+ /**
		914	+ * Returns the query needed to get some backend info.
		915	+ *
		916	+ * @param string $type What kind of info you want to retrieve
		917	+ * @return string The SQL query string
		918	+ */
		919	+ function getSpecialQuery($type)
		920	+ {
		921	+ switch ($type) {
		922	+ case 'tables':
		923	+ return 'SHOW TABLES';
		924	+ case 'views':
		925	+ return DB_ERROR_NOT_CAPABLE;
		926	+ case 'users':
		927	+ $sql = 'select distinct User from user';
		928	+ if ($this->dsn['database'] != 'mysql') {
		929	+ $dsn = $this->dsn;
		930	+ $dsn['database'] = 'mysql';
		931	+ if (DB::isError($db = DB::connect($dsn))) {
		932	+ return $db;
		933	+ }
		934	+ $sql = $db->getCol($sql);
		935	+ $db->disconnect();
		936	+ // XXX Fixme the mysql driver should take care of this
		937	+ if (!@mysqli_select_db($this->connection, $this->dsn['database'])) {
		938	+ return $this->mysqlRaiseError(DB_ERROR_NODBSELECTED);
		939	+ }
		940	+ }
		941	+ return $sql;
		942	+ case 'databases':
		943	+ return 'SHOW DATABASES';
		944	+ default:
		945	+ return null;
		946	+ }
		947	+ }
		948	+
		949	+ // }}}
		950	+
		951	+}
		952	+
		953	+/*
		954	+ * Local variables:
		955	+ * tab-width: 4
		956	+ * c-basic-offset: 4
		957	+ * End:
		958	+ */
		959	+
		960	+?>

pear/DB/oci8.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: James L. Pine <jlp@valinux.com> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// be aware... OCIError() only appears to return anything when given a
		24	+// statement, so functions return the generic DB_ERROR instead of more
		25	+// useful errors that have to do with feedback from the database.
		26	+
		27	+
		28	+require_once 'DB/common.php';
		29	+
		30	+/**
		31	+ * Database independent query interface definition for PHP's Oracle 8
		32	+ * call-interface extension.
		33	+ *
		34	+ * Definitely works with versions 8 and 9 of Oracle.
		35	+ *
		36	+ * @package DB
		37	+ * @version $Id$
		38	+ * @category Database
		39	+ * @author James L. Pine <jlp@valinux.com>
		40	+ */
		41	+class DB_oci8 extends DB_common
		42	+{
		43	+ // {{{ properties
		44	+
		45	+ var $connection;
		46	+ var $phptype, $dbsyntax;
		47	+ var $manip_query = array();
		48	+ var $prepare_types = array();
		49	+ var $autoCommit = 1;
		50	+ var $last_stmt = false;
		51	+
		52	+ /**
		53	+ * stores the $data passed to execute() in the oci8 driver
		54	+ *
		55	+ * Gets reset to array() when simpleQuery() is run.
		56	+ *
		57	+ * Needed in case user wants to call numRows() after prepare/execute
		58	+ * was used.
		59	+ *
		60	+ * @var array
		61	+ * @access private
		62	+ */
		63	+ var $_data = array();
		64	+
		65	+ // }}}
		66	+ // {{{ constructor
		67	+
		68	+ function DB_oci8()
		69	+ {
		70	+ $this->DB_common();
		71	+ $this->phptype = 'oci8';
		72	+ $this->dbsyntax = 'oci8';
		73	+ $this->features = array(
		74	+ 'prepare' => false,
		75	+ 'pconnect' => true,
		76	+ 'transactions' => true,
		77	+ 'limit' => 'alter'
		78	+ );
		79	+ $this->errorcode_map = array(
		80	+ 1 => DB_ERROR_CONSTRAINT,
		81	+ 900 => DB_ERROR_SYNTAX,
		82	+ 904 => DB_ERROR_NOSUCHFIELD,
		83	+ 921 => DB_ERROR_SYNTAX,
		84	+ 923 => DB_ERROR_SYNTAX,
		85	+ 942 => DB_ERROR_NOSUCHTABLE,
		86	+ 955 => DB_ERROR_ALREADY_EXISTS,
		87	+ 1400 => DB_ERROR_CONSTRAINT_NOT_NULL,
		88	+ 1407 => DB_ERROR_CONSTRAINT_NOT_NULL,
		89	+ 1476 => DB_ERROR_DIVZERO,
		90	+ 1722 => DB_ERROR_INVALID_NUMBER,
		91	+ 2289 => DB_ERROR_NOSUCHTABLE,
		92	+ 2291 => DB_ERROR_CONSTRAINT,
		93	+ 2292 => DB_ERROR_CONSTRAINT,
		94	+ 2449 => DB_ERROR_CONSTRAINT,
		95	+ );
		96	+ }
		97	+
		98	+ // }}}
		99	+ // {{{ connect()
		100	+
		101	+ /**
		102	+ * Connect to a database and log in as the specified user.
		103	+ *
		104	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		105	+ * @param $persistent (optional) whether the connection should
		106	+ * be persistent
		107	+ *
		108	+ * @return int DB_OK on success, a DB error code on failure
		109	+ */
		110	+ function connect($dsninfo, $persistent = false)
		111	+ {
		112	+ if (!DB::assertExtension('oci8')) {
		113	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		114	+ }
		115	+ $this->dsn = $dsninfo;
		116	+
		117	+ $connect_function = $persistent ? 'OCIPLogon' : 'OCILogon';
		118	+
		119	+ if ($dsninfo['hostspec']) {
		120	+ $conn = @$connect_function($dsninfo['username'],
		121	+ $dsninfo['password'],
		122	+ $dsninfo['hostspec']);
		123	+ } elseif ($dsninfo['username'] \|\| $dsninfo['password']) {
		124	+ $conn = @$connect_function($dsninfo['username'],
		125	+ $dsninfo['password']);
		126	+ } else {
		127	+ $conn = false;
		128	+ }
		129	+ if ($conn == false) {
		130	+ $error = OCIError();
		131	+ $error = (is_array($error)) ? $error['message'] : null;
		132	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		133	+ null, $error);
		134	+ }
		135	+ $this->connection = $conn;
		136	+ return DB_OK;
		137	+ }
		138	+
		139	+ // }}}
		140	+ // {{{ disconnect()
		141	+
		142	+ /**
		143	+ * Log out and disconnect from the database.
		144	+ *
		145	+ * @return bool true on success, false if not connected.
		146	+ */
		147	+ function disconnect()
		148	+ {
		149	+ $ret = @OCILogOff($this->connection);
		150	+ $this->connection = null;
		151	+ return $ret;
		152	+ }
		153	+
		154	+ // }}}
		155	+ // {{{ simpleQuery()
		156	+
		157	+ /**
		158	+ * Send a query to oracle and return the results as an oci8 resource
		159	+ * identifier.
		160	+ *
		161	+ * @param $query the SQL query
		162	+ *
		163	+ * @return int returns a valid oci8 result for successful SELECT
		164	+ * queries, DB_OK for other successful queries. A DB error code
		165	+ * is returned on failure.
		166	+ */
		167	+ function simpleQuery($query)
		168	+ {
		169	+ $this->_data = array();
		170	+ $this->last_query = $query;
		171	+ $query = $this->modifyQuery($query);
		172	+ $result = @OCIParse($this->connection, $query);
		173	+ if (!$result) {
		174	+ return $this->oci8RaiseError();
		175	+ }
		176	+ if ($this->autoCommit) {
		177	+ $success = @OCIExecute($result,OCI_COMMIT_ON_SUCCESS);
		178	+ } else {
		179	+ $success = @OCIExecute($result,OCI_DEFAULT);
		180	+ }
		181	+ if (!$success) {
		182	+ return $this->oci8RaiseError($result);
		183	+ }
		184	+ $this->last_stmt=$result;
		185	+ // Determine which queries that should return data, and which
		186	+ // should return an error code only.
		187	+ return DB::isManip($query) ? DB_OK : $result;
		188	+ }
		189	+
		190	+ // }}}
		191	+ // {{{ nextResult()
		192	+
		193	+ /**
		194	+ * Move the internal oracle result pointer to the next available result
		195	+ *
		196	+ * @param a valid oci8 result resource
		197	+ *
		198	+ * @access public
		199	+ *
		200	+ * @return true if a result is available otherwise return false
		201	+ */
		202	+ function nextResult($result)
		203	+ {
		204	+ return false;
		205	+ }
		206	+
		207	+ // }}}
		208	+ // {{{ fetchInto()
		209	+
		210	+ /**
		211	+ * Fetch a row and insert the data into an existing array.
		212	+ *
		213	+ * Formating of the array and the data therein are configurable.
		214	+ * See DB_result::fetchInto() for more information.
		215	+ *
		216	+ * @param resource $result query result identifier
		217	+ * @param array $arr (reference) array where data from the row
		218	+ * should be placed
		219	+ * @param int $fetchmode how the resulting array should be indexed
		220	+ * @param int $rownum the row number to fetch
		221	+ *
		222	+ * @return mixed DB_OK on success, null when end of result set is
		223	+ * reached or on failure
		224	+ *
		225	+ * @see DB_result::fetchInto()
		226	+ * @access private
		227	+ */
		228	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		229	+ {
		230	+ if ($rownum !== null) {
		231	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		232	+ }
		233	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		234	+ $moredata = @OCIFetchInto($result,$arr,OCI_ASSOC+OCI_RETURN_NULLS+OCI_RETURN_LOBS);
		235	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE &&
		236	+ $moredata)
		237	+ {
		238	+ $arr = array_change_key_case($arr, CASE_LOWER);
		239	+ }
		240	+ } else {
		241	+ $moredata = OCIFetchInto($result,$arr,OCI_RETURN_NULLS+OCI_RETURN_LOBS);
		242	+ }
		243	+ if (!$moredata) {
		244	+ return null;
		245	+ }
		246	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		247	+ $this->_rtrimArrayValues($arr);
		248	+ }
		249	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		250	+ $this->_convertNullArrayValuesToEmpty($arr);
		251	+ }
		252	+ return DB_OK;
		253	+ }
		254	+
		255	+ // }}}
		256	+ // {{{ freeResult()
		257	+
		258	+ /**
		259	+ * Free the internal resources associated with $result.
		260	+ *
		261	+ * @param $result oci8 result identifier
		262	+ *
		263	+ * @return bool true on success, false if $result is invalid
		264	+ */
		265	+ function freeResult($result)
		266	+ {
		267	+ return @OCIFreeStatement($result);
		268	+ }
		269	+
		270	+ /**
		271	+ * Free the internal resources associated with a prepared query.
		272	+ *
		273	+ * @param $stmt oci8 statement identifier
		274	+ *
		275	+ * @return bool true on success, false if $result is invalid
		276	+ */
		277	+ function freePrepared($stmt)
		278	+ {
		279	+ if (isset($this->prepare_types[(int)$stmt])) {
		280	+ unset($this->prepare_types[(int)$stmt]);
		281	+ unset($this->manip_query[(int)$stmt]);
		282	+ } else {
		283	+ return false;
		284	+ }
		285	+ return true;
		286	+ }
		287	+
		288	+ // }}}
		289	+ // {{{ numRows()
		290	+
		291	+ function numRows($result)
		292	+ {
		293	+ // emulate numRows for Oracle. yuck.
		294	+ if ($this->options['portability'] & DB_PORTABILITY_NUMROWS &&
		295	+ $result === $this->last_stmt)
		296	+ {
		297	+ $countquery = 'SELECT COUNT(*) FROM ('.$this->last_query.')';
		298	+ $save_query = $this->last_query;
		299	+ $save_stmt = $this->last_stmt;
		300	+
		301	+ if (count($this->_data)) {
		302	+ $smt = $this->prepare('SELECT COUNT(*) FROM ('.$this->last_query.')');
		303	+ $count = $this->execute($smt, $this->_data);
		304	+ } else {
		305	+ $count =& $this->query($countquery);
		306	+ }
		307	+
		308	+ if (DB::isError($count) \|\|
		309	+ DB::isError($row = $count->fetchRow(DB_FETCHMODE_ORDERED)))
		310	+ {
		311	+ $this->last_query = $save_query;
		312	+ $this->last_stmt = $save_stmt;
		313	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		314	+ }
		315	+ return $row[0];
		316	+ }
		317	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		318	+ }
		319	+
		320	+ // }}}
		321	+ // {{{ numCols()
		322	+
		323	+ /**
		324	+ * Get the number of columns in a result set.
		325	+ *
		326	+ * @param $result oci8 result identifier
		327	+ *
		328	+ * @return int the number of columns per row in $result
		329	+ */
		330	+ function numCols($result)
		331	+ {
		332	+ $cols = @OCINumCols($result);
		333	+ if (!$cols) {
		334	+ return $this->oci8RaiseError($result);
		335	+ }
		336	+ return $cols;
		337	+ }
		338	+
		339	+ // }}}
		340	+ // {{{ errorNative()
		341	+
		342	+ /**
		343	+ * Get the native error code of the last error (if any) that occured
		344	+ * on the current connection. This does not work, as OCIError does
		345	+ * not work unless given a statement. If OCIError does return
		346	+ * something, so will this.
		347	+ *
		348	+ * @return int native oci8 error code
		349	+ */
		350	+ function errorNative()
		351	+ {
		352	+ if (is_resource($this->last_stmt)) {
		353	+ $error = @OCIError($this->last_stmt);
		354	+ } else {
		355	+ $error = @OCIError($this->connection);
		356	+ }
		357	+ if (is_array($error)) {
		358	+ return $error['code'];
		359	+ }
		360	+ return false;
		361	+ }
		362	+
		363	+ // }}}
		364	+ // {{{ prepare()
		365	+
		366	+ /**
		367	+ * Prepares a query for multiple execution with execute().
		368	+ *
		369	+ * With oci8, this is emulated.
		370	+ *
		371	+ * prepare() requires a generic query as string like <code>
		372	+ * INSERT INTO numbers VALUES (?, ?, ?)
		373	+ * </code>. The <kbd>?</kbd> characters are placeholders.
		374	+ *
		375	+ * Three types of placeholders can be used:
		376	+ * + <kbd>?</kbd> a quoted scalar value, i.e. strings, integers
		377	+ * + <kbd>!</kbd> value is inserted 'as is'
		378	+ * + <kbd>&</kbd> requires a file name. The file's contents get
		379	+ * inserted into the query (i.e. saving binary
		380	+ * data in a db)
		381	+ *
		382	+ * Use backslashes to escape placeholder characters if you don't want
		383	+ * them to be interpreted as placeholders. Example: <code>
		384	+ * "UPDATE foo SET col=? WHERE col='over \& under'"
		385	+ * </code>
		386	+ *
		387	+ * @param string $query query to be prepared
		388	+ * @return mixed DB statement resource on success. DB_Error on failure.
		389	+ */
		390	+ function prepare($query)
		391	+ {
		392	+ $tokens = preg_split('/((?<!\\\)[&?!])/', $query, -1,
		393	+ PREG_SPLIT_DELIM_CAPTURE);
		394	+ $binds = count($tokens) - 1;
		395	+ $token = 0;
		396	+ $types = array();
		397	+ $newquery = '';
		398	+
		399	+ foreach ($tokens as $key => $val) {
		400	+ switch ($val) {
		401	+ case '?':
		402	+ $types[$token++] = DB_PARAM_SCALAR;
		403	+ unset($tokens[$key]);
		404	+ break;
		405	+ case '&':
		406	+ $types[$token++] = DB_PARAM_OPAQUE;
		407	+ unset($tokens[$key]);
		408	+ break;
		409	+ case '!':
		410	+ $types[$token++] = DB_PARAM_MISC;
		411	+ unset($tokens[$key]);
		412	+ break;
		413	+ default:
		414	+ $tokens[$key] = preg_replace('/\\\([&?!])/', "\\1", $val);
		415	+ if ($key != $binds) {
		416	+ $newquery .= $tokens[$key] . ':bind' . $token;
		417	+ } else {
		418	+ $newquery .= $tokens[$key];
		419	+ }
		420	+ }
		421	+ }
		422	+
		423	+ $this->last_query = $query;
		424	+ $newquery = $this->modifyQuery($newquery);
		425	+ if (!$stmt = @OCIParse($this->connection, $newquery)) {
		426	+ return $this->oci8RaiseError();
		427	+ }
		428	+ $this->prepare_types[(int)$stmt] = $types;
		429	+ $this->manip_query[(int)$stmt] = DB::isManip($query);
		430	+ return $stmt;
		431	+ }
		432	+
		433	+ // }}}
		434	+ // {{{ execute()
		435	+
		436	+ /**
		437	+ * Executes a DB statement prepared with prepare().
		438	+ *
		439	+ * @param resource $stmt a DB statement resource returned from prepare()
		440	+ * @param mixed $data array, string or numeric data to be used in
		441	+ * execution of the statement. Quantity of items
		442	+ * passed must match quantity of placeholders in
		443	+ * query: meaning 1 for non-array items or the
		444	+ * quantity of elements in the array.
		445	+ * @return int returns an oci8 result resource for successful
		446	+ * SELECT queries, DB_OK for other successful queries. A DB error
		447	+ * code is returned on failure.
		448	+ * @see DB_oci::prepare()
		449	+ */
		450	+ function &execute($stmt, $data = array())
		451	+ {
		452	+ if (!is_array($data)) {
		453	+ $data = array($data);
		454	+ }
		455	+
		456	+ $this->_data = $data;
		457	+
		458	+ $types =& $this->prepare_types[(int)$stmt];
		459	+ if (count($types) != count($data)) {
		460	+ $tmp =& $this->raiseError(DB_ERROR_MISMATCH);
		461	+ return $tmp;
		462	+ }
		463	+
		464	+ $i = 0;
		465	+ foreach ($data as $key => $value) {
		466	+ if ($types[$i] == DB_PARAM_MISC) {
		467	+ /*
		468	+ * Oracle doesn't seem to have the ability to pass a
		469	+ * parameter along unchanged, so strip off quotes from start
		470	+ * and end, plus turn two single quotes to one single quote,
		471	+ * in order to avoid the quotes getting escaped by
		472	+ * Oracle and ending up in the database.
		473	+ */
		474	+ $data[$key] = preg_replace("/^'(.*)'$/", "\\1", $data[$key]);
		475	+ $data[$key] = str_replace("''", "'", $data[$key]);
		476	+ } elseif ($types[$i] == DB_PARAM_OPAQUE) {
		477	+ $fp = @fopen($data[$key], 'rb');
		478	+ if (!$fp) {
		479	+ $tmp =& $this->raiseError(DB_ERROR_ACCESS_VIOLATION);
		480	+ return $tmp;
		481	+ }
		482	+ $data[$key] = fread($fp, filesize($data[$key]));
		483	+ fclose($fp);
		484	+ }
		485	+ if (!@OCIBindByName($stmt, ':bind' . $i, $data[$key], -1)) {
		486	+ $tmp = $this->oci8RaiseError($stmt);
		487	+ return $tmp;
		488	+ }
		489	+ $i++;
		490	+ }
		491	+ if ($this->autoCommit) {
		492	+ $success = @OCIExecute($stmt, OCI_COMMIT_ON_SUCCESS);
		493	+ } else {
		494	+ $success = @OCIExecute($stmt, OCI_DEFAULT);
		495	+ }
		496	+ if (!$success) {
		497	+ $tmp = $this->oci8RaiseError($stmt);
		498	+ return $tmp;
		499	+ }
		500	+ $this->last_stmt = $stmt;
		501	+ if ($this->manip_query[(int)$stmt]) {
		502	+ $tmp = DB_OK;
		503	+ } else {
		504	+ $tmp =& new DB_result($this, $stmt);
		505	+ }
		506	+ return $tmp;
		507	+ }
		508	+
		509	+ // }}}
		510	+ // {{{ autoCommit()
		511	+
		512	+ /**
		513	+ * Enable/disable automatic commits
		514	+ *
		515	+ * @param $onoff true/false whether to autocommit
		516	+ */
		517	+ function autoCommit($onoff = false)
		518	+ {
		519	+ $this->autoCommit = (bool)$onoff;;
		520	+ return DB_OK;
		521	+ }
		522	+
		523	+ // }}}
		524	+ // {{{ commit()
		525	+
		526	+ /**
		527	+ * Commit transactions on the current connection
		528	+ *
		529	+ * @return DB_ERROR or DB_OK
		530	+ */
		531	+ function commit()
		532	+ {
		533	+ $result = @OCICommit($this->connection);
		534	+ if (!$result) {
		535	+ return $this->oci8RaiseError();
		536	+ }
		537	+ return DB_OK;
		538	+ }
		539	+
		540	+ // }}}
		541	+ // {{{ rollback()
		542	+
		543	+ /**
		544	+ * Roll back all uncommitted transactions on the current connection.
		545	+ *
		546	+ * @return DB_ERROR or DB_OK
		547	+ */
		548	+ function rollback()
		549	+ {
		550	+ $result = @OCIRollback($this->connection);
		551	+ if (!$result) {
		552	+ return $this->oci8RaiseError();
		553	+ }
		554	+ return DB_OK;
		555	+ }
		556	+
		557	+ // }}}
		558	+ // {{{ affectedRows()
		559	+
		560	+ /**
		561	+ * Gets the number of rows affected by the last query.
		562	+ * if the last query was a select, returns 0.
		563	+ *
		564	+ * @return number of rows affected by the last query or DB_ERROR
		565	+ */
		566	+ function affectedRows()
		567	+ {
		568	+ if ($this->last_stmt === false) {
		569	+ return $this->oci8RaiseError();
		570	+ }
		571	+ $result = @OCIRowCount($this->last_stmt);
		572	+ if ($result === false) {
		573	+ return $this->oci8RaiseError($this->last_stmt);
		574	+ }
		575	+ return $result;
		576	+ }
		577	+
		578	+ // }}}
		579	+ // {{{ modifyQuery()
		580	+
		581	+ function modifyQuery($query)
		582	+ {
		583	+ // "SELECT 2+2" must be "SELECT 2+2 FROM dual" in Oracle
		584	+ if (preg_match('/^\s*SELECT/i', $query) &&
		585	+ !preg_match('/\sFROM\s/i', $query)) {
		586	+ $query .= ' FROM dual';
		587	+ }
		588	+ return $query;
		589	+ }
		590	+
		591	+ // }}}
		592	+ // {{{ modifyLimitQuery()
		593	+
		594	+ /**
		595	+ * Emulate the row limit support altering the query
		596	+ *
		597	+ * @param string $query The query to treat
		598	+ * @param int $from The row to start to fetch from
		599	+ * @param int $count The offset
		600	+ * @return string The modified query
		601	+ *
		602	+ * @author Tomas V.V.Cox <cox@idecnet.com>
		603	+ */
		604	+ function modifyLimitQuery($query, $from, $count, $params = array())
		605	+ {
		606	+ // Let Oracle return the name of the columns instead of
		607	+ // coding a "home" SQL parser
		608	+
		609	+ if (count($params)) {
		610	+ $result = $this->prepare("SELECT * FROM ($query) "
		611	+ . 'WHERE NULL = NULL');
		612	+ $tmp =& $this->execute($result, $params);
		613	+ } else {
		614	+ $q_fields = "SELECT * FROM ($query) WHERE NULL = NULL";
		615	+
		616	+ if (!$result = @OCIParse($this->connection, $q_fields)) {
		617	+ $this->last_query = $q_fields;
		618	+ return $this->oci8RaiseError();
		619	+ }
		620	+ if (!@OCIExecute($result, OCI_DEFAULT)) {
		621	+ $this->last_query = $q_fields;
		622	+ return $this->oci8RaiseError($result);
		623	+ }
		624	+ }
		625	+
		626	+ $ncols = OCINumCols($result);
		627	+ $cols = array();
		628	+ for ( $i = 1; $i <= $ncols; $i++ ) {
		629	+ $cols[] = '"' . OCIColumnName($result, $i) . '"';
		630	+ }
		631	+ $fields = implode(', ', $cols);
		632	+ // XXX Test that (tip by John Lim)
		633	+ //if (preg_match('/^\s*SELECT\s+/is', $query, $match)) {
		634	+ // // Introduce the FIRST_ROWS Oracle query optimizer
		635	+ // $query = substr($query, strlen($match[0]), strlen($query));
		636	+ // $query = "SELECT /* +FIRST_ROWS */ " . $query;
		637	+ //}
		638	+
		639	+ // Construct the query
		640	+ // more at: http://marc.theaimsgroup.com/?l=php-db&m=99831958101212&w=2
		641	+ // Perhaps this could be optimized with the use of Unions
		642	+ $query = "SELECT $fields FROM".
		643	+ " (SELECT rownum as linenum, $fields FROM".
		644	+ " ($query)".
		645	+ ' WHERE rownum <= '. ($from + $count) .
		646	+ ') WHERE linenum >= ' . ++$from;
		647	+ return $query;
		648	+ }
		649	+
		650	+ // }}}
		651	+ // {{{ nextId()
		652	+
		653	+ /**
		654	+ * Returns the next free id in a sequence
		655	+ *
		656	+ * @param string $seq_name name of the sequence
		657	+ * @param boolean $ondemand when true, the seqence is automatically
		658	+ * created if it does not exist
		659	+ *
		660	+ * @return int the next id number in the sequence. DB_Error if problem.
		661	+ *
		662	+ * @internal
		663	+ * @see DB_common::nextID()
		664	+ * @access public
		665	+ */
		666	+ function nextId($seq_name, $ondemand = true)
		667	+ {
		668	+ $seqname = $this->getSequenceName($seq_name);
		669	+ $repeat = 0;
		670	+ do {
		671	+ $this->expectError(DB_ERROR_NOSUCHTABLE);
		672	+ $result =& $this->query("SELECT ${seqname}.nextval FROM dual");
		673	+ $this->popExpect();
		674	+ if ($ondemand && DB::isError($result) &&
		675	+ $result->getCode() == DB_ERROR_NOSUCHTABLE) {
		676	+ $repeat = 1;
		677	+ $result = $this->createSequence($seq_name);
		678	+ if (DB::isError($result)) {
		679	+ return $this->raiseError($result);
		680	+ }
		681	+ } else {
		682	+ $repeat = 0;
		683	+ }
		684	+ } while ($repeat);
		685	+ if (DB::isError($result)) {
		686	+ return $this->raiseError($result);
		687	+ }
		688	+ $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
		689	+ return $arr[0];
		690	+ }
		691	+
		692	+ /**
		693	+ * Creates a new sequence
		694	+ *
		695	+ * @param string $seq_name name of the new sequence
		696	+ *
		697	+ * @return int DB_OK on success. A DB_Error object is returned if
		698	+ * problems arise.
		699	+ *
		700	+ * @internal
		701	+ * @see DB_common::createSequence()
		702	+ * @access public
		703	+ */
		704	+ function createSequence($seq_name)
		705	+ {
		706	+ $seqname = $this->getSequenceName($seq_name);
		707	+ return $this->query("CREATE SEQUENCE ${seqname}");
		708	+ }
		709	+
		710	+ // }}}
		711	+ // {{{ dropSequence()
		712	+
		713	+ /**
		714	+ * Deletes a sequence
		715	+ *
		716	+ * @param string $seq_name name of the sequence to be deleted
		717	+ *
		718	+ * @return int DB_OK on success. DB_Error if problems.
		719	+ *
		720	+ * @internal
		721	+ * @see DB_common::dropSequence()
		722	+ * @access public
		723	+ */
		724	+ function dropSequence($seq_name)
		725	+ {
		726	+ $seqname = $this->getSequenceName($seq_name);
		727	+ return $this->query("DROP SEQUENCE ${seqname}");
		728	+ }
		729	+
		730	+ // }}}
		731	+ // {{{ oci8RaiseError()
		732	+
		733	+ /**
		734	+ * Gather information about an error, then use that info to create a
		735	+ * DB error object and finally return that object.
		736	+ *
		737	+ * @param integer $errno PEAR error number (usually a DB constant) if
		738	+ * manually raising an error
		739	+ * @return object DB error object
		740	+ * @see DB_common::errorCode()
		741	+ * @see DB_common::raiseError()
		742	+ */
		743	+ function oci8RaiseError($errno = null)
		744	+ {
		745	+ if ($errno === null) {
		746	+ $error = @OCIError($this->connection);
		747	+ return $this->raiseError($this->errorCode($error['code']),
		748	+ null, null, null, $error['message']);
		749	+ } elseif (is_resource($errno)) {
		750	+ $error = @OCIError($errno);
		751	+ return $this->raiseError($this->errorCode($error['code']),
		752	+ null, null, null, $error['message']);
		753	+ }
		754	+ return $this->raiseError($this->errorCode($errno));
		755	+ }
		756	+
		757	+ // }}}
		758	+ // {{{ getSpecialQuery()
		759	+
		760	+ /**
		761	+ * Returns the query needed to get some backend info
		762	+ * @param string $type What kind of info you want to retrieve
		763	+ * @return string The SQL query string
		764	+ */
		765	+ function getSpecialQuery($type)
		766	+ {
		767	+ switch ($type) {
		768	+ case 'tables':
		769	+ return 'SELECT table_name FROM user_tables';
		770	+ default:
		771	+ return null;
		772	+ }
		773	+ }
		774	+
		775	+ // }}}
		776	+ // {{{ tableInfo()
		777	+
		778	+ /**
		779	+ * Returns information about a table or a result set.
		780	+ *
		781	+ * NOTE: only supports 'table' and 'flags' if <var>$result</var>
		782	+ * is a table name.
		783	+ *
		784	+ * NOTE: flags won't contain index information.
		785	+ *
		786	+ * @param object\|string $result DB_result object from a query or a
		787	+ * string containing the name of a table
		788	+ * @param int $mode a valid tableInfo mode
		789	+ * @return array an associative array with the information requested
		790	+ * or an error object if something is wrong
		791	+ * @access public
		792	+ * @internal
		793	+ * @see DB_common::tableInfo()
		794	+ */
		795	+ function tableInfo($result, $mode = null)
		796	+ {
		797	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		798	+ $case_func = 'strtolower';
		799	+ } else {
		800	+ $case_func = 'strval';
		801	+ }
		802	+
		803	+ if (is_string($result)) {
		804	+ /*
		805	+ * Probably received a table name.
		806	+ * Create a result resource identifier.
		807	+ */
		808	+ $result = strtoupper($result);
		809	+ $q_fields = 'SELECT column_name, data_type, data_length, '
		810	+ . 'nullable '
		811	+ . 'FROM user_tab_columns '
		812	+ . "WHERE table_name='$result' ORDER BY column_id";
		813	+
		814	+ $this->last_query = $q_fields;
		815	+
		816	+ if (!$stmt = @OCIParse($this->connection, $q_fields)) {
		817	+ return $this->oci8RaiseError(DB_ERROR_NEED_MORE_DATA);
		818	+ }
		819	+ if (!@OCIExecute($stmt, OCI_DEFAULT)) {
		820	+ return $this->oci8RaiseError($stmt);
		821	+ }
		822	+
		823	+ $i = 0;
		824	+ while (@OCIFetch($stmt)) {
		825	+ $res[$i]['table'] = $case_func($result);
		826	+ $res[$i]['name'] = $case_func(@OCIResult($stmt, 1));
		827	+ $res[$i]['type'] = @OCIResult($stmt, 2);
		828	+ $res[$i]['len'] = @OCIResult($stmt, 3);
		829	+ $res[$i]['flags'] = (@OCIResult($stmt, 4) == 'N') ? 'not_null' : '';
		830	+
		831	+ if ($mode & DB_TABLEINFO_ORDER) {
		832	+ $res['order'][$res[$i]['name']] = $i;
		833	+ }
		834	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		835	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		836	+ }
		837	+ $i++;
		838	+ }
		839	+
		840	+ if ($mode) {
		841	+ $res['num_fields'] = $i;
		842	+ }
		843	+ @OCIFreeStatement($stmt);
		844	+
		845	+ } else {
		846	+ if (isset($result->result)) {
		847	+ /*
		848	+ * Probably received a result object.
		849	+ * Extract the result resource identifier.
		850	+ */
		851	+ $result = $result->result;
		852	+ } else {
		853	+ /*
		854	+ * ELSE, probably received a result resource identifier.
		855	+ * Deprecated. Here for compatibility only.
		856	+ */
		857	+ }
		858	+
		859	+ if ($result === $this->last_stmt) {
		860	+ $count = @OCINumCols($result);
		861	+
		862	+ for ($i=0; $i<$count; $i++) {
		863	+ $res[$i]['table'] = '';
		864	+ $res[$i]['name'] = $case_func(@OCIColumnName($result, $i+1));
		865	+ $res[$i]['type'] = @OCIColumnType($result, $i+1);
		866	+ $res[$i]['len'] = @OCIColumnSize($result, $i+1);
		867	+ $res[$i]['flags'] = '';
		868	+
		869	+ if ($mode & DB_TABLEINFO_ORDER) {
		870	+ $res['order'][$res[$i]['name']] = $i;
		871	+ }
		872	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		873	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		874	+ }
		875	+ }
		876	+
		877	+ if ($mode) {
		878	+ $res['num_fields'] = $count;
		879	+ }
		880	+
		881	+ } else {
		882	+ return $this->raiseError(DB_ERROR_NOT_CAPABLE);
		883	+ }
		884	+ }
		885	+ return $res;
		886	+ }
		887	+
		888	+ // }}}
		889	+
		890	+}
		891	+
		892	+/*
		893	+ * Local variables:
		894	+ * tab-width: 4
		895	+ * c-basic-offset: 4
		896	+ * End:
		897	+ */
		898	+
		899	+?>

pear/DB/odbc.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Stig Bakken <ssb@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+
		23	+// XXX legend:
		24	+// More info on ODBC errors could be found here:
		25	+// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/trblsql/tr_err_odbc_5stz.asp
		26	+//
		27	+// XXX ERRORMSG: The error message from the odbc function should
		28	+// be registered here.
		29	+
		30	+
		31	+require_once 'DB/common.php';
		32	+
		33	+/**
		34	+ * Database independent query interface definition for PHP's ODBC
		35	+ * extension.
		36	+ *
		37	+ * @package DB
		38	+ * @version $Id$
		39	+ * @category Database
		40	+ * @author Stig Bakken <ssb@php.net>
		41	+ */
		42	+class DB_odbc extends DB_common
		43	+{
		44	+ // {{{ properties
		45	+
		46	+ var $connection;
		47	+ var $phptype, $dbsyntax;
		48	+ var $row = array();
		49	+
		50	+ // }}}
		51	+ // {{{ constructor
		52	+
		53	+ function DB_odbc()
		54	+ {
		55	+ $this->DB_common();
		56	+ $this->phptype = 'odbc';
		57	+ $this->dbsyntax = 'sql92';
		58	+ $this->features = array(
		59	+ 'prepare' => true,
		60	+ 'pconnect' => true,
		61	+ 'transactions' => false,
		62	+ 'limit' => 'emulate'
		63	+ );
		64	+ $this->errorcode_map = array(
		65	+ '01004' => DB_ERROR_TRUNCATED,
		66	+ '07001' => DB_ERROR_MISMATCH,
		67	+ '21S01' => DB_ERROR_MISMATCH,
		68	+ '21S02' => DB_ERROR_MISMATCH,
		69	+ '22003' => DB_ERROR_INVALID_NUMBER,
		70	+ '22005' => DB_ERROR_INVALID_NUMBER,
		71	+ '22008' => DB_ERROR_INVALID_DATE,
		72	+ '22012' => DB_ERROR_DIVZERO,
		73	+ '23000' => DB_ERROR_CONSTRAINT,
		74	+ '23502' => DB_ERROR_CONSTRAINT_NOT_NULL,
		75	+ '23503' => DB_ERROR_CONSTRAINT,
		76	+ '23505' => DB_ERROR_CONSTRAINT,
		77	+ '24000' => DB_ERROR_INVALID,
		78	+ '34000' => DB_ERROR_INVALID,
		79	+ '37000' => DB_ERROR_SYNTAX,
		80	+ '42000' => DB_ERROR_SYNTAX,
		81	+ '42601' => DB_ERROR_SYNTAX,
		82	+ 'IM001' => DB_ERROR_UNSUPPORTED,
		83	+ 'S0000' => DB_ERROR_NOSUCHTABLE,
		84	+ 'S0001' => DB_ERROR_ALREADY_EXISTS,
		85	+ 'S0002' => DB_ERROR_NOSUCHTABLE,
		86	+ 'S0011' => DB_ERROR_ALREADY_EXISTS,
		87	+ 'S0012' => DB_ERROR_NOT_FOUND,
		88	+ 'S0021' => DB_ERROR_ALREADY_EXISTS,
		89	+ 'S0022' => DB_ERROR_NOSUCHFIELD,
		90	+ 'S1000' => DB_ERROR_CONSTRAINT_NOT_NULL,
		91	+ 'S1009' => DB_ERROR_INVALID,
		92	+ 'S1090' => DB_ERROR_INVALID,
		93	+ 'S1C00' => DB_ERROR_NOT_CAPABLE
		94	+ );
		95	+ }
		96	+
		97	+ // }}}
		98	+ // {{{ connect()
		99	+
		100	+ /**
		101	+ * Connect to a database and log in as the specified user.
		102	+ *
		103	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		104	+ * @param $persistent (optional) whether the connection should
		105	+ * be persistent
		106	+ *
		107	+ * @return int DB_OK on success, a DB error code on failure
		108	+ */
		109	+ function connect($dsninfo, $persistent = false)
		110	+ {
		111	+ if (!DB::assertExtension('odbc')) {
		112	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		113	+ }
		114	+
		115	+ $this->dsn = $dsninfo;
		116	+ if ($dsninfo['dbsyntax']) {
		117	+ $this->dbsyntax = $dsninfo['dbsyntax'];
		118	+ }
		119	+ switch ($this->dbsyntax) {
		120	+ case 'solid':
		121	+ $this->features = array(
		122	+ 'prepare' => true,
		123	+ 'pconnect' => true,
		124	+ 'transactions' => true
		125	+ );
		126	+ break;
		127	+ case 'navision':
		128	+ // the Navision driver doesn't support fetch row by number
		129	+ $this->features['limit'] = false;
		130	+ }
		131	+
		132	+ /*
		133	+ * This is hear for backwards compatibility.
		134	+ * Should have been using 'database' all along, but used hostspec.
		135	+ */
		136	+ if ($dsninfo['database']) {
		137	+ $odbcdsn = $dsninfo['database'];
		138	+ } elseif ($dsninfo['hostspec']) {
		139	+ $odbcdsn = $dsninfo['hostspec'];
		140	+ } else {
		141	+ $odbcdsn = 'localhost';
		142	+ }
		143	+
		144	+ if ($this->provides('pconnect')) {
		145	+ $connect_function = $persistent ? 'odbc_pconnect' : 'odbc_connect';
		146	+ } else {
		147	+ $connect_function = 'odbc_connect';
		148	+ }
		149	+
		150	+ if (empty($dsninfo['cursor'])) {
		151	+ $conn = @$connect_function($odbcdsn, $dsninfo['username'],
		152	+ $dsninfo['password']);
		153	+ } else {
		154	+ $conn = @$connect_function($odbcdsn, $dsninfo['username'],
		155	+ $dsninfo['password'],
		156	+ $dsninfo['cursor']);
		157	+ }
		158	+
		159	+ if (!is_resource($conn)) {
		160	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null, null,
		161	+ null, $this->errorNative());
		162	+ }
		163	+ $this->connection = $conn;
		164	+ return DB_OK;
		165	+ }
		166	+
		167	+ // }}}
		168	+ // {{{ disconnect()
		169	+
		170	+ function disconnect()
		171	+ {
		172	+ $err = @odbc_close($this->connection);
		173	+ $this->connection = null;
		174	+ return $err;
		175	+ }
		176	+
		177	+ // }}}
		178	+ // {{{ simpleQuery()
		179	+
		180	+ /**
		181	+ * Send a query to ODBC and return the results as a ODBC resource
		182	+ * identifier.
		183	+ *
		184	+ * @param $query the SQL query
		185	+ *
		186	+ * @return int returns a valid ODBC result for successful SELECT
		187	+ * queries, DB_OK for other successful queries. A DB error code
		188	+ * is returned on failure.
		189	+ */
		190	+ function simpleQuery($query)
		191	+ {
		192	+ $this->last_query = $query;
		193	+ $query = $this->modifyQuery($query);
		194	+ $result = @odbc_exec($this->connection, $query);
		195	+ if (!$result) {
		196	+ return $this->odbcRaiseError(); // XXX ERRORMSG
		197	+ }
		198	+ // Determine which queries that should return data, and which
		199	+ // should return an error code only.
		200	+ if (DB::isManip($query)) {
		201	+ $this->manip_result = $result; // For affectedRows()
		202	+ return DB_OK;
		203	+ }
		204	+ $this->row[(int)$result] = 0;
		205	+ $this->manip_result = 0;
		206	+ return $result;
		207	+ }
		208	+
		209	+ // }}}
		210	+ // {{{ nextResult()
		211	+
		212	+ /**
		213	+ * Move the internal odbc result pointer to the next available result
		214	+ *
		215	+ * @param a valid fbsql result resource
		216	+ *
		217	+ * @access public
		218	+ *
		219	+ * @return true if a result is available otherwise return false
		220	+ */
		221	+ function nextResult($result)
		222	+ {
		223	+ return @odbc_next_result($result);
		224	+ }
		225	+
		226	+ // }}}
		227	+ // {{{ fetchInto()
		228	+
		229	+ /**
		230	+ * Fetch a row and insert the data into an existing array.
		231	+ *
		232	+ * Formating of the array and the data therein are configurable.
		233	+ * See DB_result::fetchInto() for more information.
		234	+ *
		235	+ * @param resource $result query result identifier
		236	+ * @param array $arr (reference) array where data from the row
		237	+ * should be placed
		238	+ * @param int $fetchmode how the resulting array should be indexed
		239	+ * @param int $rownum the row number to fetch
		240	+ *
		241	+ * @return mixed DB_OK on success, null when end of result set is
		242	+ * reached or on failure
		243	+ *
		244	+ * @see DB_result::fetchInto()
		245	+ * @access private
		246	+ */
		247	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		248	+ {
		249	+ $arr = array();
		250	+ if ($rownum !== null) {
		251	+ $rownum++; // ODBC first row is 1
		252	+ if (version_compare(phpversion(), '4.2.0', 'ge')) {
		253	+ $cols = @odbc_fetch_into($result, $arr, $rownum);
		254	+ } else {
		255	+ $cols = @odbc_fetch_into($result, $rownum, $arr);
		256	+ }
		257	+ } else {
		258	+ $cols = @odbc_fetch_into($result, $arr);
		259	+ }
		260	+
		261	+ if (!$cols) {
		262	+ /* XXX FIXME: doesn't work with unixODBC and easysoft
		263	+ (get corrupted $errno values)
		264	+ if ($errno = @odbc_error($this->connection)) {
		265	+ return $this->RaiseError($errno);
		266	+ }*/
		267	+ return null;
		268	+ }
		269	+ if ($fetchmode !== DB_FETCHMODE_ORDERED) {
		270	+ for ($i = 0; $i < count($arr); $i++) {
		271	+ $colName = @odbc_field_name($result, $i+1);
		272	+ $a[$colName] = $arr[$i];
		273	+ }
		274	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		275	+ $a = array_change_key_case($a, CASE_LOWER);
		276	+ }
		277	+ $arr = $a;
		278	+ }
		279	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		280	+ $this->_rtrimArrayValues($arr);
		281	+ }
		282	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		283	+ $this->_convertNullArrayValuesToEmpty($arr);
		284	+ }
		285	+ return DB_OK;
		286	+ }
		287	+
		288	+ // }}}
		289	+ // {{{ freeResult()
		290	+
		291	+ function freeResult($result)
		292	+ {
		293	+ unset($this->row[(int)$result]);
		294	+ return @odbc_free_result($result);
		295	+ }
		296	+
		297	+ // }}}
		298	+ // {{{ numCols()
		299	+
		300	+ function numCols($result)
		301	+ {
		302	+ $cols = @odbc_num_fields($result);
		303	+ if (!$cols) {
		304	+ return $this->odbcRaiseError();
		305	+ }
		306	+ return $cols;
		307	+ }
		308	+
		309	+ // }}}
		310	+ // {{{ affectedRows()
		311	+
		312	+ /**
		313	+ * Returns the number of rows affected by a manipulative query
		314	+ * (INSERT, DELETE, UPDATE)
		315	+ * @return mixed int affected rows, 0 when non manip queries or
		316	+ * DB error on error
		317	+ */
		318	+ function affectedRows()
		319	+ {
		320	+ if (empty($this->manip_result)) { // In case of SELECT stms
		321	+ return 0;
		322	+ }
		323	+ $nrows = @odbc_num_rows($this->manip_result);
		324	+ if ($nrows == -1) {
		325	+ return $this->odbcRaiseError();
		326	+ }
		327	+ return $nrows;
		328	+ }
		329	+
		330	+ // }}}
		331	+ // {{{ numRows()
		332	+
		333	+ /**
		334	+ * ODBC may or may not support counting rows in the result set of
		335	+ * SELECTs.
		336	+ *
		337	+ * @param $result the odbc result resource
		338	+ * @return the number of rows, or 0
		339	+ */
		340	+ function numRows($result)
		341	+ {
		342	+ $nrows = @odbc_num_rows($result);
		343	+ if ($nrows == -1) {
		344	+ return $this->odbcRaiseError(DB_ERROR_UNSUPPORTED);
		345	+ }
		346	+ return $nrows;
		347	+ }
		348	+
		349	+ // }}}
		350	+ // {{{ quoteIdentifier()
		351	+
		352	+ /**
		353	+ * Quote a string so it can be safely used as a table / column name
		354	+ *
		355	+ * Quoting style depends on which dbsyntax was passed in the DSN.
		356	+ *
		357	+ * Use 'mssql' as the dbsyntax in the DB DSN only if you've unchecked
		358	+ * "Use ANSI quoted identifiers" when setting up the ODBC data source.
		359	+ *
		360	+ * @param string $str identifier name to be quoted
		361	+ *
		362	+ * @return string quoted identifier string
		363	+ *
		364	+ * @since 1.6.0
		365	+ * @access public
		366	+ */
		367	+ function quoteIdentifier($str)
		368	+ {
		369	+ switch ($this->dsn['dbsyntax']) {
		370	+ case 'access':
		371	+ return '[' . $str . ']';
		372	+ case 'mssql':
		373	+ case 'sybase':
		374	+ return '[' . str_replace(']', ']]', $str) . ']';
		375	+ case 'mysql':
		376	+ case 'mysqli':
		377	+ return '`' . $str . '`';
		378	+ default:
		379	+ return '"' . str_replace('"', '""', $str) . '"';
		380	+ }
		381	+ }
		382	+
		383	+ // }}}
		384	+ // {{{ quote()
		385	+
		386	+ /**
		387	+ * @deprecated Deprecated in release 1.6.0
		388	+ * @internal
		389	+ */
		390	+ function quote($str) {
		391	+ return $this->quoteSmart($str);
		392	+ }
		393	+
		394	+ // }}}
		395	+ // {{{ errorNative()
		396	+
		397	+ /**
		398	+ * Get the native error code of the last error (if any) that
		399	+ * occured on the current connection.
		400	+ *
		401	+ * @access public
		402	+ *
		403	+ * @return int ODBC error code
		404	+ */
		405	+ function errorNative()
		406	+ {
		407	+ if (!isset($this->connection) \|\| !is_resource($this->connection)) {
		408	+ return @odbc_error() . ' ' . @odbc_errormsg();
		409	+ }
		410	+ return @odbc_error($this->connection) . ' ' . @odbc_errormsg($this->connection);
		411	+ }
		412	+
		413	+ // }}}
		414	+ // {{{ nextId()
		415	+
		416	+ /**
		417	+ * Returns the next free id in a sequence
		418	+ *
		419	+ * @param string $seq_name name of the sequence
		420	+ * @param boolean $ondemand when true, the seqence is automatically
		421	+ * created if it does not exist
		422	+ *
		423	+ * @return int the next id number in the sequence. DB_Error if problem.
		424	+ *
		425	+ * @internal
		426	+ * @see DB_common::nextID()
		427	+ * @access public
		428	+ */
		429	+ function nextId($seq_name, $ondemand = true)
		430	+ {
		431	+ $seqname = $this->getSequenceName($seq_name);
		432	+ $repeat = 0;
		433	+ do {
		434	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		435	+ $result = $this->query("update ${seqname} set id = id + 1");
		436	+ $this->popErrorHandling();
		437	+ if ($ondemand && DB::isError($result) &&
		438	+ $result->getCode() == DB_ERROR_NOSUCHTABLE) {
		439	+ $repeat = 1;
		440	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		441	+ $result = $this->createSequence($seq_name);
		442	+ $this->popErrorHandling();
		443	+ if (DB::isError($result)) {
		444	+ return $this->raiseError($result);
		445	+ }
		446	+ $result = $this->query("insert into ${seqname} (id) values(0)");
		447	+ } else {
		448	+ $repeat = 0;
		449	+ }
		450	+ } while ($repeat);
		451	+
		452	+ if (DB::isError($result)) {
		453	+ return $this->raiseError($result);
		454	+ }
		455	+
		456	+ $result = $this->query("select id from ${seqname}");
		457	+ if (DB::isError($result)) {
		458	+ return $result;
		459	+ }
		460	+
		461	+ $row = $result->fetchRow(DB_FETCHMODE_ORDERED);
		462	+ if (DB::isError($row \|\| !$row)) {
		463	+ return $row;
		464	+ }
		465	+
		466	+ return $row[0];
		467	+ }
		468	+
		469	+ /**
		470	+ * Creates a new sequence
		471	+ *
		472	+ * @param string $seq_name name of the new sequence
		473	+ *
		474	+ * @return int DB_OK on success. A DB_Error object is returned if
		475	+ * problems arise.
		476	+ *
		477	+ * @internal
		478	+ * @see DB_common::createSequence()
		479	+ * @access public
		480	+ */
		481	+ function createSequence($seq_name)
		482	+ {
		483	+ $seqname = $this->getSequenceName($seq_name);
		484	+ return $this->query("CREATE TABLE ${seqname} ".
		485	+ '(id integer NOT NULL,'.
		486	+ ' PRIMARY KEY(id))');
		487	+ }
		488	+
		489	+ // }}}
		490	+ // {{{ dropSequence()
		491	+
		492	+ /**
		493	+ * Deletes a sequence
		494	+ *
		495	+ * @param string $seq_name name of the sequence to be deleted
		496	+ *
		497	+ * @return int DB_OK on success. DB_Error if problems.
		498	+ *
		499	+ * @internal
		500	+ * @see DB_common::dropSequence()
		501	+ * @access public
		502	+ */
		503	+ function dropSequence($seq_name)
		504	+ {
		505	+ $seqname = $this->getSequenceName($seq_name);
		506	+ return $this->query("DROP TABLE ${seqname}");
		507	+ }
		508	+
		509	+ // }}}
		510	+ // {{{ autoCommit()
		511	+
		512	+ function autoCommit($onoff = false)
		513	+ {
		514	+ if (!@odbc_autocommit($this->connection, $onoff)) {
		515	+ return $this->odbcRaiseError();
		516	+ }
		517	+ return DB_OK;
		518	+ }
		519	+
		520	+ // }}}
		521	+ // {{{ commit()
		522	+
		523	+ function commit()
		524	+ {
		525	+ if (!@odbc_commit($this->connection)) {
		526	+ return $this->odbcRaiseError();
		527	+ }
		528	+ return DB_OK;
		529	+ }
		530	+
		531	+ // }}}
		532	+ // {{{ rollback()
		533	+
		534	+ function rollback()
		535	+ {
		536	+ if (!@odbc_rollback($this->connection)) {
		537	+ return $this->odbcRaiseError();
		538	+ }
		539	+ return DB_OK;
		540	+ }
		541	+
		542	+ // }}}
		543	+ // {{{ odbcRaiseError()
		544	+
		545	+ /**
		546	+ * Gather information about an error, then use that info to create a
		547	+ * DB error object and finally return that object.
		548	+ *
		549	+ * @param integer $errno PEAR error number (usually a DB constant) if
		550	+ * manually raising an error
		551	+ * @return object DB error object
		552	+ * @see errorNative()
		553	+ * @see DB_common::errorCode()
		554	+ * @see DB_common::raiseError()
		555	+ */
		556	+ function odbcRaiseError($errno = null)
		557	+ {
		558	+ if ($errno === null) {
		559	+ switch ($this->dbsyntax) {
		560	+ case 'access':
		561	+ if ($this->options['portability'] & DB_PORTABILITY_ERRORS) {
		562	+ $this->errorcode_map['07001'] = DB_ERROR_NOSUCHFIELD;
		563	+ } else {
		564	+ // Doing this in case mode changes during runtime.
		565	+ $this->errorcode_map['07001'] = DB_ERROR_MISMATCH;
		566	+ }
		567	+ }
		568	+ $errno = $this->errorCode(odbc_error($this->connection));
		569	+ }
		570	+ return $this->raiseError($errno, null, null, null,
		571	+ $this->errorNative());
		572	+ }
		573	+
		574	+ // }}}
		575	+
		576	+}
		577	+
		578	+/*
		579	+ * Local variables:
		580	+ * tab-width: 4
		581	+ * c-basic-offset: 4
		582	+ * End:
		583	+ */
		584	+
		585	+?>

pear/DB/pgsql.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Authors: Rui Hirokawa <hirokawa@php.net> \|
		17	+// \| Stig Bakken <ssb@php.net> \|
		18	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		19	+// +----------------------------------------------------------------------+
		20	+//
		21	+// $Id$
		22	+
		23	+require_once 'DB/common.php';
		24	+
		25	+/**
		26	+ * Database independent query interface definition for PHP's PostgreSQL
		27	+ * extension.
		28	+ *
		29	+ * @package DB
		30	+ * @version $Id$
		31	+ * @category Database
		32	+ * @author Rui Hirokawa <hirokawa@php.net>
		33	+ * @author Stig Bakken <ssb@php.net>
		34	+ */
		35	+class DB_pgsql extends DB_common
		36	+{
		37	+ // {{{ properties
		38	+
		39	+ var $connection;
		40	+ var $phptype, $dbsyntax;
		41	+ var $prepare_tokens = array();
		42	+ var $prepare_types = array();
		43	+ var $transaction_opcount = 0;
		44	+ var $dsn = array();
		45	+ var $row = array();
		46	+ var $num_rows = array();
		47	+ var $affected = 0;
		48	+ var $autocommit = true;
		49	+ var $fetchmode = DB_FETCHMODE_ORDERED;
		50	+
		51	+ // }}}
		52	+ // {{{ constructor
		53	+
		54	+ function DB_pgsql()
		55	+ {
		56	+ $this->DB_common();
		57	+ $this->phptype = 'pgsql';
		58	+ $this->dbsyntax = 'pgsql';
		59	+ $this->features = array(
		60	+ 'prepare' => false,
		61	+ 'pconnect' => true,
		62	+ 'transactions' => true,
		63	+ 'limit' => 'alter'
		64	+ );
		65	+ $this->errorcode_map = array(
		66	+ );
		67	+ }
		68	+
		69	+ // }}}
		70	+ // {{{ connect()
		71	+
		72	+ /**
		73	+ * Connect to a database and log in as the specified user.
		74	+ *
		75	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		76	+ * @param $persistent (optional) whether the connection should
		77	+ * be persistent
		78	+ *
		79	+ * @return int DB_OK on success, a DB error code on failure.
		80	+ */
		81	+ function connect($dsninfo, $persistent = false)
		82	+ {
		83	+ if (!DB::assertExtension('pgsql')) {
		84	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		85	+ }
		86	+
		87	+ $this->dsn = $dsninfo;
		88	+ $protocol = $dsninfo['protocol'] ? $dsninfo['protocol'] : 'tcp';
		89	+ $connstr = '';
		90	+
		91	+ if ($protocol == 'tcp') {
		92	+ if ($dsninfo['hostspec']) {
		93	+ $connstr .= 'host=' . $dsninfo['hostspec'];
		94	+ }
		95	+ if ($dsninfo['port']) {
		96	+ $connstr .= ' port=' . $dsninfo['port'];
		97	+ }
		98	+ } elseif ($protocol == 'unix') {
		99	+ // Allow for pg socket in non-standard locations.
		100	+ if ($dsninfo['socket']) {
		101	+ $connstr .= 'host=' . $dsninfo['socket'];
		102	+ }
		103	+ if ($dsninfo['port']) {
		104	+ $connstr .= ' port=' . $dsninfo['port'];
		105	+ }
		106	+ }
		107	+
		108	+ if ($dsninfo['database']) {
		109	+ $connstr .= ' dbname=\'' . addslashes($dsninfo['database']) . '\'';
		110	+ }
		111	+ if ($dsninfo['username']) {
		112	+ $connstr .= ' user=\'' . addslashes($dsninfo['username']) . '\'';
		113	+ }
		114	+ if ($dsninfo['password']) {
		115	+ $connstr .= ' password=\'' . addslashes($dsninfo['password']) . '\'';
		116	+ }
		117	+ if (!empty($dsninfo['options'])) {
		118	+ $connstr .= ' options=' . $dsninfo['options'];
		119	+ }
		120	+ if (!empty($dsninfo['tty'])) {
		121	+ $connstr .= ' tty=' . $dsninfo['tty'];
		122	+ }
		123	+
		124	+ $connect_function = $persistent ? 'pg_pconnect' : 'pg_connect';
		125	+
		126	+ $ini = ini_get('track_errors');
		127	+ if ($ini) {
		128	+ $conn = @$connect_function($connstr);
		129	+ } else {
		130	+ ini_set('track_errors', 1);
		131	+ $conn = @$connect_function($connstr);
		132	+ ini_set('track_errors', $ini);
		133	+ }
		134	+ if ($conn == false) {
		135	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED, null,
		136	+ null, null, strip_tags($php_errormsg));
		137	+ }
		138	+ $this->connection = $conn;
		139	+ return DB_OK;
		140	+ }
		141	+
		142	+ // }}}
		143	+ // {{{ disconnect()
		144	+
		145	+ /**
		146	+ * Log out and disconnect from the database.
		147	+ *
		148	+ * @return bool true on success, false if not connected.
		149	+ */
		150	+ function disconnect()
		151	+ {
		152	+ $ret = @pg_close($this->connection);
		153	+ $this->connection = null;
		154	+ return $ret;
		155	+ }
		156	+
		157	+ // }}}
		158	+ // {{{ simpleQuery()
		159	+
		160	+ /**
		161	+ * Send a query to PostgreSQL and return the results as a
		162	+ * PostgreSQL resource identifier.
		163	+ *
		164	+ * @param $query the SQL query
		165	+ *
		166	+ * @return int returns a valid PostgreSQL result for successful SELECT
		167	+ * queries, DB_OK for other successful queries. A DB error code
		168	+ * is returned on failure.
		169	+ */
		170	+ function simpleQuery($query)
		171	+ {
		172	+ $ismanip = DB::isManip($query);
		173	+ $this->last_query = $query;
		174	+ $query = $this->modifyQuery($query);
		175	+ if (!$this->autocommit && $ismanip) {
		176	+ if ($this->transaction_opcount == 0) {
		177	+ $result = @pg_exec($this->connection, 'begin;');
		178	+ if (!$result) {
		179	+ return $this->pgsqlRaiseError();
		180	+ }
		181	+ }
		182	+ $this->transaction_opcount++;
		183	+ }
		184	+ $result = @pg_exec($this->connection, $query);
		185	+ if (!$result) {
		186	+ return $this->pgsqlRaiseError();
		187	+ }
		188	+ // Determine which queries that should return data, and which
		189	+ // should return an error code only.
		190	+ if ($ismanip) {
		191	+ $this->affected = @pg_cmdtuples($result);
		192	+ return DB_OK;
		193	+ } elseif (preg_match('/^\s\(?\s(SELECT(?!\s+INTO)\|EXPLAIN\|SHOW)\s/si', $query)) {
		194	+ /* PostgreSQL commands:
		195	+ ABORT, ALTER, BEGIN, CLOSE, CLUSTER, COMMIT, COPY,
		196	+ CREATE, DECLARE, DELETE, DROP TABLE, EXPLAIN, FETCH,
		197	+ GRANT, INSERT, LISTEN, LOAD, LOCK, MOVE, NOTIFY, RESET,
		198	+ REVOKE, ROLLBACK, SELECT, SELECT INTO, SET, SHOW,
		199	+ UNLISTEN, UPDATE, VACUUM
		200	+ */
		201	+ $this->row[(int)$result] = 0; // reset the row counter.
		202	+ $numrows = $this->numrows($result);
		203	+ if (is_object($numrows)) {
		204	+ return $numrows;
		205	+ }
		206	+ $this->num_rows[(int)$result] = $numrows;
		207	+ $this->affected = 0;
		208	+ return $result;
		209	+ } else {
		210	+ $this->affected = 0;
		211	+ return DB_OK;
		212	+ }
		213	+ }
		214	+
		215	+ // }}}
		216	+ // {{{ nextResult()
		217	+
		218	+ /**
		219	+ * Move the internal pgsql result pointer to the next available result
		220	+ *
		221	+ * @param a valid fbsql result resource
		222	+ *
		223	+ * @access public
		224	+ *
		225	+ * @return true if a result is available otherwise return false
		226	+ */
		227	+ function nextResult($result)
		228	+ {
		229	+ return false;
		230	+ }
		231	+
		232	+ // }}}
		233	+ // {{{ errorCode()
		234	+
		235	+ /**
		236	+ * Determine PEAR::DB error code from the database's text error message.
		237	+ *
		238	+ * @param string $errormsg error message returned from the database
		239	+ * @return integer an error number from a DB error constant
		240	+ */
		241	+ function errorCode($errormsg)
		242	+ {
		243	+ static $error_regexps;
		244	+ if (!isset($error_regexps)) {
		245	+ $error_regexps = array(
		246	+ '/(([Rr]elation\|[Ss]equence\|[Tt]able)( [\"\'].*[\"\'])? does not exist\|[Cc]lass ".+" not found)$/' => DB_ERROR_NOSUCHTABLE,
		247	+ '/[Cc]olumn [\"\'].[\"\'] .does not exist/' => DB_ERROR_NOSUCHFIELD,
		248	+ '/[Rr]elation [\"\'].[\"\'] already exists\|[Cc]annot insert a duplicate key into (a )?unique index./' => DB_ERROR_ALREADY_EXISTS,
		249	+ '/(divide\|division) by zero$/' => DB_ERROR_DIVZERO,
		250	+ '/pg_atoi: error in .*: can\'t parse /' => DB_ERROR_INVALID_NUMBER,
		251	+ '/invalid input syntax for integer/' => DB_ERROR_INVALID_NUMBER,
		252	+ '/ttribute [\"\'].[\"\'] not found$\|[Rr]elation [\"\'].[\"\'] does not have attribute [\"\'].*[\"\']/' => DB_ERROR_NOSUCHFIELD,
		253	+ '/parser: parse error at or near \"/' => DB_ERROR_SYNTAX,
		254	+ '/syntax error at/' => DB_ERROR_SYNTAX,
		255	+ '/permission denied/' => DB_ERROR_ACCESS_VIOLATION,
		256	+ '/violates not-null constraint/' => DB_ERROR_CONSTRAINT_NOT_NULL,
		257	+ '/violates [\w ]+ constraint/' => DB_ERROR_CONSTRAINT,
		258	+ '/referential integrity violation/' => DB_ERROR_CONSTRAINT
		259	+ );
		260	+ }
		261	+ foreach ($error_regexps as $regexp => $code) {
		262	+ if (preg_match($regexp, $errormsg)) {
		263	+ return $code;
		264	+ }
		265	+ }
		266	+ // Fall back to DB_ERROR if there was no mapping.
		267	+ return DB_ERROR;
		268	+ }
		269	+
		270	+ // }}}
		271	+ // {{{ fetchInto()
		272	+
		273	+ /**
		274	+ * Fetch a row and insert the data into an existing array.
		275	+ *
		276	+ * Formating of the array and the data therein are configurable.
		277	+ * See DB_result::fetchInto() for more information.
		278	+ *
		279	+ * @param resource $result query result identifier
		280	+ * @param array $arr (reference) array where data from the row
		281	+ * should be placed
		282	+ * @param int $fetchmode how the resulting array should be indexed
		283	+ * @param int $rownum the row number to fetch
		284	+ *
		285	+ * @return mixed DB_OK on success, null when end of result set is
		286	+ * reached or on failure
		287	+ *
		288	+ * @see DB_result::fetchInto()
		289	+ * @access private
		290	+ */
		291	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		292	+ {
		293	+ $result_int = (int)$result;
		294	+ $rownum = ($rownum !== null) ? $rownum : $this->row[$result_int];
		295	+ if ($rownum >= $this->num_rows[$result_int]) {
		296	+ return null;
		297	+ }
		298	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		299	+ $arr = @pg_fetch_array($result, $rownum, PGSQL_ASSOC);
		300	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		301	+ $arr = array_change_key_case($arr, CASE_LOWER);
		302	+ }
		303	+ } else {
		304	+ $arr = @pg_fetch_row($result, $rownum);
		305	+ }
		306	+ if (!$arr) {
		307	+ $err = pg_errormessage($this->connection);
		308	+ if (!$err) {
		309	+ return null;
		310	+ }
		311	+ return $this->pgsqlRaiseError();
		312	+ }
		313	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		314	+ $this->_rtrimArrayValues($arr);
		315	+ }
		316	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		317	+ $this->_convertNullArrayValuesToEmpty($arr);
		318	+ }
		319	+ $this->row[$result_int] = ++$rownum;
		320	+ return DB_OK;
		321	+ }
		322	+
		323	+ // }}}
		324	+ // {{{ freeResult()
		325	+
		326	+ /**
		327	+ * Free the internal resources associated with $result.
		328	+ *
		329	+ * @param $result int PostgreSQL result identifier
		330	+ *
		331	+ * @return bool true on success, false if $result is invalid
		332	+ */
		333	+ function freeResult($result)
		334	+ {
		335	+ if (is_resource($result)) {
		336	+ unset($this->row[(int)$result]);
		337	+ unset($this->num_rows[(int)$result]);
		338	+ $this->affected = 0;
		339	+ return @pg_freeresult($result);
		340	+ }
		341	+ return false;
		342	+ }
		343	+
		344	+ // }}}
		345	+ // {{{ quote()
		346	+
		347	+ /**
		348	+ * @deprecated Deprecated in release 1.6.0
		349	+ * @internal
		350	+ */
		351	+ function quote($str) {
		352	+ return $this->quoteSmart($str);
		353	+ }
		354	+
		355	+ // }}}
		356	+ // {{{ quoteSmart()
		357	+
		358	+ /**
		359	+ * Format input so it can be safely used in a query
		360	+ *
		361	+ * @param mixed $in data to be quoted
		362	+ *
		363	+ * @return mixed Submitted variable's type = returned value:
		364	+ * + null = the string <samp>NULL</samp>
		365	+ * + boolean = string <samp>TRUE</samp> or <samp>FALSE</samp>
		366	+ * + integer or double = the unquoted number
		367	+ * + other (including strings and numeric strings) =
		368	+ * the data escaped according to MySQL's settings
		369	+ * then encapsulated between single quotes
		370	+ *
		371	+ * @internal
		372	+ */
		373	+ function quoteSmart($in)
		374	+ {
		375	+ if (is_int($in) \|\| is_double($in)) {
		376	+ return $in;
		377	+ } elseif (is_bool($in)) {
		378	+ return $in ? 'TRUE' : 'FALSE';
		379	+ } elseif (is_null($in)) {
		380	+ return 'NULL';
		381	+ } else {
		382	+ return "'" . $this->escapeSimple($in) . "'";
		383	+ }
		384	+ }
		385	+
		386	+ // }}}
		387	+ // {{{ escapeSimple()
		388	+
		389	+ /**
		390	+ * Escape a string according to the current DBMS's standards
		391	+ *
		392	+ * PostgreSQL treats a backslash as an escape character, so they are
		393	+ * removed.
		394	+ *
		395	+ * Not using pg_escape_string() yet because it requires PostgreSQL
		396	+ * to be at version 7.2 or greater.
		397	+ *
		398	+ * @param string $str the string to be escaped
		399	+ *
		400	+ * @return string the escaped string
		401	+ *
		402	+ * @internal
		403	+ */
		404	+ function escapeSimple($str) {
		405	+ return str_replace("'", "''", str_replace('\\', '\\\\', $str));
		406	+ }
		407	+
		408	+ // }}}
		409	+ // {{{ numCols()
		410	+
		411	+ /**
		412	+ * Get the number of columns in a result set.
		413	+ *
		414	+ * @param $result resource PostgreSQL result identifier
		415	+ *
		416	+ * @return int the number of columns per row in $result
		417	+ */
		418	+ function numCols($result)
		419	+ {
		420	+ $cols = @pg_numfields($result);
		421	+ if (!$cols) {
		422	+ return $this->pgsqlRaiseError();
		423	+ }
		424	+ return $cols;
		425	+ }
		426	+
		427	+ // }}}
		428	+ // {{{ numRows()
		429	+
		430	+ /**
		431	+ * Get the number of rows in a result set.
		432	+ *
		433	+ * @param $result resource PostgreSQL result identifier
		434	+ *
		435	+ * @return int the number of rows in $result
		436	+ */
		437	+ function numRows($result)
		438	+ {
		439	+ $rows = @pg_numrows($result);
		440	+ if ($rows === null) {
		441	+ return $this->pgsqlRaiseError();
		442	+ }
		443	+ return $rows;
		444	+ }
		445	+
		446	+ // }}}
		447	+ // {{{ errorNative()
		448	+
		449	+ /**
		450	+ * Get the native error code of the last error (if any) that
		451	+ * occured on the current connection.
		452	+ *
		453	+ * @return int native PostgreSQL error code
		454	+ */
		455	+ function errorNative()
		456	+ {
		457	+ return pg_errormessage($this->connection);
		458	+ }
		459	+
		460	+ // }}}
		461	+ // {{{ autoCommit()
		462	+
		463	+ /**
		464	+ * Enable/disable automatic commits
		465	+ */
		466	+ function autoCommit($onoff = false)
		467	+ {
		468	+ // XXX if $this->transaction_opcount > 0, we should probably
		469	+ // issue a warning here.
		470	+ $this->autocommit = $onoff ? true : false;
		471	+ return DB_OK;
		472	+ }
		473	+
		474	+ // }}}
		475	+ // {{{ commit()
		476	+
		477	+ /**
		478	+ * Commit the current transaction.
		479	+ */
		480	+ function commit()
		481	+ {
		482	+ if ($this->transaction_opcount > 0) {
		483	+ // (disabled) hack to shut up error messages from libpq.a
		484	+ //@fclose(@fopen("php://stderr", "w"));
		485	+ $result = @pg_exec($this->connection, 'end;');
		486	+ $this->transaction_opcount = 0;
		487	+ if (!$result) {
		488	+ return $this->pgsqlRaiseError();
		489	+ }
		490	+ }
		491	+ return DB_OK;
		492	+ }
		493	+
		494	+ // }}}
		495	+ // {{{ rollback()
		496	+
		497	+ /**
		498	+ * Roll back (undo) the current transaction.
		499	+ */
		500	+ function rollback()
		501	+ {
		502	+ if ($this->transaction_opcount > 0) {
		503	+ $result = @pg_exec($this->connection, 'abort;');
		504	+ $this->transaction_opcount = 0;
		505	+ if (!$result) {
		506	+ return $this->pgsqlRaiseError();
		507	+ }
		508	+ }
		509	+ return DB_OK;
		510	+ }
		511	+
		512	+ // }}}
		513	+ // {{{ affectedRows()
		514	+
		515	+ /**
		516	+ * Gets the number of rows affected by the last query.
		517	+ * if the last query was a select, returns 0.
		518	+ *
		519	+ * @return int number of rows affected by the last query or DB_ERROR
		520	+ */
		521	+ function affectedRows()
		522	+ {
		523	+ return $this->affected;
		524	+ }
		525	+
		526	+ // }}}
		527	+ // {{{ nextId()
		528	+
		529	+ /**
		530	+ * Returns the next free id in a sequence
		531	+ *
		532	+ * @param string $seq_name name of the sequence
		533	+ * @param boolean $ondemand when true, the seqence is automatically
		534	+ * created if it does not exist
		535	+ *
		536	+ * @return int the next id number in the sequence. DB_Error if problem.
		537	+ *
		538	+ * @internal
		539	+ * @see DB_common::nextID()
		540	+ * @access public
		541	+ */
		542	+ function nextId($seq_name, $ondemand = true)
		543	+ {
		544	+ $seqname = $this->getSequenceName($seq_name);
		545	+ $repeat = false;
		546	+ do {
		547	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		548	+ $result =& $this->query("SELECT NEXTVAL('${seqname}')");
		549	+ $this->popErrorHandling();
		550	+ if ($ondemand && DB::isError($result) &&
		551	+ $result->getCode() == DB_ERROR_NOSUCHTABLE) {
		552	+ $repeat = true;
		553	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		554	+ $result = $this->createSequence($seq_name);
		555	+ $this->popErrorHandling();
		556	+ if (DB::isError($result)) {
		557	+ return $this->raiseError($result);
		558	+ }
		559	+ } else {
		560	+ $repeat = false;
		561	+ }
		562	+ } while ($repeat);
		563	+ if (DB::isError($result)) {
		564	+ return $this->raiseError($result);
		565	+ }
		566	+ $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
		567	+ $result->free();
		568	+ return $arr[0];
		569	+ }
		570	+
		571	+ // }}}
		572	+ // {{{ createSequence()
		573	+
		574	+ /**
		575	+ * Create the sequence
		576	+ *
		577	+ * @param string $seq_name the name of the sequence
		578	+ * @return mixed DB_OK on success or DB error on error
		579	+ * @access public
		580	+ */
		581	+ function createSequence($seq_name)
		582	+ {
		583	+ $seqname = $this->getSequenceName($seq_name);
		584	+ $result = $this->query("CREATE SEQUENCE ${seqname}");
		585	+ return $result;
		586	+ }
		587	+
		588	+ // }}}
		589	+ // {{{ dropSequence()
		590	+
		591	+ /**
		592	+ * Drop a sequence
		593	+ *
		594	+ * @param string $seq_name the name of the sequence
		595	+ * @return mixed DB_OK on success or DB error on error
		596	+ * @access public
		597	+ */
		598	+ function dropSequence($seq_name)
		599	+ {
		600	+ $seqname = $this->getSequenceName($seq_name);
		601	+ return $this->query("DROP SEQUENCE ${seqname}");
		602	+ }
		603	+
		604	+ // }}}
		605	+ // {{{ modifyLimitQuery()
		606	+
		607	+ function modifyLimitQuery($query, $from, $count, $params = array())
		608	+ {
		609	+ $query = $query . " LIMIT $count OFFSET $from";
		610	+ return $query;
		611	+ }
		612	+
		613	+ // }}}
		614	+ // {{{ pgsqlRaiseError()
		615	+
		616	+ /**
		617	+ * Gather information about an error, then use that info to create a
		618	+ * DB error object and finally return that object.
		619	+ *
		620	+ * @param integer $errno PEAR error number (usually a DB constant) if
		621	+ * manually raising an error
		622	+ * @return object DB error object
		623	+ * @see errorNative()
		624	+ * @see errorCode()
		625	+ * @see DB_common::raiseError()
		626	+ */
		627	+ function pgsqlRaiseError($errno = null)
		628	+ {
		629	+ $native = $this->errorNative();
		630	+ if ($errno === null) {
		631	+ $err = $this->errorCode($native);
		632	+ } else {
		633	+ $err = $errno;
		634	+ }
		635	+ return $this->raiseError($err, null, null, null, $native);
		636	+ }
		637	+
		638	+ // }}}
		639	+ // {{{ _pgFieldFlags()
		640	+
		641	+ /**
		642	+ * Flags of a Field
		643	+ *
		644	+ * @param int $resource PostgreSQL result identifier
		645	+ * @param int $num_field the field number
		646	+ *
		647	+ * @return string The flags of the field ("not_null", "default_value",
		648	+ * "primary_key", "unique_key" and "multiple_key"
		649	+ * are supported). The default value is passed
		650	+ * through rawurlencode() in case there are spaces in it.
		651	+ * @access private
		652	+ */
		653	+ function _pgFieldFlags($resource, $num_field, $table_name)
		654	+ {
		655	+ $field_name = @pg_fieldname($resource, $num_field);
		656	+
		657	+ $result = @pg_exec($this->connection, "SELECT f.attnotnull, f.atthasdef
		658	+ FROM pg_attribute f, pg_class tab, pg_type typ
		659	+ WHERE tab.relname = typ.typname
		660	+ AND typ.typrelid = f.attrelid
		661	+ AND f.attname = '$field_name'
		662	+ AND tab.relname = '$table_name'");
		663	+ if (@pg_numrows($result) > 0) {
		664	+ $row = @pg_fetch_row($result, 0);
		665	+ $flags = ($row[0] == 't') ? 'not_null ' : '';
		666	+
		667	+ if ($row[1] == 't') {
		668	+ $result = @pg_exec($this->connection, "SELECT a.adsrc
		669	+ FROM pg_attribute f, pg_class tab, pg_type typ, pg_attrdef a
		670	+ WHERE tab.relname = typ.typname AND typ.typrelid = f.attrelid
		671	+ AND f.attrelid = a.adrelid AND f.attname = '$field_name'
		672	+ AND tab.relname = '$table_name' AND f.attnum = a.adnum");
		673	+ $row = @pg_fetch_row($result, 0);
		674	+ $num = preg_replace("/'(.*)'::\w+/", "\\1", $row[0]);
		675	+ $flags .= 'default_' . rawurlencode($num) . ' ';
		676	+ }
		677	+ } else {
		678	+ $flags = '';
		679	+ }
		680	+ $result = @pg_exec($this->connection, "SELECT i.indisunique, i.indisprimary, i.indkey
		681	+ FROM pg_attribute f, pg_class tab, pg_type typ, pg_index i
		682	+ WHERE tab.relname = typ.typname
		683	+ AND typ.typrelid = f.attrelid
		684	+ AND f.attrelid = i.indrelid
		685	+ AND f.attname = '$field_name'
		686	+ AND tab.relname = '$table_name'");
		687	+ $count = @pg_numrows($result);
		688	+
		689	+ for ($i = 0; $i < $count ; $i++) {
		690	+ $row = @pg_fetch_row($result, $i);
		691	+ $keys = explode(' ', $row[2]);
		692	+
		693	+ if (in_array($num_field + 1, $keys)) {
		694	+ $flags .= ($row[0] == 't' && $row[1] == 'f') ? 'unique_key ' : '';
		695	+ $flags .= ($row[1] == 't') ? 'primary_key ' : '';
		696	+ if (count($keys) > 1)
		697	+ $flags .= 'multiple_key ';
		698	+ }
		699	+ }
		700	+
		701	+ return trim($flags);
		702	+ }
		703	+
		704	+ // }}}
		705	+ // {{{ tableInfo()
		706	+
		707	+ /**
		708	+ * Returns information about a table or a result set.
		709	+ *
		710	+ * NOTE: only supports 'table' and 'flags' if <var>$result</var>
		711	+ * is a table name.
		712	+ *
		713	+ * @param object\|string $result DB_result object from a query or a
		714	+ * string containing the name of a table
		715	+ * @param int $mode a valid tableInfo mode
		716	+ * @return array an associative array with the information requested
		717	+ * or an error object if something is wrong
		718	+ * @access public
		719	+ * @internal
		720	+ * @see DB_common::tableInfo()
		721	+ */
		722	+ function tableInfo($result, $mode = null)
		723	+ {
		724	+ if (isset($result->result)) {
		725	+ /*
		726	+ * Probably received a result object.
		727	+ * Extract the result resource identifier.
		728	+ */
		729	+ $id = $result->result;
		730	+ $got_string = false;
		731	+ } elseif (is_string($result)) {
		732	+ /*
		733	+ * Probably received a table name.
		734	+ * Create a result resource identifier.
		735	+ */
		736	+ $id = @pg_exec($this->connection, "SELECT * FROM $result LIMIT 0");
		737	+ $got_string = true;
		738	+ } else {
		739	+ /*
		740	+ * Probably received a result resource identifier.
		741	+ * Copy it.
		742	+ * Deprecated. Here for compatibility only.
		743	+ */
		744	+ $id = $result;
		745	+ $got_string = false;
		746	+ }
		747	+
		748	+ if (!is_resource($id)) {
		749	+ return $this->pgsqlRaiseError(DB_ERROR_NEED_MORE_DATA);
		750	+ }
		751	+
		752	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		753	+ $case_func = 'strtolower';
		754	+ } else {
		755	+ $case_func = 'strval';
		756	+ }
		757	+
		758	+ $count = @pg_numfields($id);
		759	+
		760	+ // made this IF due to performance (one if is faster than $count if's)
		761	+ if (!$mode) {
		762	+
		763	+ for ($i=0; $i<$count; $i++) {
		764	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		765	+ $res[$i]['name'] = $case_func(@pg_fieldname($id, $i));
		766	+ $res[$i]['type'] = @pg_fieldtype($id, $i);
		767	+ $res[$i]['len'] = @pg_fieldsize($id, $i);
		768	+ $res[$i]['flags'] = $got_string ? $this->_pgFieldflags($id, $i, $result) : '';
		769	+ }
		770	+
		771	+ } else { // full
		772	+ $res['num_fields']= $count;
		773	+
		774	+ for ($i=0; $i<$count; $i++) {
		775	+ $res[$i]['table'] = $got_string ? $case_func($result) : '';
		776	+ $res[$i]['name'] = $case_func(@pg_fieldname($id, $i));
		777	+ $res[$i]['type'] = @pg_fieldtype($id, $i);
		778	+ $res[$i]['len'] = @pg_fieldsize($id, $i);
		779	+ $res[$i]['flags'] = $got_string ? $this->_pgFieldFlags($id, $i, $result) : '';
		780	+
		781	+ if ($mode & DB_TABLEINFO_ORDER) {
		782	+ $res['order'][$res[$i]['name']] = $i;
		783	+ }
		784	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		785	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		786	+ }
		787	+ }
		788	+ }
		789	+
		790	+ // free the result only if we were called on a table
		791	+ if ($got_string) {
		792	+ @pg_freeresult($id);
		793	+ }
		794	+ return $res;
		795	+ }
		796	+
		797	+ // }}}
		798	+ // {{{ getTablesQuery()
		799	+
		800	+ /**
		801	+ * Returns the query needed to get some backend info
		802	+ * @param string $type What kind of info you want to retrieve
		803	+ * @return string The SQL query string
		804	+ */
		805	+ function getSpecialQuery($type)
		806	+ {
		807	+ switch ($type) {
		808	+ case 'tables':
		809	+ return "SELECT c.relname as \"Name\"
		810	+ FROM pg_class c, pg_user u
		811	+ WHERE c.relowner = u.usesysid AND c.relkind = 'r'
		812	+ AND not exists (select 1 from pg_views where viewname = c.relname)
		813	+ AND c.relname !~ '^(pg_\|sql_)'
		814	+ UNION
		815	+ SELECT c.relname as \"Name\"
		816	+ FROM pg_class c
		817	+ WHERE c.relkind = 'r'
		818	+ AND not exists (select 1 from pg_views where viewname = c.relname)
		819	+ AND not exists (select 1 from pg_user where usesysid = c.relowner)
		820	+ AND c.relname !~ '^pg_'";
		821	+ case 'views':
		822	+ // Table cols: viewname \| viewowner \| definition
		823	+ return 'SELECT viewname FROM pg_views';
		824	+ case 'users':
		825	+ // cols: usename \|usesysid\|usecreatedb\|usetrace\|usesuper\|usecatupd\|passwd \|valuntil
		826	+ return 'SELECT usename FROM pg_user';
		827	+ case 'databases':
		828	+ return 'SELECT datname FROM pg_database';
		829	+ case 'functions':
		830	+ return 'SELECT proname FROM pg_proc';
		831	+ default:
		832	+ return null;
		833	+ }
		834	+ }
		835	+
		836	+ // }}}
		837	+
		838	+}
		839	+
		840	+/*
		841	+ * Local variables:
		842	+ * tab-width: 4
		843	+ * c-basic-offset: 4
		844	+ * End:
		845	+ */
		846	+
		847	+?>

pear/DB/sqlite.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Authors: Urs Gehrig <urs@circle.ch> \|
		17	+// \| Mika Tuupola <tuupola@appelsiini.net> \|
		18	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		19	+// +----------------------------------------------------------------------+
		20	+//
		21	+// $Id$
		22	+
		23	+require_once 'DB/common.php';
		24	+
		25	+/**
		26	+ * Database independent query interface definition for the SQLite
		27	+ * PECL extension.
		28	+ *
		29	+ * @package DB
		30	+ * @version $Id$
		31	+ * @category Database
		32	+ * @author Urs Gehrig <urs@circle.ch>
		33	+ * @author Mika Tuupola <tuupola@appelsiini.net>
		34	+ */
		35	+class DB_sqlite extends DB_common
		36	+{
		37	+ // {{{ properties
		38	+
		39	+ var $connection;
		40	+ var $phptype, $dbsyntax;
		41	+ var $prepare_tokens = array();
		42	+ var $prepare_types = array();
		43	+ var $_lasterror = '';
		44	+
		45	+ // }}}
		46	+ // {{{ constructor
		47	+
		48	+ /**
		49	+ * Constructor for this class.
		50	+ *
		51	+ * Error codes according to sqlite_exec. Error Codes specification is
		52	+ * in the {@link http://sqlite.org/c_interface.html online manual}.
		53	+ *
		54	+ * This errorhandling based on sqlite_exec is not yet implemented.
		55	+ *
		56	+ * @access public
		57	+ */
		58	+ function DB_sqlite()
		59	+ {
		60	+
		61	+ $this->DB_common();
		62	+ $this->phptype = 'sqlite';
		63	+ $this->dbsyntax = 'sqlite';
		64	+ $this->features = array (
		65	+ 'prepare' => false,
		66	+ 'pconnect' => true,
		67	+ 'transactions' => false,
		68	+ 'limit' => 'alter'
		69	+ );
		70	+
		71	+ // SQLite data types, http://www.sqlite.org/datatypes.html
		72	+ $this->keywords = array (
		73	+ 'BLOB' => '',
		74	+ 'BOOLEAN' => '',
		75	+ 'CHARACTER' => '',
		76	+ 'CLOB' => '',
		77	+ 'FLOAT' => '',
		78	+ 'INTEGER' => '',
		79	+ 'KEY' => '',
		80	+ 'NATIONAL' => '',
		81	+ 'NUMERIC' => '',
		82	+ 'NVARCHAR' => '',
		83	+ 'PRIMARY' => '',
		84	+ 'TEXT' => '',
		85	+ 'TIMESTAMP' => '',
		86	+ 'UNIQUE' => '',
		87	+ 'VARCHAR' => '',
		88	+ 'VARYING' => ''
		89	+ );
		90	+ $this->errorcode_map = array(
		91	+ );
		92	+ }
		93	+
		94	+ // }}}
		95	+ // {{{ connect()
		96	+
		97	+ /**
		98	+ * Connect to a database represented by a file.
		99	+ *
		100	+ * @param $dsn the data source name; the file is taken as
		101	+ * database; "sqlite://root:@host/test.db?mode=0644"
		102	+ * @param $persistent (optional) whether the connection should
		103	+ * be persistent
		104	+ * @access public
		105	+ * @return int DB_OK on success, a DB error on failure
		106	+ */
		107	+ function connect($dsninfo, $persistent = false)
		108	+ {
		109	+ if (!DB::assertExtension('sqlite')) {
		110	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		111	+ }
		112	+
		113	+ $this->dsn = $dsninfo;
		114	+
		115	+ if ($dsninfo['database']) {
		116	+ if (!file_exists($dsninfo['database'])) {
		117	+ if (!touch($dsninfo['database'])) {
		118	+ return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);
		119	+ }
		120	+ if (!isset($dsninfo['mode']) \|\|
		121	+ !is_numeric($dsninfo['mode']))
		122	+ {
		123	+ $mode = 0644;
		124	+ } else {
		125	+ $mode = octdec($dsninfo['mode']);
		126	+ }
		127	+ if (!chmod($dsninfo['database'], $mode)) {
		128	+ return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);
		129	+ }
		130	+ if (!file_exists($dsninfo['database'])) {
		131	+ return $this->sqliteRaiseError(DB_ERROR_NOT_FOUND);
		132	+ }
		133	+ }
		134	+ if (!is_file($dsninfo['database'])) {
		135	+ return $this->sqliteRaiseError(DB_ERROR_INVALID);
		136	+ }
		137	+ if (!is_readable($dsninfo['database'])) {
		138	+ return $this->sqliteRaiseError(DB_ERROR_ACCESS_VIOLATION);
		139	+ }
		140	+ } else {
		141	+ return $this->sqliteRaiseError(DB_ERROR_ACCESS_VIOLATION);
		142	+ }
		143	+
		144	+ $connect_function = $persistent ? 'sqlite_popen' : 'sqlite_open';
		145	+ if (!($conn = @$connect_function($dsninfo['database']))) {
		146	+ return $this->sqliteRaiseError(DB_ERROR_NODBSELECTED);
		147	+ }
		148	+ $this->connection = $conn;
		149	+
		150	+ return DB_OK;
		151	+ }
		152	+
		153	+ // }}}
		154	+ // {{{ disconnect()
		155	+
		156	+ /**
		157	+ * Log out and disconnect from the database.
		158	+ *
		159	+ * @access public
		160	+ * @return bool true on success, false if not connected.
		161	+ * @todo fix return values
		162	+ */
		163	+ function disconnect()
		164	+ {
		165	+ $ret = @sqlite_close($this->connection);
		166	+ $this->connection = null;
		167	+ return $ret;
		168	+ }
		169	+
		170	+ // }}}
		171	+ // {{{ simpleQuery()
		172	+
		173	+ /**
		174	+ * Send a query to SQLite and returns the results as a SQLite resource
		175	+ * identifier.
		176	+ *
		177	+ * @param the SQL query
		178	+ * @access public
		179	+ * @return mixed returns a valid SQLite result for successful SELECT
		180	+ * queries, DB_OK for other successful queries. A DB error is
		181	+ * returned on failure.
		182	+ */
		183	+ function simpleQuery($query)
		184	+ {
		185	+ $ismanip = DB::isManip($query);
		186	+ $this->last_query = $query;
		187	+ $query = $this->_modifyQuery($query);
		188	+ ini_set('track_errors', true);
		189	+ $result = @sqlite_query($query, $this->connection);
		190	+ ini_restore('track_errors');
		191	+ $this->_lasterror = isset($php_errormsg) ? $php_errormsg : '';
		192	+ $this->result = $result;
		193	+ if (!$this->result) {
		194	+ return $this->sqliteRaiseError(null);
		195	+ }
		196	+
		197	+ /* sqlite_query() seems to allways return a resource */
		198	+ /* so cant use that. Using $ismanip instead */
		199	+ if (!$ismanip) {
		200	+ $numRows = $this->numRows($result);
		201	+
		202	+ /* if numRows() returned PEAR_Error */
		203	+ if (is_object($numRows)) {
		204	+ return $numRows;
		205	+ }
		206	+ return $result;
		207	+ }
		208	+ return DB_OK;
		209	+ }
		210	+
		211	+ // }}}
		212	+ // {{{ nextResult()
		213	+
		214	+ /**
		215	+ * Move the internal sqlite result pointer to the next available result.
		216	+ *
		217	+ * @param a valid sqlite result resource
		218	+ * @access public
		219	+ * @return true if a result is available otherwise return false
		220	+ */
		221	+ function nextResult($result)
		222	+ {
		223	+ return false;
		224	+ }
		225	+
		226	+ // }}}
		227	+ // {{{ fetchInto()
		228	+
		229	+ /**
		230	+ * Fetch a row and insert the data into an existing array.
		231	+ *
		232	+ * Formating of the array and the data therein are configurable.
		233	+ * See DB_result::fetchInto() for more information.
		234	+ *
		235	+ * @param resource $result query result identifier
		236	+ * @param array $arr (reference) array where data from the row
		237	+ * should be placed
		238	+ * @param int $fetchmode how the resulting array should be indexed
		239	+ * @param int $rownum the row number to fetch
		240	+ *
		241	+ * @return mixed DB_OK on success, null when end of result set is
		242	+ * reached or on failure
		243	+ *
		244	+ * @see DB_result::fetchInto()
		245	+ * @access private
		246	+ */
		247	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		248	+ {
		249	+ if ($rownum !== null) {
		250	+ if (!@sqlite_seek($this->result, $rownum)) {
		251	+ return null;
		252	+ }
		253	+ }
		254	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		255	+ $arr = @sqlite_fetch_array($result, SQLITE_ASSOC);
		256	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		257	+ $arr = array_change_key_case($arr, CASE_LOWER);
		258	+ }
		259	+ } else {
		260	+ $arr = @sqlite_fetch_array($result, SQLITE_NUM);
		261	+ }
		262	+ if (!$arr) {
		263	+ /* See: http://bugs.php.net/bug.php?id=22328 */
		264	+ return null;
		265	+ }
		266	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		267	+ /*
		268	+ * Even though this DBMS already trims output, we do this because
		269	+ * a field might have intentional whitespace at the end that
		270	+ * gets removed by DB_PORTABILITY_RTRIM under another driver.
		271	+ */
		272	+ $this->_rtrimArrayValues($arr);
		273	+ }
		274	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		275	+ $this->_convertNullArrayValuesToEmpty($arr);
		276	+ }
		277	+ return DB_OK;
		278	+ }
		279	+
		280	+ // }}}
		281	+ // {{{ freeResult()
		282	+
		283	+ /**
		284	+ * Free the internal resources associated with $result.
		285	+ *
		286	+ * @param $result SQLite result identifier
		287	+ * @access public
		288	+ * @return bool true on success, false if $result is invalid
		289	+ */
		290	+ function freeResult(&$result)
		291	+ {
		292	+ // XXX No native free?
		293	+ if (!is_resource($result)) {
		294	+ return false;
		295	+ }
		296	+ $result = null;
		297	+ return true;
		298	+ }
		299	+
		300	+ // }}}
		301	+ // {{{ numCols()
		302	+
		303	+ /**
		304	+ * Gets the number of columns in a result set.
		305	+ *
		306	+ * @return number of columns in a result set
		307	+ */
		308	+ function numCols($result)
		309	+ {
		310	+ $cols = @sqlite_num_fields($result);
		311	+ if (!$cols) {
		312	+ return $this->sqliteRaiseError();
		313	+ }
		314	+ return $cols;
		315	+ }
		316	+
		317	+ // }}}
		318	+ // {{{ numRows()
		319	+
		320	+ /**
		321	+ * Gets the number of rows affected by a query.
		322	+ *
		323	+ * @return number of rows affected by the last query
		324	+ */
		325	+ function numRows($result)
		326	+ {
		327	+ $rows = @sqlite_num_rows($result);
		328	+ if (!is_integer($rows)) {
		329	+ return $this->raiseError();
		330	+ }
		331	+ return $rows;
		332	+ }
		333	+
		334	+ // }}}
		335	+ // {{{ affected()
		336	+
		337	+ /**
		338	+ * Gets the number of rows affected by a query.
		339	+ *
		340	+ * @return number of rows affected by the last query
		341	+ */
		342	+ function affectedRows()
		343	+ {
		344	+ return @sqlite_changes($this->connection);
		345	+ }
		346	+
		347	+ // }}}
		348	+ // {{{ errorNative()
		349	+
		350	+ /**
		351	+ * Get the native error string of the last error (if any) that
		352	+ * occured on the current connection.
		353	+ *
		354	+ * This is used to retrieve more meaningfull error messages DB_pgsql
		355	+ * way since sqlite_last_error() does not provide adequate info.
		356	+ *
		357	+ * @return string native SQLite error message
		358	+ */
		359	+ function errorNative()
		360	+ {
		361	+ return($this->_lasterror);
		362	+ }
		363	+
		364	+ // }}}
		365	+ // {{{ errorCode()
		366	+
		367	+ /**
		368	+ * Determine PEAR::DB error code from the database's text error message.
		369	+ *
		370	+ * @param string $errormsg error message returned from the database
		371	+ * @return integer an error number from a DB error constant
		372	+ */
		373	+ function errorCode($errormsg)
		374	+ {
		375	+ static $error_regexps;
		376	+ if (!isset($error_regexps)) {
		377	+ $error_regexps = array(
		378	+ '/^no such table:/' => DB_ERROR_NOSUCHTABLE,
		379	+ '/^table .* already exists$/' => DB_ERROR_ALREADY_EXISTS,
		380	+ '/PRIMARY KEY must be unique/i' => DB_ERROR_CONSTRAINT,
		381	+ '/is not unique/' => DB_ERROR_CONSTRAINT,
		382	+ '/uniqueness constraint failed/' => DB_ERROR_CONSTRAINT,
		383	+ '/may not be NULL/' => DB_ERROR_CONSTRAINT_NOT_NULL,
		384	+ '/^no such column:/' => DB_ERROR_NOSUCHFIELD,
		385	+ '/^near ".*": syntax error$/' => DB_ERROR_SYNTAX
		386	+ );
		387	+ }
		388	+ foreach ($error_regexps as $regexp => $code) {
		389	+ if (preg_match($regexp, $errormsg)) {
		390	+ return $code;
		391	+ }
		392	+ }
		393	+ // Fall back to DB_ERROR if there was no mapping.
		394	+ return DB_ERROR;
		395	+ }
		396	+
		397	+ // }}}
		398	+ // {{{ dropSequence()
		399	+
		400	+ /**
		401	+ * Deletes a sequence
		402	+ *
		403	+ * @param string $seq_name name of the sequence to be deleted
		404	+ *
		405	+ * @return int DB_OK on success. DB_Error if problems.
		406	+ *
		407	+ * @internal
		408	+ * @see DB_common::dropSequence()
		409	+ * @access public
		410	+ */
		411	+ function dropSequence($seq_name)
		412	+ {
		413	+ $seqname = $this->getSequenceName($seq_name);
		414	+ return $this->query("DROP TABLE $seqname");
		415	+ }
		416	+
		417	+ /**
		418	+ * Creates a new sequence
		419	+ *
		420	+ * @param string $seq_name name of the new sequence
		421	+ *
		422	+ * @return int DB_OK on success. A DB_Error object is returned if
		423	+ * problems arise.
		424	+ *
		425	+ * @internal
		426	+ * @see DB_common::createSequence()
		427	+ * @access public
		428	+ */
		429	+ function createSequence($seq_name)
		430	+ {
		431	+ $seqname = $this->getSequenceName($seq_name);
		432	+ $query = 'CREATE TABLE ' . $seqname .
		433	+ ' (id INTEGER UNSIGNED PRIMARY KEY) ';
		434	+ $result = $this->query($query);
		435	+ if (DB::isError($result)) {
		436	+ return($result);
		437	+ }
		438	+ $query = "CREATE TRIGGER ${seqname}_cleanup AFTER INSERT ON $seqname
		439	+ BEGIN
		440	+ DELETE FROM $seqname WHERE id<LAST_INSERT_ROWID();
		441	+ END ";
		442	+ $result = $this->query($query);
		443	+ if (DB::isError($result)) {
		444	+ return($result);
		445	+ }
		446	+ }
		447	+
		448	+ // }}}
		449	+ // {{{ nextId()
		450	+
		451	+ /**
		452	+ * Returns the next free id in a sequence
		453	+ *
		454	+ * @param string $seq_name name of the sequence
		455	+ * @param boolean $ondemand when true, the seqence is automatically
		456	+ * created if it does not exist
		457	+ *
		458	+ * @return int the next id number in the sequence. DB_Error if problem.
		459	+ *
		460	+ * @internal
		461	+ * @see DB_common::nextID()
		462	+ * @access public
		463	+ */
		464	+ function nextId($seq_name, $ondemand = true)
		465	+ {
		466	+ $seqname = $this->getSequenceName($seq_name);
		467	+
		468	+ do {
		469	+ $repeat = 0;
		470	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		471	+ $result = $this->query("INSERT INTO $seqname (id) VALUES (NULL)");
		472	+ $this->popErrorHandling();
		473	+ if ($result === DB_OK) {
		474	+ $id = @sqlite_last_insert_rowid($this->connection);
		475	+ if ($id != 0) {
		476	+ return $id;
		477	+ }
		478	+ } elseif ($ondemand && DB::isError($result) &&
		479	+ $result->getCode() == DB_ERROR_NOSUCHTABLE)
		480	+ {
		481	+ $result = $this->createSequence($seq_name);
		482	+ if (DB::isError($result)) {
		483	+ return $this->raiseError($result);
		484	+ } else {
		485	+ $repeat = 1;
		486	+ }
		487	+ }
		488	+ } while ($repeat);
		489	+
		490	+ return $this->raiseError($result);
		491	+ }
		492	+
		493	+ // }}}
		494	+ // {{{ getSpecialQuery()
		495	+
		496	+ /**
		497	+ * Returns the query needed to get some backend info.
		498	+ *
		499	+ * Refer to the online manual at http://sqlite.org/sqlite.html.
		500	+ *
		501	+ * @param string $type What kind of info you want to retrieve
		502	+ * @return string The SQL query string
		503	+ */
		504	+ function getSpecialQuery($type, $args=array())
		505	+ {
		506	+ if (!is_array($args))
		507	+ return $this->raiseError('no key specified', null, null, null,
		508	+ 'Argument has to be an array.');
		509	+ switch (strtolower($type)) {
		510	+ case 'master':
		511	+ return 'SELECT * FROM sqlite_master;';
		512	+ case 'tables':
		513	+ return "SELECT name FROM sqlite_master WHERE type='table' "
		514	+ . 'UNION ALL SELECT name FROM sqlite_temp_master '
		515	+ . "WHERE type='table' ORDER BY name;";
		516	+ case 'schema':
		517	+ return 'SELECT sql FROM (SELECT * FROM sqlite_master UNION ALL '
		518	+ . 'SELECT * FROM sqlite_temp_master) '
		519	+ . "WHERE type!='meta' ORDER BY tbl_name, type DESC, name;";
		520	+ case 'schemax':
		521	+ case 'schema_x':
		522	+ /*
		523	+ * Use like:
		524	+ * $res = $db->query($db->getSpecialQuery('schema_x', array('table' => 'table3')));
		525	+ */
		526	+ return 'SELECT sql FROM (SELECT * FROM sqlite_master UNION ALL '
		527	+ . 'SELECT * FROM sqlite_temp_master) '
		528	+ . "WHERE tbl_name LIKE '{$args['table']}' AND type!='meta' "
		529	+ . 'ORDER BY type DESC, name;';
		530	+ case 'alter':
		531	+ /*
		532	+ * SQLite does not support ALTER TABLE; this is a helper query
		533	+ * to handle this. 'table' represents the table name, 'rows'
		534	+ * the news rows to create, 'save' the row(s) to keep _with_
		535	+ * the data.
		536	+ *
		537	+ * Use like:
		538	+ * $args = array(
		539	+ * 'table' => $table,
		540	+ * 'rows' => "id INTEGER PRIMARY KEY, firstname TEXT, surname TEXT, datetime TEXT",
		541	+ * 'save' => "NULL, titel, content, datetime"
		542	+ * );
		543	+ * $res = $db->query( $db->getSpecialQuery('alter', $args));
		544	+ */
		545	+ $rows = strtr($args['rows'], $this->keywords);
		546	+
		547	+ $q = array(
		548	+ 'BEGIN TRANSACTION',
		549	+ "CREATE TEMPORARY TABLE {$args['table']}_backup ({$args['rows']})",
		550	+ "INSERT INTO {$args['table']}_backup SELECT {$args['save']} FROM {$args['table']}",
		551	+ "DROP TABLE {$args['table']}",
		552	+ "CREATE TABLE {$args['table']} ({$args['rows']})",
		553	+ "INSERT INTO {$args['table']} SELECT {$rows} FROM {$args['table']}_backup",
		554	+ "DROP TABLE {$args['table']}_backup",
		555	+ 'COMMIT',
		556	+ );
		557	+
		558	+ // This is a dirty hack, since the above query will no get executed with a single
		559	+ // query call; so here the query method will be called directly and return a select instead.
		560	+ foreach ($q as $query) {
		561	+ $this->query($query);
		562	+ }
		563	+ return "SELECT * FROM {$args['table']};";
		564	+ default:
		565	+ return null;
		566	+ }
		567	+ }
		568	+
		569	+ // }}}
		570	+ // {{{ getDbFileStats()
		571	+
		572	+ /**
		573	+ * Get the file stats for the current database.
		574	+ *
		575	+ * Possible arguments are dev, ino, mode, nlink, uid, gid, rdev, size,
		576	+ * atime, mtime, ctime, blksize, blocks or a numeric key between
		577	+ * 0 and 12.
		578	+ *
		579	+ * @param string $arg Array key for stats()
		580	+ * @return mixed array on an unspecified key, integer on a passed arg and
		581	+ * false at a stats error.
		582	+ */
		583	+ function getDbFileStats($arg = '')
		584	+ {
		585	+ $stats = stat($this->dsn['database']);
		586	+ if ($stats == false) {
		587	+ return false;
		588	+ }
		589	+ if (is_array($stats)) {
		590	+ if (is_numeric($arg)) {
		591	+ if (((int)$arg <= 12) & ((int)$arg >= 0)) {
		592	+ return false;
		593	+ }
		594	+ return $stats[$arg ];
		595	+ }
		596	+ if (array_key_exists(trim($arg), $stats)) {
		597	+ return $stats[$arg ];
		598	+ }
		599	+ }
		600	+ return $stats;
		601	+ }
		602	+
		603	+ // }}}
		604	+ // {{{ escapeSimple()
		605	+
		606	+ /**
		607	+ * Escape a string according to the current DBMS's standards
		608	+ *
		609	+ * In SQLite, this makes things safe for inserts/updates, but may
		610	+ * cause problems when performing text comparisons against columns
		611	+ * containing binary data. See the
		612	+ * {@link http://php.net/sqlite_escape_string PHP manual} for more info.
		613	+ *
		614	+ * @param string $str the string to be escaped
		615	+ *
		616	+ * @return string the escaped string
		617	+ *
		618	+ * @since 1.6.1
		619	+ * @see DB_common::escapeSimple()
		620	+ * @internal
		621	+ */
		622	+ function escapeSimple($str) {
		623	+ return @sqlite_escape_string($str);
		624	+ }
		625	+
		626	+ // }}}
		627	+ // {{{ modifyLimitQuery()
		628	+
		629	+ function modifyLimitQuery($query, $from, $count, $params = array())
		630	+ {
		631	+ $query = $query . " LIMIT $count OFFSET $from";
		632	+ return $query;
		633	+ }
		634	+
		635	+ // }}}
		636	+ // {{{ modifyQuery()
		637	+
		638	+ /**
		639	+ * "DELETE FROM table" gives 0 affected rows in SQLite.
		640	+ *
		641	+ * This little hack lets you know how many rows were deleted.
		642	+ *
		643	+ * @param string $query The SQL query string
		644	+ * @return string The SQL query string
		645	+ */
		646	+ function _modifyQuery($query)
		647	+ {
		648	+ if ($this->options['portability'] & DB_PORTABILITY_DELETE_COUNT) {
		649	+ if (preg_match('/^\sDELETE\s+FROM\s+(\S+)\s$/i', $query)) {
		650	+ $query = preg_replace('/^\sDELETE\s+FROM\s+(\S+)\s$/',
		651	+ 'DELETE FROM \1 WHERE 1=1', $query);
		652	+ }
		653	+ }
		654	+ return $query;
		655	+ }
		656	+
		657	+ // }}}
		658	+ // {{{ sqliteRaiseError()
		659	+
		660	+ /**
		661	+ * Gather information about an error, then use that info to create a
		662	+ * DB error object and finally return that object.
		663	+ *
		664	+ * @param integer $errno PEAR error number (usually a DB constant) if
		665	+ * manually raising an error
		666	+ * @return object DB error object
		667	+ * @see errorNative()
		668	+ * @see errorCode()
		669	+ * @see DB_common::raiseError()
		670	+ */
		671	+ function sqliteRaiseError($errno = null)
		672	+ {
		673	+
		674	+ $native = $this->errorNative();
		675	+ if ($errno === null) {
		676	+ $errno = $this->errorCode($native);
		677	+ }
		678	+
		679	+ $errorcode = @sqlite_last_error($this->connection);
		680	+ $userinfo = "$errorcode ** $this->last_query";
		681	+
		682	+ return $this->raiseError($errno, null, null, $userinfo, $native);
		683	+ }
		684	+
		685	+ // }}}
		686	+}
		687	+
		688	+/*
		689	+ * Local variables:
		690	+ * tab-width: 4
		691	+ * c-basic-offset: 4
		692	+ * End:
		693	+ */
		694	+
		695	+?>

pear/DB/storage.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Author: Stig Bakken <stig@php.net> \|
		17	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		18	+// +----------------------------------------------------------------------+
		19	+//
		20	+// $Id$
		21	+
		22	+require_once 'DB.php';
		23	+
		24	+/**
		25	+ * Provides an object interface to a table row.
		26	+ *
		27	+ * It lets you add, delete and change rows using objects rather than SQL
		28	+ * statements.
		29	+ *
		30	+ * @package DB
		31	+ * @version $Id$
		32	+ * @category Database
		33	+ * @author Stig Bakken <stig@php.net>
		34	+ */
		35	+class DB_storage extends PEAR
		36	+{
		37	+ // {{{ properties
		38	+
		39	+ /** the name of the table (or view, if the backend database supports
		40	+ updates in views) we hold data from */
		41	+ var $_table = null;
		42	+
		43	+ /** which column(s) in the table contains primary keys, can be a
		44	+ string for single-column primary keys, or an array of strings
		45	+ for multiple-column primary keys */
		46	+ var $_keycolumn = null;
		47	+
		48	+ /** DB connection handle used for all transactions */
		49	+ var $_dbh = null;
		50	+
		51	+ /** an assoc with the names of database fields stored as properties
		52	+ in this object */
		53	+ var $_properties = array();
		54	+
		55	+ /** an assoc with the names of the properties in this object that
		56	+ have been changed since they were fetched from the database */
		57	+ var $_changes = array();
		58	+
		59	+ /** flag that decides if data in this object can be changed.
		60	+ objects that don't have their table's key column in their
		61	+ property lists will be flagged as read-only. */
		62	+ var $_readonly = false;
		63	+
		64	+ /** function or method that implements a validator for fields that
		65	+ are set, this validator function returns true if the field is
		66	+ valid, false if not */
		67	+ var $_validator = null;
		68	+
		69	+ // }}}
		70	+ // {{{ constructor
		71	+
		72	+ /**
		73	+ * Constructor
		74	+ *
		75	+ * @param $table string the name of the database table
		76	+ *
		77	+ * @param $keycolumn mixed string with name of key column, or array of
		78	+ * strings if the table has a primary key of more than one column
		79	+ *
		80	+ * @param $dbh object database connection object
		81	+ *
		82	+ * @param $validator mixed function or method used to validate
		83	+ * each new value, called with three parameters: the name of the
		84	+ * field/column that is changing, a reference to the new value and
		85	+ * a reference to this object
		86	+ *
		87	+ */
		88	+ function DB_storage($table, $keycolumn, &$dbh, $validator = null)
		89	+ {
		90	+ $this->PEAR('DB_Error');
		91	+ $this->_table = $table;
		92	+ $this->_keycolumn = $keycolumn;
		93	+ $this->_dbh = $dbh;
		94	+ $this->_readonly = false;
		95	+ $this->_validator = $validator;
		96	+ }
		97	+
		98	+ // }}}
		99	+ // {{{ _makeWhere()
		100	+
		101	+ /**
		102	+ * Utility method to build a "WHERE" clause to locate ourselves in
		103	+ * the table.
		104	+ *
		105	+ * XXX future improvement: use rowids?
		106	+ *
		107	+ * @access private
		108	+ */
		109	+ function _makeWhere($keyval = null)
		110	+ {
		111	+ if (is_array($this->_keycolumn)) {
		112	+ if ($keyval === null) {
		113	+ for ($i = 0; $i < sizeof($this->_keycolumn); $i++) {
		114	+ $keyval[] = $this->{$this->_keycolumn[$i]};
		115	+ }
		116	+ }
		117	+ $whereclause = '';
		118	+ for ($i = 0; $i < sizeof($this->_keycolumn); $i++) {
		119	+ if ($i > 0) {
		120	+ $whereclause .= ' AND ';
		121	+ }
		122	+ $whereclause .= $this->_keycolumn[$i];
		123	+ if (is_null($keyval[$i])) {
		124	+ // there's not much point in having a NULL key,
		125	+ // but we support it anyway
		126	+ $whereclause .= ' IS NULL';
		127	+ } else {
		128	+ $whereclause .= ' = ' . $this->_dbh->quote($keyval[$i]);
		129	+ }
		130	+ }
		131	+ } else {
		132	+ if ($keyval === null) {
		133	+ $keyval = @$this->{$this->_keycolumn};
		134	+ }
		135	+ $whereclause = $this->_keycolumn;
		136	+ if (is_null($keyval)) {
		137	+ // there's not much point in having a NULL key,
		138	+ // but we support it anyway
		139	+ $whereclause .= ' IS NULL';
		140	+ } else {
		141	+ $whereclause .= ' = ' . $this->_dbh->quote($keyval);
		142	+ }
		143	+ }
		144	+ return $whereclause;
		145	+ }
		146	+
		147	+ // }}}
		148	+ // {{{ setup()
		149	+
		150	+ /**
		151	+ * Method used to initialize a DB_storage object from the
		152	+ * configured table.
		153	+ *
		154	+ * @param $keyval mixed the key[s] of the row to fetch (string or array)
		155	+ *
		156	+ * @return int DB_OK on success, a DB error if not
		157	+ */
		158	+ function setup($keyval)
		159	+ {
		160	+ $whereclause = $this->_makeWhere($keyval);
		161	+ $query = 'SELECT * FROM ' . $this->_table . ' WHERE ' . $whereclause;
		162	+ $sth = $this->_dbh->query($query);
		163	+ if (DB::isError($sth)) {
		164	+ return $sth;
		165	+ }
		166	+ $row = $sth->fetchRow(DB_FETCHMODE_ASSOC);
		167	+ if (DB::isError($row)) {
		168	+ return $row;
		169	+ }
		170	+ if (!$row) {
		171	+ return $this->raiseError(null, DB_ERROR_NOT_FOUND, null, null,
		172	+ $query, null, true);
		173	+ }
		174	+ foreach ($row as $key => $value) {
		175	+ $this->_properties[$key] = true;
		176	+ $this->$key = $value;
		177	+ }
		178	+ return DB_OK;
		179	+ }
		180	+
		181	+ // }}}
		182	+ // {{{ insert()
		183	+
		184	+ /**
		185	+ * Create a new (empty) row in the configured table for this
		186	+ * object.
		187	+ */
		188	+ function insert($newpk)
		189	+ {
		190	+ if (is_array($this->_keycolumn)) {
		191	+ $primarykey = $this->_keycolumn;
		192	+ } else {
		193	+ $primarykey = array($this->_keycolumn);
		194	+ }
		195	+ settype($newpk, "array");
		196	+ for ($i = 0; $i < sizeof($primarykey); $i++) {
		197	+ $pkvals[] = $this->_dbh->quote($newpk[$i]);
		198	+ }
		199	+
		200	+ $sth = $this->_dbh->query("INSERT INTO $this->_table (" .
		201	+ implode(",", $primarykey) . ") VALUES(" .
		202	+ implode(",", $pkvals) . ")");
		203	+ if (DB::isError($sth)) {
		204	+ return $sth;
		205	+ }
		206	+ if (sizeof($newpk) == 1) {
		207	+ $newpk = $newpk[0];
		208	+ }
		209	+ $this->setup($newpk);
		210	+ }
		211	+
		212	+ // }}}
		213	+ // {{{ toString()
		214	+
		215	+ /**
		216	+ * Output a simple description of this DB_storage object.
		217	+ * @return string object description
		218	+ */
		219	+ function toString()
		220	+ {
		221	+ $info = strtolower(get_class($this));
		222	+ $info .= " (table=";
		223	+ $info .= $this->_table;
		224	+ $info .= ", keycolumn=";
		225	+ if (is_array($this->_keycolumn)) {
		226	+ $info .= "(" . implode(",", $this->_keycolumn) . ")";
		227	+ } else {
		228	+ $info .= $this->_keycolumn;
		229	+ }
		230	+ $info .= ", dbh=";
		231	+ if (is_object($this->_dbh)) {
		232	+ $info .= $this->_dbh->toString();
		233	+ } else {
		234	+ $info .= "null";
		235	+ }
		236	+ $info .= ")";
		237	+ if (sizeof($this->_properties)) {
		238	+ $info .= " [loaded, key=";
		239	+ $keyname = $this->_keycolumn;
		240	+ if (is_array($keyname)) {
		241	+ $info .= "(";
		242	+ for ($i = 0; $i < sizeof($keyname); $i++) {
		243	+ if ($i > 0) {
		244	+ $info .= ",";
		245	+ }
		246	+ $info .= $this->$keyname[$i];
		247	+ }
		248	+ $info .= ")";
		249	+ } else {
		250	+ $info .= $this->$keyname;
		251	+ }
		252	+ $info .= "]";
		253	+ }
		254	+ if (sizeof($this->_changes)) {
		255	+ $info .= " [modified]";
		256	+ }
		257	+ return $info;
		258	+ }
		259	+
		260	+ // }}}
		261	+ // {{{ dump()
		262	+
		263	+ /**
		264	+ * Dump the contents of this object to "standard output".
		265	+ */
		266	+ function dump()
		267	+ {
		268	+ foreach ($this->_properties as $prop => $foo) {
		269	+ print "$prop = ";
		270	+ print htmlentities($this->$prop);
		271	+ print "<br />\n";
		272	+ }
		273	+ }
		274	+
		275	+ // }}}
		276	+ // {{{ &create()
		277	+
		278	+ /**
		279	+ * Static method used to create new DB storage objects.
		280	+ * @param $data assoc. array where the keys are the names
		281	+ * of properties/columns
		282	+ * @return object a new instance of DB_storage or a subclass of it
		283	+ */
		284	+ function &create($table, &$data)
		285	+ {
		286	+ $classname = strtolower(get_class($this));
		287	+ $obj =& new $classname($table);
		288	+ foreach ($data as $name => $value) {
		289	+ $obj->_properties[$name] = true;
		290	+ $obj->$name = &$value;
		291	+ }
		292	+ return $obj;
		293	+ }
		294	+
		295	+ // }}}
		296	+ // {{{ loadFromQuery()
		297	+
		298	+ /**
		299	+ * Loads data into this object from the given query. If this
		300	+ * object already contains table data, changes will be saved and
		301	+ * the object re-initialized first.
		302	+ *
		303	+ * @param $query SQL query
		304	+ *
		305	+ * @param $params parameter list in case you want to use
		306	+ * prepare/execute mode
		307	+ *
		308	+ * @return int DB_OK on success, DB_WARNING_READ_ONLY if the
		309	+ * returned object is read-only (because the object's specified
		310	+ * key column was not found among the columns returned by $query),
		311	+ * or another DB error code in case of errors.
		312	+ */
		313	+// XXX commented out for now
		314	+/*
		315	+ function loadFromQuery($query, $params = null)
		316	+ {
		317	+ if (sizeof($this->_properties)) {
		318	+ if (sizeof($this->_changes)) {
		319	+ $this->store();
		320	+ $this->_changes = array();
		321	+ }
		322	+ $this->_properties = array();
		323	+ }
		324	+ $rowdata = $this->_dbh->getRow($query, DB_FETCHMODE_ASSOC, $params);
		325	+ if (DB::isError($rowdata)) {
		326	+ return $rowdata;
		327	+ }
		328	+ reset($rowdata);
		329	+ $found_keycolumn = false;
		330	+ while (list($key, $value) = each($rowdata)) {
		331	+ if ($key == $this->_keycolumn) {
		332	+ $found_keycolumn = true;
		333	+ }
		334	+ $this->_properties[$key] = true;
		335	+ $this->$key = &$value;
		336	+ unset($value); // have to unset, or all properties will
		337	+ // refer to the same value
		338	+ }
		339	+ if (!$found_keycolumn) {
		340	+ $this->_readonly = true;
		341	+ return DB_WARNING_READ_ONLY;
		342	+ }
		343	+ return DB_OK;
		344	+ }
		345	+ */
		346	+
		347	+ // }}}
		348	+ // {{{ set()
		349	+
		350	+ /**
		351	+ * Modify an attriute value.
		352	+ */
		353	+ function set($property, $newvalue)
		354	+ {
		355	+ // only change if $property is known and object is not
		356	+ // read-only
		357	+ if ($this->_readonly) {
		358	+ return $this->raiseError(null, DB_WARNING_READ_ONLY, null,
		359	+ null, null, null, true);
		360	+ }
		361	+ if (@isset($this->_properties[$property])) {
		362	+ if (empty($this->_validator)) {
		363	+ $valid = true;
		364	+ } else {
		365	+ $valid = @call_user_func($this->_validator,
		366	+ $this->_table,
		367	+ $property,
		368	+ $newvalue,
		369	+ $this->$property,
		370	+ $this);
		371	+ }
		372	+ if ($valid) {
		373	+ $this->$property = $newvalue;
		374	+ if (empty($this->_changes[$property])) {
		375	+ $this->_changes[$property] = 0;
		376	+ } else {
		377	+ $this->_changes[$property]++;
		378	+ }
		379	+ } else {
		380	+ return $this->raiseError(null, DB_ERROR_INVALID, null,
		381	+ null, "invalid field: $property",
		382	+ null, true);
		383	+ }
		384	+ return true;
		385	+ }
		386	+ return $this->raiseError(null, DB_ERROR_NOSUCHFIELD, null,
		387	+ null, "unknown field: $property",
		388	+ null, true);
		389	+ }
		390	+
		391	+ // }}}
		392	+ // {{{ &get()
		393	+
		394	+ /**
		395	+ * Fetch an attribute value.
		396	+ *
		397	+ * @param string attribute name
		398	+ *
		399	+ * @return attribute contents, or null if the attribute name is
		400	+ * unknown
		401	+ */
		402	+ function &get($property)
		403	+ {
		404	+ // only return if $property is known
		405	+ if (isset($this->_properties[$property])) {
		406	+ return $this->$property;
		407	+ }
		408	+ $tmp = null;
		409	+ return $tmp;
		410	+ }
		411	+
		412	+ // }}}
		413	+ // {{{ _DB_storage()
		414	+
		415	+ /**
		416	+ * Destructor, calls DB_storage::store() if there are changes
		417	+ * that are to be kept.
		418	+ */
		419	+ function _DB_storage()
		420	+ {
		421	+ if (sizeof($this->_changes)) {
		422	+ $this->store();
		423	+ }
		424	+ $this->_properties = array();
		425	+ $this->_changes = array();
		426	+ $this->_table = null;
		427	+ }
		428	+
		429	+ // }}}
		430	+ // {{{ store()
		431	+
		432	+ /**
		433	+ * Stores changes to this object in the database.
		434	+ *
		435	+ * @return DB_OK or a DB error
		436	+ */
		437	+ function store()
		438	+ {
		439	+ foreach ($this->_changes as $name => $foo) {
		440	+ $params[] = &$this->$name;
		441	+ $vars[] = $name . ' = ?';
		442	+ }
		443	+ if ($vars) {
		444	+ $query = 'UPDATE ' . $this->_table . ' SET ' .
		445	+ implode(', ', $vars) . ' WHERE ' .
		446	+ $this->_makeWhere();
		447	+ $stmt = $this->_dbh->prepare($query);
		448	+ $res = $this->_dbh->execute($stmt, $params);
		449	+ if (DB::isError($res)) {
		450	+ return $res;
		451	+ }
		452	+ $this->_changes = array();
		453	+ }
		454	+ return DB_OK;
		455	+ }
		456	+
		457	+ // }}}
		458	+ // {{{ remove()
		459	+
		460	+ /**
		461	+ * Remove the row represented by this object from the database.
		462	+ *
		463	+ * @return mixed DB_OK or a DB error
		464	+ */
		465	+ function remove()
		466	+ {
		467	+ if ($this->_readonly) {
		468	+ return $this->raiseError(null, DB_WARNING_READ_ONLY, null,
		469	+ null, null, null, true);
		470	+ }
		471	+ $query = 'DELETE FROM ' . $this->_table .' WHERE '.
		472	+ $this->_makeWhere();
		473	+ $res = $this->_dbh->query($query);
		474	+ if (DB::isError($res)) {
		475	+ return $res;
		476	+ }
		477	+ foreach ($this->_properties as $prop => $foo) {
		478	+ unset($this->$prop);
		479	+ }
		480	+ $this->_properties = array();
		481	+ $this->_changes = array();
		482	+ return DB_OK;
		483	+ }
		484	+
		485	+ // }}}
		486	+}
		487	+
		488	+/*
		489	+ * Local variables:
		490	+ * tab-width: 4
		491	+ * c-basic-offset: 4
		492	+ * End:
		493	+ */
		494	+
		495	+?>

pear/DB/sybase.php 0 → 100644

View file @affd3e4

		1	+<?php
		2	+/* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
		3	+// +----------------------------------------------------------------------+
		4	+// \| PHP Version 4 \|
		5	+// +----------------------------------------------------------------------+
		6	+// \| Copyright (c) 1997-2004 The PHP Group \|
		7	+// +----------------------------------------------------------------------+
		8	+// \| This source file is subject to version 2.02 of the PHP license, \|
		9	+// \| that is bundled with this package in the file LICENSE, and is \|
		10	+// \| available at through the world-wide-web at \|
		11	+// \| http://www.php.net/license/2_02.txt. \|
		12	+// \| If you did not receive a copy of the PHP license and are unable to \|
		13	+// \| obtain it through the world-wide-web, please send a note to \|
		14	+// \| license@php.net so we can mail you a copy immediately. \|
		15	+// +----------------------------------------------------------------------+
		16	+// \| Authors: Sterling Hughes <sterling@php.net> \|
		17	+// \| Antônio Carlos Venâncio Júnior <floripa@php.net> \|
		18	+// \| Maintainer: Daniel Convissor <danielc@php.net> \|
		19	+// +----------------------------------------------------------------------+
		20	+//
		21	+// $Id$
		22	+
		23	+
		24	+// TODO
		25	+// - This driver may fail with multiple connections under the same
		26	+// user/pass/host and different databases
		27	+
		28	+
		29	+require_once 'DB/common.php';
		30	+
		31	+/**
		32	+ * Database independent query interface definition for PHP's Sybase
		33	+ * extension.
		34	+ *
		35	+ * @package DB
		36	+ * @version $Id$
		37	+ * @category Database
		38	+ * @author Sterling Hughes <sterling@php.net>
		39	+ * @author Antônio Carlos Venâncio Júnior <floripa@php.net>
		40	+ */
		41	+class DB_sybase extends DB_common
		42	+{
		43	+ // {{{ properties
		44	+
		45	+ var $connection;
		46	+ var $phptype, $dbsyntax;
		47	+ var $prepare_tokens = array();
		48	+ var $prepare_types = array();
		49	+ var $transaction_opcount = 0;
		50	+ var $autocommit = true;
		51	+
		52	+ // }}}
		53	+ // {{{ constructor
		54	+
		55	+ /**
		56	+ * DB_sybase constructor.
		57	+ *
		58	+ * @access public
		59	+ */
		60	+ function DB_sybase()
		61	+ {
		62	+ $this->DB_common();
		63	+ $this->phptype = 'sybase';
		64	+ $this->dbsyntax = 'sybase';
		65	+ $this->features = array(
		66	+ 'prepare' => false,
		67	+ 'pconnect' => true,
		68	+ 'transactions' => false,
		69	+ 'limit' => 'emulate'
		70	+ );
		71	+ $this->errorcode_map = array(
		72	+ );
		73	+ }
		74	+
		75	+ // }}}
		76	+ // {{{ connect()
		77	+
		78	+ /**
		79	+ * Connect to a database and log in as the specified user.
		80	+ *
		81	+ * @param $dsn the data source name (see DB::parseDSN for syntax)
		82	+ * @param $persistent (optional) whether the connection should
		83	+ * be persistent
		84	+ * @access public
		85	+ * @return int DB_OK on success, a DB error on failure
		86	+ */
		87	+ function connect($dsninfo, $persistent = false)
		88	+ {
		89	+ if (!DB::assertExtension('sybase') &&
		90	+ !DB::assertExtension('sybase_ct'))
		91	+ {
		92	+ return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
		93	+ }
		94	+
		95	+ $this->dsn = $dsninfo;
		96	+
		97	+ $interface = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
		98	+ $connect_function = $persistent ? 'sybase_pconnect' : 'sybase_connect';
		99	+ $dsninfo['password'] = !empty($dsninfo['password']) ? $dsninfo['password'] : false;
		100	+ $dsninfo['charset'] = isset($dsninfo['charset']) ? $dsninfo['charset'] : false;
		101	+ $dsninfo['appname'] = isset($dsninfo['appname']) ? $dsninfo['appname'] : false;
		102	+
		103	+ if ($interface && $dsninfo['username']) {
		104	+ $conn = @$connect_function($interface, $dsninfo['username'],
		105	+ $dsninfo['password'],
		106	+ $dsninfo['charset'],
		107	+ $dsninfo['appname']);
		108	+ } else {
		109	+ $conn = false;
		110	+ }
		111	+
		112	+ if (!$conn) {
		113	+ return $this->raiseError(DB_ERROR_CONNECT_FAILED);
		114	+ }
		115	+
		116	+ if ($dsninfo['database']) {
		117	+ if (!@sybase_select_db($dsninfo['database'], $conn)) {
		118	+ return $this->raiseError(DB_ERROR_NODBSELECTED, null,
		119	+ null, null, @sybase_get_last_message());
		120	+ }
		121	+ $this->_db = $dsninfo['database'];
		122	+ }
		123	+
		124	+ $this->connection = $conn;
		125	+ return DB_OK;
		126	+ }
		127	+
		128	+ // }}}
		129	+ // {{{ disconnect()
		130	+
		131	+ /**
		132	+ * Log out and disconnect from the database.
		133	+ *
		134	+ * @access public
		135	+ *
		136	+ * @return bool true on success, false if not connected.
		137	+ */
		138	+ function disconnect()
		139	+ {
		140	+ $ret = @sybase_close($this->connection);
		141	+ $this->connection = null;
		142	+ return $ret;
		143	+ }
		144	+
		145	+ // }}}
		146	+ // {{{ errorNative()
		147	+
		148	+ /**
		149	+ * Get the last server error messge (if any)
		150	+ *
		151	+ * @return string sybase last error message
		152	+ */
		153	+ function errorNative()
		154	+ {
		155	+ return @sybase_get_last_message();
		156	+ }
		157	+
		158	+ // }}}
		159	+ // {{{ errorCode()
		160	+
		161	+ /**
		162	+ * Determine PEAR::DB error code from the database's text error message.
		163	+ *
		164	+ * @param string $errormsg error message returned from the database
		165	+ * @return integer an error number from a DB error constant
		166	+ */
		167	+ function errorCode($errormsg)
		168	+ {
		169	+ static $error_regexps;
		170	+ if (!isset($error_regexps)) {
		171	+ $error_regexps = array(
		172	+ '/Incorrect syntax near/'
		173	+ => DB_ERROR_SYNTAX,
		174	+ '/^Unclosed quote before the character string [\"\'].*[\"\']\./'
		175	+ => DB_ERROR_SYNTAX,
		176	+ '/Implicit conversion from datatype [\"\'].+[\"\'] to [\"\'].+[\"\'] is not allowed\./'
		177	+ => DB_ERROR_INVALID_NUMBER,
		178	+ '/Cannot drop the table [\"\'].+[\"\'], because it doesn\'t exist in the system catalogs\./'
		179	+ => DB_ERROR_NOSUCHTABLE,
		180	+ '/Only the owner of object [\"\'].+[\"\'] or a user with System Administrator $SA$ role can run this command\./'
		181	+ => DB_ERROR_ACCESS_VIOLATION,
		182	+ '/^.+ permission denied on object .+, database .+, owner .+/'
		183	+ => DB_ERROR_ACCESS_VIOLATION,
		184	+ '/^.* permission denied, database .+, owner .+/'
		185	+ => DB_ERROR_ACCESS_VIOLATION,
		186	+ '/[^.*] not found\./'
		187	+ => DB_ERROR_NOSUCHTABLE,
		188	+ '/There is already an object named/'
		189	+ => DB_ERROR_ALREADY_EXISTS,
		190	+ '/Invalid column name/'
		191	+ => DB_ERROR_NOSUCHFIELD,
		192	+ '/does not allow null values/'
		193	+ => DB_ERROR_CONSTRAINT_NOT_NULL,
		194	+ '/Command has been aborted/'
		195	+ => DB_ERROR_CONSTRAINT,
		196	+ );
		197	+ }
		198	+
		199	+ foreach ($error_regexps as $regexp => $code) {
		200	+ if (preg_match($regexp, $errormsg)) {
		201	+ return $code;
		202	+ }
		203	+ }
		204	+ return DB_ERROR;
		205	+ }
		206	+
		207	+ // }}}
		208	+ // {{{ sybaseRaiseError()
		209	+
		210	+ /**
		211	+ * Gather information about an error, then use that info to create a
		212	+ * DB error object and finally return that object.
		213	+ *
		214	+ * @param integer $errno PEAR error number (usually a DB constant) if
		215	+ * manually raising an error
		216	+ * @return object DB error object
		217	+ * @see errorNative()
		218	+ * @see errorCode()
		219	+ * @see DB_common::raiseError()
		220	+ */
		221	+ function sybaseRaiseError($errno = null)
		222	+ {
		223	+ $native = $this->errorNative();
		224	+ if ($errno === null) {
		225	+ $errno = $this->errorCode($native);
		226	+ }
		227	+ return $this->raiseError($errno, null, null, null, $native);
		228	+ }
		229	+
		230	+ // }}}
		231	+ // {{{ simpleQuery()
		232	+
		233	+ /**
		234	+ * Send a query to Sybase and return the results as a Sybase resource
		235	+ * identifier.
		236	+ *
		237	+ * @param the SQL query
		238	+ *
		239	+ * @access public
		240	+ *
		241	+ * @return mixed returns a valid Sybase result for successful SELECT
		242	+ * queries, DB_OK for other successful queries. A DB error is
		243	+ * returned on failure.
		244	+ */
		245	+ function simpleQuery($query)
		246	+ {
		247	+ $ismanip = DB::isManip($query);
		248	+ $this->last_query = $query;
		249	+ if (!@sybase_select_db($this->_db, $this->connection)) {
		250	+ return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
		251	+ }
		252	+ $query = $this->modifyQuery($query);
		253	+ if (!$this->autocommit && $ismanip) {
		254	+ if ($this->transaction_opcount == 0) {
		255	+ $result = @sybase_query('BEGIN TRANSACTION', $this->connection);
		256	+ if (!$result) {
		257	+ return $this->sybaseRaiseError();
		258	+ }
		259	+ }
		260	+ $this->transaction_opcount++;
		261	+ }
		262	+ $result = @sybase_query($query, $this->connection);
		263	+ if (!$result) {
		264	+ return $this->sybaseRaiseError();
		265	+ }
		266	+ if (is_resource($result)) {
		267	+ $numrows = $this->numRows($result);
		268	+ if (is_object($numrows)) {
		269	+ return $numrows;
		270	+ }
		271	+ $this->num_rows[(int)$result] = $numrows;
		272	+ return $result;
		273	+ }
		274	+ // Determine which queries that should return data, and which
		275	+ // should return an error code only.
		276	+ return $ismanip ? DB_OK : $result;
		277	+ }
		278	+
		279	+ // }}}
		280	+ // {{{ nextResult()
		281	+
		282	+ /**
		283	+ * Move the internal sybase result pointer to the next available result
		284	+ *
		285	+ * @param a valid sybase result resource
		286	+ *
		287	+ * @access public
		288	+ *
		289	+ * @return true if a result is available otherwise return false
		290	+ */
		291	+ function nextResult($result)
		292	+ {
		293	+ return false;
		294	+ }
		295	+
		296	+ // }}}
		297	+ // {{{ fetchInto()
		298	+
		299	+ /**
		300	+ * Fetch a row and insert the data into an existing array.
		301	+ *
		302	+ * Formating of the array and the data therein are configurable.
		303	+ * See DB_result::fetchInto() for more information.
		304	+ *
		305	+ * @param resource $result query result identifier
		306	+ * @param array $arr (reference) array where data from the row
		307	+ * should be placed
		308	+ * @param int $fetchmode how the resulting array should be indexed
		309	+ * @param int $rownum the row number to fetch
		310	+ *
		311	+ * @return mixed DB_OK on success, null when end of result set is
		312	+ * reached or on failure
		313	+ *
		314	+ * @see DB_result::fetchInto()
		315	+ * @access private
		316	+ */
		317	+ function fetchInto($result, &$arr, $fetchmode, $rownum=null)
		318	+ {
		319	+ if ($rownum !== null) {
		320	+ if (!@sybase_data_seek($result, $rownum)) {
		321	+ return null;
		322	+ }
		323	+ }
		324	+ if ($fetchmode & DB_FETCHMODE_ASSOC) {
		325	+ if (function_exists('sybase_fetch_assoc')) {
		326	+ $arr = @sybase_fetch_assoc($result);
		327	+ } else {
		328	+ if ($arr = @sybase_fetch_array($result)) {
		329	+ foreach ($arr as $key => $value) {
		330	+ if (is_int($key)) {
		331	+ unset($arr[$key]);
		332	+ }
		333	+ }
		334	+ }
		335	+ }
		336	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
		337	+ $arr = array_change_key_case($arr, CASE_LOWER);
		338	+ }
		339	+ } else {
		340	+ $arr = @sybase_fetch_row($result);
		341	+ }
		342	+ if (!$arr) {
		343	+ // reported not work as seems that sybase_get_last_message()
		344	+ // always return a message here
		345	+ //if ($errmsg = @sybase_get_last_message()) {
		346	+ // return $this->sybaseRaiseError($errmsg);
		347	+ //} else {
		348	+ return null;
		349	+ //}
		350	+ }
		351	+ if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
		352	+ $this->_rtrimArrayValues($arr);
		353	+ }
		354	+ if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
		355	+ $this->_convertNullArrayValuesToEmpty($arr);
		356	+ }
		357	+ return DB_OK;
		358	+ }
		359	+
		360	+ // }}}
		361	+ // {{{ freeResult()
		362	+
		363	+ /**
		364	+ * Free the internal resources associated with $result.
		365	+ *
		366	+ * @param $result Sybase result identifier
		367	+ *
		368	+ * @access public
		369	+ *
		370	+ * @return bool true on success, false if $result is invalid
		371	+ */
		372	+ function freeResult($result)
		373	+ {
		374	+ unset($this->num_rows[(int)$result]);
		375	+ return @sybase_free_result($result);
		376	+ }
		377	+
		378	+ // }}}
		379	+ // {{{ numCols()
		380	+
		381	+ /**
		382	+ * Get the number of columns in a result set.
		383	+ *
		384	+ * @param $result Sybase result identifier
		385	+ *
		386	+ * @access public
		387	+ *
		388	+ * @return int the number of columns per row in $result
		389	+ */
		390	+ function numCols($result)
		391	+ {
		392	+ $cols = @sybase_num_fields($result);
		393	+ if (!$cols) {
		394	+ return $this->sybaseRaiseError();
		395	+ }
		396	+ return $cols;
		397	+ }
		398	+
		399	+ // }}}
		400	+ // {{{ numRows()
		401	+
		402	+ /**
		403	+ * Get the number of rows in a result set.
		404	+ *
		405	+ * @param $result Sybase result identifier
		406	+ *
		407	+ * @access public
		408	+ *
		409	+ * @return int the number of rows in $result
		410	+ */
		411	+ function numRows($result)
		412	+ {
		413	+ $rows = @sybase_num_rows($result);
		414	+ if ($rows === false) {
		415	+ return $this->sybaseRaiseError();
		416	+ }
		417	+ return $rows;
		418	+ }
		419	+
		420	+ // }}}
		421	+ // {{{ affectedRows()
		422	+
		423	+ /**
		424	+ * Gets the number of rows affected by the data manipulation
		425	+ * query. For other queries, this function returns 0.
		426	+ *
		427	+ * @return number of rows affected by the last query
		428	+ */
		429	+ function affectedRows()
		430	+ {
		431	+ if (DB::isManip($this->last_query)) {
		432	+ $result = @sybase_affected_rows($this->connection);
		433	+ } else {
		434	+ $result = 0;
		435	+ }
		436	+ return $result;
		437	+ }
		438	+
		439	+ // }}}
		440	+ // {{{ nextId()
		441	+
		442	+ /**
		443	+ * Returns the next free id in a sequence
		444	+ *
		445	+ * @param string $seq_name name of the sequence
		446	+ * @param boolean $ondemand when true, the seqence is automatically
		447	+ * created if it does not exist
		448	+ *
		449	+ * @return int the next id number in the sequence. DB_Error if problem.
		450	+ *
		451	+ * @internal
		452	+ * @see DB_common::nextID()
		453	+ * @access public
		454	+ */
		455	+ function nextId($seq_name, $ondemand = true)
		456	+ {
		457	+ $seqname = $this->getSequenceName($seq_name);
		458	+ if (!@sybase_select_db($this->_db, $this->connection)) {
		459	+ return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
		460	+ }
		461	+ $repeat = 0;
		462	+ do {
		463	+ $this->pushErrorHandling(PEAR_ERROR_RETURN);
		464	+ $result = $this->query("INSERT INTO $seqname (vapor) VALUES (0)");
		465	+ $this->popErrorHandling();
		466	+ if ($ondemand && DB::isError($result) &&
		467	+ ($result->getCode() == DB_ERROR \|\| $result->getCode() == DB_ERROR_NOSUCHTABLE))
		468	+ {
		469	+ $repeat = 1;
		470	+ $result = $this->createSequence($seq_name);
		471	+ if (DB::isError($result)) {
		472	+ return $this->raiseError($result);
		473	+ }
		474	+ } elseif (!DB::isError($result)) {
		475	+ $result =& $this->query("SELECT @@IDENTITY FROM $seqname");
		476	+ $repeat = 0;
		477	+ } else {
		478	+ $repeat = false;
		479	+ }
		480	+ } while ($repeat);
		481	+ if (DB::isError($result)) {
		482	+ return $this->raiseError($result);
		483	+ }
		484	+ $result = $result->fetchRow(DB_FETCHMODE_ORDERED);
		485	+ return $result[0];
		486	+ }
		487	+
		488	+ /**
		489	+ * Creates a new sequence
		490	+ *
		491	+ * @param string $seq_name name of the new sequence
		492	+ *
		493	+ * @return int DB_OK on success. A DB_Error object is returned if
		494	+ * problems arise.
		495	+ *
		496	+ * @internal
		497	+ * @see DB_common::createSequence()
		498	+ * @access public
		499	+ */
		500	+ function createSequence($seq_name)
		501	+ {
		502	+ $seqname = $this->getSequenceName($seq_name);
		503	+ return $this->query("CREATE TABLE $seqname ".
		504	+ '(id numeric(10,0) IDENTITY NOT NULL ,' .
		505	+ 'vapor int NULL)');
		506	+ }
		507	+
		508	+ // }}}
		509	+ // {{{ dropSequence()
		510	+
		511	+ /**
		512	+ * Deletes a sequence
		513	+ *
		514	+ * @param string $seq_name name of the sequence to be deleted
		515	+ *
		516	+ * @return int DB_OK on success. DB_Error if problems.
		517	+ *
		518	+ * @internal
		519	+ * @see DB_common::dropSequence()
		520	+ * @access public
		521	+ */
		522	+ function dropSequence($seq_name)
		523	+ {
		524	+ $seqname = $this->getSequenceName($seq_name);
		525	+ return $this->query("DROP TABLE $seqname");
		526	+ }
		527	+
		528	+ // }}}
		529	+ // {{{ getSpecialQuery()
		530	+
		531	+ /**
		532	+ * Returns the query needed to get some backend info
		533	+ * @param string $type What kind of info you want to retrieve
		534	+ * @return string The SQL query string
		535	+ */
		536	+ function getSpecialQuery($type)
		537	+ {
		538	+ switch ($type) {
		539	+ case 'tables':
		540	+ return "select name from sysobjects where type = 'U' order by name";
		541	+ case 'views':
		542	+ return "select name from sysobjects where type = 'V'";
		543	+ default:
		544	+ return null;
		545	+ }
		546	+ }
		547	+
		548	+ // }}}
		549	+ // {{{ autoCommit()
		550	+
		551	+ /**
		552	+ * Enable/disable automatic commits
		553	+ */
		554	+ function autoCommit($onoff = false)
		555	+ {
		556	+ // XXX if $this->transaction_opcount > 0, we should probably
		557	+ // issue a warning here.
		558	+ $this->autocommit = $onoff ? true : false;
		559	+ return DB_OK;
		560	+ }
		561	+
		562	+ // }}}
		563	+ // {{{ commit()
		564	+
		565	+ /**
		566	+ * Commit the current transaction.
		567	+ */
		568	+ function commit()
		569	+ {
		570	+ if ($this->transaction_opcount > 0) {
		571	+ if (!@sybase_select_db($this->_db, $this->connection)) {
		572	+ return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
		573	+ }
		574	+ $result = @sybase_query('COMMIT', $this->connection);
		575	+ $this->transaction_opcount = 0;
		576	+ if (!$result) {
		577	+ return $this->sybaseRaiseError();
		578	+ }
		579	+ }
		580	+ return DB_OK;
		581	+ }
		582	+
		583	+ // }}}
		584	+ // {{{ rollback()
		585	+
		586	+ /**
		587	+ * Roll back (undo) the current transaction.
		588	+ */
		589	+ function rollback()
		590	+ {
		591	+ if ($this->transaction_opcount > 0) {
		592	+ if (!@sybase_select_db($this->_db, $this->connection)) {
		593	+ return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
		594	+ }
		595	+ $result = @sybase_query('ROLLBACK', $this->connection);
		596	+ $this->transaction_opcount = 0;
		597	+ if (!$result) {
		598	+ return $this->sybaseRaiseError();
		599	+ }
		600	+ }
		601	+ return DB_OK;
		602	+ }
		603	+
		604	+ // }}}
		605	+ // {{{ tableInfo()
		606	+
		607	+ /**
		608	+ * Returns information about a table or a result set.
		609	+ *
		610	+ * NOTE: only supports 'table' and 'flags' if <var>$result</var>
		611	+ * is a table name.
		612	+ *
		613	+ * @param object\|string $result DB_result object from a query or a
		614	+ * string containing the name of a table
		615	+ * @param int $mode a valid tableInfo mode
		616	+ * @return array an associative array with the information requested
		617	+ * or an error object if something is wrong
		618	+ * @access public
		619	+ * @internal
		620	+ * @since 1.6.0
		621	+ * @see DB_common::tableInfo()
		622	+ */
		623	+ function tableInfo($result, $mode = null)
		624	+ {
		625	+ if (isset($result->result)) {
		626	+ /*
		627	+ * Probably received a result object.
		628	+ * Extract the result resource identifier.
		629	+ */
		630	+ $id = $result->result;
		631	+ $got_string = false;
		632	+ } elseif (is_string($result)) {
		633	+ /*
		634	+ * Probably received a table name.
		635	+ * Create a result resource identifier.
		636	+ */
		637	+ if (!@sybase_select_db($this->_db, $this->connection)) {
		638	+ return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
		639	+ }
		640	+ $id = @sybase_query("SELECT * FROM $result WHERE 1=0",
		641	+ $this->connection);
		642	+ $got_string = true;
		643	+ } else {
		644	+ /*
		645	+ * Probably received a result resource identifier.
		646	+ * Copy it.
		647	+ * Deprecated. Here for compatibility only.
		648	+ */
		649	+ $id = $result;
		650	+ $got_string = false;
		651	+ }
		652	+
		653	+ if (!is_resource($id)) {
		654	+ return $this->sybaseRaiseError(DB_ERROR_NEED_MORE_DATA);
		655	+ }
		656	+
		657	+ if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
		658	+ $case_func = 'strtolower';
		659	+ } else {
		660	+ $case_func = 'strval';
		661	+ }
		662	+
		663	+ $count = @sybase_num_fields($id);
		664	+
		665	+ // made this IF due to performance (one if is faster than $count if's)
		666	+ if (!$mode) {
		667	+
		668	+ for ($i=0; $i<$count; $i++) {
		669	+ $f = @sybase_fetch_field($id, $i);
		670	+
		671	+ // column_source is often blank
		672	+ if ($got_string) {
		673	+ $res[$i]['table'] = $case_func($result);
		674	+ } else {
		675	+ $res[$i]['table'] = $case_func($f->column_source);
		676	+ }
		677	+ $res[$i]['name'] = $case_func($f->name);
		678	+ $res[$i]['type'] = $f->type;
		679	+ $res[$i]['len'] = $f->max_length;
		680	+ if ($res[$i]['table']) {
		681	+ $res[$i]['flags'] = $this->_sybase_field_flags(
		682	+ $res[$i]['table'], $res[$i]['name']);
		683	+ } else {
		684	+ $res[$i]['flags'] = '';
		685	+ }
		686	+ }
		687	+
		688	+ } else {
		689	+ // get full info
		690	+
		691	+ $res['num_fields'] = $count;
		692	+
		693	+ for ($i=0; $i<$count; $i++) {
		694	+ $f = @sybase_fetch_field($id, $i);
		695	+
		696	+ // column_source is often blank
		697	+ if ($got_string) {
		698	+ $res[$i]['table'] = $case_func($result);
		699	+ } else {
		700	+ $res[$i]['table'] = $case_func($f->column_source);
		701	+ }
		702	+ $res[$i]['name'] = $case_func($f->name);
		703	+ $res[$i]['type'] = $f->type;
		704	+ $res[$i]['len'] = $f->max_length;
		705	+ if ($res[$i]['table']) {
		706	+ $res[$i]['flags'] = $this->_sybase_field_flags(
		707	+ $res[$i]['table'], $res[$i]['name']);
		708	+ } else {
		709	+ $res[$i]['flags'] = '';
		710	+ }
		711	+
		712	+ if ($mode & DB_TABLEINFO_ORDER) {
		713	+ $res['order'][$res[$i]['name']] = $i;
		714	+ }
		715	+ if ($mode & DB_TABLEINFO_ORDERTABLE) {
		716	+ $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
		717	+ }
		718	+ }
		719	+ }
		720	+
		721	+ // free the result only if we were called on a table
		722	+ if ($got_string) {
		723	+ @sybase_free_result($id);
		724	+ }
		725	+ return $res;
		726	+ }
		727	+
		728	+ // }}}
		729	+ // {{{ _sybase_field_flags()
		730	+
		731	+ /**
		732	+ * Get the flags for a field.
		733	+ *
		734	+ * Currently supports:
		735	+ * + <samp>unique_key</samp> (unique index, unique check or primary_key)
		736	+ * + <samp>multiple_key</samp> (multi-key index)
		737	+ *
		738	+ * @param string $table table name
		739	+ * @param string $column field name
		740	+ * @return string space delimited string of flags. Empty string if none.
		741	+ * @access private
		742	+ */
		743	+ function _sybase_field_flags($table, $column)
		744	+ {
		745	+ static $tableName = null;
		746	+ static $flags = array();
		747	+
		748	+ if ($table != $tableName) {
		749	+ $flags = array();
		750	+ $tableName = $table;
		751	+
		752	+ // get unique/primary keys
		753	+ $res = $this->getAll("sp_helpindex $table", DB_FETCHMODE_ASSOC);
		754	+
		755	+ if (!isset($res[0]['index_description'])) {
		756	+ return '';
		757	+ }
		758	+
		759	+ foreach ($res as $val) {
		760	+ $keys = explode(', ', trim($val['index_keys']));
		761	+
		762	+ if (sizeof($keys) > 1) {
		763	+ foreach ($keys as $key) {
		764	+ $this->_add_flag($flags[$key], 'multiple_key');
		765	+ }
		766	+ }
		767	+
		768	+ if (strpos($val['index_description'], 'unique')) {
		769	+ foreach ($keys as $key) {
		770	+ $this->_add_flag($flags[$key], 'unique_key');
		771	+ }
		772	+ }
		773	+ }
		774	+
		775	+ }
		776	+
		777	+ if (array_key_exists($column, $flags)) {
		778	+ return(implode(' ', $flags[$column]));
		779	+ }
		780	+
		781	+ return '';
		782	+ }
		783	+
		784	+ // }}}
		785	+ // {{{ _add_flag()
		786	+
		787	+ /**
		788	+ * Adds a string to the flags array if the flag is not yet in there
		789	+ * - if there is no flag present the array is created.
		790	+ *
		791	+ * @param array $array reference of flags array to add a value to
		792	+ * @param mixed $value value to add to the flag array
		793	+ * @access private
		794	+ */
		795	+ function _add_flag(&$array, $value)
		796	+ {
		797	+ if (!is_array($array)) {
		798	+ $array = array($value);
		799	+ } elseif (!in_array($value, $array)) {
		800	+ array_push($array, $value);
		801	+ }
		802	+ }
		803	+
		804	+ // }}}
		805	+ // {{{ quoteIdentifier()
		806	+
		807	+ /**
		808	+ * Quote a string so it can be safely used as a table / column name
		809	+ *
		810	+ * Quoting style depends on which database driver is being used.
		811	+ *
		812	+ * @param string $str identifier name to be quoted
		813	+ *
		814	+ * @return string quoted identifier string
		815	+ *
		816	+ * @since 1.6.0
		817	+ * @access public
		818	+ */
		819	+ function quoteIdentifier($str)
		820	+ {
		821	+ return '[' . str_replace(']', ']]', $str) . ']';
		822	+ }
		823	+
		824	+ // }}}
		825	+
		826	+}
		827	+
		828	+/*
		829	+ * Local variables:
		830	+ * tab-width: 4
		831	+ * c-basic-offset: 4
		832	+ * End:
		833	+ */
		834	+
		835	+?>