The error message.
153 | * @param bool|null $force_exception_after_error154 | * If you use default "null" here, then the behavior depends 155 | * on "$this->exit_on_error (default: true)". 156 | *
157 | * 158 | * @throws QueryException 159 | * 160 | * @return void 161 | */ 162 | public function displayError($error, $force_exception_after_error = null) 163 | { 164 | $fileInfo = $this->getFileAndLineFromSql(); 165 | 166 | $log = '[' . \date('Y-m-d H:i:s') . ']: SQL-Error: ' . $error . ' | Trace: ' . $fileInfo['path'] . '
190 | Error:' . $error . '
191 |
192 | Trace: ' . $fileInfo['path'] . '
193 |
194 | Will return false, if no logging was used.
297 | */ 298 | public function logQuery($sql, $duration, $results, bool $sql_error = false) 299 | { 300 | $logLevelUse = \strtolower($this->logger_level); 301 | 302 | if ( 303 | $sql_error === false 304 | && 305 | ($logLevelUse !== 'trace' && $logLevelUse !== 'debug') 306 | ) { 307 | return false; 308 | } 309 | 310 | // set log-level 311 | $logLevel = $logLevelUse; 312 | if ($sql_error === true) { 313 | $logLevel = 'error'; 314 | } 315 | 316 | // 317 | // logging 318 | // 319 | 320 | $traceStringExtra = ''; 321 | if ($logLevelUse === 'trace') { 322 | $tmpLink = $this->_db->getLink(); 323 | if ($tmpLink && $tmpLink instanceof \mysqli) { 324 | /** @noinspection PhpUsageOfSilenceOperatorInspection */ 325 | $traceStringExtra = @\mysqli_info($tmpLink); 326 | if ($traceStringExtra) { 327 | $traceStringExtra = ' | info => ' . $traceStringExtra; 328 | } 329 | } 330 | 331 | $traceStringExtra = ' | results => ' . \print_r($results, true) . $traceStringExtra; 332 | } 333 | 334 | static $SLOW_QUERY_WARNING = null; 335 | static $QUERY_LOG_FILE_INFO = []; 336 | 337 | $queryStatus = ''; 338 | if ($duration >= $this->slowQueryTimeWarning) { 339 | $queryStatus = ' WARN (DURATION) '; 340 | } 341 | if ($duration >= $this->slowQueryTimeError) { 342 | $queryStatus = ' ERROR (DURATION) '; 343 | } 344 | 345 | $fileInfo = $this->getFileAndLineFromSql(); 346 | $cacheKey = \md5($fileInfo['path']); 347 | if (empty($QUERY_LOG_FILE_INFO[$cacheKey])) { 348 | $QUERY_LOG_FILE_INFO[$cacheKey] = 0; 349 | } 350 | ++$QUERY_LOG_FILE_INFO[$cacheKey]; 351 | 352 | if ($QUERY_LOG_FILE_INFO[$cacheKey] >= $this->maxQueryRepeatWarning) { 353 | $queryStatus = ' WARN (REPEAT) '; 354 | } 355 | if ($QUERY_LOG_FILE_INFO[$cacheKey] >= $this->maxQueryRepeatError) { 356 | $queryStatus = ' ERROR (REPEAT) '; 357 | } 358 | 359 | $queryLog = '[' . \date('Y-m-d H:i:s') . ']: ' . $queryStatus . ' Duration: SQL::::DURATION-START' . \round($duration, 5) . 'SQL::::DURATION-END | Repeat: ' . $QUERY_LOG_FILE_INFO[$cacheKey] . ' | Host: ' . $this->_db->getConfig()['hostname'] . ' | Trace: ' . $fileInfo['path'] . ' | SQL: SQL::::QUERY-START ' . \str_replace("\n", '', $sql) . ' SQL::::QUERY-END' . $traceStringExtra . "\n"; 360 | 361 | return $this->logger([$logLevel, $queryLog, 'sql']); 362 | } 363 | 364 | /** 365 | * Wrapper-Function for a "Logger"-Class. 366 | * 367 | * INFO: 368 | * The "Logger"-ClassName is set by "$this->logger_class_name",Will return false, if no logging was used.
377 | */ 378 | public function logger(array $log) 379 | { 380 | // init 381 | $logMethod = ''; 382 | $logText = ''; 383 | $logType = 'sql'; 384 | $logClass = $this->logger_class_name; 385 | 386 | if (isset($log[0])) { 387 | $logMethod = $log[0]; 388 | } 389 | 390 | if (isset($log[1])) { 391 | $logText = $log[1]; 392 | } 393 | 394 | if (isset($log[2])) { 395 | $logType = $log[2]; 396 | } 397 | 398 | if ( 399 | $logClass 400 | && 401 | $logMethod 402 | && 403 | \class_exists($logClass) 404 | && 405 | \method_exists($logClass, $logMethod) 406 | ) { 407 | if (\method_exists($logClass, 'getInstance')) { 408 | return $logClass::getInstance()->{$logMethod}($logText, ['log_type' => $logType]); 409 | } 410 | 411 | return $logClass::$logMethod($logText, $logType); 412 | } 413 | 414 | return false; 415 | } 416 | 417 | /** 418 | * Send a error mail to the admin / dev. 419 | * 420 | * @param string $subject 421 | * @param string $htmlBody 422 | * @param int $priority 423 | * 424 | * @return void 425 | */ 426 | public function mailToAdmin($subject, $htmlBody, $priority = 3) 427 | { 428 | if (\function_exists('mailToAdmin')) { 429 | mailToAdmin($subject, $htmlBody, $priority); 430 | } else { 431 | if ($priority === 3) { 432 | $this->logger(['debug', $subject . ' | ' . $htmlBody]); 433 | } elseif ($priority > 3) { 434 | $this->logger(['error', $subject . ' | ' . $htmlBody]); 435 | } else { 436 | $this->logger(['info', $subject . ' | ' . $htmlBody]); 437 | } 438 | } 439 | } 440 | 441 | /** 442 | * @param bool $echo_on_error 443 | * 444 | * @return void 445 | */ 446 | public function setEchoOnError($echo_on_error) 447 | { 448 | $this->echo_on_error = (bool) $echo_on_error; 449 | } 450 | 451 | /** 452 | * @param bool $exit_on_error 453 | * 454 | * @return void 455 | */ 456 | public function setExitOnError($exit_on_error) 457 | { 458 | $this->exit_on_error = (bool) $exit_on_error; 459 | } 460 | 461 | /** 462 | * @param string $logger_class_name 463 | * 464 | * @return void 465 | */ 466 | public function setLoggerClassName($logger_class_name) 467 | { 468 | $this->logger_class_name = (string) $logger_class_name; 469 | } 470 | 471 | /** 472 | * @param string $logger_level 473 | * 474 | * @return void 475 | */ 476 | public function setLoggerLevel($logger_level) 477 | { 478 | $this->logger_level = (string) $logger_level; 479 | } 480 | } 481 | -------------------------------------------------------------------------------- /src/voku/db/Helper.php: -------------------------------------------------------------------------------- 1 | getConfig(); 23 | \array_walk_recursive( 24 | $configOrig, 25 | static function ($k, $v) use (&$configTmp) { 26 | $configTmp[] = $v; 27 | $configTmp[] = $k; 28 | } 29 | ); 30 | 31 | return \implode('--', $configTmp); 32 | } 33 | 34 | /** 35 | * Optimize tables 36 | * 37 | * @param array $tables database table names 38 | * @param DB|null $dbConnectionUse null to get your first singleton instance.
39 | * 40 | * @return int 41 | */ 42 | public static function optimizeTables(array $tables = [], DB $dbConnection = null): int 43 | { 44 | if ($dbConnection === null) { 45 | $dbConnection = DB::getInstance(); 46 | } 47 | 48 | $optimized = 0; 49 | if (!empty($tables)) { 50 | foreach ($tables as $table) { 51 | $optimize = 'OPTIMIZE TABLE ' . $dbConnection->quote_string($table); 52 | $result = $dbConnection->query($optimize); 53 | if ($result) { 54 | $optimized++; 55 | } 56 | } 57 | } 58 | 59 | return $optimized; 60 | } 61 | 62 | /** 63 | * Repair tables 64 | * 65 | * @param array $tables database table names 66 | * @param DB|null $dbConnectionUse null to get your first singleton instance.
67 | * 68 | * @return int 69 | */ 70 | public static function repairTables(array $tables = [], DB $dbConnection = null): int 71 | { 72 | if ($dbConnection === null) { 73 | $dbConnection = DB::getInstance(); 74 | } 75 | 76 | $optimized = 0; 77 | if (!empty($tables)) { 78 | foreach ($tables as $table) { 79 | $optimize = 'REPAIR TABLE ' . $dbConnection->quote_string($table); 80 | $result = $dbConnection->query($optimize); 81 | if ($result) { 82 | $optimized++; 83 | } 84 | } 85 | } 86 | 87 | return $optimized; 88 | } 89 | 90 | /** 91 | * Check if "mysqlnd"-driver is used. 92 | * 93 | * @return bool 94 | */ 95 | public static function isMysqlndIsUsed(): bool 96 | { 97 | static $MYSQLND_IS_USED_CACHE = null; 98 | 99 | if ($MYSQLND_IS_USED_CACHE === null) { 100 | $MYSQLND_IS_USED_CACHE = ( 101 | \extension_loaded('mysqlnd') 102 | && 103 | \function_exists('mysqli_fetch_all') 104 | ); 105 | } 106 | 107 | return $MYSQLND_IS_USED_CACHE; 108 | } 109 | 110 | /** 111 | * Check if the current environment supports "utf8mb4". 112 | * 113 | * @param DB $dbConnection 114 | * 115 | * @return bool 116 | */ 117 | public static function isUtf8mb4Supported(DB $dbConnection = null): bool 118 | { 119 | /** 120 | * https://make.wordpress.org/core/2015/04/02/the-utf8mb4-upgrade/ 121 | * 122 | * - You’re currently using the utf8 character set. 123 | * - Your MySQL server is version 5.5.3 or higher (including all 10.x versions of MariaDB). 124 | * - Your MySQL client libraries are version 5.5.3 or higher. If you’re using mysqlnd, 5.0.9 or higher. 125 | * 126 | * INFO: utf8mb4 is 100% backwards compatible with utf8. 127 | */ 128 | if ($dbConnection === null) { 129 | $dbConnection = DB::getInstance(); 130 | } 131 | 132 | $server_version = self::get_mysql_server_version($dbConnection); 133 | $client_version = self::get_mysql_client_version($dbConnection); 134 | 135 | if ( 136 | $server_version >= 50503 137 | && 138 | ( 139 | ( 140 | self::isMysqlndIsUsed() 141 | && 142 | $client_version >= 50009 143 | ) 144 | || 145 | ( 146 | !self::isMysqlndIsUsed() 147 | && 148 | $client_version >= 50503 149 | ) 150 | ) 151 | 152 | ) { 153 | return true; 154 | } 155 | 156 | return false; 157 | } 158 | 159 | /** 160 | * A phonetic search algorithms for different languages. 161 | * 162 | * INFO: if you need better performance, please save the "voku\helper\Phonetic"-output into the DB and search for it 163 | * 164 | * @param string $searchString 165 | * @param string $searchFieldName 166 | * @param string $idFieldName 167 | * @param string $languageen, de, fr
168 | * @param string $table 169 | * @param array $whereArray 170 | * @param DB|null $dbConnectionuse null if you will use the current database-connection
171 | * @param string|null $databaseNameuse null if you will use the current database
172 | * @param bool $useCache use cache? 173 | * @param int $cacheTTL cache-ttl in seconds 174 | * 175 | * @return array 176 | */ 177 | public static function phoneticSearch( 178 | string $searchString, 179 | string $searchFieldName, 180 | string $idFieldName = null, 181 | string $language = 'de', 182 | string $table = '', 183 | array $whereArray = null, 184 | DB $dbConnection = null, 185 | string $databaseName = null, 186 | bool $useCache = false, 187 | int $cacheTTL = 3600 188 | ): array { 189 | // init 190 | $cacheKey = null; 191 | 192 | if ($dbConnection === null) { 193 | $dbConnection = DB::getInstance(); 194 | } 195 | 196 | if ($table === '') { 197 | $debug = new Debug($dbConnection); 198 | $debug->displayError('Invalid table name, table name in empty.', false); 199 | 200 | return []; 201 | } 202 | 203 | if ($idFieldName === null) { 204 | $idFieldName = 'id'; 205 | } 206 | 207 | if ($whereArray === null) { 208 | $whereArray = []; 209 | } 210 | 211 | $whereSQL = $dbConnection->_parseArrayPair($whereArray, 'AND'); 212 | if ($whereSQL) { 213 | $whereSQL = 'AND ' . $whereSQL; 214 | } 215 | 216 | if ($databaseName) { 217 | $databaseName = $dbConnection->quote_string(\trim($databaseName)) . '.'; 218 | } 219 | 220 | // get the row 221 | $query = 'SELECT ' . $dbConnection->quote_string($searchFieldName) . ', ' . $dbConnection->quote_string($idFieldName) . ' 222 | FROM ' . $databaseName . $dbConnection->quote_string($table) . ' 223 | WHERE 1 = 1 224 | ' . $whereSQL . ' 225 | '; 226 | 227 | if ($useCache) { 228 | $cache = new \voku\cache\Cache(null, null, false, $useCache); 229 | $cacheKey = 'sql-phonetic-search-' . \md5($query); 230 | 231 | if ( 232 | $cache->getCacheIsReady() 233 | && 234 | $cache->existsItem($cacheKey) 235 | ) { 236 | return $cache->getItem($cacheKey); 237 | } 238 | } else { 239 | $cache = false; 240 | } 241 | 242 | $result = $dbConnection->query($query); 243 | 244 | if (!$result instanceof Result) { 245 | return []; 246 | } 247 | 248 | // make sure the row exists 249 | if ($result->num_rows <= 0) { 250 | return []; 251 | } 252 | 253 | $dataToSearchIn = []; 254 | /** @noinspection PhpAssignmentInConditionInspection */ 255 | while ($tmpArray = $result->fetchArray()) { 256 | $dataToSearchIn[$tmpArray[$idFieldName]] = $tmpArray[$searchFieldName]; 257 | } 258 | 259 | $phonetic = new \voku\helper\Phonetic($language); 260 | $return = $phonetic->phonetic_matches($searchString, $dataToSearchIn); 261 | 262 | // save into the cache 263 | if ( 264 | $cacheKey !== null 265 | && 266 | $useCache 267 | && 268 | $cache instanceof \voku\cache\Cache 269 | && 270 | $cache->getCacheIsReady() 271 | ) { 272 | $cache->setItem($cacheKey, $return, $cacheTTL); 273 | } 274 | 275 | return $return; 276 | } 277 | 278 | /** 279 | * A string that represents the MySQL client library version. 280 | * 281 | * @param DB $dbConnection 282 | * 283 | * @return string 284 | */ 285 | public static function get_mysql_client_version(DB $dbConnection = null): string 286 | { 287 | static $MYSQL_CLIENT_VERSION_CACHE = []; 288 | 289 | if ($dbConnection === null) { 290 | $dbConnection = DB::getInstance(); 291 | } 292 | 293 | $cacheKey = self::generateCacheKey($dbConnection); 294 | 295 | if (isset($MYSQL_CLIENT_VERSION_CACHE[$cacheKey])) { 296 | return $MYSQL_CLIENT_VERSION_CACHE[$cacheKey]; 297 | } 298 | 299 | $doctrineConnection = $dbConnection->getDoctrineConnection(); 300 | if ($doctrineConnection) { 301 | $doctrineWrappedConnection = $doctrineConnection->getWrappedConnection(); 302 | if ($doctrineWrappedConnection instanceof \Doctrine\DBAL\Driver\PDOConnection) { 303 | return $MYSQL_CLIENT_VERSION_CACHE[$cacheKey] = $doctrineWrappedConnection->getAttribute(5); // 5 = PDO::ATTR_CLIENT_VERSION 304 | } 305 | } 306 | 307 | $mysqli_link = $dbConnection->getLink(); 308 | if (!$mysqli_link) { 309 | return ''; 310 | } 311 | 312 | /** @noinspection PhpParamsInspection - false-positiv | https://github.com/voku/simple-mysqli/issues/50 */ 313 | return $MYSQL_CLIENT_VERSION_CACHE[$cacheKey] = (string) \mysqli_get_client_version(); 314 | } 315 | 316 | /** 317 | * Returns a string representing the version of the MySQL server that the MySQLi extension is connected to. 318 | * 319 | * @param DB $dbConnection 320 | * 321 | * @return string 322 | */ 323 | public static function get_mysql_server_version(DB $dbConnection = null): string 324 | { 325 | static $MYSQL_SERVER_VERSION_CACHE = []; 326 | 327 | if ($dbConnection === null) { 328 | $dbConnection = DB::getInstance(); 329 | } 330 | 331 | $cacheKey = self::generateCacheKey($dbConnection); 332 | 333 | if (isset($MYSQL_SERVER_VERSION_CACHE[$cacheKey])) { 334 | return $MYSQL_SERVER_VERSION_CACHE[$cacheKey]; 335 | } 336 | 337 | $doctrineConnection = $dbConnection->getDoctrineConnection(); 338 | if ($doctrineConnection) { 339 | $doctrineWrappedConnection = $doctrineConnection->getWrappedConnection(); 340 | if ($doctrineWrappedConnection instanceof \Doctrine\DBAL\Driver\PDOConnection) { 341 | return $MYSQL_SERVER_VERSION_CACHE[$cacheKey] = (string) $doctrineWrappedConnection->getServerVersion(); 342 | } 343 | } 344 | 345 | $mysqli_link = $dbConnection->getLink(); 346 | if (!$mysqli_link) { 347 | return ''; 348 | } 349 | 350 | return $MYSQL_SERVER_VERSION_CACHE[$cacheKey] = (string) \mysqli_get_server_version($mysqli_link); 351 | } 352 | 353 | /** 354 | * Return all db-fields from a table. 355 | * 356 | * @param string $table 357 | * @param bool $useStaticCache 358 | * @param DB|null $dbConnectionuse null if you will use the current database-connection
359 | * @param string|null $databaseNameuse null if you will use the current database
360 | * 361 | * @return array 362 | */ 363 | public static function getDbFields(string $table, bool $useStaticCache = true, DB $dbConnection = null, string $databaseName = null): array 364 | { 365 | static $DB_FIELDS_CACHE = []; 366 | 367 | // use the static cache 368 | if ( 369 | $useStaticCache 370 | && 371 | isset($DB_FIELDS_CACHE[$table]) 372 | ) { 373 | return $DB_FIELDS_CACHE[$table]; 374 | } 375 | 376 | // init 377 | $dbFields = []; 378 | 379 | if ($dbConnection === null) { 380 | $dbConnection = DB::getInstance(); 381 | } 382 | 383 | if ($table === '') { 384 | $debug = new Debug($dbConnection); 385 | $debug->displayError('Invalid table name, table name in empty.', false); 386 | 387 | return []; 388 | } 389 | 390 | if ($databaseName) { 391 | $databaseName = $dbConnection->quote_string(\trim($databaseName)) . '.'; 392 | } 393 | 394 | /** @var string $table */ 395 | $table = $dbConnection->escape($table); 396 | 397 | $sql = 'SHOW COLUMNS FROM ' . $databaseName . $table; 398 | $result = $dbConnection->query($sql); 399 | 400 | if ($result instanceof Result && $result->num_rows > 0) { 401 | foreach ($result->fetchAllArray() as $tmpResult) { 402 | $dbFields[] = $tmpResult['Field']; 403 | } 404 | } 405 | 406 | // add to static cache 407 | $DB_FIELDS_CACHE[$table] = $dbFields; 408 | 409 | return $dbFields; 410 | } 411 | 412 | /** 413 | * Copy row within a DB table and making updates to the columns. 414 | * 415 | * @param string $table 416 | * @param array $whereArray 417 | * @param array $updateArray 418 | * @param array $ignoreArray 419 | * @param DB|null $dbConnectionUse null to get your first singleton instance.
420 | * @param string|null $databaseNameuse null if you will use the current database
421 | * 422 | * @return false|int|string "int|string" (insert_id) by "INSERT / REPLACE"-queries262 | * The query, as a string. It must consist of a single SQL statement. 263 | *
264 | *265 | * You can include one or more parameter markers in the SQL statement by 266 | * embedding question mark (?) characters at the 267 | * appropriate positions. 268 | *
269 | *270 | * You should not add a terminating semicolon or \g 271 | * to the statement. 272 | *
273 | *274 | * The markers are legal only in certain places in SQL statements. 275 | * For example, they are allowed in the VALUES() list of an INSERT statement 276 | * (to specify column values for a row), or in a comparison with a column in 277 | * a WHERE clause to specify a comparison value. 278 | *
279 | *280 | * However, they are not allowed for identifiers (such as table or column names), 281 | * in the select list that names the columns to be returned by a SELECT statement), 282 | * or to specify both operands of a binary operator such as the = 283 | * equal sign. The latter restriction is necessary because it would be impossible 284 | * to determine the parameter type. In general, parameters are legal only in Data 285 | * Manipulation Language (DML) statements, and not in Data Definition Language 286 | * (DDL) statements. 287 | *
288 | * 289 | * @return bool 290 | *false on error
291 | * 292 | * @since 5.0 293 | */ 294 | public function prepare($query): bool 295 | { 296 | if (!\is_string($query)) { 297 | throw new \InvalidArgumentException('$query was no string: ' . \gettype($query)); 298 | } 299 | 300 | $this->_sql = $query; 301 | $this->_sql_with_bound_parameters = $query; 302 | 303 | if (!$this->_db->isReady()) { 304 | return false; 305 | } 306 | 307 | if (!$query) { 308 | $this->_debug->displayError('Can not prepare an empty query.', false); 309 | 310 | return false; 311 | } 312 | 313 | $bool = parent::prepare($query); 314 | 315 | if ($bool === false) { 316 | $this->_debug->displayError('Can not prepare query: ' . $query . ' | ' . $this->error, true); 317 | } 318 | 319 | return $bool; 320 | } 321 | 322 | /** 323 | * Ger the bound parameters from sql-query as array, if you use the "$this->bind_param_debug()" method. 324 | * 325 | * @return array 326 | */ 327 | public function get_bound_params(): array 328 | { 329 | return $this->_boundParams; 330 | } 331 | 332 | /** 333 | * @return string 334 | */ 335 | public function get_sql(): string 336 | { 337 | return $this->_sql; 338 | } 339 | 340 | /** 341 | * Get the sql-query with bound parameters, if you use the "$this->bind_param_debug()" method. 342 | * 343 | * @return string 344 | */ 345 | public function get_sql_with_bound_parameters(): string 346 | { 347 | return $this->_sql_with_bound_parameters; 348 | } 349 | 350 | /** 351 | * @return int|string 352 | */ 353 | public function insert_id() 354 | { 355 | return $this->insert_id; 356 | } 357 | 358 | /** 359 | * Copies $this->_sql then replaces bound markers with associated values ($this->_sql is not modified 360 | * but the resulting query string is assigned to $this->sql_bound_parameters) 361 | * 362 | * @return string $testQuery - interpolated db query string 363 | */ 364 | private function interpolateQuery(): string 365 | { 366 | $testQuery = $this->_sql; 367 | if ($this->_boundParams) { 368 | /** @noinspection AlterInForeachInspection */ 369 | foreach ($this->_boundParams as &$param) { 370 | $values = $this->_prepareValue($param); 371 | 372 | // set new values 373 | $param['value'] = $values[0]; 374 | // we need to replace the question mark "?" here 375 | $values[1] = \str_replace('?', '###simple_mysqli__prepare_question_mark###', (string)$values[1]); 376 | // build the query (only for debugging) 377 | $testQuery = (string) \preg_replace("/\?/", (string)$values[1], $testQuery, 1); 378 | } 379 | $testQuery = \str_replace('###simple_mysqli__prepare_question_mark###', '?', $testQuery); 380 | } 381 | $this->_sql_with_bound_parameters = $testQuery; 382 | 383 | return $testQuery; 384 | } 385 | 386 | /** 387 | * Error-handling for the sql-query. 388 | * 389 | * @param string $errorMsg 390 | * @param string $sql 391 | * 392 | * @throws DBGoneAwayException 393 | * @throws QueryException 394 | * 395 | * @return bool|int|Result|string "Result" by "SELECT"-queries
222 | *
223 | * INFO: install / use "mysqlnd"-driver for better performance
224 | *
false on error
230 | */ 231 | private function &cast(&$data) 232 | { 233 | if ( 234 | !$this->doctrinePdoStmt // pdo only have limited support for types, so we try to improve it 235 | && 236 | Helper::isMysqlndIsUsed() 237 | ) { 238 | return $data; 239 | } 240 | 241 | // init 242 | static $FIELDS_CACHE = []; 243 | static $TYPES_CACHE = []; 244 | 245 | $result_hash = \spl_object_hash($this->_result); 246 | if (!isset($FIELDS_CACHE[$result_hash])) { 247 | $FIELDS_CACHE[$result_hash] = $this->fetch_fields(); 248 | } 249 | 250 | if ( 251 | !isset($FIELDS_CACHE[$result_hash]) 252 | || 253 | $FIELDS_CACHE[$result_hash] === false 254 | ) { 255 | /** @noinspection PhpUnnecessaryLocalVariableInspection */ 256 | $dataTmp = false; 257 | 258 | return $dataTmp; 259 | } 260 | 261 | if (!isset($TYPES_CACHE[$result_hash])) { 262 | foreach ($FIELDS_CACHE[$result_hash] as $field) { 263 | switch ($field->type) { 264 | case self::MYSQL_TYPE_BIT: 265 | $TYPES_CACHE[$result_hash][$field->name] = 'boolean'; 266 | 267 | break; 268 | case self::MYSQL_TYPE_TINY: 269 | case self::MYSQL_TYPE_SHORT: 270 | case self::MYSQL_TYPE_LONG: 271 | case self::MYSQL_TYPE_LONGLONG: 272 | case self::MYSQL_TYPE_INT24: 273 | $TYPES_CACHE[$result_hash][$field->name] = 'integer'; 274 | 275 | break; 276 | case self::MYSQL_TYPE_DOUBLE: 277 | case self::MYSQL_TYPE_FLOAT: 278 | $TYPES_CACHE[$result_hash][$field->name] = 'float'; 279 | 280 | break; 281 | case self::MYSQL_TYPE_DECIMAL: // INFO: DECIMAL is a "string"-format for numbers 282 | case self::MYSQL_TYPE_NEWDECIMAL: 283 | default: 284 | $TYPES_CACHE[$result_hash][$field->name] = 'string'; 285 | 286 | break; 287 | } 288 | } 289 | } 290 | 291 | if (\is_array($data)) { 292 | foreach ($TYPES_CACHE[$result_hash] as $type_name => $type) { 293 | if (isset($data[$type_name])) { 294 | \settype($data[$type_name], $type); 295 | } 296 | } 297 | } elseif (\is_object($data)) { 298 | foreach ($TYPES_CACHE[$result_hash] as $type_name => $type) { 299 | if (isset($data->{$type_name})) { 300 | \settype($data->{$type_name}, $type); 301 | } 302 | } 303 | } 304 | 305 | return $data; 306 | } 307 | 308 | /** 309 | * Countable interface implementation. 310 | * 311 | * @return int The number of rows in the result 312 | */ 313 | public function count(): int 314 | { 315 | return $this->num_rows; 316 | } 317 | 318 | /** 319 | * Iterator interface implementation. 320 | * 321 | * @return mixed The current element 322 | */ 323 | #[\ReturnTypeWillChange] 324 | public function current() 325 | { 326 | return $this->fetchCallable($this->current_row); 327 | } 328 | 329 | /** 330 | * Iterator interface implementation. 331 | * 332 | * @return int The current element key (row index; zero-based) 333 | */ 334 | public function key(): int 335 | { 336 | return $this->current_row; 337 | } 338 | 339 | /** 340 | * Iterator interface implementation. 341 | * 342 | * @return void 343 | */ 344 | #[\ReturnTypeWillChange] 345 | public function next() 346 | { 347 | $this->current_row++; 348 | } 349 | 350 | /** 351 | * Iterator interface implementation. 352 | * 353 | * @param int $row Row position to rewind to; defaults to 0 354 | * 355 | * @return void 356 | */ 357 | #[\ReturnTypeWillChange] 358 | public function rewind($row = 0) 359 | { 360 | if ($this->seek($row)) { 361 | $this->current_row = $row; 362 | } 363 | } 364 | 365 | /** 366 | * Moves the internal pointer to the specified row position. 367 | * 368 | * @param int $rowRow position; zero-based and set to 0 by default
369 | * 370 | * @return bool 371 | *true on success, false otherwise
372 | */ 373 | #[\ReturnTypeWillChange] 374 | public function seek($row = 0): bool 375 | { 376 | if (\is_int($row) && $row >= 0 && $row < $this->num_rows) { 377 | if ( 378 | $this->doctrineMySQLiStmt 379 | && 380 | $this->doctrineMySQLiStmt instanceof \mysqli_stmt 381 | ) { 382 | $this->doctrineMySQLiStmt->data_seek($row); 383 | 384 | return true; 385 | } 386 | 387 | if ( 388 | $this->doctrinePdoStmt 389 | && 390 | $this->doctrinePdoStmt instanceof \Doctrine\DBAL\Driver\PDOStatement 391 | ) { 392 | return true; 393 | } 394 | 395 | if ($this->_result instanceof \mysqli_result) { 396 | return \mysqli_data_seek($this->_result, $row); 397 | } 398 | } 399 | 400 | return false; 401 | } 402 | 403 | /** 404 | * Iterator interface implementation. 405 | * 406 | * @return bool 407 | *true if the current index is valid, false otherwise
408 | */ 409 | public function valid(): bool 410 | { 411 | return $this->current_row < $this->num_rows; 412 | } 413 | 414 | /** 415 | * Fetch. 416 | * 417 | *
418 | *
419 | * INFO: this will return an object by default, not an array
420 | * and you can change the behaviour via "Result->setDefaultResultType()"
421 | *
Reset the \mysqli_result counter.
424 | * 425 | * @return array|false|object 426 | *false on error
427 | */ 428 | public function &fetch(bool $reset = false) 429 | { 430 | // init 431 | $return = false; 432 | 433 | if ($this->_default_result_type === self::RESULT_TYPE_OBJECT) { 434 | $return = $this->fetchObject(null, null, $reset); 435 | } elseif ($this->_default_result_type === self::RESULT_TYPE_ARRAY) { 436 | $return = $this->fetchArray($reset); 437 | } elseif ($this->_default_result_type === self::RESULT_TYPE_ARRAYY) { 438 | $return = $this->fetchArrayy($reset); 439 | } elseif ($this->_default_result_type === self::RESULT_TYPE_YIELD) { 440 | $return = $this->fetchYield(null, null, $reset); 441 | } 442 | 443 | return $return; 444 | } 445 | 446 | /** 447 | * Fetch all results. 448 | * 449 | *
450 | *
451 | * INFO: this will return an object by default, not an array
452 | * and you can change the behaviour via "Result->setDefaultResultType()"
453 | *
Skip "NULL"-values. | default: false
551 | * 552 | * @return array 553 | *Return an empty array if the "$column" wasn't found
554 | */ 555 | public function fetchAllColumn(string $column, bool $skipNullValues = false): array 556 | { 557 | $return = $this->fetchColumn( 558 | $column, 559 | $skipNullValues, 560 | true 561 | ); 562 | 563 | \assert(\is_array($return)); 564 | 565 | return $return; 566 | } 567 | 568 | /** 569 | * Fetch all results as array with objects. 570 | * 571 | * @param object|string|null $class
572 | * string: create a new object (with optional constructor
573 | * parameter)
574 | * object: use a object and fill the the data into
575 | *
578 | * An array of parameters to pass to the constructor, used if $class is a 579 | * string. 580 | *
581 | * 582 | * @return object[] 583 | * 584 | * @psalm-param class-string|object|null $class 585 | * @psalm-param array
605 | * string: create a new object (with optional constructor
606 | * parameter)
607 | * object: use a object and fill the the data into
608 | *
611 | * An array of parameters to pass to the constructor, used if $class is a 612 | * string. 613 | *
614 | * 615 | * @return \Generator 616 | * @psalm-param class-string|object|null $class 617 | * @psalm-param arrayfalse on error
677 | */ 678 | public function fetchArray(bool $reset = false) 679 | { 680 | if ($reset) { 681 | $this->reset(); 682 | } 683 | 684 | $row = $this->fetch_assoc(); 685 | if ($row) { 686 | $return = $this->cast($row); 687 | 688 | \assert(\is_array($return)); 689 | 690 | return $return; 691 | } 692 | 693 | if ($row === null || $row === false) { 694 | return []; 695 | } 696 | 697 | return false; 698 | } 699 | 700 | /** 701 | * Fetch data as a key/value pair array. 702 | * 703 | *
704 | *
705 | * INFO: both "key" and "value" must exists in the fetched data
706 | * the key will be the new key of the result-array
707 | *
708 | *
712 | * fetchArrayPair('some_id', 'some_value');
713 | * // array(127 => 'some value', 128 => 'some other value')
714 | *
715 | *
716 | * @param string $key
717 | * @param string $value
718 | *
719 | * @return \Arrayy\Arrayy
720 | */
721 | public function fetchArrayPair(string $key, string $value): \Arrayy\Arrayy
722 | {
723 | // init
724 | $arrayPair = new \Arrayy\Arrayy();
725 | $data = $this->fetchAllArrayyYield();
726 |
727 | foreach ($data as $_row) {
728 | assert($_row instanceof \Arrayy\Arrayy);
729 |
730 | if (
731 | $_row->offsetExists($key)
732 | &&
733 | $_row->offsetExists($value)
734 | ) {
735 | $_key = $_row[$key];
736 | $_value = $_row[$value];
737 | $arrayPair[$_key] = $_value;
738 | }
739 | }
740 |
741 | return $arrayPair;
742 | }
743 |
744 | /**
745 | * Fetch as "Arrayy"-object.
746 | *
747 | * @param bool $reset optional Reset the \mysqli_result counter.
748 | * 749 | * @return \Arrayy\Arrayy|false 750 | *false on error
751 | */ 752 | public function fetchArrayy(bool $reset = false) 753 | { 754 | if ($reset) { 755 | $this->reset(); 756 | } 757 | 758 | $row = $this->fetch_assoc(); 759 | if ($row) { 760 | return \Arrayy\Arrayy::create($this->cast($row)); 761 | } 762 | 763 | if ($row === null || $row === false) { 764 | return \Arrayy\Arrayy::create(); 765 | } 766 | 767 | return false; 768 | } 769 | 770 | /** 771 | * Fetches a row or a single column within a row. Returns null if there are 772 | * no more rows in the result. 773 | * 774 | * @param int $row The row number (optional) 775 | * @param string $column The column name (optional) 776 | * 777 | * @return mixed An associative array or a scalar value 778 | */ 779 | public function fetchCallable(int $row = null, string $column = null) 780 | { 781 | if (!$this->num_rows) { 782 | return null; 783 | } 784 | 785 | if ($row !== null) { 786 | $this->seek($row); 787 | } 788 | 789 | $rows = $this->fetch_assoc(); 790 | 791 | if ($column) { 792 | if ( 793 | \is_array($rows) 794 | && 795 | isset($rows[$column]) 796 | ) { 797 | return $rows[$column]; 798 | } 799 | 800 | return null; 801 | } 802 | 803 | if (\is_callable($this->_mapper)) { 804 | return \call_user_func($this->_mapper, $rows); 805 | } 806 | 807 | return $rows; 808 | } 809 | 810 | /** 811 | * Fetch a single column as string (or as 1-dimension array). 812 | * 813 | * @param string $column 814 | * @param bool $skipNullValuesSkip "NULL"-values. | default: true
815 | * @param bool $asArrayGet all values and not only the last one. | default: false
816 | * 817 | * @return array|string 818 | *Return a empty string or an empty array if the "$column" wasn't found, depend on 819 | * "$asArray"
820 | */ 821 | public function &fetchColumn( 822 | string $column = '', 823 | bool $skipNullValues = true, 824 | bool $asArray = false 825 | ) { 826 | if (!$asArray) { 827 | // init 828 | $columnData = ''; 829 | 830 | $data = $this->fetchAllArrayy()->reverse()->getArray(); 831 | foreach ($data as &$_row) { 832 | if ($skipNullValues) { 833 | if (!isset($_row[$column])) { 834 | continue; 835 | } 836 | } elseif (!\array_key_exists($column, $_row)) { 837 | break; 838 | } 839 | 840 | $columnData = $_row[$column]; 841 | 842 | break; 843 | } 844 | 845 | return $columnData; 846 | } 847 | 848 | // -- return as array --> 849 | 850 | // init 851 | $columnData = []; 852 | 853 | foreach ($this->fetchAllYield() as $_row) { 854 | if ($skipNullValues) { 855 | if (!isset($_row->{$column})) { 856 | continue; 857 | } 858 | } elseif (!\property_exists($_row, $column)) { 859 | break; 860 | } 861 | 862 | $columnData[] = $_row->{$column}; 863 | } 864 | 865 | return $columnData; 866 | } 867 | 868 | /** 869 | * Return rows of field information in a result set. 870 | * 871 | * @param bool $as_array Return each field info as array; defaults to false 872 | * 873 | * @return array 874 | *Array of field information each as an associative array.
875 | */ 876 | public function &fetchFields(bool $as_array = false): array 877 | { 878 | $fields = $this->fetch_fields(); 879 | if ($fields === false) { 880 | $fields = []; 881 | 882 | return $fields; 883 | } 884 | 885 | if ($as_array) { 886 | $fields = \array_map( 887 | static function ($object) { 888 | return (array) $object; 889 | }, 890 | $fields 891 | ); 892 | 893 | return $fields; 894 | } 895 | 896 | return $fields; 897 | } 898 | 899 | /** 900 | * Returns all rows at once as a grouped array of scalar values or arrays. 901 | * 902 | * @param string $group The column name to use for grouping 903 | * @param string $column The column name to use as values (optional) 904 | * 905 | * @return array 906 | *A grouped array of scalar values or arrays.
907 | */ 908 | public function &fetchGroups(string $group, string $column = null): array 909 | { 910 | // init 911 | $groups = []; 912 | $pos = $this->current_row; 913 | 914 | foreach ($this->fetchAllArrayyYield() as $row) { 915 | assert($row instanceof \Arrayy\Arrayy); 916 | 917 | if (!$row->offsetExists($group)) { 918 | continue; 919 | } 920 | 921 | if ($column !== null) { 922 | if (!$row->offsetExists($column)) { 923 | continue; 924 | } 925 | 926 | $groups[$row[$group]][] = $row[$column]; 927 | } else { 928 | $groups[$row[$group]][] = $row; 929 | } 930 | } 931 | 932 | $this->rewind($pos); 933 | 934 | return $groups; 935 | } 936 | 937 | /** 938 | * Fetch as object. 939 | * 940 | * @param object|string|null $class
941 | * string: create a new object (with optional constructor
942 | * parameter)
943 | * object: use a object and fill the the data into
944 | *
947 | * An array of parameters to pass to the constructor, used if $class is a 948 | * string. 949 | *
950 | * @param bool $reset optionalReset the \mysqli_result counter.
951 | * 952 | * @return false|object 953 | *false on error
954 | * 955 | * @psalm-param class-string|object|null $class 956 | * @psalm-param arrayAn array of key-value pairs.
1017 | */ 1018 | public function fetchPairs(string $key, string $column = null): array 1019 | { 1020 | // init 1021 | $pairs = []; 1022 | $pos = $this->current_row; 1023 | 1024 | foreach ($this->fetchAllArrayyYield() as $row) { 1025 | assert($row instanceof \Arrayy\Arrayy); 1026 | 1027 | if (!$row->offsetExists($key)) { 1028 | continue; 1029 | } 1030 | 1031 | if ($column !== null) { 1032 | if (!$row->offsetExists($column)) { 1033 | continue; 1034 | } 1035 | 1036 | $pairs[$row[$key]] = $row[$column]; 1037 | } else { 1038 | $pairs[$row[$key]] = $row; 1039 | } 1040 | } 1041 | 1042 | $this->rewind($pos); 1043 | 1044 | return $pairs; 1045 | } 1046 | 1047 | /** 1048 | * Returns all rows at once, transposed as an array of arrays. Instead of 1049 | * returning rows of columns, this method returns columns of rows. 1050 | * 1051 | * @param string $column The column name to use as keys (optional) 1052 | * 1053 | * @return array 1054 | *A transposed array of arrays
1055 | */ 1056 | public function fetchTranspose(string $column = null) 1057 | { 1058 | // init 1059 | $keys = $column !== null ? $this->fetchAllColumn($column) : []; 1060 | $rows = []; 1061 | $pos = $this->current_row; 1062 | 1063 | foreach ($this->fetchAllYield() as $row) { 1064 | foreach ($row as $key => &$value) { 1065 | $rows[$key][] = $value; 1066 | } 1067 | } 1068 | 1069 | $this->rewind($pos); 1070 | 1071 | if (empty($keys)) { 1072 | return $rows; 1073 | } 1074 | 1075 | return \array_map( 1076 | static function ($values) use ($keys) { 1077 | return \array_combine($keys, $values); 1078 | }, 1079 | $rows 1080 | ); 1081 | } 1082 | 1083 | /** 1084 | * Fetch as "\Generator" via yield. 1085 | * 1086 | * @param object|string|null $class
1087 | * string: create a new object (with optional constructor
1088 | * parameter)
1089 | * object: use a object and fill the the data into
1090 | *
1093 | * An array of parameters to pass to the constructor, used if $class is a 1094 | * string. 1095 | *
1096 | * @param bool $reset optionalReset the \mysqli_result counter.
1097 | * 1098 | * @return \Generator 1099 | * 1100 | * @psalm-param class-string|object|null $class 1101 | * @psalm-param arrayA row array or a single scalar value
1254 | */ 1255 | public function first(string $column = null) 1256 | { 1257 | $pos = $this->current_row; 1258 | $first = $this->fetchCallable(0, $column); 1259 | $this->rewind($pos); 1260 | 1261 | return $first; 1262 | } 1263 | 1264 | /** 1265 | * free the memory 1266 | * 1267 | * @return bool 1268 | */ 1269 | public function free() 1270 | { 1271 | if ($this->_result instanceof \mysqli_result) { 1272 | try { 1273 | /** @noinspection PhpUsageOfSilenceOperatorInspection */ 1274 | @\mysqli_free_result($this->_result); 1275 | } catch (\Throwable $e) { 1276 | return false; 1277 | } 1278 | 1279 | return true; 1280 | } 1281 | 1282 | if ( 1283 | $this->doctrineMySQLiStmt 1284 | && 1285 | $this->doctrineMySQLiStmt instanceof \mysqli_stmt 1286 | ) { 1287 | $this->doctrineMySQLiStmt->free_result(); 1288 | 1289 | return true; 1290 | } 1291 | 1292 | return false; 1293 | } 1294 | 1295 | /** 1296 | * alias for "Result->fetch()" 1297 | * 1298 | * @return array|false|object 1299 | *false on error
1300 | * 1301 | * @see Result::fetch() 1302 | */ 1303 | public function get() 1304 | { 1305 | return $this->fetch(); 1306 | } 1307 | 1308 | /** 1309 | * alias for "Result->fetchAll()" 1310 | * 1311 | * @return array 1312 | * 1313 | * @see Result::fetchAll() 1314 | */ 1315 | public function getAll(): array 1316 | { 1317 | return $this->fetchAll(); 1318 | } 1319 | 1320 | /** 1321 | * alias for "Result->fetchAllColumn()" 1322 | * 1323 | * @param string $column 1324 | * @param bool $skipNullValues 1325 | * 1326 | * @return array 1327 | * 1328 | * @see Result::fetchAllColumn() 1329 | */ 1330 | public function getAllColumn(string $column, bool $skipNullValues = false): array 1331 | { 1332 | return $this->fetchAllColumn($column, $skipNullValues); 1333 | } 1334 | 1335 | /** 1336 | * alias for "Result->fetchAllArray()" 1337 | * 1338 | * @return array 1339 | * 1340 | * @see Result::fetchAllArray() 1341 | */ 1342 | public function getArray(): array 1343 | { 1344 | return $this->fetchAllArray(); 1345 | } 1346 | 1347 | /** 1348 | * alias for "Result->fetchAllArrayy()" 1349 | * 1350 | * @return \Arrayy\Arrayy 1351 | * 1352 | * @see Result::fetchAllArrayy() 1353 | */ 1354 | public function getArrayy(): \Arrayy\Arrayy 1355 | { 1356 | return $this->fetchAllArrayy(); 1357 | } 1358 | 1359 | /** 1360 | * alias for "Result->fetchColumn()" 1361 | * 1362 | * @param string $column 1363 | * @param bool $asArray 1364 | * @param bool $skipNullValues 1365 | * 1366 | * @return array|string 1367 | *Return a empty string or an empty array if the "$column" wasn't found, depend on 1368 | * "$asArray"
1369 | * 1370 | * @see Result::fetchColumn() 1371 | */ 1372 | public function getColumn( 1373 | string $column, 1374 | bool $skipNullValues = true, 1375 | bool $asArray = false 1376 | ) { 1377 | return $this->fetchColumn( 1378 | $column, 1379 | $skipNullValues, 1380 | $asArray 1381 | ); 1382 | } 1383 | 1384 | /** 1385 | * @return string 1386 | */ 1387 | public function getDefaultResultType(): string 1388 | { 1389 | return $this->_default_result_type; 1390 | } 1391 | 1392 | /** 1393 | * alias for "Result->fetchAllObject()" 1394 | * 1395 | * @return array of mysql-objects 1396 | * 1397 | * @see Result::fetchAllObject() 1398 | */ 1399 | public function getObject(): array 1400 | { 1401 | return $this->fetchAllObject(); 1402 | } 1403 | 1404 | /** 1405 | * alias for "Result->fetchAllYield()" 1406 | * 1407 | * @return \Generator 1408 | * 1409 | * @see Result::fetchAllYield() 1410 | */ 1411 | public function getYield(): \Generator 1412 | { 1413 | return $this->fetchAllYield(); 1414 | } 1415 | 1416 | /** 1417 | * Check if the result is empty. 1418 | * 1419 | * @return bool 1420 | */ 1421 | public function is_empty(): bool 1422 | { 1423 | return !($this->num_rows > 0); 1424 | } 1425 | 1426 | /** 1427 | * Fetch all results as "json"-string. 1428 | * 1429 | * @return false|string 1430 | */ 1431 | public function json() 1432 | { 1433 | $data = $this->fetchAllArray(); 1434 | 1435 | return \voku\helper\UTF8::json_encode($data); 1436 | } 1437 | 1438 | /** 1439 | * Returns the last row element from the result. 1440 | * 1441 | * @param string $column The column name to use as value (optional) 1442 | * 1443 | * @return mixed A row array or a single scalar value 1444 | */ 1445 | public function last(string $column = null) 1446 | { 1447 | $pos = $this->current_row; 1448 | $last = $this->fetchCallable($this->num_rows - 1, $column); 1449 | $this->rewind($pos); 1450 | 1451 | return $last; 1452 | } 1453 | 1454 | /** 1455 | * Set the mapper... 1456 | * 1457 | * @param \Closure $callable 1458 | * 1459 | * @return $this 1460 | */ 1461 | public function map(\Closure $callable): self 1462 | { 1463 | $this->_mapper = $callable; 1464 | 1465 | return $this; 1466 | } 1467 | 1468 | /** 1469 | * Alias of count(). Deprecated. 1470 | * 1471 | * @return int 1472 | *The number of rows in the result.
1473 | */ 1474 | public function num_rows(): int 1475 | { 1476 | return $this->count(); 1477 | } 1478 | 1479 | /** 1480 | * ArrayAccess interface implementation. 1481 | * 1482 | * @param int $offsetOffset number
1483 | * 1484 | * @return bool 1485 | *true if offset exists, false otherwise.
1486 | */ 1487 | public function offsetExists($offset): bool 1488 | { 1489 | return \is_int($offset) && $offset >= 0 && $offset < $this->num_rows; 1490 | } 1491 | 1492 | /** 1493 | * ArrayAccess interface implementation. 1494 | * 1495 | * @param int $offset Offset number 1496 | * 1497 | * @return mixed 1498 | */ 1499 | #[\ReturnTypeWillChange] 1500 | public function offsetGet($offset) 1501 | { 1502 | if ($this->offsetExists($offset)) { 1503 | return $this->fetchCallable($offset); 1504 | } 1505 | 1506 | throw new \OutOfBoundsException("undefined offset (${offset})"); 1507 | } 1508 | 1509 | /** 1510 | * ArrayAccess interface implementation. Not implemented by design. 1511 | * 1512 | * @param mixed $offset 1513 | * @param mixed $value 1514 | * 1515 | * @return void 1516 | */ 1517 | #[\ReturnTypeWillChange] 1518 | public function offsetSet($offset, $value) 1519 | { 1520 | } 1521 | 1522 | /** 1523 | * ArrayAccess interface implementation. Not implemented by design. 1524 | * 1525 | * @param mixed $offset 1526 | * 1527 | * @return void 1528 | */ 1529 | #[\ReturnTypeWillChange] 1530 | public function offsetUnset($offset) 1531 | { 1532 | } 1533 | 1534 | /** 1535 | * Reset the offset (data_seek) for the results. 1536 | * 1537 | * @return Result 1538 | */ 1539 | public function reset(): self 1540 | { 1541 | $this->doctrinePdoStmtDataSeekFake = 0; 1542 | 1543 | if (!$this->is_empty()) { 1544 | if ($this->doctrineMySQLiStmt instanceof \mysqli_stmt) { 1545 | $this->doctrineMySQLiStmt->data_seek(0); 1546 | } 1547 | 1548 | if ($this->_result instanceof \mysqli_result) { 1549 | \mysqli_data_seek($this->_result, 0); 1550 | } 1551 | } 1552 | 1553 | return $this; 1554 | } 1555 | 1556 | /** 1557 | * You can set the default result-type to Result::RESULT_TYPE_*. 1558 | * 1559 | * INFO: used for "fetch()" and "fetchAll()" 1560 | * 1561 | * @param string $default_result_type 1562 | * 1563 | * @return void 1564 | */ 1565 | public function setDefaultResultType(string $default_result_type = self::RESULT_TYPE_OBJECT) 1566 | { 1567 | if ( 1568 | $default_result_type === self::RESULT_TYPE_OBJECT 1569 | || 1570 | $default_result_type === self::RESULT_TYPE_ARRAY 1571 | || 1572 | $default_result_type === self::RESULT_TYPE_ARRAYY 1573 | || 1574 | $default_result_type === self::RESULT_TYPE_YIELD 1575 | ) { 1576 | $this->_default_result_type = $default_result_type; 1577 | } 1578 | } 1579 | 1580 | /** 1581 | * @param int $offset 1582 | * @param int|null $length 1583 | * @param bool $preserve_keys 1584 | * 1585 | * @return array 1586 | */ 1587 | public function &slice( 1588 | int $offset = 0, 1589 | int $length = null, 1590 | bool $preserve_keys = false 1591 | ): array { 1592 | // init 1593 | $slice = []; 1594 | 1595 | if ($offset < 0) { 1596 | if (\abs($offset) > $this->num_rows) { 1597 | $offset = 0; 1598 | } else { 1599 | $offset = $this->num_rows - (int) \abs($offset); 1600 | } 1601 | } 1602 | 1603 | $length = $length !== null ? (int) $length : $this->num_rows; 1604 | $n = 0; 1605 | for ($i = $offset; $i < $this->num_rows && $n < $length; $i++) { 1606 | if ($preserve_keys) { 1607 | $slice[$i] = $this->fetchCallable($i); 1608 | } else { 1609 | $slice[] = $this->fetchCallable($i); 1610 | } 1611 | ++$n; 1612 | } 1613 | 1614 | return $slice; 1615 | } 1616 | } 1617 | -------------------------------------------------------------------------------- /src/voku/db/exceptions/DBConnectException.php: -------------------------------------------------------------------------------- 1 |