/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/database/drivers/cubrid/cubrid_driver.php

  • Committer: galaxyAbstractor
  • Date: 2013-04-10 15:49:32 UTC
  • mto: (19.1.5 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410154932-4vizlzk0ar5gykvi
* Added an simple admin panel to the codeviewer-cmssy stuff
* Redesigned a bit like the mockups - still stuff to come
* Implemented the codeviewer + admin panel again using the Framework CodeIgniter instead 

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/system/database/drivers/cubrid/cubrid_driver.php
 
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 */
 
 
b'\\ No newline at end of file'