]>
Commit | Line | Data |
---|---|---|
59c06b17 CS |
1 | <?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
2 | /** | |
3 | * CodeIgniter | |
4 | * | |
5 | * An open source application development framework for PHP 5.1.6 or newer | |
6 | * | |
7 | * @package CodeIgniter | |
8 | * @author Esen Sagynov | |
9 | * @copyright Copyright (c) 2008 - 2011, EllisLab, Inc. | |
10 | * @license http://codeigniter.com/user_guide/license.html | |
11 | * @link http://codeigniter.com | |
12 | * @since Version 2.0.2 | |
13 | * @filesource | |
14 | */ | |
15 | ||
16 | // ------------------------------------------------------------------------ | |
17 | ||
18 | /** | |
19 | * CUBRID Database Adapter Class | |
20 | * | |
21 | * Note: _DB is an extender class that the app controller | |
22 | * creates dynamically based on whether the active record | |
23 | * class is being used or not. | |
24 | * | |
25 | * @package CodeIgniter | |
26 | * @subpackage Drivers | |
27 | * @category Database | |
28 | * @author Esen Sagynov | |
29 | * @link http://codeigniter.com/user_guide/database/ | |
30 | */ | |
31 | class CI_DB_cubrid_driver extends CI_DB { | |
32 | ||
33 | // Default CUBRID Broker port. Will be used unless user | |
34 | // explicitly specifies another one. | |
35 | const DEFAULT_PORT = 33000; | |
36 | ||
37 | var $dbdriver = 'cubrid'; | |
38 | ||
39 | // The character used for escaping - no need in CUBRID | |
40 | var $_escape_char = ''; | |
41 | ||
42 | // clause and character used for LIKE escape sequences - not used in CUBRID | |
43 | var $_like_escape_str = ''; | |
44 | var $_like_escape_chr = ''; | |
45 | ||
46 | /** | |
47 | * The syntax to count rows is slightly different across different | |
48 | * database engines, so this string appears in each driver and is | |
49 | * used for the count_all() and count_all_results() functions. | |
50 | */ | |
51 | var $_count_string = 'SELECT COUNT(*) AS '; | |
52 | var $_random_keyword = ' RAND()'; // database specific random keyword | |
53 | ||
54 | /** | |
55 | * Non-persistent database connection | |
56 | * | |
57 | * @access private called by the base class | |
58 | * @return resource | |
59 | */ | |
60 | function db_connect() | |
61 | { | |
62 | // If no port is defined by the user, use the default value | |
63 | if ($this->port == '') | |
64 | { | |
65 | $this->port = self::DEFAULT_PORT; | |
66 | } | |
67 | ||
68 | $conn = cubrid_connect($this->hostname, $this->port, $this->database, $this->username, $this->password); | |
69 | ||
70 | if ($conn) | |
71 | { | |
72 | // Check if a user wants to run queries in dry, i.e. run the | |
73 | // queries but not commit them. | |
74 | if (isset($this->auto_commit) && ! $this->auto_commit) | |
75 | { | |
76 | cubrid_set_autocommit($conn, CUBRID_AUTOCOMMIT_FALSE); | |
77 | } | |
78 | else | |
79 | { | |
80 | cubrid_set_autocommit($conn, CUBRID_AUTOCOMMIT_TRUE); | |
81 | $this->auto_commit = TRUE; | |
82 | } | |
83 | } | |
84 | ||
85 | return $conn; | |
86 | } | |
87 | ||
88 | // -------------------------------------------------------------------- | |
89 | ||
90 | /** | |
91 | * Persistent database connection | |
92 | * In CUBRID persistent DB connection is supported natively in CUBRID | |
93 | * engine which can be configured in the CUBRID Broker configuration | |
94 | * file by setting the CCI_PCONNECT parameter to ON. In that case, all | |
95 | * connections established between the client application and the | |
96 | * server will become persistent. This is calling the same | |
97 | * @cubrid_connect function will establish persisten connection | |
98 | * considering that the CCI_PCONNECT is ON. | |
99 | * | |
100 | * @access private called by the base class | |
101 | * @return resource | |
102 | */ | |
103 | function db_pconnect() | |
104 | { | |
105 | return $this->db_connect(); | |
106 | } | |
107 | ||
108 | // -------------------------------------------------------------------- | |
109 | ||
110 | /** | |
111 | * Reconnect | |
112 | * | |
113 | * Keep / reestablish the db connection if no queries have been | |
114 | * sent for a length of time exceeding the server's idle timeout | |
115 | * | |
116 | * @access public | |
117 | * @return void | |
118 | */ | |
119 | function reconnect() | |
120 | { | |
121 | if (cubrid_ping($this->conn_id) === FALSE) | |
122 | { | |
123 | $this->conn_id = FALSE; | |
124 | } | |
125 | } | |
126 | ||
127 | // -------------------------------------------------------------------- | |
128 | ||
129 | /** | |
130 | * Select the database | |
131 | * | |
132 | * @access private called by the base class | |
133 | * @return resource | |
134 | */ | |
135 | function db_select() | |
136 | { | |
137 | // In CUBRID there is no need to select a database as the database | |
138 | // is chosen at the connection time. | |
139 | // So, to determine if the database is "selected", all we have to | |
140 | // do is ping the server and return that value. | |
141 | return cubrid_ping($this->conn_id); | |
142 | } | |
143 | ||
144 | // -------------------------------------------------------------------- | |
145 | ||
146 | /** | |
147 | * Set client character set | |
148 | * | |
149 | * @access public | |
150 | * @param string | |
151 | * @param string | |
152 | * @return resource | |
153 | */ | |
154 | function db_set_charset($charset, $collation) | |
155 | { | |
156 | // In CUBRID, there is no need to set charset or collation. | |
157 | // This is why returning true will allow the application continue | |
158 | // its normal process. | |
159 | return TRUE; | |
160 | } | |
161 | ||
162 | // -------------------------------------------------------------------- | |
163 | ||
164 | /** | |
165 | * Version number query string | |
166 | * | |
167 | * @access public | |
168 | * @return string | |
169 | */ | |
170 | function _version() | |
171 | { | |
172 | // To obtain the CUBRID Server version, no need to run the SQL query. | |
173 | // CUBRID PHP API provides a function to determin this value. | |
174 | // This is why we also need to add 'cubrid' value to the list of | |
175 | // $driver_version_exceptions array in DB_driver class in | |
176 | // version() function. | |
177 | return cubrid_get_server_info($this->conn_id); | |
178 | } | |
179 | ||
180 | // -------------------------------------------------------------------- | |
181 | ||
182 | /** | |
183 | * Execute the query | |
184 | * | |
185 | * @access private called by the base class | |
186 | * @param string an SQL query | |
187 | * @return resource | |
188 | */ | |
189 | function _execute($sql) | |
190 | { | |
191 | $sql = $this->_prep_query($sql); | |
192 | return @cubrid_query($sql, $this->conn_id); | |
193 | } | |
194 | ||
195 | // -------------------------------------------------------------------- | |
196 | ||
197 | /** | |
198 | * Prep the query | |
199 | * | |
200 | * If needed, each database adapter can prep the query string | |
201 | * | |
202 | * @access private called by execute() | |
203 | * @param string an SQL query | |
204 | * @return string | |
205 | */ | |
206 | function _prep_query($sql) | |
207 | { | |
208 | // No need to prepare | |
209 | return $sql; | |
210 | } | |
211 | ||
212 | // -------------------------------------------------------------------- | |
213 | ||
214 | /** | |
215 | * Begin Transaction | |
216 | * | |
217 | * @access public | |
218 | * @return bool | |
219 | */ | |
220 | function trans_begin($test_mode = FALSE) | |
221 | { | |
222 | if ( ! $this->trans_enabled) | |
223 | { | |
224 | return TRUE; | |
225 | } | |
226 | ||
227 | // When transactions are nested we only begin/commit/rollback the outermost ones | |
228 | if ($this->_trans_depth > 0) | |
229 | { | |
230 | return TRUE; | |
231 | } | |
232 | ||
233 | // Reset the transaction failure flag. | |
234 | // If the $test_mode flag is set to TRUE transactions will be rolled back | |
235 | // even if the queries produce a successful result. | |
236 | $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE; | |
237 | ||
238 | if (cubrid_get_autocommit($this->conn_id)) | |
239 | { | |
240 | cubrid_set_autocommit($this->conn_id, CUBRID_AUTOCOMMIT_FALSE); | |
241 | } | |
242 | ||
243 | return TRUE; | |
244 | } | |
245 | ||
246 | // -------------------------------------------------------------------- | |
247 | ||
248 | /** | |
249 | * Commit Transaction | |
250 | * | |
251 | * @access public | |
252 | * @return bool | |
253 | */ | |
254 | function trans_commit() | |
255 | { | |
256 | if ( ! $this->trans_enabled) | |
257 | { | |
258 | return TRUE; | |
259 | } | |
260 | ||
261 | // When transactions are nested we only begin/commit/rollback the outermost ones | |
262 | if ($this->_trans_depth > 0) | |
263 | { | |
264 | return TRUE; | |
265 | } | |
266 | ||
267 | cubrid_commit($this->conn_id); | |
268 | ||
269 | if ($this->auto_commit && ! cubrid_get_autocommit($this->conn_id)) | |
270 | { | |
271 | cubrid_set_autocommit($this->conn_id, CUBRID_AUTOCOMMIT_TRUE); | |
272 | } | |
273 | ||
274 | return TRUE; | |
275 | } | |
276 | ||
277 | // -------------------------------------------------------------------- | |
278 | ||
279 | /** | |
280 | * Rollback Transaction | |
281 | * | |
282 | * @access public | |
283 | * @return bool | |
284 | */ | |
285 | function trans_rollback() | |
286 | { | |
287 | if ( ! $this->trans_enabled) | |
288 | { | |
289 | return TRUE; | |
290 | } | |
291 | ||
292 | // When transactions are nested we only begin/commit/rollback the outermost ones | |
293 | if ($this->_trans_depth > 0) | |
294 | { | |
295 | return TRUE; | |
296 | } | |
297 | ||
298 | cubrid_rollback($this->conn_id); | |
299 | ||
300 | if ($this->auto_commit && ! cubrid_get_autocommit($this->conn_id)) | |
301 | { | |
302 | cubrid_set_autocommit($this->conn_id, CUBRID_AUTOCOMMIT_TRUE); | |
303 | } | |
304 | ||
305 | return TRUE; | |
306 | } | |
307 | ||
308 | // -------------------------------------------------------------------- | |
309 | ||
310 | /** | |
311 | * Escape String | |
312 | * | |
313 | * @access public | |
314 | * @param string | |
315 | * @param bool whether or not the string will be used in a LIKE condition | |
316 | * @return string | |
317 | */ | |
318 | function escape_str($str, $like = FALSE) | |
319 | { | |
320 | if (is_array($str)) | |
321 | { | |
322 | foreach ($str as $key => $val) | |
323 | { | |
324 | $str[$key] = $this->escape_str($val, $like); | |
325 | } | |
326 | ||
327 | return $str; | |
328 | } | |
329 | ||
330 | if (function_exists('cubrid_real_escape_string') AND is_resource($this->conn_id)) | |
331 | { | |
332 | $str = cubrid_real_escape_string($str, $this->conn_id); | |
333 | } | |
334 | else | |
335 | { | |
336 | $str = addslashes($str); | |
337 | } | |
338 | ||
339 | // escape LIKE condition wildcards | |
340 | if ($like === TRUE) | |
341 | { | |
342 | $str = str_replace(array('%', '_'), array('\\%', '\\_'), $str); | |
343 | } | |
344 | ||
345 | return $str; | |
346 | } | |
347 | ||
348 | // -------------------------------------------------------------------- | |
349 | ||
350 | /** | |
351 | * Affected Rows | |
352 | * | |
353 | * @access public | |
354 | * @return integer | |
355 | */ | |
356 | function affected_rows() | |
357 | { | |
358 | return @cubrid_affected_rows($this->conn_id); | |
359 | } | |
360 | ||
361 | // -------------------------------------------------------------------- | |
362 | ||
363 | /** | |
364 | * Insert ID | |
365 | * | |
366 | * @access public | |
367 | * @return integer | |
368 | */ | |
369 | function insert_id() | |
370 | { | |
371 | return @cubrid_insert_id($this->conn_id); | |
372 | } | |
373 | ||
374 | // -------------------------------------------------------------------- | |
375 | ||
376 | /** | |
377 | * "Count All" query | |
378 | * | |
379 | * Generates a platform-specific query string that counts all records in | |
380 | * the specified table | |
381 | * | |
382 | * @access public | |
383 | * @param string | |
384 | * @return string | |
385 | */ | |
386 | function count_all($table = '') | |
387 | { | |
388 | if ($table == '') | |
389 | { | |
390 | return 0; | |
391 | } | |
392 | ||
393 | $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows') . " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE)); | |
394 | ||
395 | if ($query->num_rows() == 0) | |
396 | { | |
397 | return 0; | |
398 | } | |
399 | ||
400 | $row = $query->row(); | |
401 | $this->_reset_select(); | |
402 | return (int) $row->numrows; | |
403 | } | |
404 | ||
405 | // -------------------------------------------------------------------- | |
406 | ||
407 | /** | |
408 | * List table query | |
409 | * | |
410 | * Generates a platform-specific query string so that the table names can be fetched | |
411 | * | |
412 | * @access private | |
413 | * @param boolean | |
414 | * @return string | |
415 | */ | |
416 | function _list_tables($prefix_limit = FALSE) | |
417 | { | |
418 | $sql = "SHOW TABLES"; | |
419 | ||
420 | if ($prefix_limit !== FALSE AND $this->dbprefix != '') | |
421 | { | |
422 | $sql .= " LIKE '".$this->escape_like_str($this->dbprefix)."%'"; | |
423 | } | |
424 | ||
425 | return $sql; | |
426 | } | |
427 | ||
428 | // -------------------------------------------------------------------- | |
429 | ||
430 | /** | |
431 | * Show column query | |
432 | * | |
433 | * Generates a platform-specific query string so that the column names can be fetched | |
434 | * | |
435 | * @access public | |
436 | * @param string the table name | |
437 | * @return string | |
438 | */ | |
439 | function _list_columns($table = '') | |
440 | { | |
441 | return "SHOW COLUMNS FROM ".$this->_protect_identifiers($table, TRUE, NULL, FALSE); | |
442 | } | |
443 | ||
444 | // -------------------------------------------------------------------- | |
445 | ||
446 | /** | |
447 | * Field data query | |
448 | * | |
449 | * Generates a platform-specific query so that the column data can be retrieved | |
450 | * | |
451 | * @access public | |
452 | * @param string the table name | |
453 | * @return object | |
454 | */ | |
455 | function _field_data($table) | |
456 | { | |
457 | return "SELECT * FROM ".$table." LIMIT 1"; | |
458 | } | |
459 | ||
460 | // -------------------------------------------------------------------- | |
461 | ||
462 | /** | |
463 | * The error message string | |
464 | * | |
465 | * @access private | |
466 | * @return string | |
467 | */ | |
468 | function _error_message() | |
469 | { | |
470 | return cubrid_error($this->conn_id); | |
471 | } | |
472 | ||
473 | // -------------------------------------------------------------------- | |
474 | ||
475 | /** | |
476 | * The error message number | |
477 | * | |
478 | * @access private | |
479 | * @return integer | |
480 | */ | |
481 | function _error_number() | |
482 | { | |
483 | return cubrid_errno($this->conn_id); | |
484 | } | |
485 | ||
486 | // -------------------------------------------------------------------- | |
487 | ||
488 | /** | |
489 | * Escape the SQL Identifiers | |
490 | * | |
491 | * This function escapes column and table names | |
492 | * | |
493 | * @access private | |
494 | * @param string | |
495 | * @return string | |
496 | */ | |
497 | function _escape_identifiers($item) | |
498 | { | |
499 | if ($this->_escape_char == '') | |
500 | { | |
501 | return $item; | |
502 | } | |
503 | ||
504 | foreach ($this->_reserved_identifiers as $id) | |
505 | { | |
506 | if (strpos($item, '.'.$id) !== FALSE) | |
507 | { | |
508 | $str = $this->_escape_char. str_replace('.', $this->_escape_char.'.', $item); | |
509 | ||
510 | // remove duplicates if the user already included the escape | |
511 | return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); | |
512 | } | |
513 | } | |
514 | ||
515 | if (strpos($item, '.') !== FALSE) | |
516 | { | |
517 | $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char; | |
518 | } | |
519 | else | |
520 | { | |
521 | $str = $this->_escape_char.$item.$this->_escape_char; | |
522 | } | |
523 | ||
524 | // remove duplicates if the user already included the escape | |
525 | return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str); | |
526 | } | |
527 | ||
528 | // -------------------------------------------------------------------- | |
529 | ||
530 | /** | |
531 | * From Tables | |
532 | * | |
533 | * This function implicitly groups FROM tables so there is no confusion | |
534 | * about operator precedence in harmony with SQL standards | |
535 | * | |
536 | * @access public | |
537 | * @param type | |
538 | * @return type | |
539 | */ | |
540 | function _from_tables($tables) | |
541 | { | |
542 | if ( ! is_array($tables)) | |
543 | { | |
544 | $tables = array($tables); | |
545 | } | |
546 | ||
547 | return '('.implode(', ', $tables).')'; | |
548 | } | |
549 | ||
550 | // -------------------------------------------------------------------- | |
551 | ||
552 | /** | |
553 | * Insert statement | |
554 | * | |
555 | * Generates a platform-specific insert string from the supplied data | |
556 | * | |
557 | * @access public | |
558 | * @param string the table name | |
559 | * @param array the insert keys | |
560 | * @param array the insert values | |
561 | * @return string | |
562 | */ | |
563 | function _insert($table, $keys, $values) | |
564 | { | |
565 | return "INSERT INTO ".$table." (\"".implode('", "', $keys)."\") VALUES (".implode(', ', $values).")"; | |
566 | } | |
567 | ||
568 | // -------------------------------------------------------------------- | |
569 | ||
570 | ||
571 | /** | |
572 | * Replace statement | |
573 | * | |
574 | * Generates a platform-specific replace string from the supplied data | |
575 | * | |
576 | * @access public | |
577 | * @param string the table name | |
578 | * @param array the insert keys | |
579 | * @param array the insert values | |
580 | * @return string | |
581 | */ | |
582 | function _replace($table, $keys, $values) | |
583 | { | |
584 | return "REPLACE INTO ".$table." (\"".implode('", "', $keys)."\") VALUES (".implode(', ', $values).")"; | |
585 | } | |
586 | ||
587 | // -------------------------------------------------------------------- | |
588 | ||
589 | /** | |
590 | * Insert_batch statement | |
591 | * | |
592 | * Generates a platform-specific insert string from the supplied data | |
593 | * | |
594 | * @access public | |
595 | * @param string the table name | |
596 | * @param array the insert keys | |
597 | * @param array the insert values | |
598 | * @return string | |
599 | */ | |
600 | function _insert_batch($table, $keys, $values) | |
601 | { | |
602 | return "INSERT INTO ".$table." (\"".implode('", "', $keys)."\") VALUES ".implode(', ', $values); | |
603 | } | |
604 | ||
605 | // -------------------------------------------------------------------- | |
606 | ||
607 | ||
608 | /** | |
609 | * Update statement | |
610 | * | |
611 | * Generates a platform-specific update string from the supplied data | |
612 | * | |
613 | * @access public | |
614 | * @param string the table name | |
615 | * @param array the update data | |
616 | * @param array the where clause | |
617 | * @param array the orderby clause | |
618 | * @param array the limit clause | |
619 | * @return string | |
620 | */ | |
621 | function _update($table, $values, $where, $orderby = array(), $limit = FALSE) | |
622 | { | |
623 | foreach ($values as $key => $val) | |
624 | { | |
625 | $valstr[] = sprintf('"%s" = %s', $key, $val); | |
626 | } | |
627 | ||
628 | $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; | |
629 | ||
630 | $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):''; | |
631 | ||
632 | $sql = "UPDATE ".$table." SET ".implode(', ', $valstr); | |
633 | ||
634 | $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : ''; | |
635 | ||
636 | $sql .= $orderby.$limit; | |
637 | ||
638 | return $sql; | |
639 | } | |
640 | ||
641 | // -------------------------------------------------------------------- | |
642 | ||
643 | ||
644 | /** | |
645 | * Update_Batch statement | |
646 | * | |
647 | * Generates a platform-specific batch update string from the supplied data | |
648 | * | |
649 | * @access public | |
650 | * @param string the table name | |
651 | * @param array the update data | |
652 | * @param array the where clause | |
653 | * @return string | |
654 | */ | |
655 | function _update_batch($table, $values, $index, $where = NULL) | |
656 | { | |
657 | $ids = array(); | |
658 | $where = ($where != '' AND count($where) >=1) ? implode(" ", $where).' AND ' : ''; | |
659 | ||
660 | foreach ($values as $key => $val) | |
661 | { | |
662 | $ids[] = $val[$index]; | |
663 | ||
664 | foreach (array_keys($val) as $field) | |
665 | { | |
666 | if ($field != $index) | |
667 | { | |
668 | $final[$field][] = 'WHEN '.$index.' = '.$val[$index].' THEN '.$val[$field]; | |
669 | } | |
670 | } | |
671 | } | |
672 | ||
673 | $sql = "UPDATE ".$table." SET "; | |
674 | $cases = ''; | |
675 | ||
676 | foreach ($final as $k => $v) | |
677 | { | |
678 | $cases .= $k.' = CASE '."\n"; | |
679 | foreach ($v as $row) | |
680 | { | |
681 | $cases .= $row."\n"; | |
682 | } | |
683 | ||
684 | $cases .= 'ELSE '.$k.' END, '; | |
685 | } | |
686 | ||
687 | $sql .= substr($cases, 0, -2); | |
688 | ||
689 | $sql .= ' WHERE '.$where.$index.' IN ('.implode(',', $ids).')'; | |
690 | ||
691 | return $sql; | |
692 | } | |
693 | ||
694 | // -------------------------------------------------------------------- | |
695 | ||
696 | ||
697 | /** | |
698 | * Truncate statement | |
699 | * | |
700 | * Generates a platform-specific truncate string from the supplied data | |
701 | * If the database does not support the truncate() command | |
702 | * This function maps to "DELETE FROM table" | |
703 | * | |
704 | * @access public | |
705 | * @param string the table name | |
706 | * @return string | |
707 | */ | |
708 | function _truncate($table) | |
709 | { | |
710 | return "TRUNCATE ".$table; | |
711 | } | |
712 | ||
713 | // -------------------------------------------------------------------- | |
714 | ||
715 | /** | |
716 | * Delete statement | |
717 | * | |
718 | * Generates a platform-specific delete string from the supplied data | |
719 | * | |
720 | * @access public | |
721 | * @param string the table name | |
722 | * @param array the where clause | |
723 | * @param string the limit clause | |
724 | * @return string | |
725 | */ | |
726 | function _delete($table, $where = array(), $like = array(), $limit = FALSE) | |
727 | { | |
728 | $conditions = ''; | |
729 | ||
730 | if (count($where) > 0 OR count($like) > 0) | |
731 | { | |
732 | $conditions = "\nWHERE "; | |
733 | $conditions .= implode("\n", $this->ar_where); | |
734 | ||
735 | if (count($where) > 0 && count($like) > 0) | |
736 | { | |
737 | $conditions .= " AND "; | |
738 | } | |
739 | $conditions .= implode("\n", $like); | |
740 | } | |
741 | ||
742 | $limit = ( ! $limit) ? '' : ' LIMIT '.$limit; | |
743 | ||
744 | return "DELETE FROM ".$table.$conditions.$limit; | |
745 | } | |
746 | ||
747 | // -------------------------------------------------------------------- | |
748 | ||
749 | /** | |
750 | * Limit string | |
751 | * | |
752 | * Generates a platform-specific LIMIT clause | |
753 | * | |
754 | * @access public | |
755 | * @param string the sql query string | |
756 | * @param integer the number of rows to limit the query to | |
757 | * @param integer the offset value | |
758 | * @return string | |
759 | */ | |
760 | function _limit($sql, $limit, $offset) | |
761 | { | |
762 | if ($offset == 0) | |
763 | { | |
764 | $offset = ''; | |
765 | } | |
766 | else | |
767 | { | |
768 | $offset .= ", "; | |
769 | } | |
770 | ||
771 | return $sql."LIMIT ".$offset.$limit; | |
772 | } | |
773 | ||
774 | // -------------------------------------------------------------------- | |
775 | ||
776 | /** | |
777 | * Close DB Connection | |
778 | * | |
779 | * @access public | |
780 | * @param resource | |
781 | * @return void | |
782 | */ | |
783 | function _close($conn_id) | |
784 | { | |
785 | @cubrid_close($conn_id); | |
786 | } | |
787 | ||
788 | } | |
789 | ||
790 | ||
791 | /* End of file cubrid_driver.php */ | |
792 | /* Location: ./system/database/drivers/cubrid/cubrid_driver.php */ |