Context Navigation

Extended.php @ 20764

Visit:

Revision 20764, 25.7 KB checked in by nanasess, 13 years ago (diff)
#601 (コピーライトの更新)
Property svn:eol-style set to `LF` Property svn:mime-type set to `text/x-httpd-php; charset=UTF-8`

Line
1	<?php
2	// +----------------------------------------------------------------------+
3	// \| PHP versions 4 and 5 \|
4	// +----------------------------------------------------------------------+
5	// \| Copyright (c) 1998-2006 Manuel Lemos, Tomas V.V.Cox, \|
6	// \| Stig. S. Bakken, Lukas Smith \|
7	// \| All rights reserved. \|
8	// +----------------------------------------------------------------------+
9	// \| MDB2 is a merge of PEAR DB and Metabases that provides a unified DB \|
10	// \| API as well as database abstraction for PHP applications. \|
11	// \| This LICENSE is in the BSD license style. \|
12	// \| \|
13	// \| Redistribution and use in source and binary forms, with or without \|
14	// \| modification, are permitted provided that the following conditions \|
15	// \| are met: \|
16	// \| \|
17	// \| Redistributions of source code must retain the above copyright \|
18	// \| notice, this list of conditions and the following disclaimer. \|
19	// \| \|
20	// \| Redistributions in binary form must reproduce the above copyright \|
21	// \| notice, this list of conditions and the following disclaimer in the \|
22	// \| documentation and/or other materials provided with the distribution. \|
23	// \| \|
24	// \| Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken, \|
25	// \| Lukas Smith nor the names of his contributors may be used to endorse \|
26	// \| or promote products derived from this software without specific prior\|
27	// \| written permission. \|
28	// \| \|
29	// \| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \|
30	// \| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \|
31	// \| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS \|
32	// \| FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE \|
33	// \| REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, \|
34	// \| INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, \|
35	// \| BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS\|
36	// \| OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED \|
37	// \| AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT \|
38	// \| LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY\|
39	// \| WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \|
40	// \| POSSIBILITY OF SUCH DAMAGE. \|
41	// +----------------------------------------------------------------------+
42	// \| Author: Lukas Smith <smith@pooteeweet.org> \|
43	// +----------------------------------------------------------------------+
44	//
45	// $Id: Extended.php,v 1.60 2007/11/28 19:49:34 quipo Exp $
46
47	/**
48	* @package MDB2
49	* @category Database
50	* @author Lukas Smith <smith@pooteeweet.org>
51	*/
52
53	/**
54	* Used by autoPrepare()
55	*/
56	define('MDB2_AUTOQUERY_INSERT', 1);
57	define('MDB2_AUTOQUERY_UPDATE', 2);
58	define('MDB2_AUTOQUERY_DELETE', 3);
59	define('MDB2_AUTOQUERY_SELECT', 4);
60
61	/**
62	* MDB2_Extended: class which adds several high level methods to MDB2
63	*
64	* @package MDB2
65	* @category Database
66	* @author Lukas Smith <smith@pooteeweet.org>
67	*/
68	class MDB2_Extended extends MDB2_Module_Common
69	{
70	// {{{ autoPrepare()
71
72	/**
73	* Generate an insert, update or delete query and call prepare() on it
74	*
75	* @param string table
76	* @param array the fields names
77	* @param int type of query to build
78	* MDB2_AUTOQUERY_INSERT
79	* MDB2_AUTOQUERY_UPDATE
80	* MDB2_AUTOQUERY_DELETE
81	* MDB2_AUTOQUERY_SELECT
82	* @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
83	* @param array that contains the types of the placeholders
84	* @param mixed array that contains the types of the columns in
85	* the result set or MDB2_PREPARE_RESULT, if set to
86	* MDB2_PREPARE_MANIP the query is handled as a manipulation query
87	*
88	* @return resource handle for the query
89	* @see buildManipSQL
90	* @access public
91	*/
92	function autoPrepare($table, $table_fields, $mode = MDB2_AUTOQUERY_INSERT,
93	$where = false, $types = null, $result_types = MDB2_PREPARE_MANIP)
94	{
95	$query = $this->buildManipSQL($table, $table_fields, $mode, $where);
96	if (PEAR::isError($query)) {
97	return $query;
98	}
99	$db =& $this->getDBInstance();
100	if (PEAR::isError($db)) {
101	return $db;
102	}
103	$lobs = array();
104	foreach ((array)$types as $param => $type) {
105	if (($type == 'clob') \|\| ($type == 'blob')) {
106	$lobs[$param] = $table_fields[$param];
107	}
108	}
109	return $db->prepare($query, $types, $result_types, $lobs);
110	}
111
112	// }}}
113	// {{{ autoExecute()
114
115	/**
116	* Generate an insert, update or delete query and call prepare() and execute() on it
117	*
118	* @param string name of the table
119	* @param array assoc ($key=>$value) where $key is a field name and $value its value
120	* @param int type of query to build
121	* MDB2_AUTOQUERY_INSERT
122	* MDB2_AUTOQUERY_UPDATE
123	* MDB2_AUTOQUERY_DELETE
124	* MDB2_AUTOQUERY_SELECT
125	* @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
126	* @param array that contains the types of the placeholders
127	* @param string which specifies which result class to use
128	* @param mixed array that contains the types of the columns in
129	* the result set or MDB2_PREPARE_RESULT, if set to
130	* MDB2_PREPARE_MANIP the query is handled as a manipulation query
131	*
132	* @return bool\|MDB2_Error true on success, a MDB2 error on failure
133	* @see buildManipSQL
134	* @see autoPrepare
135	* @access public
136	*/
137	function &autoExecute($table, $fields_values, $mode = MDB2_AUTOQUERY_INSERT,
138	$where = false, $types = null, $result_class = true, $result_types = MDB2_PREPARE_MANIP)
139	{
140	$fields_values = (array)$fields_values;
141	if ($mode == MDB2_AUTOQUERY_SELECT) {
142	if (is_array($result_types)) {
143	$keys = array_keys($result_types);
144	} elseif (!empty($fields_values)) {
145	$keys = $fields_values;
146	} else {
147	$keys = array();
148	}
149	} else {
150	$keys = array_keys($fields_values);
151	}
152	$params = array_values($fields_values);
153	if (empty($params)) {
154	$query = $this->buildManipSQL($table, $keys, $mode, $where);
155
156	$db =& $this->getDBInstance();
157	if (PEAR::isError($db)) {
158	return $db;
159	}
160	if ($mode == MDB2_AUTOQUERY_SELECT) {
161	$result =& $db->query($query, $result_types, $result_class);
162	} else {
163	$result = $db->exec($query);
164	}
165	} else {
166	$stmt = $this->autoPrepare($table, $keys, $mode, $where, $types, $result_types);
167	if (PEAR::isError($stmt)) {
168	return $stmt;
169	}
170	$result =& $stmt->execute($params, $result_class);
171	$stmt->free();
172	}
173	return $result;
174	}
175
176	// }}}
177	// {{{ buildManipSQL()
178
179	/**
180	* Make automaticaly an sql query for prepare()
181	*
182	* Example : buildManipSQL('table_sql', array('field1', 'field2', 'field3'), MDB2_AUTOQUERY_INSERT)
183	* will return the string : INSERT INTO table_sql (field1,field2,field3) VALUES (?,?,?)
184	* NB : - This belongs more to a SQL Builder class, but this is a simple facility
185	* - Be carefull ! If you don't give a $where param with an UPDATE/DELETE query, all
186	* the records of the table will be updated/deleted !
187	*
188	* @param string name of the table
189	* @param ordered array containing the fields names
190	* @param int type of query to build
191	* MDB2_AUTOQUERY_INSERT
192	* MDB2_AUTOQUERY_UPDATE
193	* MDB2_AUTOQUERY_DELETE
194	* MDB2_AUTOQUERY_SELECT
195	* @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
196	*
197	* @return string sql query for prepare()
198	* @access public
199	*/
200	function buildManipSQL($table, $table_fields, $mode, $where = false)
201	{
202	$db =& $this->getDBInstance();
203	if (PEAR::isError($db)) {
204	return $db;
205	}
206
207	if ($db->options['quote_identifier']) {
208	$table = $db->quoteIdentifier($table);
209	}
210
211	if (!empty($table_fields) && $db->options['quote_identifier']) {
212	foreach ($table_fields as $key => $field) {
213	$table_fields[$key] = $db->quoteIdentifier($field);
214	}
215	}
216
217	if ($where !== false && !is_null($where)) {
218	if (is_array($where)) {
219	$where = implode(' AND ', $where);
220	}
221	$where = ' WHERE '.$where;
222	}
223
224	switch ($mode) {
225	case MDB2_AUTOQUERY_INSERT:
226	if (empty($table_fields)) {
227	return $db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
228	'Insert requires table fields', __FUNCTION__);
229	}
230	$cols = implode(', ', $table_fields);
231	$values = '?'.str_repeat(', ?', (count($table_fields) - 1));
232	return 'INSERT INTO '.$table.' ('.$cols.') VALUES ('.$values.')';
233	break;
234	case MDB2_AUTOQUERY_UPDATE:
235	if (empty($table_fields)) {
236	return $db->raiseError(MDB2_ERROR_NEED_MORE_DATA, null, null,
237	'Update requires table fields', __FUNCTION__);
238	}
239	$set = implode(' = ?, ', $table_fields).' = ?';
240	$sql = 'UPDATE '.$table.' SET '.$set.$where;
241	return $sql;
242	break;
243	case MDB2_AUTOQUERY_DELETE:
244	$sql = 'DELETE FROM '.$table.$where;
245	return $sql;
246	break;
247	case MDB2_AUTOQUERY_SELECT:
248	$cols = !empty($table_fields) ? implode(', ', $table_fields) : '*';
249	$sql = 'SELECT '.$cols.' FROM '.$table.$where;
250	return $sql;
251	break;
252	}
253	return $db->raiseError(MDB2_ERROR_SYNTAX, null, null,
254	'Non existant mode', __FUNCTION__);
255	}
256
257	// }}}
258	// {{{ limitQuery()
259
260	/**
261	* Generates a limited query
262	*
263	* @param string query
264	* @param array that contains the types of the columns in the result set
265	* @param integer the numbers of rows to fetch
266	* @param integer the row to start to fetching
267	* @param string which specifies which result class to use
268	* @param mixed string which specifies which class to wrap results in
269	*
270	* @return MDB2_Result\|MDB2_Error result set on success, a MDB2 error on failure
271	* @access public
272	*/
273	function &limitQuery($query, $types, $limit, $offset = 0, $result_class = true,
274	$result_wrap_class = false)
275	{
276	$db =& $this->getDBInstance();
277	if (PEAR::isError($db)) {
278	return $db;
279	}
280
281	$result = $db->setLimit($limit, $offset);
282	if (PEAR::isError($result)) {
283	return $result;
284	}
285	$result =& $db->query($query, $types, $result_class, $result_wrap_class);
286	return $result;
287	}
288
289	// }}}
290	// {{{ execParam()
291
292	/**
293	* Execute a parameterized DML statement.
294	*
295	* @param string the SQL query
296	* @param array if supplied, prepare/execute will be used
297	* with this array as execute parameters
298	* @param array that contains the types of the values defined in $params
299	*
300	* @return int\|MDB2_Error affected rows on success, a MDB2 error on failure
301	* @access public
302	*/
303	function execParam($query, $params = array(), $param_types = null)
304	{
305	$db =& $this->getDBInstance();
306	if (PEAR::isError($db)) {
307	return $db;
308	}
309
310	settype($params, 'array');
311	if (empty($params)) {
312	return $db->exec($query);
313	}
314
315	$stmt = $db->prepare($query, $param_types, MDB2_PREPARE_MANIP);
316	if (PEAR::isError($stmt)) {
317	return $stmt;
318	}
319
320	$result = $stmt->execute($params);
321	if (PEAR::isError($result)) {
322	return $result;
323	}
324
325	$stmt->free();
326	return $result;
327	}
328
329	// }}}
330	// {{{ getOne()
331
332	/**
333	* Fetch the first column of the first row of data returned from a query.
334	* Takes care of doing the query and freeing the results when finished.
335	*
336	* @param string the SQL query
337	* @param string that contains the type of the column in the result set
338	* @param array if supplied, prepare/execute will be used
339	* with this array as execute parameters
340	* @param array that contains the types of the values defined in $params
341	* @param int\|string which column to return
342	*
343	* @return scalar\|MDB2_Error data on success, a MDB2 error on failure
344	* @access public
345	*/
346	function getOne($query, $type = null, $params = array(),
347	$param_types = null, $colnum = 0)
348	{
349	$db =& $this->getDBInstance();
350	if (PEAR::isError($db)) {
351	return $db;
352	}
353
354	settype($params, 'array');
355	settype($type, 'array');
356	if (empty($params)) {
357	return $db->queryOne($query, $type, $colnum);
358	}
359
360	$stmt = $db->prepare($query, $param_types, $type);
361	if (PEAR::isError($stmt)) {
362	return $stmt;
363	}
364
365	$result = $stmt->execute($params);
366	if (!MDB2::isResultCommon($result)) {
367	return $result;
368	}
369
370	$one = $result->fetchOne($colnum);
371	$stmt->free();
372	$result->free();
373	return $one;
374	}
375
376	// }}}
377	// {{{ getRow()
378
379	/**
380	* Fetch the first row of data returned from a query. Takes care
381	* of doing the query and freeing the results when finished.
382	*
383	* @param string the SQL query
384	* @param array that contains the types of the columns in the result set
385	* @param array if supplied, prepare/execute will be used
386	* with this array as execute parameters
387	* @param array that contains the types of the values defined in $params
388	* @param int the fetch mode to use
389	*
390	* @return array\|MDB2_Error data on success, a MDB2 error on failure
391	* @access public
392	*/
393	function getRow($query, $types = null, $params = array(),
394	$param_types = null, $fetchmode = MDB2_FETCHMODE_DEFAULT)
395	{
396	$db =& $this->getDBInstance();
397	if (PEAR::isError($db)) {
398	return $db;
399	}
400
401	settype($params, 'array');
402	if (empty($params)) {
403	return $db->queryRow($query, $types, $fetchmode);
404	}
405
406	$stmt = $db->prepare($query, $param_types, $types);
407	if (PEAR::isError($stmt)) {
408	return $stmt;
409	}
410
411	$result = $stmt->execute($params);
412	if (!MDB2::isResultCommon($result)) {
413	return $result;
414	}
415
416	$row = $result->fetchRow($fetchmode);
417	$stmt->free();
418	$result->free();
419	return $row;
420	}
421
422	// }}}
423	// {{{ getCol()
424
425	/**
426	* Fetch a single column from a result set and return it as an
427	* indexed array.
428	*
429	* @param string the SQL query
430	* @param string that contains the type of the column in the result set
431	* @param array if supplied, prepare/execute will be used
432	* with this array as execute parameters
433	* @param array that contains the types of the values defined in $params
434	* @param int\|string which column to return
435	*
436	* @return array\|MDB2_Error data on success, a MDB2 error on failure
437	* @access public
438	*/
439	function getCol($query, $type = null, $params = array(),
440	$param_types = null, $colnum = 0)
441	{
442	$db =& $this->getDBInstance();
443	if (PEAR::isError($db)) {
444	return $db;
445	}
446
447	settype($params, 'array');
448	settype($type, 'array');
449	if (empty($params)) {
450	return $db->queryCol($query, $type, $colnum);
451	}
452
453	$stmt = $db->prepare($query, $param_types, $type);
454	if (PEAR::isError($stmt)) {
455	return $stmt;
456	}
457
458	$result = $stmt->execute($params);
459	if (!MDB2::isResultCommon($result)) {
460	return $result;
461	}
462
463	$col = $result->fetchCol($colnum);
464	$stmt->free();
465	$result->free();
466	return $col;
467	}
468
469	// }}}
470	// {{{ getAll()
471
472	/**
473	* Fetch all the rows returned from a query.
474	*
475	* @param string the SQL query
476	* @param array that contains the types of the columns in the result set
477	* @param array if supplied, prepare/execute will be used
478	* with this array as execute parameters
479	* @param array that contains the types of the values defined in $params
480	* @param int the fetch mode to use
481	* @param bool if set to true, the $all will have the first
482	* column as its first dimension
483	* @param bool $force_array used only when the query returns exactly
484	* two columns. If true, the values of the returned array will be
485	* one-element arrays instead of scalars.
486	* @param bool $group if true, the values of the returned array is
487	* wrapped in another array. If the same key value (in the first
488	* column) repeats itself, the values will be appended to this array
489	* instead of overwriting the existing values.
490	*
491	* @return array\|MDB2_Error data on success, a MDB2 error on failure
492	* @access public
493	*/
494	function getAll($query, $types = null, $params = array(),
495	$param_types = null, $fetchmode = MDB2_FETCHMODE_DEFAULT,
496	$rekey = false, $force_array = false, $group = false)
497	{
498	$db =& $this->getDBInstance();
499	if (PEAR::isError($db)) {
500	return $db;
501	}
502
503	settype($params, 'array');
504	if (empty($params)) {
505	return $db->queryAll($query, $types, $fetchmode, $rekey, $force_array, $group);
506	}
507
508	$stmt = $db->prepare($query, $param_types, $types);
509	if (PEAR::isError($stmt)) {
510	return $stmt;
511	}
512
513	$result = $stmt->execute($params);
514	if (!MDB2::isResultCommon($result)) {
515	return $result;
516	}
517
518	$all = $result->fetchAll($fetchmode, $rekey, $force_array, $group);
519	$stmt->free();
520	$result->free();
521	return $all;
522	}
523
524	// }}}
525	// {{{ getAssoc()
526
527	/**
528	* Fetch the entire result set of a query and return it as an
529	* associative array using the first column as the key.
530	*
531	* If the result set contains more than two columns, the value
532	* will be an array of the values from column 2-n. If the result
533	* set contains only two columns, the returned value will be a
534	* scalar with the value of the second column (unless forced to an
535	* array with the $force_array parameter). A MDB2 error code is
536	* returned on errors. If the result set contains fewer than two
537	* columns, a MDB2_ERROR_TRUNCATED error is returned.
538	*
539	* For example, if the table 'mytable' contains:
540	* <pre>
541	* ID TEXT DATE
542	* --------------------------------
543	* 1 'one' 944679408
544	* 2 'two' 944679408
545	* 3 'three' 944679408
546	* </pre>
547	* Then the call getAssoc('SELECT id,text FROM mytable') returns:
548	* <pre>
549	* array(
550	* '1' => 'one',
551	* '2' => 'two',
552	* '3' => 'three',
553	* )
554	* </pre>
555	* ...while the call getAssoc('SELECT id,text,date FROM mytable') returns:
556	* <pre>
557	* array(
558	* '1' => array('one', '944679408'),
559	* '2' => array('two', '944679408'),
560	* '3' => array('three', '944679408')
561	* )
562	* </pre>
563	*
564	* If the more than one row occurs with the same value in the
565	* first column, the last row overwrites all previous ones by
566	* default. Use the $group parameter if you don't want to
567	* overwrite like this. Example:
568	* <pre>
569	* getAssoc('SELECT category,id,name FROM mytable', null, null
570	* MDB2_FETCHMODE_ASSOC, false, true) returns:
571	* array(
572	* '1' => array(array('id' => '4', 'name' => 'number four'),
573	* array('id' => '6', 'name' => 'number six')
574	* ),
575	* '9' => array(array('id' => '4', 'name' => 'number four'),
576	* array('id' => '6', 'name' => 'number six')
577	* )
578	* )
579	* </pre>
580	*
581	* Keep in mind that database functions in PHP usually return string
582	* values for results regardless of the database's internal type.
583	*
584	* @param string the SQL query
585	* @param array that contains the types of the columns in the result set
586	* @param array if supplied, prepare/execute will be used
587	* with this array as execute parameters
588	* @param array that contains the types of the values defined in $params
589	* @param bool $force_array used only when the query returns
590	* exactly two columns. If TRUE, the values of the returned array
591	* will be one-element arrays instead of scalars.
592	* @param bool $group if TRUE, the values of the returned array
593	* is wrapped in another array. If the same key value (in the first
594	* column) repeats itself, the values will be appended to this array
595	* instead of overwriting the existing values.
596	*
597	* @return array\|MDB2_Error data on success, a MDB2 error on failure
598	* @access public
599	*/
600	function getAssoc($query, $types = null, $params = array(), $param_types = null,
601	$fetchmode = MDB2_FETCHMODE_DEFAULT, $force_array = false, $group = false)
602	{
603	$db =& $this->getDBInstance();
604	if (PEAR::isError($db)) {
605	return $db;
606	}
607
608	settype($params, 'array');
609	if (empty($params)) {
610	return $db->queryAll($query, $types, $fetchmode, true, $force_array, $group);
611	}
612
613	$stmt = $db->prepare($query, $param_types, $types);
614	if (PEAR::isError($stmt)) {
615	return $stmt;
616	}
617
618	$result = $stmt->execute($params);
619	if (!MDB2::isResultCommon($result)) {
620	return $result;
621	}
622
623	$all = $result->fetchAll($fetchmode, true, $force_array, $group);
624	$stmt->free();
625	$result->free();
626	return $all;
627	}
628
629	// }}}
630	// {{{ executeMultiple()
631
632	/**
633	* This function does several execute() calls on the same statement handle.
634	* $params must be an array indexed numerically from 0, one execute call is
635	* done for every 'row' in the array.
636	*
637	* If an error occurs during execute(), executeMultiple() does not execute
638	* the unfinished rows, but rather returns that error.
639	*
640	* @param resource query handle from prepare()
641	* @param array numeric array containing the data to insert into the query
642	*
643	* @return bool\|MDB2_Error true on success, a MDB2 error on failure
644	* @access public
645	* @see prepare(), execute()
646	*/
647	function executeMultiple(&$stmt, $params = null)
648	{
649	for ($i = 0, $j = count($params); $i < $j; $i++) {
650	$result = $stmt->execute($params[$i]);
651	if (PEAR::isError($result)) {
652	return $result;
653	}
654	}
655	return MDB2_OK;
656	}
657
658	// }}}
659	// {{{ getBeforeID()
660
661	/**
662	* Returns the next free id of a sequence if the RDBMS
663	* does not support auto increment
664	*
665	* @param string name of the table into which a new row was inserted
666	* @param string name of the field into which a new row was inserted
667	* @param bool when true the sequence is automatic created, if it not exists
668	* @param bool if the returned value should be quoted
669	*
670	* @return int\|MDB2_Error id on success, a MDB2 error on failure
671	* @access public
672	*/
673	function getBeforeID($table, $field = null, $ondemand = true, $quote = true)
674	{
675	$db =& $this->getDBInstance();
676	if (PEAR::isError($db)) {
677	return $db;
678	}
679
680	if ($db->supports('auto_increment') !== true) {
681	$seq = $table.(empty($field) ? '' : '_'.$field);
682	$id = $db->nextID($seq, $ondemand);
683	if (!$quote \|\| PEAR::isError($id)) {
684	return $id;
685	}
686	return $db->quote($id, 'integer');
687	} elseif (!$quote) {
688	return null;
689	}
690	return 'NULL';
691	}
692
693	// }}}
694	// {{{ getAfterID()
695
696	/**
697	* Returns the autoincrement ID if supported or $id
698	*
699	* @param mixed value as returned by getBeforeId()
700	* @param string name of the table into which a new row was inserted
701	* @param string name of the field into which a new row was inserted
702	*
703	* @return int\|MDB2_Error id on success, a MDB2 error on failure
704	* @access public
705	*/
706	function getAfterID($id, $table, $field = null)
707	{
708	$db =& $this->getDBInstance();
709	if (PEAR::isError($db)) {
710	return $db;
711	}
712
713	if ($db->supports('auto_increment') !== true) {
714	return $id;
715	}
716	return $db->lastInsertID($table, $field);
717	}
718
719	// }}}
720	}
721	?>

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: branches/version-2_5-dev/data/module/MDB2/Extended.php @ 20764

Download in other formats: