1 |
rodolico |
1 |
<?php
|
|
|
2 |
|
13 |
rodolico |
3 |
/*
|
|
|
4 |
* Class DBQuery
|
|
|
5 |
*
|
16 |
rodolico |
6 |
* PHP Class as a wrapper around the mysqli class. Allows you to make
|
13 |
rodolico |
7 |
* the connection and run queries and/or DDL's if needed with the
|
16 |
rodolico |
8 |
* most common parameters (ie, not as flexible as mysqli itself).
|
13 |
rodolico |
9 |
* Enhancements include:
|
|
|
10 |
*
|
|
|
11 |
* Logs all queries with an optional username except select statements
|
|
|
12 |
* ie, anything that will change the system ( insert, delete, update,
|
|
|
13 |
* create, drop, alter, etc... ). Statement are logged with a date/time
|
|
|
14 |
* stamp, the user who performed the function, and the query executed
|
|
|
15 |
*
|
|
|
16 |
* Errors are simply trapped and the message is stored in the public
|
|
|
17 |
* member $error. Functions which find an error return boolean false
|
|
|
18 |
*
|
|
|
19 |
* Public Functions are:
|
|
|
20 |
* __construct -- creates connection
|
|
|
21 |
* doSQL -- executes an SQL query or DDL
|
|
|
22 |
* errors -- returns all errors not yet cleared
|
|
|
23 |
* can also directly access via public member errors
|
|
|
24 |
*
|
|
|
25 |
* public static function makeSafeSQLConstant ( $value, $type='S', $default='null', $falsetrue='10' ) {
|
1 |
rodolico |
26 |
|
4 |
rodolico |
27 |
|
13 |
rodolico |
28 |
* Author: R. W. Rodolico (rodo@dailydata.net)
|
|
|
29 |
* Date: 2018-04-30
|
|
|
30 |
*
|
|
|
31 |
*/
|
|
|
32 |
|
|
|
33 |
class DBQuery extends mysqli {
|
|
|
34 |
|
|
|
35 |
/* everything is in the one $parameters array, which can then
|
|
|
36 |
* be set/saved/loaded as needed
|
|
|
37 |
*/
|
6 |
rodolico |
38 |
protected $parameters = array(
|
13 |
rodolico |
39 |
// query(s) to be run
|
|
|
40 |
'query' => '',
|
|
|
41 |
// additional clause to be added to where on a statement
|
|
|
42 |
'whereClause' => '',
|
|
|
43 |
// additional order by clause to be added
|
|
|
44 |
'orderBy' => '',
|
|
|
45 |
// the number of rows 1) affectd by an insert, update or delete or 2) returned by a select
|
|
|
46 |
'rowsAffected' => '',
|
|
|
47 |
// the value of the last row inserted
|
|
|
48 |
'lastInsertKey' => '',
|
|
|
49 |
// an array that contains the data retrieved by a query (select only)
|
29 |
rodolico |
50 |
'returnData' => array(),
|
13 |
rodolico |
51 |
// an array that contains the meta data from the query for each column
|
29 |
rodolico |
52 |
'columnMetaData' => array(),
|
13 |
rodolico |
53 |
// number of columns (fields) returned by query (select only)
|
|
|
54 |
'numfields' => 0,
|
|
|
55 |
// human readable form of fetchType
|
36 |
rodolico |
56 |
'returnType' => 'both',
|
13 |
rodolico |
57 |
// array of any errors which occurred
|
|
|
58 |
'error' => array(),
|
|
|
59 |
// if set to a table name, all modifying queries are written to it
|
|
|
60 |
// must contain, at a minimum, columns whenrun timestamp, whoran varchar and query text
|
|
|
61 |
// can be created with $this->buildAuditTable
|
|
|
62 |
'auditTable' => '_activity_log'
|
|
|
63 |
);
|
|
|
64 |
|
37 |
rodolico |
65 |
public function __construct( $server, $username, $password, $database ) {
|
|
|
66 |
parent::__construct( $server, $username, $password, $database );
|
|
|
67 |
}
|
4 |
rodolico |
68 |
|
13 |
rodolico |
69 |
/*
|
|
|
70 |
* static function which simply parses out an error and returns
|
|
|
71 |
* a string suitable for printing. NOTE: it includes line returns
|
|
|
72 |
*/
|
|
|
73 |
public static function error2String( $error ) {
|
|
|
74 |
$return = array();
|
|
|
75 |
for ( $i = 0; $i < count( $error ); $i++ ) {
|
|
|
76 |
$return[] = implode( "\n", array( 'Error ' . $error[$i]['id'] . ' - ' . $error[$i]['message'], 'while executing query', $error[$i]['query'] ) );
|
6 |
rodolico |
77 |
}
|
13 |
rodolico |
78 |
return implode( "\n\n", $return ) . "\n";
|
|
|
79 |
} // error2String
|
6 |
rodolico |
80 |
|
13 |
rodolico |
81 |
// simply returns parameters for saving and reloading later
|
6 |
rodolico |
82 |
public function save() {
|
|
|
83 |
return $this->parameters;
|
|
|
84 |
} // function save
|
13 |
rodolico |
85 |
|
|
|
86 |
// loads parameters from $this->save(), or hand built
|
6 |
rodolico |
87 |
public function load( $parameters = array() ) {
|
|
|
88 |
$this->parameters = $parameters;
|
|
|
89 |
} // function load
|
|
|
90 |
|
13 |
rodolico |
91 |
// sets a key/value pair in $this->parameters
|
|
|
92 |
// returns $value
|
1 |
rodolico |
93 |
public function __set( $name, $value ) {
|
6 |
rodolico |
94 |
$this->parameters[$name] = $value;
|
4 |
rodolico |
95 |
return $value;
|
1 |
rodolico |
96 |
}
|
13 |
rodolico |
97 |
|
|
|
98 |
// gets the current value of $this->parameters[$name]
|
1 |
rodolico |
99 |
public function __get( $name ) {
|
6 |
rodolico |
100 |
return isset( $this->parameters[$name] ) ? $this->parameters[$name] : null;
|
1 |
rodolico |
101 |
}
|
13 |
rodolico |
102 |
|
|
|
103 |
// returns true if $parameters[$name] is set
|
1 |
rodolico |
104 |
public function __isset( $name ) {
|
6 |
rodolico |
105 |
return isset( $this->parameters[$name] );
|
1 |
rodolico |
106 |
}
|
13 |
rodolico |
107 |
|
|
|
108 |
|
|
|
109 |
/*
|
|
|
110 |
* function: buildAuditTable
|
|
|
111 |
* parameters:
|
|
|
112 |
* $tablename - name of table to be built
|
|
|
113 |
* $createStatement - SQL DDL to build the table
|
|
|
114 |
*
|
|
|
115 |
* If $tablename is set, will use that, otherwise will use
|
|
|
116 |
* $parameters[auditTable]. In either case, $parameters[auditTable]
|
|
|
117 |
* is set to the value of the table used
|
|
|
118 |
*
|
|
|
119 |
* if $createStatement is set, will be run WITHOUT MODIFICATION, and
|
|
|
120 |
* $parameters[auditTable] is not set to anything (unless $tablename
|
|
|
121 |
* is set)
|
|
|
122 |
*
|
|
|
123 |
* If $createStatement is not set, will use a default to build
|
|
|
124 |
* a table from $parameters[auditTable].
|
|
|
125 |
*
|
|
|
126 |
* Can definitely blow up if the table name is not set both places
|
|
|
127 |
* or if $createStatement is fubar
|
|
|
128 |
*/
|
|
|
129 |
|
|
|
130 |
public function buildAuditTable( $tablename = '', $createStatement = '' ) {
|
|
|
131 |
if ( $tablename ) // they sent us one, so set it
|
|
|
132 |
$this->parameters[ 'auditTable' ] = $tablename;
|
|
|
133 |
if ( ! $createStatement ) { // they did not set createStatement, so use our default
|
15 |
rodolico |
134 |
$auditTable = $this->parameters['auditTable'];
|
13 |
rodolico |
135 |
$createStatement = "
|
29 |
rodolico |
136 |
create table if not exists $auditTable (
|
13 |
rodolico |
137 |
_activity_log_id int unsigned not null auto_increment,
|
|
|
138 |
timestamp timestamp,
|
|
|
139 |
user varchar(64),
|
|
|
140 |
query text,
|
|
|
141 |
primary key(_activity_log_id)
|
|
|
142 |
) comment 'tracks queries which modify data'";
|
|
|
143 |
} // if
|
|
|
144 |
if ( parent::query( $createStatement ) === false ) {
|
|
|
145 |
// on error, die
|
|
|
146 |
print "Can not create audit table with query<br />\n$createStatement<br />\n";
|
|
|
147 |
die ( printf("Errormessage: %d - %s\n", $this->errno, $this->error ) );
|
|
|
148 |
} // if error, die
|
|
|
149 |
} // buildAuditTable
|
|
|
150 |
|
|
|
151 |
/*
|
|
|
152 |
* log queries to a table, file, or nothing
|
|
|
153 |
* log contains date/time, username and query
|
|
|
154 |
* to turn off logginging:
|
|
|
155 |
* unset( $parameters['auditTable'] )
|
|
|
156 |
*/
|
|
|
157 |
private function logIt( $username, $query, $recursion = false ) {
|
|
|
158 |
if ( ! isset( $this->parameters['auditTable'] ) )
|
|
|
159 |
return;
|
|
|
160 |
$username = $this->real_escape_string( $username );
|
|
|
161 |
$query = $this->real_escape_string( $query );
|
15 |
rodolico |
162 |
$logEntry = "insert into " . $this->parameters['auditTable'] . " (user, query) values ( '$username', '$query')";
|
13 |
rodolico |
163 |
//print "Loggging\n$logEntry\n";
|
|
|
164 |
if ( parent::query( $logEntry ) !== false ) { // good
|
|
|
165 |
return;
|
|
|
166 |
} else { // we had an error
|
|
|
167 |
if ( ! $recursion && $this->errno == 1146 ) { // table doesn't exist, so let's create it
|
15 |
rodolico |
168 |
$result = parent::query( "show tables like '" . $this->parameters['auditTable'] . "'" );
|
13 |
rodolico |
169 |
if ( $result->num_rows == 0 ) {
|
|
|
170 |
$this->buildAuditTable( );
|
|
|
171 |
return $this->logIt( $username, $query, true );
|
|
|
172 |
}
|
6 |
rodolico |
173 |
} else {
|
13 |
rodolico |
174 |
print "Trying to log transaction with query<br />\n$logEntry<br />\n";
|
|
|
175 |
die ( printf("Errormessage: %d - %s\n", $this->errno, $this->error ) );
|
|
|
176 |
} // if..else
|
1 |
rodolico |
177 |
} // if
|
13 |
rodolico |
178 |
} // function logIt
|
|
|
179 |
|
|
|
180 |
|
|
|
181 |
/*
|
|
|
182 |
* doSQL
|
|
|
183 |
* Parameters: $query - string or array of strings to be executed
|
|
|
184 |
* $parameters - hash used to pass additional parameters, to include
|
|
|
185 |
* $parameters['username'] = 'fred'; // username for logging
|
36 |
rodolico |
186 |
* $parameters['returnType'] = 'hash'; or array or both
|
13 |
rodolico |
187 |
*
|
|
|
188 |
* executes one or more queries
|
|
|
189 |
*
|
|
|
190 |
* If the query is one of select, show, describe or explain, it must
|
|
|
191 |
* be a single string. It will return the data results in a hash
|
|
|
192 |
* containing
|
39 |
rodolico |
193 |
* 'returnData' - an array of array/hash/both depending on what you asked for
|
13 |
rodolico |
194 |
* 'count' - number of results (ie, count(data)
|
|
|
195 |
* 'meta' - metadata for each column returned
|
|
|
196 |
* 'numfields' - number of columns in result (ie, count(meta))
|
|
|
197 |
* 'errors' - normally empty array of errors
|
|
|
198 |
*
|
|
|
199 |
* if the query modifies data (ie, NOT above), query may be an array
|
|
|
200 |
* which will be surrounded by a transaction and rolled back if
|
|
|
201 |
* anything causes an error.
|
|
|
202 |
*
|
|
|
203 |
* These will return a hash containing
|
|
|
204 |
* 'count' l- number of rows affected by last statement
|
|
|
205 |
* 'last_insert_id' - last insert id created by BLOCK of queries
|
|
|
206 |
* 'errors' - normally empty array of errors which occurred (caused a rollback)
|
|
|
207 |
*
|
|
|
208 |
*/
|
15 |
rodolico |
209 |
public function doSQL( $query = null, $parameters = array() ) {
|
13 |
rodolico |
210 |
$errors = array();
|
15 |
rodolico |
211 |
if ( isset( $query ) ) {
|
|
|
212 |
$this->parameters['query'] = $query;
|
|
|
213 |
}
|
42 |
rodolico |
214 |
if ( isset( $parameters['returnType'] ) ) {
|
|
|
215 |
$this->parameters['returnType'] = $parameters['returnType'];
|
|
|
216 |
}
|
13 |
rodolico |
217 |
// if it is a "selectstatement" it doesn't modify data
|
|
|
218 |
// if query is an array, assume it modifies something
|
|
|
219 |
// if it is a single statement, look for the regex
|
15 |
rodolico |
220 |
$selectStatement = is_array( $this->parameters['query'] ) ?
|
13 |
rodolico |
221 |
false :
|
29 |
rodolico |
222 |
( preg_match( '/^\s*(select)|(show)|(describe)|(explain)/xsi', $this->parameters['query'] ) === 1 );
|
13 |
rodolico |
223 |
|
|
|
224 |
// different actions based on whether it modifies data or not
|
|
|
225 |
if ( $selectStatement ) { // if a select, simply return the rows
|
|
|
226 |
// dataset is small enough, we just read it into memory all at one time.
|
42 |
rodolico |
227 |
// set MYSQLI_USE_RESULT for unbuffered results
|
15 |
rodolico |
228 |
if ( $sth = parent::query( $this->parameters['query'], MYSQLI_USE_RESULT ) ) {
|
13 |
rodolico |
229 |
if ( $sth === false ) {
|
|
|
230 |
$errors[] = array( 'id' => $this->errno, 'message' => $this->error );
|
|
|
231 |
} else {
|
42 |
rodolico |
232 |
// query can return either an array of array, array of hash, or both. Default is both
|
|
|
233 |
$returnType = MYSQLI_BOTH;
|
13 |
rodolico |
234 |
$this->parameters['columnMetaData'] = $sth->fetch_fields(); // get metadata
|
|
|
235 |
$this->parameters['returnData'] = array(); // we'll put all the results in an array
|
42 |
rodolico |
236 |
// $fetchtype returns either an array of array, array of hash, or both. Default is both
|
|
|
237 |
switch ( $this->parameters['returnType'] ) {
|
|
|
238 |
case 'array':
|
|
|
239 |
$returnType = MYSQLI_NUM;
|
|
|
240 |
break;
|
|
|
241 |
case 'associative':
|
|
|
242 |
$returnType = MYSQLI_ASSOC;
|
|
|
243 |
break;
|
|
|
244 |
default: $returnType = MYSQLI_BOTH;
|
13 |
rodolico |
245 |
}
|
|
|
246 |
// slurp all the stuff in
|
42 |
rodolico |
247 |
while ( $values = $sth->fetch_array( $returnType ) ) {
|
38 |
rodolico |
248 |
$this->parameters['returnData'][] = $values;
|
13 |
rodolico |
249 |
}
|
|
|
250 |
$sth->free(); // cleanup memory, don't need two copies
|
|
|
251 |
} // if we had no errors
|
1 |
rodolico |
252 |
}
|
13 |
rodolico |
253 |
$this->parameters[ 'rowsAffected' ] = count( $this->parameters[ 'returnData' ] );
|
|
|
254 |
$this->parameters[ 'numfields' ] = count( $this->parameters['columnMetaData'] );
|
|
|
255 |
$this->parameters[ 'lastInsertKey' ] = 0;
|
|
|
256 |
$this->parameters[ 'error' ] = $errors;
|
|
|
257 |
} else {
|
|
|
258 |
if ( ! is_array( $this->parameters['query'] ) ) { // not an array, so make it one
|
|
|
259 |
$temp = $this->parameters['query'];
|
|
|
260 |
$this->parameters['query'] = array( $temp );
|
1 |
rodolico |
261 |
}
|
13 |
rodolico |
262 |
// do it in a transaction so we can back out on failure
|
|
|
263 |
$this->autocommit(false);
|
|
|
264 |
$allOk = true;
|
|
|
265 |
for ( $i = 0; $i < count( $this->parameters['query'] ); $i++ ) {
|
15 |
rodolico |
266 |
// debugging
|
|
|
267 |
//print "$i\t" . $this->parameters['query'][$i] ."\n"; continue;
|
|
|
268 |
// debugging
|
13 |
rodolico |
269 |
$this->logIt( isset( $parameters['username'] ) ? $parameters['username'] : 'unknown', $this->parameters['query'][$i] );
|
|
|
270 |
if ( parent::query( $this->parameters['query'][$i] ) === false ) { // we had an erorr
|
|
|
271 |
// record it
|
|
|
272 |
$errors[] = array( 'id' => $this->errno, 'message' => $this->error, 'query' => $this->parameters['query'][$i] );
|
|
|
273 |
$allOk = false;
|
|
|
274 |
// and bail
|
|
|
275 |
break;
|
|
|
276 |
}
|
|
|
277 |
}
|
|
|
278 |
// if we made it through ok, commit, otherwise rollback
|
|
|
279 |
$allOk ? $this->commit() : $this->rollback();
|
|
|
280 |
// reset autocommit to true
|
|
|
281 |
$this->autocommit(true);
|
|
|
282 |
$this->parameters['query'] = $query;
|
|
|
283 |
$this->parameters[ 'rowsAffected' ] = $this->affected_rows;
|
|
|
284 |
$this->parameters[ 'lastInsertKey' ] = $this->insert_id;
|
|
|
285 |
$this->parameters[ 'error' ] = $errors;
|
|
|
286 |
} // if select .. else
|
|
|
287 |
return $this->parameters;
|
|
|
288 |
} // function doSQL
|
17 |
rodolico |
289 |
|
|
|
290 |
public function run () {
|
|
|
291 |
return $this->doSQL( );
|
|
|
292 |
}
|
34 |
rodolico |
293 |
|
|
|
294 |
/**
|
40 |
rodolico |
295 |
* Simple function returns last inserted id on succes, false on
|
|
|
296 |
* failure
|
|
|
297 |
*
|
|
|
298 |
* @params string $query An insert query to execute
|
|
|
299 |
* @return integer The insert id from this insert, if applicable
|
|
|
300 |
*/
|
|
|
301 |
|
|
|
302 |
public function insert( $query ) {
|
|
|
303 |
return $this->query( $query ) ? $this->insert_id : false;
|
|
|
304 |
}
|
|
|
305 |
|
|
|
306 |
|
|
|
307 |
/**
|
34 |
rodolico |
308 |
* returns an array of the first column for each row returned from query
|
|
|
309 |
*
|
|
|
310 |
* The query is run, then for each row returns, the first column
|
|
|
311 |
* is added to $return (an array). $return is then returned.
|
|
|
312 |
*
|
|
|
313 |
* Used to do things like get an array of keyfields, or something
|
|
|
314 |
* else.
|
|
|
315 |
*
|
|
|
316 |
* @param string $query Query to run
|
|
|
317 |
* @returns string[] Array of values
|
|
|
318 |
*/
|
|
|
319 |
public function columnToArray( $query ) {
|
|
|
320 |
$return = array();
|
|
|
321 |
$result = $this->doSQL( $query );
|
|
|
322 |
foreach ( $result['returnData'] as $row ) {
|
|
|
323 |
$return[] = $row['id'];
|
|
|
324 |
}
|
|
|
325 |
return $return;
|
|
|
326 |
}
|
1 |
rodolico |
327 |
|
|
|
328 |
/*
|
|
|
329 |
* function will return one and only one row, NOT as an array of array
|
|
|
330 |
* but as a single row array
|
|
|
331 |
* if more than one row is returned by query, error is set and function
|
|
|
332 |
* returns false.
|
|
|
333 |
* Otherwise, function returns true
|
|
|
334 |
*/
|
|
|
335 |
public function getOneRow( $sql = null ) {
|
|
|
336 |
if ( isset( $sql ) )
|
6 |
rodolico |
337 |
$this->parameters[ 'query' ] = $sql;
|
36 |
rodolico |
338 |
$save = $this->parameters[ 'returnType' ];
|
|
|
339 |
//print "<pre>" . print_r( $this->parameters['query'], true) . '</pre>';
|
43 |
rodolico |
340 |
$this->parameters['returnType'] = 'associative';
|
1 |
rodolico |
341 |
$this->run();
|
43 |
rodolico |
342 |
$this->parameters[ 'returnType' ] = $save;
|
|
|
343 |
if ( $this->parameters[ 'rowsAffected' ] == 0 ) {
|
|
|
344 |
return array();
|
|
|
345 |
} elseif ( $this->parameters[ 'rowsAffected' ] == 1 ) {
|
6 |
rodolico |
346 |
$this->parameters[ 'returnData' ] = $this->parameters[ 'returnData' ][0];
|
35 |
rodolico |
347 |
return $this->parameters[ 'returnData' ];
|
37 |
rodolico |
348 |
} else {
|
43 |
rodolico |
349 |
$this->parameters['error'] = "$this->parameters[query] did not return a unique row";
|
|
|
350 |
print "<pre>In Class DBQuery->getOneRow, no unique row in\n" . print_r($this->parameters[query], true) . "\n</pre>"; die;
|
37 |
rodolico |
351 |
}
|
1 |
rodolico |
352 |
return false;
|
|
|
353 |
} // getOneRow
|
|
|
354 |
|
|
|
355 |
|
|
|
356 |
// function returns the first column of the first row of data returned from query
|
|
|
357 |
// or null no value returned
|
6 |
rodolico |
358 |
public function getOneDBValue( $sql = null ) {
|
34 |
rodolico |
359 |
//print '<pre>' . $sql . '</pre>';
|
1 |
rodolico |
360 |
if ( isset( $sql ) )
|
6 |
rodolico |
361 |
$this->parameters[ 'query' ] = $sql;
|
36 |
rodolico |
362 |
$save = $this->parameters['returnType'];
|
|
|
363 |
$this->parameters['returnType'] = 'array';
|
1 |
rodolico |
364 |
$this->run();
|
36 |
rodolico |
365 |
$this->parameters['returnType'] = $save;
|
|
|
366 |
//print "<pre>" . print_r($this->parameters,true ) . "</pre>";
|
6 |
rodolico |
367 |
return $this->parameters[ 'rowsAffected' ] ? $this->parameters[ 'returnData' ][0][0] : null;
|
1 |
rodolico |
368 |
}
|
6 |
rodolico |
369 |
|
4 |
rodolico |
370 |
/*
|
|
|
371 |
* function will attempt to make a constant ($value) safe for SQL depending on the type.
|
|
|
372 |
*
|
|
|
373 |
* if $value is empty, $default is returned, as will happen if any of the
|
|
|
374 |
* conversions (date, datetime, etc...) fail.
|
|
|
375 |
*
|
|
|
376 |
* First, it will pass it through get_magic_quotes_gpc,
|
|
|
377 |
* then will run through mysql_real_escape_string
|
|
|
378 |
*
|
|
|
379 |
* For strings, will encapsulate in quotes
|
|
|
380 |
* Dates will attempt a conversion, then change to YYYY-MM-DD and encapsulate in quotes
|
|
|
381 |
* DateTime will perform the same, but change to YYYY-MM-DD HH:MM:SS
|
|
|
382 |
* Integer and Floats are passed through builtins intval and floatval
|
|
|
383 |
* Boolean only checks the first character, a '0', 'f' and 'n' denoting false
|
|
|
384 |
* all else denoting true. The result is converted based on the variable
|
|
|
385 |
* $falsetrue, with the first char denoting false and the second denoting true
|
|
|
386 |
*/
|
|
|
387 |
public static function makeSafeSQLConstant ( $value, $type='S', $default='null', $falsetrue='10' ) {
|
|
|
388 |
if (strlen($value) == 0) // simply set any empty values to null
|
|
|
389 |
return $default;
|
|
|
390 |
// print "Processing $value as $type with default $default<br>\n";
|
|
|
391 |
switch ( strtolower( $type ) ) {
|
|
|
392 |
case 'string' :
|
|
|
393 |
case 's' :
|
|
|
394 |
if ( get_magic_quotes_gpc() )
|
|
|
395 |
$value = stripslashes($value);
|
13 |
rodolico |
396 |
$value = $this->real_escape_string( $value );
|
4 |
rodolico |
397 |
$value = strlen( $value ) > 0 ? "'$value'" : $default;
|
|
|
398 |
break;
|
|
|
399 |
case 'date' :
|
|
|
400 |
case 'd' :
|
|
|
401 |
if ( $value != 'null' ) {
|
|
|
402 |
$result = strtotime( $value );
|
|
|
403 |
$value = ( $result === false ) ? $default : "'" . Date( 'Y-m-d', $result) . "'";
|
|
|
404 |
}
|
|
|
405 |
break;
|
|
|
406 |
case 'datetime':
|
|
|
407 |
case 'timestamp':
|
|
|
408 |
case 'dt':
|
|
|
409 |
if ( $value != 'null' ) {
|
|
|
410 |
$result = strtotime( $value );
|
|
|
411 |
$value = ( $result === false ) ? $default : "'" . Date( 'Y-m-d H:i:s', $result) . "'";
|
|
|
412 |
}
|
|
|
413 |
break;
|
|
|
414 |
case 'integer':
|
|
|
415 |
case 'i' :
|
|
|
416 |
$value = intval( $value );
|
|
|
417 |
break;
|
|
|
418 |
case 'float':
|
|
|
419 |
case 'f' :
|
|
|
420 |
$value = floatval( $value );
|
|
|
421 |
break;
|
|
|
422 |
case 'bool':
|
|
|
423 |
case 'boolean':
|
|
|
424 |
case 'b' : // note, because of the way strpos works, you can not
|
|
|
425 |
// simply set $value based on the output; you MUST do
|
|
|
426 |
// as below; specifically check for false, then set the result
|
|
|
427 |
$value = strpos( '0fn', strtolower(substr( $value, 0, 1 )) ) === false ? 0 : 1;
|
|
|
428 |
$value = substr( $falsetrue, $value, 0, 1 );
|
|
|
429 |
break;
|
|
|
430 |
} // switch
|
|
|
431 |
return $value;
|
|
|
432 |
}
|
1 |
rodolico |
433 |
|
29 |
rodolico |
434 |
/*
|
|
|
435 |
'[^']*(?!\\)'(*SKIP)(*F) # Make sure we're not matching inside of quotes
|
|
|
436 |
|(?m-s:\s*(?:\-{2}|\#)[^\n]*$) # Single line comment
|
|
|
437 |
|(?:
|
|
|
438 |
\/\*.*?\*\/ # Multi-line comment
|
|
|
439 |
(?(?=(?m-s:\h+$)) # Get trailing whitespace if any exists and only if it's the rest of the line
|
|
|
440 |
\h+
|
|
|
441 |
)
|
|
|
442 |
)
|
|
|
443 |
*/
|
|
|
444 |
/**
|
|
|
445 |
* Functions strips SQL queries from a file. Above is a commented copy of the regex used
|
|
|
446 |
*
|
|
|
447 |
* @param string $query An arbitrary sized SQL script
|
|
|
448 |
* @returns string $query, with all SQL comments removed
|
|
|
449 |
*/
|
4 |
rodolico |
450 |
|
29 |
rodolico |
451 |
public function strip_sqlcomment ($query = '') {
|
|
|
452 |
$regex = '\'[^\']*(?!\\\)\'(*SKIP)(*F)|(?m-s:\\s*(?:\\-{2}|\\#)[^\\n]*$)|(?:\\/\\*.*?\\*\\/(?(?=(?m-s:\h+$))\\h+))';
|
|
|
453 |
//print "<pre>$regex</pre>" ; die;
|
|
|
454 |
return (($query == '') ? '' : preg_replace( "/$regex/xs", '', $query ));
|
|
|
455 |
}
|
|
|
456 |
|
|
|
457 |
/**
|
|
|
458 |
* runs an SQL script with multiple statements in it
|
|
|
459 |
*
|
37 |
rodolico |
460 |
* If $sql is an array, it is assumed each row is a separate query
|
|
|
461 |
*
|
|
|
462 |
* If $sql is a string, will separate it into different lines and
|
|
|
463 |
* execute them
|
|
|
464 |
*
|
29 |
rodolico |
465 |
* NOTE: it does this by breaking it based on the semicolon, so
|
|
|
466 |
* in some weird situations, it will break at the wrong place.
|
|
|
467 |
*
|
|
|
468 |
*/
|
|
|
469 |
public function runSQLScript( $sql ) {
|
37 |
rodolico |
470 |
if ( is_array( $sql ) ) {
|
|
|
471 |
$queries = $sql;
|
|
|
472 |
} else {
|
|
|
473 |
$sql = $this->strip_sqlcomment( $sql );
|
|
|
474 |
$queries = explode( ";", $sql );
|
|
|
475 |
}
|
29 |
rodolico |
476 |
//print "<pre>" . print_r( $queries, true ) . '</pre>'; die;
|
|
|
477 |
foreach ( $queries as $query ) {
|
|
|
478 |
$this->doSQL( trim( implode( ' ', explode("\n",$query ) ) ) );
|
|
|
479 |
}
|
37 |
rodolico |
480 |
} // runSQLScript
|
|
|
481 |
|
|
|
482 |
/**
|
|
|
483 |
* Overrides real_escape_string to change behaviour slightly
|
|
|
484 |
*
|
|
|
485 |
* Will check if string is pure numeric and, if it is, will return
|
|
|
486 |
* as it is. Otherwise, will call real_escape_string, then wrap
|
|
|
487 |
* result in single quotes
|
|
|
488 |
*/
|
|
|
489 |
public function my_escape_string( $string, $additionalEscapes = array() ) {
|
|
|
490 |
if ( is_numeric( $string ) )
|
|
|
491 |
return $string;
|
|
|
492 |
$string = $this->real_escape_string( $string );
|
|
|
493 |
if ( count( $additionalEscapes ) )
|
|
|
494 |
$string = addcslashes( $string, implode( '', $additionalEscapes ) );
|
|
|
495 |
return "'$string'";
|
|
|
496 |
}
|
|
|
497 |
|
|
|
498 |
/**
|
|
|
499 |
* Builds a query of form update $tablename set $fields where $where
|
|
|
500 |
*
|
|
|
501 |
* Creates a query that will update table $tablename. It assumes
|
|
|
502 |
* $fields is an array where the indexes are fieldnames and the values
|
|
|
503 |
* are the new values for the field. Will escape the values.
|
|
|
504 |
*
|
|
|
505 |
* Appends $where, again where index is a field name
|
|
|
506 |
*/
|
|
|
507 |
public function updateQuery( $tablename, $where, $fields ) {
|
|
|
508 |
/*
|
|
|
509 |
print "<pre>updateQuery\n\ntable\n$tablename\n</pre>";
|
|
|
510 |
print "<pre>\nwhere\n" . print_r( $where, true ) . "\n</pre>";
|
|
|
511 |
print "<pre>fields\n" . print_r( $fields, true ) . "\n</pre>"; die;
|
|
|
512 |
*/
|
|
|
513 |
$sql = '';
|
|
|
514 |
$updateFields = array();
|
|
|
515 |
foreach ( $fields as $fieldname => $value ) {
|
|
|
516 |
$updateFields[] = sprintf( "%s = %s", $fieldname, $this->my_escape_string( $value ) );
|
|
|
517 |
}
|
|
|
518 |
$sql = "update $tablename set " . implode( ", ", $updateFields );
|
|
|
519 |
$updateFields = array();
|
|
|
520 |
foreach ( $where as $fieldname => $value ) {
|
|
|
521 |
$updateFields[] = sprintf( "%s = %s", $fieldname, $this->my_escape_string( $value ) );
|
|
|
522 |
}
|
|
|
523 |
if ( count( $updateFields ) ) {
|
|
|
524 |
$sql .= ' where ' . implode( ' and ', $updateFields );
|
|
|
525 |
}
|
|
|
526 |
return $sql;
|
|
|
527 |
}
|
|
|
528 |
|
|
|
529 |
/**
|
|
|
530 |
* Creates an insert query from $fields
|
|
|
531 |
*
|
|
|
532 |
*/
|
|
|
533 |
public function insertQuery( $tablename, $fields ) {
|
40 |
rodolico |
534 |
//print "<pre>insertQuery\n\ntable\n$tablename\n</pre>";
|
|
|
535 |
//print "<pre>fields\n" . print_r( $fields, true ) . "\n</pre>"; die;
|
37 |
rodolico |
536 |
$query = "insert into $tablename (" . implode( ',',array_keys($fields) );
|
40 |
rodolico |
537 |
$query .= ") values (" . implode( ',', array_map( array($this, 'my_escape_string'), array_values( $fields ) ) );
|
37 |
rodolico |
538 |
return "$query)";
|
|
|
539 |
} // insertQuery
|
|
|
540 |
|
29 |
rodolico |
541 |
|
1 |
rodolico |
542 |
} // class DBQuery
|
|
|
543 |
|
17 |
rodolico |
544 |
/*
|
|
|
545 |
* $db = new DBQuery( '127.0.0.1', 'camp', 'camp', 'camp' );
|
13 |
rodolico |
546 |
|
|
|
547 |
if ($db->connect_error) {
|
|
|
548 |
die('Connect Error (' . $db->connect_errno . ') ' . $db->connect_error);
|
|
|
549 |
}
|
|
|
550 |
$result = $db->doSQL(
|
|
|
551 |
array(
|
|
|
552 |
'drop table if exists temp',
|
|
|
553 |
'create table temp ( col1 int unsigned )',
|
|
|
554 |
"insert into temp values ('mike')"
|
|
|
555 |
)
|
|
|
556 |
);
|
15 |
rodolico |
557 |
if ( $result['error'] ) {
|
13 |
rodolico |
558 |
print_r ( $result );
|
15 |
rodolico |
559 |
die ( DBQuery::error2String( $result['error'] ) );
|
13 |
rodolico |
560 |
} else {
|
|
|
561 |
print "running select\n";
|
|
|
562 |
$result = $db->doSQL( 'select * from temp' );
|
|
|
563 |
print_r( $result );
|
|
|
564 |
}
|
|
|
565 |
// $return = $db->doSQL( "select device.device_id 'id',device.name 'name', device_type.name 'type' from device join device_type using (device_type_id) where device.removed_date is null and device_type.show_as_system = 'Y'" );
|
|
|
566 |
// print_r( $return );
|
|
|
567 |
// print_r( $db );
|
17 |
rodolico |
568 |
*/
|
1 |
rodolico |
569 |
?>
|
13 |
rodolico |
570 |
|
|
|
571 |
|
|
|
572 |
|
|
|
573 |
|
|
|
574 |
|
|
|
575 |
|
|
|
576 |
|
|
|
577 |
|
|
|
578 |
|
|
|
579 |
|