← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/php/phpBB3/includes/db/mssql_odbc.php

Merge setup-stuff.

phpBB is gone, configuration, setup and jail building are completely redone.

Please read doc/setup/install_proc.txt, or you'll not get far.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/php/phpBB3/includes/db/mssql_odbc.php
1
 
<?php
2
 
/**
3
 
*
4
 
* @package dbal
5
 
* @version $Id: mssql_odbc.php,v 1.37 2007/10/05 14:36:32 acydburn Exp $
6
 
* @copyright (c) 2005 phpBB Group
7
 
* @license http://opensource.org/licenses/gpl-license.php GNU Public License
8
 
*
9
 
*/
10
 
 
11
 
/**
12
 
* @ignore
13
 
*/
14
 
if (!defined('IN_PHPBB'))
15
 
{
16
 
        exit;
17
 
}
18
 
 
19
 
include_once($phpbb_root_path . 'includes/db/dbal.' . $phpEx);
20
 
 
21
 
/**
22
 
* Unified ODBC functions
23
 
* Unified ODBC functions support any database having ODBC driver, for example Adabas D, IBM DB2, iODBC, Solid, Sybase SQL Anywhere...
24
 
* Here we only support MSSQL Server 2000+ because of the provided schema
25
 
*
26
 
* @note number of bytes returned for returning data depends on odbc.defaultlrl php.ini setting.
27
 
* If it is limited to 4K for example only 4K of data is returned max, resulting in incomplete theme data for example.
28
 
* @note odbc.defaultbinmode may affect UTF8 characters
29
 
*
30
 
* @package dbal
31
 
*/
32
 
class dbal_mssql_odbc extends dbal
33
 
{
34
 
        var $last_query_text = '';
35
 
 
36
 
        /**
37
 
        * Connect to server
38
 
        */
39
 
        function sql_connect($sqlserver, $sqluser, $sqlpassword, $database, $port = false, $persistency = false, $new_link = false)
40
 
        {
41
 
                $this->persistency = $persistency;
42
 
                $this->user = $sqluser;
43
 
                $this->server = $sqlserver . (($port) ? ':' . $port : '');
44
 
                $this->dbname = $database;
45
 
 
46
 
                $max_size = @ini_get('odbc.defaultlrl');
47
 
                if (!empty($max_size))
48
 
                {
49
 
                        $unit = strtolower(substr($max_size, -1, 1));
50
 
                        $max_size = (int) $max_size;
51
 
 
52
 
                        if ($unit == 'k')
53
 
                        {
54
 
                                $max_size = floor($max_size / 1024);
55
 
                        }
56
 
                        else if ($unit == 'g')
57
 
                        {
58
 
                                $max_size *= 1024;
59
 
                        }
60
 
                        else if (is_numeric($unit))
61
 
                        {
62
 
                                $max_size = floor((int) ($max_size . $unit) / 1048576);
63
 
                        }
64
 
                        $max_size = max(8, $max_size) . 'M';
65
 
 
66
 
                        @ini_set('odbc.defaultlrl', $max_size);
67
 
                }
68
 
 
69
 
                $this->db_connect_id = ($this->persistency) ? @odbc_pconnect($this->server, $this->user, $sqlpassword) : @odbc_connect($this->server, $this->user, $sqlpassword);
70
 
 
71
 
                return ($this->db_connect_id) ? $this->db_connect_id : $this->sql_error('');
72
 
        }
73
 
 
74
 
        /**
75
 
        * Version information about used database
76
 
        */
77
 
        function sql_server_info()
78
 
        {
79
 
                $result_id = @odbc_exec($this->db_connect_id, "SELECT SERVERPROPERTY('productversion'), SERVERPROPERTY('productlevel'), SERVERPROPERTY('edition')");
80
 
 
81
 
                $row = false;
82
 
                if ($result_id)
83
 
                {
84
 
                        $row = @odbc_fetch_array($result_id);
85
 
                        @odbc_free_result($result_id);
86
 
                }
87
 
 
88
 
                if ($row)
89
 
                {
90
 
                        return 'MSSQL (ODBC)<br />' . implode(' ', $row);
91
 
                }
92
 
 
93
 
                return 'MSSQL (ODBC)';
94
 
        }
95
 
 
96
 
        /**
97
 
        * SQL Transaction
98
 
        * @access private
99
 
        */
100
 
        function _sql_transaction($status = 'begin')
101
 
        {
102
 
                switch ($status)
103
 
                {
104
 
                        case 'begin':
105
 
                                return @odbc_exec($this->db_connect_id, 'BEGIN TRANSACTION');
106
 
                        break;
107
 
 
108
 
                        case 'commit':
109
 
                                return @odbc_exec($this->db_connect_id, 'COMMIT TRANSACTION');
110
 
                        break;
111
 
 
112
 
                        case 'rollback':
113
 
                                return @odbc_exec($this->db_connect_id, 'ROLLBACK TRANSACTION');
114
 
                        break;
115
 
                }
116
 
 
117
 
                return true;
118
 
        }
119
 
 
120
 
        /**
121
 
        * Base query method
122
 
        *
123
 
        * @param        string  $query          Contains the SQL query which shall be executed
124
 
        * @param        int             $cache_ttl      Either 0 to avoid caching or the time in seconds which the result shall be kept in cache
125
 
        * @return       mixed                           When casted to bool the returned value returns true on success and false on failure
126
 
        *
127
 
        * @access       public
128
 
        */
129
 
        function sql_query($query = '', $cache_ttl = 0)
130
 
        {
131
 
                if ($query != '')
132
 
                {
133
 
                        global $cache;
134
 
 
135
 
                        // EXPLAIN only in extra debug mode
136
 
                        if (defined('DEBUG_EXTRA'))
137
 
                        {
138
 
                                $this->sql_report('start', $query);
139
 
                        }
140
 
 
141
 
                        $this->last_query_text = $query;
142
 
                        $this->query_result = ($cache_ttl && method_exists($cache, 'sql_load')) ? $cache->sql_load($query) : false;
143
 
                        $this->sql_add_num_queries($this->query_result);
144
 
 
145
 
                        if ($this->query_result === false)
146
 
                        {
147
 
                                if (($this->query_result = @odbc_exec($this->db_connect_id, $query)) === false)
148
 
                                {
149
 
                                        $this->sql_error($query);
150
 
                                }
151
 
 
152
 
                                if (defined('DEBUG_EXTRA'))
153
 
                                {
154
 
                                        $this->sql_report('stop', $query);
155
 
                                }
156
 
 
157
 
                                if ($cache_ttl && method_exists($cache, 'sql_save'))
158
 
                                {
159
 
                                        $this->open_queries[(int) $this->query_result] = $this->query_result;
160
 
                                        $cache->sql_save($query, $this->query_result, $cache_ttl);
161
 
                                }
162
 
                                else if (strpos($query, 'SELECT') === 0 && $this->query_result)
163
 
                                {
164
 
                                        $this->open_queries[(int) $this->query_result] = $this->query_result;
165
 
                                }
166
 
                        }
167
 
                        else if (defined('DEBUG_EXTRA'))
168
 
                        {
169
 
                                $this->sql_report('fromcache', $query);
170
 
                        }
171
 
                }
172
 
                else
173
 
                {
174
 
                        return false;
175
 
                }
176
 
 
177
 
                return ($this->query_result) ? $this->query_result : false;
178
 
        }
179
 
 
180
 
        /**
181
 
        * Build LIMIT query
182
 
        */
183
 
        function _sql_query_limit($query, $total, $offset = 0, $cache_ttl = 0)
184
 
        {
185
 
                $this->query_result = false;
186
 
 
187
 
                // Since TOP is only returning a set number of rows we won't need it if total is set to 0 (return all rows)
188
 
                if ($total)
189
 
                {
190
 
                        // We need to grab the total number of rows + the offset number of rows to get the correct result
191
 
                        if (strpos($query, 'SELECT DISTINCT') === 0)
192
 
                        {
193
 
                                $query = 'SELECT DISTINCT TOP ' . ($total + $offset) . ' ' . substr($query, 15);
194
 
                        }
195
 
                        else
196
 
                        {
197
 
                                $query = 'SELECT TOP ' . ($total + $offset) . ' ' . substr($query, 6);
198
 
                        }
199
 
                }
200
 
 
201
 
                $result = $this->sql_query($query, $cache_ttl);
202
 
 
203
 
                // Seek by $offset rows
204
 
                if ($offset)
205
 
                {
206
 
                        $this->sql_rowseek($offset, $result);
207
 
                }
208
 
 
209
 
                return $result;
210
 
        }
211
 
 
212
 
        /**
213
 
        * Return number of affected rows
214
 
        */
215
 
        function sql_affectedrows()
216
 
        {
217
 
                return ($this->db_connect_id) ? @odbc_num_rows($this->query_result) : false;
218
 
        }
219
 
 
220
 
        /**
221
 
        * Fetch current row
222
 
        * @note number of bytes returned depends on odbc.defaultlrl php.ini setting. If it is limited to 4K for example only 4K of data is returned max.
223
 
        */
224
 
        function sql_fetchrow($query_id = false, $debug = false)
225
 
        {
226
 
                global $cache;
227
 
 
228
 
                if ($query_id === false)
229
 
                {
230
 
                        $query_id = $this->query_result;
231
 
                }
232
 
 
233
 
                if (isset($cache->sql_rowset[$query_id]))
234
 
                {
235
 
                        return $cache->sql_fetchrow($query_id);
236
 
                }
237
 
 
238
 
                return ($query_id !== false) ? @odbc_fetch_array($query_id) : false;
239
 
        }
240
 
 
241
 
        /**
242
 
        * Seek to given row number
243
 
        * rownum is zero-based
244
 
        */
245
 
        function sql_rowseek($rownum, &$query_id)
246
 
        {
247
 
                global $cache;
248
 
 
249
 
                if ($query_id === false)
250
 
                {
251
 
                        $query_id = $this->query_result;
252
 
                }
253
 
 
254
 
                if (isset($cache->sql_rowset[$query_id]))
255
 
                {
256
 
                        return $cache->sql_rowseek($rownum, $query_id);
257
 
                }
258
 
 
259
 
                if ($query_id === false)
260
 
                {
261
 
                        return false;
262
 
                }
263
 
 
264
 
                $this->sql_freeresult($query_id);
265
 
                $query_id = $this->sql_query($this->last_query_text);
266
 
 
267
 
                if ($query_id === false)
268
 
                {
269
 
                        return false;
270
 
                }
271
 
 
272
 
                // We do not fetch the row for rownum == 0 because then the next resultset would be the second row
273
 
                for ($i = 0; $i < $rownum; $i++)
274
 
                {
275
 
                        if (!$this->sql_fetchrow($query_id))
276
 
                        {
277
 
                                return false;
278
 
                        }
279
 
                }
280
 
 
281
 
                return true;
282
 
        }
283
 
 
284
 
        /**
285
 
        * Get last inserted id after insert statement
286
 
        */
287
 
        function sql_nextid()
288
 
        {
289
 
                $result_id = @odbc_exec($this->db_connect_id, 'SELECT @@IDENTITY');
290
 
 
291
 
                if ($result_id)
292
 
                {
293
 
                        if (@odbc_fetch_array($result_id))
294
 
                        {
295
 
                                $id = @odbc_result($result_id, 1);
296
 
                                @odbc_free_result($result_id);
297
 
                                return $id;
298
 
                        }
299
 
                        @odbc_free_result($result_id);
300
 
                }
301
 
 
302
 
                return false;
303
 
        }
304
 
 
305
 
        /**
306
 
        * Free sql result
307
 
        */
308
 
        function sql_freeresult($query_id = false)
309
 
        {
310
 
                global $cache;
311
 
 
312
 
                if ($query_id === false)
313
 
                {
314
 
                        $query_id = $this->query_result;
315
 
                }
316
 
 
317
 
                if (isset($cache->sql_rowset[$query_id]))
318
 
                {
319
 
                        return $cache->sql_freeresult($query_id);
320
 
                }
321
 
 
322
 
                if (isset($this->open_queries[(int) $query_id]))
323
 
                {
324
 
                        unset($this->open_queries[(int) $query_id]);
325
 
                        return @odbc_free_result($query_id);
326
 
                }
327
 
 
328
 
                return false;
329
 
        }
330
 
 
331
 
        /**
332
 
        * Escape string used in sql query
333
 
        */
334
 
        function sql_escape($msg)
335
 
        {
336
 
                return str_replace("'", "''", $msg);
337
 
        }
338
 
 
339
 
        /**
340
 
        * Build LIKE expression
341
 
        * @access private
342
 
        */
343
 
        function _sql_like_expression($expression)
344
 
        {
345
 
                return $expression . " ESCAPE '\\'";
346
 
        }
347
 
 
348
 
        /**
349
 
        * Build db-specific query data
350
 
        * @access private
351
 
        */
352
 
        function _sql_custom_build($stage, $data)
353
 
        {
354
 
                return $data;
355
 
        }
356
 
 
357
 
        /**
358
 
        * return sql error array
359
 
        * @access private
360
 
        */
361
 
        function _sql_error()
362
 
        {
363
 
                return array(
364
 
                        'message'       => @odbc_errormsg(),
365
 
                        'code'          => @odbc_error()
366
 
                );
367
 
        }
368
 
 
369
 
        /**
370
 
        * Close sql connection
371
 
        * @access private
372
 
        */
373
 
        function _sql_close()
374
 
        {
375
 
                return @odbc_close($this->db_connect_id);
376
 
        }
377
 
 
378
 
        /**
379
 
        * Build db-specific report
380
 
        * @access private
381
 
        */
382
 
        function _sql_report($mode, $query = '')
383
 
        {
384
 
                switch ($mode)
385
 
                {
386
 
                        case 'start':
387
 
                        break;
388
 
 
389
 
                        case 'fromcache':
390
 
                                $endtime = explode(' ', microtime());
391
 
                                $endtime = $endtime[0] + $endtime[1];
392
 
 
393
 
                                $result = @odbc_exec($this->db_connect_id, $query);
394
 
                                while ($void = @odbc_fetch_array($result))
395
 
                                {
396
 
                                        // Take the time spent on parsing rows into account
397
 
                                }
398
 
                                @odbc_free_result($result);
399
 
 
400
 
                                $splittime = explode(' ', microtime());
401
 
                                $splittime = $splittime[0] + $splittime[1];
402
 
 
403
 
                                $this->sql_report('record_fromcache', $query, $endtime, $splittime);
404
 
 
405
 
                        break;
406
 
                }
407
 
        }
408
 
}
409
 
 
410
 
?>
 
 
b'\\ No newline at end of file'