← Back to branch summary

~hexmode/+junk/main

« back to all changes in this revision

Viewing changes to install-files/apps/sqlitemanager1.2.0/include/sqlite3.class.php

  • Committer: Mark A. Hershberger
  • Date: 2008-01-05 19:38:56 UTC
  • Revision ID: hershberger@spawn-xp-20080105193856-6rnzgwa4nehue3qj
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
install-files/apps/sqlitemanager1.2.0/include/sqlite3.class.php
 
1
<?php
 
2
include_once dirname(__FILE__) . '/sqlite.class.php';
 
3
if( !defined('PDO_ATTR_TIMEOUT') )              define('PDO_ATTR_TIMEOUT',              PDO::ATTR_TIMEOUT);
 
4
if( !defined('PDO_FETCH_ASSOC') )               define('PDO_FETCH_ASSOC',               PDO::FETCH_ASSOC);
 
5
if( !defined('PDO_FETCH_NUM') )                 define('PDO_FETCH_NUM',                 PDO::FETCH_NUM);
 
6
if( !defined('PDO_FETCH_BOTH') )                define('PDO_FETCH_BOTH',                PDO::FETCH_BOTH);
 
7
if( !defined('PDO_ATTR_PERSISTENT') )   define('PDO_ATTR_PERSISTENT',   PDO::ATTR_PERSISTENT);
 
8
if( !defined('PDO_ATTR_CASE') )                 define('PDO_ATTR_CASE',                 PDO::ATTR_CASE);
 
9
if( !defined('PDO_CASE_NATURAL') )              define('PDO_CASE_NATURAL',              PDO::CASE_NATURAL);
 
10
if( !defined('PDO_ATTR_AUTOCOMMIT') )   define('PDO_ATTR_AUTOCOMMIT',   PDO::ATTR_AUTOCOMMIT);
 
11
if( !defined('PDO_ATTR_ERRMODE') )              define('PDO_ATTR_ERRMODE',              PDO::ATTR_ERRMODE);
 
12
if( !defined('PDO_ERRMODE_EXCEPTION') ) define('PDO_ERRMODE_EXCEPTION', PDO::ERRMODE_EXCEPTION);
 
13
if( !defined('PDO_ERRMODE_SILENT') )    define('PDO_ERRMODE_SILENT',    PDO::ERRMODE_SILENT);
 
14
 
 
15
if( !defined('SQLITE_BOTH') )   define('SQLITE_BOTH',   PDO_FETCH_BOTH);
 
16
if( !defined('SQLITE_ASSOC') )  define('SQLITE_ASSOC',  PDO_FETCH_ASSOC);
 
17
if( !defined('SQLITE_NUM') )    define('SQLITE_NUM',    PDO_FETCH_NUM);
 
18
 
 
19
class sqlite3 extends sqlite {
 
20
 
 
21
 
 
22
    function sqlite3($dbPath) {
 
23
        $this->dbVersion = 3;
 
24
        if($dbPath == ':memory:') {
 
25
                $this->readOnly = false;                
 
26
        } else {
 
27
                $this->readOnly = !is_writable($dbPath);
 
28
        } 
 
29
        parent::sqlite($dbPath);
 
30
        if(class_exists('PDO') && $this->connect($dbPath)) {
 
31
                return $this->connId;
 
32
        } else {
 
33
                $this->getError();
 
34
                return false;
 
35
        }
 
36
    }
 
37
    
 
38
    function connect($dbPath) {
 
39
                try {
 
40
                        $user = '';
 
41
                        $password = '';
 
42
                        $arrayAttrib = array();
 
43
                        if($dbPath == ':memory:') $arrayAttrib[PDO_ATTR_PERSISTENT] = true;
 
44
                        $this->connId = new PDO('sqlite:'.$dbPath, $user, $password, $arrayAttrib); 
 
45
                        
 
46
                        $this->connId->setAttribute(PDO_ATTR_CASE, PDO_CASE_NATURAL);
 
47
                        $this->connId->query("PRAGMA count_changes=1;");
 
48
                } catch (PDOException $e) {
 
49
                        $this->error = true;
 
50
                        $this->errorMessage = $e->getMessage();
 
51
                        return false;
 
52
                }
 
53
                if(DEBUG) {
 
54
                        $this->connId->setAttribute(PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION);
 
55
                } else {
 
56
                        $this->connId->setAttribute(PDO_ATTR_ERRMODE, PDO_ERRMODE_SILENT);
 
57
                }
 
58
        return $this->connId;
 
59
    }
 
60
    
 
61
    function getError($errorCode = null) {
 
62
                if(is_resource($this->resId)) {
 
63
                        $errorInfo = $this->resId->errorInfo();
 
64
                } else {
 
65
                        $errorInfo = $this->connId->errorInfo();
 
66
                }
 
67
                if(is_array($errorInfo) && isset($errorInfo[2])) {
 
68
                        $this->error = true;
 
69
                        $this->errorMessage = $errorInfo[2];
 
70
                } else {
 
71
                        $this->errorMessage = 'not an error';
 
72
                }
 
73
        return $this->errorMessage;
 
74
    }
 
75
    
 
76
    function getErrorMessage() {
 
77
        return $this->errorMessage;
 
78
    }
 
79
    
 
80
    function escape($string) {
 
81
                if(function_exists('sqlite_escape_string')) {
 
82
                        $res = sqlite_escape_string($string);
 
83
                } else {
 
84
                        $res = str_replace("'", "''", $string);
 
85
                }
 
86
                return $res;
 
87
    }
 
88
    
 
89
    function query($sqlString, $buffered = true, $assign = true) {
 
90
        try {
 
91
                if($assign && is_object($this->resId)) $this->resId->closeCursor();
 
92
                        if(substr(trim($sqlString), -1) != ';') $sqlString .= ';';
 
93
                if(DEBUG) $resId = $this->connId->query($sqlString);
 
94
                else $resId = @$this->connId->query($sqlString);
 
95
                if($assign) $this->resId = $resId;
 
96
        } catch(PDOException $e) {
 
97
                        $this->error = true;
 
98
                        $this->errorMessage = $e->getMessage();
 
99
                        return false; 
 
100
        }
 
101
        $tempErrorInfo = $this->connId->errorInfo();
 
102
        if(is_array($tempErrorInfo) && isset($tempErrorInfo[0]) && ($tempErrorInfo[0] != '00000')) {
 
103
                        $this->error = true;
 
104
                        $this->errorMessage = $tempErrorInfo[2];
 
105
                        return false;
 
106
        }
 
107
        return $resId;
 
108
    }
 
109
    
 
110
    function array_query($sqlString, $result_type=SQLITE_BOTH, $decode_binary=true) {
 
111
        try {
 
112
                        $result_type = $this->convertResultType($result_type);
 
113
                        $q = $this->query($sqlString); 
 
114
                        $rows = $q->fetchAll($result_type);
 
115
        } catch(PDOException $e) {
 
116
                        $this->error = true;
 
117
                        $this->errorMessage = $e->getMessage();
 
118
                        return false; 
 
119
        }
 
120
                return $rows;
 
121
    }
 
122
    
 
123
    function num_rows($resId = null) {
 
124
        try {
 
125
                if($resId == null) $resId = $this->resId;
 
126
                if(DEBUG) $out = $resId->rowCount();
 
127
                else $out =  @$resId->rowCount();
 
128
        } catch(PDOException $e) {
 
129
                        $this->error = true;
 
130
                        $this->errorMessage = $e->getMessage();
 
131
                        return false; 
 
132
        }
 
133
        return $out;
 
134
    }
 
135
    
 
136
    function fetch_single($resId=null, $result_type=SQLITE_BOTH) {
 
137
        try {
 
138
                        $result_type = $this->convertResultType($result_type);
 
139
                if($resId == null) $resId = $this->resId;
 
140
                if(DEBUG) $out =  $resId->fetchColumn();
 
141
                else $out =  @$resId->fetchColumn();
 
142
        } catch(PDOException $e) {
 
143
                        $this->error = true;
 
144
                        $this->errorMessage = $e->getMessage();
 
145
                        return false; 
 
146
        }
 
147
        return $out;
 
148
    }
 
149
    
 
150
    function fetch_array($resId=null, $result_type=SQLITE_BOTH, $decode_binary=true) {
 
151
                try {
 
152
                        $result_type = $this->convertResultType($result_type);
 
153
                if($resId == null) $resId = $this->resId;
 
154
                if(DEBUG) $out =  $resId->fetch($result_type);
 
155
                else $out =  @$resId->fetch($result_type);
 
156
        } catch(PDOException $e) {
 
157
                        $this->error = true;
 
158
                        $this->errorMessage = $e->getMessage();
 
159
                        return false; 
 
160
        }
 
161
        return $out;
 
162
    }
 
163
 
 
164
    function last_insert_id() {
 
165
                try {
 
166
                if(DEBUG) $out = $this->connId->lastInsertId();
 
167
                else $out = @$this->connId->lastInsertId();
 
168
        } catch(PDOException $e) {
 
169
                        $this->error = true;
 
170
                        $this->errorMessage = $e->getMessage();
 
171
                        return false; 
 
172
        }
 
173
        return $out;    
 
174
    }    
 
175
    
 
176
    function changes($resId = null) {
 
177
        try {
 
178
                        if($resId == null) $resId = $this->resId;               
 
179
                if(is_object($resId)) $out = $this->num_rows($resId);
 
180
                else $out = 0;
 
181
        } catch(PDOException $e) {
 
182
                        $this->error = true;
 
183
                        $this->errorMessage = $e->getMessage();
 
184
                        return false; 
 
185
        }
 
186
        return $out;
 
187
    }
 
188
        
 
189
    function num_fields($resId = null) {
 
190
        try {
 
191
                if($resId == null) $resId = $this->resId;
 
192
                if(DEBUG) $out =  $resId->columnCount();
 
193
                else $out =  @$resId->columnCount();
 
194
        } catch(PDOException $e) {
 
195
                        $this->error = true;
 
196
                        $this->errorMessage = $e->getMessage();
 
197
                        return false; 
 
198
        }
 
199
        return $out;            
 
200
    }
 
201
 
 
202
    function field_name($resId = null, $index) {
 
203
                try {
 
204
                if($resId == null) $resId = $this->resId;
 
205
                if(DEBUG) $tempColInfo = $resId->getColumnMeta($index);
 
206
                else $tempColInfo = @$resId->getColumnMeta($index);
 
207
        } catch(PDOException $e) {
 
208
                        $this->error = true;
 
209
                        $this->errorMessage = $e->getMessage();
 
210
                        return false; 
 
211
        }       
 
212
                return $tempColInfo["name"];
 
213
    }
 
214
 
 
215
        function create_function($function_name, $callback, $num_arg=null) {
 
216
                try {
 
217
                        if(method_exists($this->connId, 'sqliteCreateFunction')) {
 
218
                                if(DEBUG) return $this->connId->sqliteCreateFunction($function_name, $callback, $num_arg);
 
219
                                else return @$this->connId->sqliteCreateFunction($function_name, $callback, $num_arg);
 
220
                        } else {
 
221
                                return false;
 
222
                        }
 
223
        } catch(PDOException $e) {
 
224
                        $this->error = true;
 
225
                        $this->errorMessage = $e->getMessage();
 
226
                        return false; 
 
227
        }
 
228
        }
 
229
        
 
230
        function create_aggregate($function_name, $step_func, $finalize_func, $num_args=null) {
 
231
                if(method_exists($this->connId, 'sqliteCreateAggregate')) {
 
232
                        try {
 
233
                                if(DEBUG) return $this->connId->sqliteCreateAggregate($function_name, $step_func, $finalize_func, $num_args);
 
234
                                else return @$this->connId->sqliteCreateAggregate($function_name, $step_func, $finalize_func, $num_args);
 
235
                } catch(PDOException $e) {
 
236
                                $this->error = true;
 
237
                                $this->errorMessage = $e->getMessage();
 
238
                                return false; 
 
239
                }
 
240
                } else {
 
241
                        return false;
 
242
                }
 
243
        }
 
244
        
 
245
    function sqlite_version() {
 
246
                try {
 
247
                $query = "SELECT sqlite_version();";
 
248
                $res = $this->query($query, true, false);
 
249
                $Result = $this->fetch_single($res, SQLITE_NUM);
 
250
                if($Result) return $Result;
 
251
                else return false;
 
252
        } catch(PDOException $e) {
 
253
                        $this->error = true;
 
254
                        $this->errorMessage = $e->getMessage();
 
255
                        return false; 
 
256
        }
 
257
    }
 
258
    
 
259
    function close() {
 
260
        // set obj to null
 
261
    }
 
262
 
 
263
        function sqlitem_busy_timeout($milliseconds=0) {
 
264
                try {
 
265
                        $this->connId->setAttribute(PDO_ATTR_TIMEOUT, $milliseconds);
 
266
                        return true;
 
267
        } catch(PDOException $e) {
 
268
                        $this->error = true;
 
269
                        $this->errorMessage = $e->getMessage();
 
270
                        return false; 
 
271
        }
 
272
        }
 
273
        
 
274
        function convertResultType($type) {
 
275
                $fetch_style = PDO_FETCH_BOTH;
 
276
                if($type == SQLITE_ASSOC)               $fetch_style = PDO_FETCH_ASSOC;
 
277
                elseif($type == SQLITE_NUM)     $fetch_style = PDO_FETCH_NUM;
 
278
                elseif($type == SQLITE_BOTH)    $fetch_style = PDO_FETCH_BOTH;  
 
279
                return  $fetch_style;
 
280
        }
 
281
        
 
282
        function beginTransaction() {
 
283
                try {
 
284
                        $this->connId->beginTransaction();
 
285
        } catch(PDOException $e) {
 
286
                        $this->error = true;
 
287
                        $this->errorMessage = $e->getMessage();
 
288
                        return false; 
 
289
        }
 
290
        }
 
291
        
 
292
        function commitTransaction() {
 
293
                try {
 
294
                        $this->connId->commit();
 
295
        } catch(PDOException $e) {
 
296
                        $this->error = true;
 
297
                        $this->errorMessage = $e->getMessage();
 
298
                        return false; 
 
299
        }
 
300
        }
 
301
        
 
302
        function rollBackTransaction() {
 
303
                try {
 
304
                        $this->connId->rollBack();
 
305
        } catch(PDOException $e) {
 
306
                        $this->error = true;
 
307
                        $this->errorMessage = $e->getMessage();
 
308
                        return false; 
 
309
        }
 
310
        }
 
311
}
 
312
?>