/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/oci8/oci8_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:
 
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              ExpressionEngine Dev Team
 
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 1.0
 
13
 * @filesource
 
14
 */
 
15
 
 
16
// ------------------------------------------------------------------------
 
17
 
 
18
/**
 
19
 * oci8 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              ExpressionEngine Dev Team
 
29
 * @link                http://codeigniter.com/user_guide/database/
 
30
 */
 
31
 
 
32
/**
 
33
 * oci8 Database Adapter Class
 
34
 *
 
35
 * This is a modification of the DB_driver class to
 
36
 * permit access to oracle databases
 
37
 *
 
38
 * @author        Kelly McArdle
 
39
 *
 
40
 */
 
41
 
 
42
class CI_DB_oci8_driver extends CI_DB {
 
43
 
 
44
        var $dbdriver = 'oci8';
 
45
 
 
46
        // The character used for excaping
 
47
        var $_escape_char = '"';
 
48
 
 
49
        // clause and character used for LIKE escape sequences
 
50
        var $_like_escape_str = " escape '%s' ";
 
51
        var $_like_escape_chr = '!';
 
52
 
 
53
        /**
 
54
         * The syntax to count rows is slightly different across different
 
55
         * database engines, so this string appears in each driver and is
 
56
         * used for the count_all() and count_all_results() functions.
 
57
         */
 
58
        var $_count_string = "SELECT COUNT(1) AS ";
 
59
        var $_random_keyword = ' ASC'; // not currently supported
 
60
 
 
61
        // Set "auto commit" by default
 
62
        var $_commit = OCI_COMMIT_ON_SUCCESS;
 
63
 
 
64
        // need to track statement id and cursor id
 
65
        var $stmt_id;
 
66
        var $curs_id;
 
67
 
 
68
        // if we use a limit, we will add a field that will
 
69
        // throw off num_fields later
 
70
        var $limit_used;
 
71
 
 
72
        /**
 
73
         * Non-persistent database connection
 
74
         *
 
75
         * @access  private called by the base class
 
76
         * @return  resource
 
77
         */
 
78
        public function db_connect()
 
79
        {
 
80
                return @oci_connect($this->username, $this->password, $this->hostname, $this->char_set);
 
81
        }
 
82
 
 
83
        // --------------------------------------------------------------------
 
84
 
 
85
        /**
 
86
         * Persistent database connection
 
87
         *
 
88
         * @access  private called by the base class
 
89
         * @return  resource
 
90
         */
 
91
        public function db_pconnect()
 
92
        {
 
93
                return @oci_pconnect($this->username, $this->password, $this->hostname, $this->char_set);
 
94
        }
 
95
 
 
96
        // --------------------------------------------------------------------
 
97
 
 
98
        /**
 
99
         * Reconnect
 
100
         *
 
101
         * Keep / reestablish the db connection if no queries have been
 
102
         * sent for a length of time exceeding the server's idle timeout
 
103
         *
 
104
         * @access      public
 
105
         * @return      void
 
106
         */
 
107
        public function reconnect()
 
108
        {
 
109
                // not implemented in oracle
 
110
                return;
 
111
        }
 
112
 
 
113
        // --------------------------------------------------------------------
 
114
 
 
115
        /**
 
116
         * Select the database
 
117
         *
 
118
         * @access  private called by the base class
 
119
         * @return  resource
 
120
         */
 
121
        public function db_select()
 
122
        {
 
123
                // Not in Oracle - schemas are actually usernames
 
124
                return TRUE;
 
125
        }
 
126
 
 
127
        // --------------------------------------------------------------------
 
128
 
 
129
        /**
 
130
         * Set client character set
 
131
         *
 
132
         * @access      public
 
133
         * @param       string
 
134
         * @param       string
 
135
         * @return      resource
 
136
         */
 
137
        public function db_set_charset($charset, $collation)
 
138
        {
 
139
                // @todo - add support if needed
 
140
                return TRUE;
 
141
        }
 
142
 
 
143
        // --------------------------------------------------------------------
 
144
 
 
145
        /**
 
146
         * Version number query string
 
147
         *
 
148
         * @access  protected
 
149
         * @return  string
 
150
         */
 
151
        protected function _version()
 
152
        {
 
153
                return oci_server_version($this->conn_id);
 
154
        }
 
155
 
 
156
        // --------------------------------------------------------------------
 
157
 
 
158
        /**
 
159
         * Execute the query
 
160
         *
 
161
         * @access  protected  called by the base class
 
162
         * @param   string  an SQL query
 
163
         * @return  resource
 
164
         */
 
165
        protected function _execute($sql)
 
166
        {
 
167
                // oracle must parse the query before it is run. All of the actions with
 
168
                // the query are based on the statement id returned by ociparse
 
169
                $this->stmt_id = FALSE;
 
170
                $this->_set_stmt_id($sql);
 
171
                oci_set_prefetch($this->stmt_id, 1000);
 
172
                return @oci_execute($this->stmt_id, $this->_commit);
 
173
        }
 
174
 
 
175
        /**
 
176
         * Generate a statement ID
 
177
         *
 
178
         * @access  private
 
179
         * @param   string  an SQL query
 
180
         * @return  none
 
181
         */
 
182
        private function _set_stmt_id($sql)
 
183
        {
 
184
                if ( ! is_resource($this->stmt_id))
 
185
                {
 
186
                        $this->stmt_id = oci_parse($this->conn_id, $this->_prep_query($sql));
 
187
                }
 
188
        }
 
189
 
 
190
        // --------------------------------------------------------------------
 
191
 
 
192
        /**
 
193
         * Prep the query
 
194
         *
 
195
         * If needed, each database adapter can prep the query string
 
196
         *
 
197
         * @access  private called by execute()
 
198
         * @param   string  an SQL query
 
199
         * @return  string
 
200
         */
 
201
        private function _prep_query($sql)
 
202
        {
 
203
                return $sql;
 
204
        }
 
205
 
 
206
        // --------------------------------------------------------------------
 
207
 
 
208
        /**
 
209
         * getCursor.  Returns a cursor from the datbase
 
210
         *
 
211
         * @access  public
 
212
         * @return  cursor id
 
213
         */
 
214
        public function get_cursor()
 
215
        {
 
216
                $this->curs_id = oci_new_cursor($this->conn_id);
 
217
                return $this->curs_id;
 
218
        }
 
219
 
 
220
        // --------------------------------------------------------------------
 
221
 
 
222
        /**
 
223
         * Stored Procedure.  Executes a stored procedure
 
224
         *
 
225
         * @access  public
 
226
         * @param   package      package stored procedure is in
 
227
         * @param   procedure   stored procedure to execute
 
228
         * @param   params        array of parameters
 
229
         * @return  array
 
230
         *
 
231
         * params array keys
 
232
         *
 
233
         * KEY    OPTIONAL      NOTES
 
234
         * name         no              the name of the parameter should be in :<param_name> format
 
235
         * value        no              the value of the parameter.  If this is an OUT or IN OUT parameter,
 
236
         *                                      this should be a reference to a variable
 
237
         * type         yes             the type of the parameter
 
238
         * length       yes             the max size of the parameter
 
239
         */
 
240
        public function stored_procedure($package, $procedure, $params)
 
241
        {
 
242
                if ($package == '' OR $procedure == '' OR ! is_array($params))
 
243
                {
 
244
                        if ($this->db_debug)
 
245
                        {
 
246
                                log_message('error', 'Invalid query: '.$package.'.'.$procedure);
 
247
                                return $this->display_error('db_invalid_query');
 
248
                        }
 
249
                        return FALSE;
 
250
                }
 
251
 
 
252
                // build the query string
 
253
                $sql = "begin $package.$procedure(";
 
254
 
 
255
                $have_cursor = FALSE;
 
256
                foreach ($params as $param)
 
257
                {
 
258
                        $sql .= $param['name'] . ",";
 
259
 
 
260
                        if (array_key_exists('type', $param) && ($param['type'] === OCI_B_CURSOR))
 
261
                        {
 
262
                                $have_cursor = TRUE;
 
263
                        }
 
264
                }
 
265
                $sql = trim($sql, ",") . "); end;";
 
266
 
 
267
                $this->stmt_id = FALSE;
 
268
                $this->_set_stmt_id($sql);
 
269
                $this->_bind_params($params);
 
270
                $this->query($sql, FALSE, $have_cursor);
 
271
        }
 
272
 
 
273
        // --------------------------------------------------------------------
 
274
 
 
275
        /**
 
276
         * Bind parameters
 
277
         *
 
278
         * @access  private
 
279
         * @return  none
 
280
         */
 
281
        private function _bind_params($params)
 
282
        {
 
283
                if ( ! is_array($params) OR ! is_resource($this->stmt_id))
 
284
                {
 
285
                        return;
 
286
                }
 
287
 
 
288
                foreach ($params as $param)
 
289
                {
 
290
                        foreach (array('name', 'value', 'type', 'length') as $val)
 
291
                        {
 
292
                                if ( ! isset($param[$val]))
 
293
                                {
 
294
                                        $param[$val] = '';
 
295
                                }
 
296
                        }
 
297
 
 
298
                        oci_bind_by_name($this->stmt_id, $param['name'], $param['value'], $param['length'], $param['type']);
 
299
                }
 
300
        }
 
301
 
 
302
        // --------------------------------------------------------------------
 
303
 
 
304
        /**
 
305
         * Begin Transaction
 
306
         *
 
307
         * @access      public
 
308
         * @return      bool
 
309
         */
 
310
        public function trans_begin($test_mode = FALSE)
 
311
        {
 
312
                if ( ! $this->trans_enabled)
 
313
                {
 
314
                        return TRUE;
 
315
                }
 
316
 
 
317
                // When transactions are nested we only begin/commit/rollback the outermost ones
 
318
                if ($this->_trans_depth > 0)
 
319
                {
 
320
                        return TRUE;
 
321
                }
 
322
 
 
323
                // Reset the transaction failure flag.
 
324
                // If the $test_mode flag is set to TRUE transactions will be rolled back
 
325
                // even if the queries produce a successful result.
 
326
                $this->_trans_failure = ($test_mode === TRUE) ? TRUE : FALSE;
 
327
 
 
328
                $this->_commit = OCI_DEFAULT;
 
329
                return TRUE;
 
330
        }
 
331
 
 
332
        // --------------------------------------------------------------------
 
333
 
 
334
        /**
 
335
         * Commit Transaction
 
336
         *
 
337
         * @access      public
 
338
         * @return      bool
 
339
         */
 
340
        public function trans_commit()
 
341
        {
 
342
                if ( ! $this->trans_enabled)
 
343
                {
 
344
                        return TRUE;
 
345
                }
 
346
 
 
347
                // When transactions are nested we only begin/commit/rollback the outermost ones
 
348
                if ($this->_trans_depth > 0)
 
349
                {
 
350
                        return TRUE;
 
351
                }
 
352
 
 
353
                $ret = oci_commit($this->conn_id);
 
354
                $this->_commit = OCI_COMMIT_ON_SUCCESS;
 
355
                return $ret;
 
356
        }
 
357
 
 
358
        // --------------------------------------------------------------------
 
359
 
 
360
        /**
 
361
         * Rollback Transaction
 
362
         *
 
363
         * @access      public
 
364
         * @return      bool
 
365
         */
 
366
        public function trans_rollback()
 
367
        {
 
368
                if ( ! $this->trans_enabled)
 
369
                {
 
370
                        return TRUE;
 
371
                }
 
372
 
 
373
                // When transactions are nested we only begin/commit/rollback the outermost ones
 
374
                if ($this->_trans_depth > 0)
 
375
                {
 
376
                        return TRUE;
 
377
                }
 
378
 
 
379
                $ret = oci_rollback($this->conn_id);
 
380
                $this->_commit = OCI_COMMIT_ON_SUCCESS;
 
381
                return $ret;
 
382
        }
 
383
 
 
384
        // --------------------------------------------------------------------
 
385
 
 
386
        /**
 
387
         * Escape String
 
388
         *
 
389
         * @access  public
 
390
         * @param   string
 
391
         * @param       bool    whether or not the string will be used in a LIKE condition
 
392
         * @return  string
 
393
         */
 
394
        public function escape_str($str, $like = FALSE)
 
395
        {
 
396
                if (is_array($str))
 
397
                {
 
398
                        foreach ($str as $key => $val)
 
399
                        {
 
400
                                $str[$key] = $this->escape_str($val, $like);
 
401
                        }
 
402
 
 
403
                        return $str;
 
404
                }
 
405
 
 
406
                $str = remove_invisible_characters($str);
 
407
 
 
408
                // escape LIKE condition wildcards
 
409
                if ($like === TRUE)
 
410
                {
 
411
                        $str = str_replace(     array('%', '_', $this->_like_escape_chr),
 
412
                                                                array($this->_like_escape_chr.'%', $this->_like_escape_chr.'_', $this->_like_escape_chr.$this->_like_escape_chr),
 
413
                                                                $str);
 
414
                }
 
415
 
 
416
                return $str;
 
417
        }
 
418
 
 
419
        // --------------------------------------------------------------------
 
420
 
 
421
        /**
 
422
         * Affected Rows
 
423
         *
 
424
         * @access  public
 
425
         * @return  integer
 
426
         */
 
427
        public function affected_rows()
 
428
        {
 
429
                return @oci_num_rows($this->stmt_id);
 
430
        }
 
431
 
 
432
        // --------------------------------------------------------------------
 
433
 
 
434
        /**
 
435
         * Insert ID
 
436
         *
 
437
         * @access  public
 
438
         * @return  integer
 
439
         */
 
440
        public function insert_id()
 
441
        {
 
442
                // not supported in oracle
 
443
                return $this->display_error('db_unsupported_function');
 
444
        }
 
445
 
 
446
        // --------------------------------------------------------------------
 
447
 
 
448
        /**
 
449
         * "Count All" query
 
450
         *
 
451
         * Generates a platform-specific query string that counts all records in
 
452
         * the specified database
 
453
         *
 
454
         * @access  public
 
455
         * @param   string
 
456
         * @return  string
 
457
         */
 
458
        public function count_all($table = '')
 
459
        {
 
460
                if ($table == '')
 
461
                {
 
462
                        return 0;
 
463
                }
 
464
 
 
465
                $query = $this->query($this->_count_string . $this->_protect_identifiers('numrows') . " FROM " . $this->_protect_identifiers($table, TRUE, NULL, FALSE));
 
466
 
 
467
                if ($query == FALSE)
 
468
                {
 
469
                        return 0;
 
470
                }
 
471
 
 
472
                $row = $query->row();
 
473
                $this->_reset_select();
 
474
                return (int) $row->numrows;
 
475
        }
 
476
 
 
477
        // --------------------------------------------------------------------
 
478
 
 
479
        /**
 
480
         * Show table query
 
481
         *
 
482
         * Generates a platform-specific query string so that the table names can be fetched
 
483
         *
 
484
         * @access      protected
 
485
         * @param       boolean
 
486
         * @return      string
 
487
         */
 
488
        protected function _list_tables($prefix_limit = FALSE)
 
489
        {
 
490
                $sql = "SELECT TABLE_NAME FROM ALL_TABLES";
 
491
 
 
492
                if ($prefix_limit !== FALSE AND $this->dbprefix != '')
 
493
                {
 
494
                        $sql .= " WHERE TABLE_NAME LIKE '".$this->escape_like_str($this->dbprefix)."%' ".sprintf($this->_like_escape_str, $this->_like_escape_chr);
 
495
                }
 
496
 
 
497
                return $sql;
 
498
        }
 
499
 
 
500
        // --------------------------------------------------------------------
 
501
 
 
502
        /**
 
503
         * Show column query
 
504
         *
 
505
         * Generates a platform-specific query string so that the column names can be fetched
 
506
         *
 
507
         * @access  protected
 
508
         * @param   string  the table name
 
509
         * @return  string
 
510
         */
 
511
        protected function _list_columns($table = '')
 
512
        {
 
513
                return "SELECT COLUMN_NAME FROM all_tab_columns WHERE table_name = '$table'";
 
514
        }
 
515
 
 
516
        // --------------------------------------------------------------------
 
517
 
 
518
        /**
 
519
         * Field data query
 
520
         *
 
521
         * Generates a platform-specific query so that the column data can be retrieved
 
522
         *
 
523
         * @access  public
 
524
         * @param   string  the table name
 
525
         * @return  object
 
526
         */
 
527
        protected function _field_data($table)
 
528
        {
 
529
                return "SELECT * FROM ".$table." where rownum = 1";
 
530
        }
 
531
 
 
532
        // --------------------------------------------------------------------
 
533
 
 
534
        /**
 
535
         * The error message string
 
536
         *
 
537
         * @access  protected
 
538
         * @return  string
 
539
         */
 
540
        protected function _error_message()
 
541
        {
 
542
                // If the error was during connection, no conn_id should be passed
 
543
                $error = is_resource($this->conn_id) ? oci_error($this->conn_id) : oci_error();
 
544
                return $error['message'];
 
545
        }
 
546
 
 
547
        // --------------------------------------------------------------------
 
548
 
 
549
        /**
 
550
         * The error message number
 
551
         *
 
552
         * @access  protected
 
553
         * @return  integer
 
554
         */
 
555
        protected function _error_number()
 
556
        {
 
557
                // Same as _error_message()
 
558
                $error = is_resource($this->conn_id) ? oci_error($this->conn_id) : oci_error();
 
559
                return $error['code'];
 
560
        }
 
561
 
 
562
        // --------------------------------------------------------------------
 
563
 
 
564
        /**
 
565
         * Escape the SQL Identifiers
 
566
         *
 
567
         * This function escapes column and table names
 
568
         *
 
569
         * @access      protected
 
570
         * @param       string
 
571
         * @return      string
 
572
         */
 
573
        protected function _escape_identifiers($item)
 
574
        {
 
575
                if ($this->_escape_char == '')
 
576
                {
 
577
                        return $item;
 
578
                }
 
579
 
 
580
                foreach ($this->_reserved_identifiers as $id)
 
581
                {
 
582
                        if (strpos($item, '.'.$id) !== FALSE)
 
583
                        {
 
584
                                $str = $this->_escape_char. str_replace('.', $this->_escape_char.'.', $item);
 
585
 
 
586
                                // remove duplicates if the user already included the escape
 
587
                                return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str);
 
588
                        }
 
589
                }
 
590
 
 
591
                if (strpos($item, '.') !== FALSE)
 
592
                {
 
593
                        $str = $this->_escape_char.str_replace('.', $this->_escape_char.'.'.$this->_escape_char, $item).$this->_escape_char;
 
594
                }
 
595
                else
 
596
                {
 
597
                        $str = $this->_escape_char.$item.$this->_escape_char;
 
598
                }
 
599
 
 
600
                // remove duplicates if the user already included the escape
 
601
                return preg_replace('/['.$this->_escape_char.']+/', $this->_escape_char, $str);
 
602
        }
 
603
 
 
604
        // --------------------------------------------------------------------
 
605
 
 
606
        /**
 
607
         * From Tables
 
608
         *
 
609
         * This function implicitly groups FROM tables so there is no confusion
 
610
         * about operator precedence in harmony with SQL standards
 
611
         *
 
612
         * @access      protected
 
613
         * @param       type
 
614
         * @return      type
 
615
         */
 
616
        protected function _from_tables($tables)
 
617
        {
 
618
                if ( ! is_array($tables))
 
619
                {
 
620
                        $tables = array($tables);
 
621
                }
 
622
 
 
623
                return implode(', ', $tables);
 
624
        }
 
625
 
 
626
        // --------------------------------------------------------------------
 
627
 
 
628
        /**
 
629
         * Insert statement
 
630
         *
 
631
         * Generates a platform-specific insert string from the supplied data
 
632
         *
 
633
         * @access  public
 
634
         * @param   string  the table name
 
635
         * @param   array   the insert keys
 
636
         * @param   array   the insert values
 
637
         * @return  string
 
638
         */
 
639
        protected function _insert($table, $keys, $values)
 
640
        {
 
641
                return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")";
 
642
        }
 
643
 
 
644
        // --------------------------------------------------------------------
 
645
 
 
646
        /**
 
647
         * Insert_batch statement
 
648
         *
 
649
         * Generates a platform-specific insert string from the supplied data
 
650
         *
 
651
         * @access      protected
 
652
         * @param       string  the table name
 
653
         * @param       array   the insert keys
 
654
         * @param       array   the insert values
 
655
         * @return      string
 
656
         */
 
657
        protected function _insert_batch($table, $keys, $values)
 
658
        {
 
659
                $keys = implode(', ', $keys);
 
660
                $sql = "INSERT ALL\n";
 
661
 
 
662
                for ($i = 0, $c = count($values); $i < $c; $i++)
 
663
                {
 
664
                        $sql .= '       INTO ' . $table . ' (' . $keys . ') VALUES ' . $values[$i] . "\n";
 
665
                }
 
666
 
 
667
                $sql .= 'SELECT * FROM dual';
 
668
 
 
669
                return $sql;
 
670
        }
 
671
 
 
672
        // --------------------------------------------------------------------
 
673
 
 
674
        /**
 
675
         * Update statement
 
676
         *
 
677
         * Generates a platform-specific update string from the supplied data
 
678
         *
 
679
         * @access      protected
 
680
         * @param       string  the table name
 
681
         * @param       array   the update data
 
682
         * @param       array   the where clause
 
683
         * @param       array   the orderby clause
 
684
         * @param       array   the limit clause
 
685
         * @return      string
 
686
         */
 
687
        protected function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
 
688
        {
 
689
                foreach ($values as $key => $val)
 
690
                {
 
691
                        $valstr[] = $key." = ".$val;
 
692
                }
 
693
 
 
694
                $limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 
695
 
 
696
                $orderby = (count($orderby) >= 1)?' ORDER BY '.implode(", ", $orderby):'';
 
697
 
 
698
                $sql = "UPDATE ".$table." SET ".implode(', ', $valstr);
 
699
 
 
700
                $sql .= ($where != '' AND count($where) >=1) ? " WHERE ".implode(" ", $where) : '';
 
701
 
 
702
                $sql .= $orderby.$limit;
 
703
 
 
704
                return $sql;
 
705
        }
 
706
 
 
707
        // --------------------------------------------------------------------
 
708
 
 
709
        /**
 
710
         * Truncate statement
 
711
         *
 
712
         * Generates a platform-specific truncate string from the supplied data
 
713
         * If the database does not support the truncate() command
 
714
         * This function maps to "DELETE FROM table"
 
715
         *
 
716
         * @access      protected
 
717
         * @param       string  the table name
 
718
         * @return      string
 
719
         */
 
720
        protected function _truncate($table)
 
721
        {
 
722
                return "TRUNCATE TABLE ".$table;
 
723
        }
 
724
 
 
725
        // --------------------------------------------------------------------
 
726
 
 
727
        /**
 
728
         * Delete statement
 
729
         *
 
730
         * Generates a platform-specific delete string from the supplied data
 
731
         *
 
732
         * @access      protected
 
733
         * @param       string  the table name
 
734
         * @param       array   the where clause
 
735
         * @param       string  the limit clause
 
736
         * @return      string
 
737
         */
 
738
        protected function _delete($table, $where = array(), $like = array(), $limit = FALSE)
 
739
        {
 
740
                $conditions = '';
 
741
 
 
742
                if (count($where) > 0 OR count($like) > 0)
 
743
                {
 
744
                        $conditions = "\nWHERE ";
 
745
                        $conditions .= implode("\n", $this->ar_where);
 
746
 
 
747
                        if (count($where) > 0 && count($like) > 0)
 
748
                        {
 
749
                                $conditions .= " AND ";
 
750
                        }
 
751
                        $conditions .= implode("\n", $like);
 
752
                }
 
753
 
 
754
                $limit = ( ! $limit) ? '' : ' LIMIT '.$limit;
 
755
 
 
756
                return "DELETE FROM ".$table.$conditions.$limit;
 
757
        }
 
758
 
 
759
        // --------------------------------------------------------------------
 
760
 
 
761
        /**
 
762
         * Limit string
 
763
         *
 
764
         * Generates a platform-specific LIMIT clause
 
765
         *
 
766
         * @access  protected
 
767
         * @param   string  the sql query string
 
768
         * @param   integer the number of rows to limit the query to
 
769
         * @param   integer the offset value
 
770
         * @return  string
 
771
         */
 
772
        protected function _limit($sql, $limit, $offset)
 
773
        {
 
774
                $limit = $offset + $limit;
 
775
                $newsql = "SELECT * FROM (select inner_query.*, rownum rnum FROM ($sql) inner_query WHERE rownum < $limit)";
 
776
 
 
777
                if ($offset != 0)
 
778
                {
 
779
                        $newsql .= " WHERE rnum >= $offset";
 
780
                }
 
781
 
 
782
                // remember that we used limits
 
783
                $this->limit_used = TRUE;
 
784
 
 
785
                return $newsql;
 
786
        }
 
787
 
 
788
        // --------------------------------------------------------------------
 
789
 
 
790
        /**
 
791
         * Close DB Connection
 
792
         *
 
793
         * @access  protected
 
794
         * @param   resource
 
795
         * @return  void
 
796
         */
 
797
        protected function _close($conn_id)
 
798
        {
 
799
                @oci_close($conn_id);
 
800
        }
 
801
 
 
802
 
 
803
}
 
804
 
 
805
 
 
806
 
 
807
/* End of file oci8_driver.php */
 
808
/* Location: ./system/database/drivers/oci8/oci8_driver.php */