githubFork/roundcubemail.git

alecpl

2008-04-29 6ee5ed253b92593ac5784300ac425f34f7fd1728

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