├── LICENSE
├── README.md
├── composer.json
├── phpdoc.xml
└── src
    ├── DatabaseException.php
    ├── DatabaseOptions.php
    ├── DatabaseOptionsTrait.php
    ├── Dialects
        ├── Dialect.php
        ├── DialectAbstract.php
        ├── Firebird.php
        ├── MSSQL.php
        ├── MySQL.php
        ├── Postgres.php
        └── SQLite.php
    ├── Drivers
        ├── DriverAbstract.php
        ├── DriverException.php
        ├── DriverInterface.php
        ├── MSSqlSrv.php
        ├── MySQLiDrv.php
        ├── PDODriverAbstract.php
        ├── PDOFirebird.php
        ├── PDOMSSqlSrv.php
        ├── PDOMySQL.php
        ├── PDOPostgreSQL.php
        ├── PDOSQLite.php
        └── PostgreSQL.php
    ├── Query
        ├── Alter.php
        ├── AlterDatabase.php
        ├── AlterTable.php
        ├── BindValues.php
        ├── CachedQuery.php
        ├── Create.php
        ├── CreateDatabase.php
        ├── CreateTable.php
        ├── Delete.php
        ├── Drop.php
        ├── DropDatabase.php
        ├── DropTable.php
        ├── IfExists.php
        ├── IfNotExists.php
        ├── Insert.php
        ├── Limit.php
        ├── MultiQuery.php
        ├── Query.php
        ├── QueryException.php
        ├── Select.php
        ├── Show.php
        ├── ShowCreateTable.php
        ├── ShowDatabases.php
        ├── ShowTables.php
        ├── Statement.php
        ├── StatementAbstract.php
        ├── Truncate.php
        ├── Update.php
        └── Where.php
    ├── Result.php
    ├── ResultInterface.php
    └── ResultRow.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2017 Smiley <smiley@chillerlan.net>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # chillerlan/php-database
 2 | 
 3 | A PHP SQL client and querybuilder for the most common databases, namely: MySQL, PostgreSQL, SQLite3, Microsoft SQL Server (Transact) and Firebird.
 4 | 
 5 | [![PHP Version Support][php-badge]][php]
 6 | [![version][packagist-badge]][packagist]
 7 | [![license][license-badge]][license]
 8 | [![Continuous Integration][gh-action-badge]][gh-action]
 9 | [![Coverage][coverage-badge]][coverage]
10 | [![Packagist downloads][downloads-badge]][downloads]
11 | 
12 | [php-badge]: https://img.shields.io/packagist/php-v/chillerlan/php-database?logo=php&color=8892BF&logoColor=fff
13 | [php]: https://www.php.net/supported-versions.php
14 | [packagist-badge]: https://img.shields.io/packagist/v/chillerlan/php-database.svg?logo=packagist&logoColor=fff
15 | [packagist]: https://packagist.org/packages/chillerlan/php-database
16 | [license-badge]: https://img.shields.io/github/license/chillerlan/php-database.svg
17 | [license]: https://github.com/chillerlan/php-database/blob/main/LICENSE
18 | [gh-action-badge]: https://img.shields.io/github/actions/workflow/status/chillerlan/php-database/ci.yml?branch=main&logo=github&logoColor=fff
19 | [gh-action]: https://github.com/chillerlan/php-database/actions/workflows/ci.yml?query=branch%3Amain
20 | [coverage-badge]: https://img.shields.io/codecov/c/github/chillerlan/php-database.svg?logo=codecov&logoColor=fff
21 | [coverage]: https://codecov.io/github/chillerlan/php-database
22 | [downloads-badge]: https://img.shields.io/packagist/dt/chillerlan/php-database.svg?logo=packagist&logoColor=fff
23 | [downloads]: https://packagist.org/packages/chillerlan/php-database/stats
24 | 
25 | # Documentation
26 | 
27 | ## Requirements
28 | - PHP 8.2+
29 | - one of the supported databases, set up to work with PHP:
30 |   - [MySQL](https://dev.mysql.com/doc/refman/5.6/en/) (5.5+) / [MariaDB](https://mariadb.com/kb/en/library/basic-sql-statements/) via [ext-mysqli](https://www.php.net/manual/en/book.mysqli.php) or [ext-pdo_mysql](https://www.php.net/manual/en/ref.pdo-mysql.php)
31 |   - [PostgreSQL](https://www.postgresql.org/docs/9.5/static/index.html) (9.5+) via [ext-pgsql](https://www.php.net/manual/en/book.pgsql.php) or [ext-pdo_pgsql](https://www.php.net/manual/en/ref.pdo-pgsql.php)
32 |   - [SQLite3](https://www.sqlite.org/lang.html) via [ext-pdo_sqlite](https://www.php.net/manual/en/ref.pdo-sqlite.php)
33 |   - [Firebird](https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25.html) (2.5+) via [ext-pdo_firebird](https://www.php.net/manual/en/ref.pdo-firebird.php)
34 |   - [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-downloads) ([transact-sql](https://docs.microsoft.com/sql/t-sql/language-reference)) via [ext-sqlsrv or ext-pdo_sqlsrv](https://github.com/Microsoft/msphpsql)
35 | 
36 | ## Installation
37 | **requires [composer](https://getcomposer.org)**
38 | 
39 | ### *composer.json*
40 | (note: replace `dev-main` with a [version boundary](https://getcomposer.org/doc/articles/versions.md#summary))
41 | ```json
42 | {
43 | 	"require": {
44 | 		"php": "^8.2",
45 | 		"chillerlan/php-database": "dev-main"
46 | 	}
47 | }
48 | ```
49 | 
50 | Profit!
51 | 
52 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "chillerlan/php-database",
 3 | 	"description": "An extensible database wrapper and query builder.",
 4 | 	"homepage": "https://github.com/chillerlan/php-database",
 5 | 	"license": "MIT",
 6 | 	"type": "library",
 7 | 	"minimum-stability": "dev",
 8 | 	"prefer-stable": true,
 9 | 	"keywords": [
10 | 		"database", "query", "builder", "querybuilder", "driver", "mysql",
11 |         "postgres", "mariadb", "firebird", "sqlite", "mssql"
12 | 	],
13 | 	"authors": [
14 | 		{
15 | 			"name": "Smiley",
16 | 			"email": "smiley@chillerlan.net",
17 | 			"homepage": "https://github.com/codemasher"
18 | 		}
19 | 	],
20 | 	"support": {
21 | 		"issues": "https://github.com/chillerlan/php-database/issues",
22 | 		"source": "https://github.com/chillerlan/php-database"
23 | 	},
24 | 	"require": {
25 | 		"php": "^8.2",
26 | 		"ext-json": "*",
27 | 		"ext-mbstring": "*",
28 | 		"ext-sodium": "*",
29 | 		"chillerlan/php-settings-container": "^3.2.1",
30 | 		"psr/simple-cache": "^1.0 || ^2.0 || ^3.0",
31 | 		"psr/log": "^1.1 || ^2.0 || ^3.0"
32 | 	},
33 | 	"require-dev": {
34 | 		"chillerlan/php-dotenv": "^3.0",
35 | 		"chillerlan/php-cache": "^5.1",
36 | 		"monolog/monolog": "^3.7",
37 | 		"phan/phan": "^5.4.5",
38 | 		"phpunit/phpunit": "^11.3"
39 | 	},
40 | 	"autoload": {
41 | 		"psr-4": {
42 | 			"chillerlan\\Database\\": "src"
43 | 		}
44 | 	},
45 | 	"autoload-dev": {
46 | 		"psr-4": {
47 | 			"chillerlan\\DatabaseTest\\": "tests"
48 | 		}
49 | 	},
50 | 	"scripts": {
51 | 		"phpunit": "@php vendor/phpunit/phpunit/phpunit",
52 | 		"phan": "@php vendor/phan/phan/phan"
53 | 	},
54 | 	"config": {
55 | 		"lock": false,
56 | 		"sort-packages": true,
57 | 		"platform-check": true
58 | 	}
59 | }
60 | 


--------------------------------------------------------------------------------
/phpdoc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <phpdocumentor xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |                xmlns="https://www.phpdoc.org"
 4 |                xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/phpDocumentor/phpDocumentor/master/data/xsd/phpdoc.xsd"
 5 |                configVersion="3"
 6 | >
 7 | 	<!-- https://docs.phpdoc.org/3.0/guide/references/configuration.html#configuration -->
 8 | 	<paths>
 9 | 		<output>.build/phpdocs</output>
10 | 		<cache>.build/phpdocs-cache</cache>
11 | 	</paths>
12 | 	<version number="3.0.0">
13 | 		<api>
14 | 			<source dsn=".">
15 | 				<path>src</path>
16 | 				<path>tests</path>
17 | 			</source>
18 | 			<extensions>
19 | 				<extension>php</extension>
20 | 			</extensions>
21 | 		</api>
22 | 	</version>
23 | 	<setting name="template.color" value="deep-purple"/>
24 | 	<template name="default" />
25 | </phpdocumentor>
26 | 


--------------------------------------------------------------------------------
/src/DatabaseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class DatabaseException
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database;
13 | 
14 | class DatabaseException extends \Exception{}
15 | 


--------------------------------------------------------------------------------
/src/DatabaseOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class DatabaseOptions
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database;
13 | 
14 | use chillerlan\Settings\SettingsContainerAbstract;
15 | 
16 | class DatabaseOptions extends SettingsContainerAbstract{
17 | 	use DatabaseOptionsTrait;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/DatabaseOptionsTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Trait DatabaseOptionsTrait
  4 |  *
  5 |  * @created      24.01.2018
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2018 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database;
 13 | 
 14 | /**
 15 |  * @property string $host
 16 |  * @property int    $port
 17 |  * @property string $socket
 18 |  * @property string $database
 19 |  * @property string $username
 20 |  * @property string $password
 21 |  * @property bool   $use_ssl
 22 |  * @property string $ssl_key
 23 |  * @property string $ssl_cert
 24 |  * @property string $ssl_ca
 25 |  * @property string $ssl_capath
 26 |  * @property string $ssl_cipher
 27 |  * @property int    $mysqli_timeout
 28 |  * @property string $mysql_charset
 29 |  * @property string $pgsql_charset
 30 |  * @property string $odbc_driver
 31 |  * @property string $convert_encoding_src
 32 |  * @property string $convert_encoding_dest
 33 |  * @property int    $mssql_timeout
 34 |  * @property string $mssql_charset
 35 |  * @property bool   $mssql_encrypt
 36 |  * @property string $firebird_encoding
 37 |  * @property string $cachekey_hash_algo
 38 |  * @property string $storage_path
 39 |  */
 40 | trait DatabaseOptionsTrait{
 41 | 
 42 | 	/**
 43 | 	 * The host to connect to
 44 | 	 */
 45 | 	protected string|null $host = 'localhost';
 46 | 
 47 | 	/**
 48 | 	 * The port number
 49 | 	 */
 50 | 	protected int|null $port = null;
 51 | 
 52 | 	/**
 53 | 	 * A socket
 54 | 	 */
 55 | 	protected string|null $socket = null;
 56 | 
 57 | 	/**
 58 | 	 * The database name
 59 | 	 */
 60 | 	protected string|null $database = null;
 61 | 
 62 | 	/**
 63 | 	 * The username
 64 | 	 */
 65 | 	protected string|null $username = null;
 66 | 
 67 | 	/**
 68 | 	 * The password
 69 | 	 */
 70 | 	protected string|null $password = null;
 71 | 
 72 | 	/**
 73 | 	 * Indicates whether the connection should use SSL
 74 | 	 */
 75 | 	protected bool $use_ssl = false;
 76 | 
 77 | 	/**
 78 | 	 * The SSL key
 79 | 	 */
 80 | 	protected string|null $ssl_key = null;
 81 | 
 82 | 	/**
 83 | 	 * The SSL certificate
 84 | 	 */
 85 | 	protected string|null $ssl_cert = null;
 86 | 
 87 | 	/**
 88 | 	 * The path to a SSL certificate authority file
 89 | 	 */
 90 | 	protected string|null $ssl_ca = null;
 91 | 
 92 | 	/**
 93 | 	 * The directory containing SSL certificate authority files
 94 | 	 */
 95 | 	protected string|null $ssl_capath = null;
 96 | 
 97 | 	/**
 98 | 	 * The SSL cipher
 99 | 	 */
100 | 	protected string|null $ssl_cipher = null;
101 | 
102 | 	/**
103 | 	 * MySQLi connection timeout
104 | 	 */
105 | 	protected int $mysqli_timeout = 3;
106 | 
107 | 	/**
108 | 	 * MySQL connection character set
109 | 	 *
110 | 	 * @link https://mathiasbynens.be/notes/mysql-utf8mb4 How to support full Unicode in MySQL
111 | 	 */
112 | 	protected string $mysql_charset = 'utf8mb4';
113 | 
114 | 	/**
115 | 	 * PostgreSQL connection character set
116 | 	 */
117 | 	protected string $pgsql_charset = 'UTF8';
118 | 
119 | 	/**
120 | 	 * The driver name to use for an ODBC connection (@todo)
121 | 	 */
122 | 	protected string|null $odbc_driver = null;
123 | 
124 | 	/**
125 | 	 * Database result encoding
126 | 	 *
127 | 	 * @see \mb_convert_encoding()
128 | 	 */
129 | 	protected string|null $convert_encoding_src = null;
130 | 
131 | 	/**
132 | 	 * @see \mb_convert_encoding()
133 | 	 */
134 | 	protected string|null $convert_encoding_dest = 'UTF-8';
135 | 
136 | 	/**
137 | 	 * MS SQL Server connection timeout
138 | 	 *
139 | 	 * @link https://docs.microsoft.com/en-us/sql/connect/php/connection-options
140 | 	 */
141 | 	protected int $mssql_timeout = 3;
142 | 
143 | 	/**
144 | 	 * MS SQL Server connection character set
145 | 	 */
146 | 	protected string $mssql_charset = 'UTF-8';
147 | 
148 | 	/**
149 | 	 * Specifies whether the communication with MS SQL Server is encrypted or unencrypted.
150 | 	 */
151 | 	protected int $mssql_encrypt = 0; // @todo: how???
152 | 
153 | 	/**
154 | 	 * Firebird connection encoding
155 | 	 */
156 | 	protected string $firebird_encoding = 'UTF8';
157 | 
158 | 	/**
159 | 	 * a hash algorithm for the cache keys
160 | 	 */
161 | 	protected string $cachekey_hash_algo = 'sha256';
162 | 
163 | 	/**
164 | 	 * @todo
165 | 	 */
166 | 	protected string $storage_path;
167 | 
168 | }
169 | 


--------------------------------------------------------------------------------
/src/Dialects/Dialect.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Interface Dialect
  4 |  *
  5 |  * @filesource   Dialect.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | interface Dialect{
 17 | 
 18 | 	/**
 19 | 	 *
 20 | 	 */
 21 | 	public function quote(string $str):string;
 22 | 
 23 | 	/**
 24 | 	 *
 25 | 	 */
 26 | 	public function select(
 27 | 		array       $cols,
 28 | 		array       $from,
 29 | 		string|null $where = null,
 30 | 		mixed       $limit = null,
 31 | 		mixed       $offset = null,
 32 | 		bool|null   $distinct = null,
 33 | 		array|null  $groupby = null,
 34 | 		array|null  $orderby = null,
 35 | 	):array;
 36 | 
 37 | 	/**
 38 | 	 *
 39 | 	 */
 40 | 	public function cols(array $expressions):array;
 41 | 
 42 | 	/**
 43 | 	 *
 44 | 	 */
 45 | 	public function from(array $expressions):array;
 46 | 
 47 | 	/**
 48 | 	 *
 49 | 	 */
 50 | 	public function orderby(array $expressions):array;
 51 | 
 52 | 	/**
 53 | 	 * @todo: offset?
 54 | 	 */
 55 | 	public function selectCount(
 56 | 		array       $from,
 57 | 		string|null $where = null,
 58 | 		bool|null   $distinct = null,
 59 | 		array|null  $groupby = null,
 60 | 	):array;
 61 | 
 62 | 	/**
 63 | 	 *
 64 | 	 */
 65 | 	public function insert(
 66 | 		string      $table,
 67 | 		array       $fields,
 68 | 		string|null $onConflict = null,
 69 | 		string|null $conflictTarget = null,
 70 | 	):array;
 71 | 
 72 | 	/**
 73 | 	 *
 74 | 	 */
 75 | 	public function update(string $table, array $set, string $where):array;
 76 | 
 77 | 	/**
 78 | 	 *
 79 | 	 */
 80 | 	public function delete(string $table, string $where):array;
 81 | 
 82 | 	/**
 83 | 	 *
 84 | 	 */
 85 | 	public function createDatabase(string $dbname, bool|null $ifNotExists = null, string|null $collate = null):array;
 86 | 
 87 | 	/**
 88 | 	 *
 89 | 	 */
 90 | 	public function createTable(
 91 | 		string      $table,
 92 | 		array       $cols,
 93 | 		string|null $primaryKey = null,
 94 | 		bool|null   $ifNotExists = null,
 95 | 		bool|null   $temp = null,
 96 | 		string|null $dir = null,
 97 | 	):array;
 98 | 
 99 | 	/**
100 | 	 *
101 | 	 */
102 | 	public function dropDatabase(string $dbname, bool $ifExists):array;
103 | 
104 | 	/**
105 | 	 *
106 | 	 */
107 | 	public function dropTable(string $table, bool $ifExists):array;
108 | 
109 | 	/**
110 | 	 *
111 | 	 */
112 | 	public function truncate(string $table):array;
113 | 
114 | 	/**
115 | 	 *
116 | 	 */
117 | 	public function fieldspec(
118 | 		string      $name,
119 | 		string      $type,
120 | 		mixed       $length = null,
121 | 		string|null $attribute = null,
122 | 		string|null $collation = null,
123 | 		bool|null   $isNull = null,
124 | 		string|null $defaultType = null,
125 | 		mixed       $defaultValue = null,
126 | 		string|null $extra = null,
127 | 	):string;
128 | 
129 | 	/**
130 | 	 *
131 | 	 */
132 | 	public function enum(string $name, array $values, mixed $defaultValue = null, bool|null $isNull = null):string;
133 | 
134 | 	/**
135 | 	 *
136 | 	 */
137 | 	public function showDatabases():array;
138 | 
139 | 	/**
140 | 	 *
141 | 	 */
142 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array;
143 | 
144 | 	/**
145 | 	 *
146 | 	 */
147 | 	public function showCreateTable(string $table):array;
148 | }
149 | 


--------------------------------------------------------------------------------
/src/Dialects/DialectAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class DialectAbstract
  4 |  *
  5 |  * @filesource   DialectAbstract.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use chillerlan\Database\Query\QueryException;
 17 | use function array_fill, count, explode, implode, in_array, is_array, is_float,
 18 | 	is_int, is_string, sprintf, strtolower, strtoupper;
 19 | 
 20 | /**
 21 |  * please don't look at it
 22 |  *
 23 |  * @link https://en.wikibooks.org/wiki/SQL_Dialects_Reference
 24 |  * @link https://en.wikibooks.org/wiki/Converting_MySQL_to_PostgreSQL
 25 |  */
 26 | abstract class DialectAbstract implements Dialect{
 27 | 
 28 | 	/**
 29 | 	 * @var string[]
 30 | 	 */
 31 | 	protected array $quotes = ['"', '"'];
 32 | 
 33 | 	/**
 34 | 	 * @var string
 35 | 	 */
 36 | 	protected string $charset = 'utf8';
 37 | 
 38 | 	public function select(
 39 | 		array       $cols,
 40 | 		array       $from,
 41 | 		string|null $where = null,
 42 | 		mixed       $limit = null,
 43 | 		mixed       $offset = null,
 44 | 		bool|null   $distinct = null,
 45 | 		array|null  $groupby = null,
 46 | 		array|null  $orderby = null,
 47 | 	):array{
 48 | 		$sql = ['SELECT'];
 49 | 
 50 | 		if($distinct){
 51 | 			$sql[] = 'DISTINCT';
 52 | 		}
 53 | 
 54 | 		!empty($cols)
 55 | 			? $sql[] = implode(', ', $cols)
 56 | 			: $sql[] = '*';
 57 | 
 58 | 		$sql[] = 'FROM';
 59 | 		$sql[] = implode(', ', $from);
 60 | 		$sql[] = $where;
 61 | 
 62 | 		if(!empty($groupby)){
 63 | 			$sql[] = 'GROUP BY';
 64 | 			$sql[] = implode(', ', $groupby);
 65 | 		}
 66 | 
 67 | 		if(!empty($orderby)){
 68 | 			$sql[] = 'ORDER BY';
 69 | 			$sql[] = implode(', ', $orderby);
 70 | 		}
 71 | 
 72 | 		if($limit !== null){
 73 | 			$sql[] = 'LIMIT';
 74 | 			$sql[] = $offset !== null ? '?, ?' : '?';
 75 | 		}
 76 | 
 77 | 		return $sql;
 78 | 	}
 79 | 
 80 | 	public function insert(
 81 | 		string      $table,
 82 | 		array       $fields,
 83 | 		string|null $onConflict = null,
 84 | 		string|null $conflictTarget = null,
 85 | 	):array{
 86 | 		$sql = ['INSERT INTO'];
 87 | 		$sql[] = $this->quote($table);
 88 | 		$sql[] = '('.$this->quotes[0].implode($this->quotes[1].', '.$this->quotes[0], $fields).$this->quotes[1].')';
 89 | 		$sql[] = 'VALUES';
 90 | 		$sql[] = '('.implode(',', array_fill(0, count($fields), '?')).')';
 91 | 
 92 | 		return $sql;
 93 | 	}
 94 | 
 95 | 	public function update(string $table, array $set, string $where):array{
 96 | 		$sql = ['UPDATE'];
 97 | 		$sql[] = $this->quote($table);
 98 | 		$sql[] = 'SET';
 99 | 		$sql[] = implode(', ', $set);
100 | 		$sql[] = $where;
101 | 
102 | 		return $sql;
103 | 	}
104 | 
105 | 	public function delete(string $table, string $where):array{
106 | 		$sql = ['DELETE FROM'];
107 | 		$sql[] = $this->quote($table);
108 | 		$sql[] = $where;
109 | 
110 | 		return $sql;
111 | 	}
112 | 
113 | 	public function createDatabase(string $dbname, bool|null $ifNotExists = null, string|null $collate = null):array{
114 | 		throw new QueryException('not supported');
115 | 	}
116 | 
117 | 	public function quote(string $str):string{ // @todo: fixme
118 | 		return $this->quotes[0].implode($this->quotes[1].'.'.$this->quotes[0], explode('.', $str)).$this->quotes[1];
119 | 	}
120 | 
121 | 	public function dropDatabase(string $dbname, bool $ifExists):array{
122 | 		$sql = ['DROP DATABASE'];
123 | 
124 | 		if($ifExists){
125 | 			$sql[] = 'IF EXISTS';
126 | 		}
127 | 
128 | 		$sql[] = $this->quote($dbname);
129 | 
130 | 		return $sql;
131 | 	}
132 | 
133 | 	public function dropTable(string $table, bool $ifExists):array{
134 | 		$sql = ['DROP TABLE'];
135 | 
136 | 		if($ifExists){
137 | 			$sql[] = 'IF EXISTS';
138 | 		}
139 | 
140 | 		$sql[] = $this->quote($table);
141 | 
142 | 		return $sql;
143 | 	}
144 | 
145 | 	public function selectCount(
146 | 		array       $from,
147 | 		string|null $where = null,
148 | 		bool|null   $distinct = null,
149 | 		array|null  $groupby = null,
150 | 	):array{
151 | 		$sql = ['SELECT'];
152 | 
153 | 		if($distinct){
154 | 			$sql[] = 'DISTINCT';
155 | 		}
156 | 
157 | 		$sql[] = 'COUNT(*) AS';
158 | 		$sql[] = $this->quote('count');
159 | 		$sql[] = 'FROM '.implode(', ', $from);
160 | 		$sql[] = $where;
161 | 
162 | 		if(!empty($groupby)){
163 | 			$sql[] = 'GROUP BY ';
164 | 			$sql[] = implode(', ', $groupby);
165 | 		}
166 | 
167 | 		return $sql;
168 | 	}
169 | 
170 | 	public function orderby(array $expressions):array {
171 | 		$orderby = [];
172 | 
173 | 		foreach($expressions as $alias => $expression){
174 | 
175 | 			if(is_string($alias)){
176 | 
177 | 				if(is_array($expression)){
178 | 					$dir = strtoupper($expression[0]);
179 | 
180 | 					if(in_array($dir, ['ASC', 'DESC'], true)){
181 | 						$orderby[] = isset($expression[1]) ? strtoupper($expression[1]).'('.$this->quote($alias).') '.$dir : $dir;
182 | 					}
183 | 
184 | 				}
185 | 				else{
186 | 					$dir = strtoupper($expression);
187 | 
188 | 					if(in_array($dir, ['ASC', 'DESC'], true)){
189 | 						$orderby[] = $this->quote($alias).' '.$dir;
190 | 					}
191 | 
192 | 				}
193 | 
194 | 			}
195 | 			else{
196 | 				$orderby[] = $this->quote($expression);
197 | 			}
198 | 
199 | 		}
200 | 
201 | 		return $orderby;
202 | 	}
203 | 
204 | 	public function cols(array $expressions):array {
205 | 		$r = [];
206 | 
207 | 		foreach($expressions as $k => $ref){
208 | 			if(is_string($k)){
209 | 				$r[$ref[0] ?? $k] = is_array($ref)
210 | 					? $this->col_ref($ref[0], $k, $ref[1] ?? null)
211 | 					: $this->col_ref($ref, $k);
212 | 			}
213 | 			else{
214 | 				$r[$ref] = is_array($ref)
215 | 					? $this->col_ref($ref[0], null, $ref[1] ?? null)
216 | 					: $this->col_ref($ref);
217 | 			}
218 | 
219 | 		}
220 | 
221 | 		return $r;
222 | 	}
223 | 
224 | 	protected function col_ref(string $expr1, string|null $expr2 = null, string|null $func = null):string{
225 | 		// @todo: fixme, cleanup
226 | 		// errors on [alias => col, alias, alias => col...]
227 | 		return match(true){
228 | 			$expr2 !== null && $func !== null => sprintf('%s(%s) AS %s', strtoupper($func), $expr1, $this->quote($expr2)),
229 | 			$expr2 !== null && $func === null => sprintf('%s AS %s', $this->quote($expr1), $this->quote($expr2)),
230 | 			$expr2 === null && $func !== null => sprintf('%s(%s)', strtoupper($func), $expr1),
231 | 			default                           => $this->quote($expr1),
232 | 		};
233 | 	}
234 | 
235 | 
236 | 	public function from(array $expressions):array {
237 | 		$r = [];
238 | 
239 | 		foreach($expressions as $k => $ref){
240 | 
241 | 			if(is_string($k)){
242 | 				$r[$ref ?? $k] = $this->from_ref($k, $ref);
243 | 			}
244 | 			else{
245 | 				$x = explode(' ', $ref);
246 | 
247 | 				if(count($x) === 2){
248 | 					$r[$ref ?? $k] = $this->from_ref($x[0], $x[1]);
249 | 				}
250 | 				else{
251 | 					$r[$ref] = $this->from_ref($ref);
252 | 				}
253 | 			}
254 | 
255 | 		}
256 | 
257 | 		return $r;
258 | 	}
259 | 
260 | 	protected function from_ref(string $table, string|null $ref = null):string{
261 | 		// @todo: quotes
262 | 		$from = $this->quote($table);
263 | 
264 | 		if($ref !== null){
265 | 			$from = sprintf('%s AS %s', $this->quote($ref), $this->quote($table)); // @todo: index hint
266 | 		}
267 | 
268 | 		return $from;
269 | 	}
270 | 
271 | 	public function enum(string $name, array $values, mixed $defaultValue = null, bool|null $isNull = null):string{
272 | 		$field = $this->quote($name);
273 | 		$field .= 'ENUM (\''.implode('\', \'', $values).'\')';
274 | 
275 | 		if($isNull !== null){
276 | 			$field .= $isNull === true ? 'NULL' : 'NOT NULL';
277 | 		}
278 | 
279 | 		if(in_array($defaultValue, $values, true)){
280 | 			$field .= 'DEFAULT '.(is_int($defaultValue) || is_float($defaultValue) ? $defaultValue : '\''.$defaultValue.'\'');
281 | 		}
282 | 		elseif($isNull && strtolower($defaultValue) === 'null'){
283 | 			$field .= 'DEFAULT NULL';
284 | 		}
285 | 
286 | 		return $field;
287 | 	}
288 | 
289 | 	public function truncate(string $table):array{
290 | 		$sql = ['TRUNCATE TABLE'];
291 | 		$sql[] = $this->quote($table);
292 | 
293 | 		return $sql;
294 | 	}
295 | 
296 | 	public function showDatabases():array{
297 | 		throw new QueryException('not supported');
298 | 	}
299 | 
300 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
301 | 		throw new QueryException('not supported');
302 | 	}
303 | 
304 | 	public function showCreateTable(string $table):array{
305 | 		throw new QueryException('not supported');
306 | 	}
307 | 
308 | }
309 | 


--------------------------------------------------------------------------------
/src/Dialects/Firebird.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class Firebird
  4 |  *
  5 |  * @filesource   Firebird.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use function count, explode, implode, in_array, intval, preg_match, strtolower, strtoupper, trim;
 17 | 
 18 | final class Firebird extends DialectAbstract{
 19 | 
 20 | 	private const TYPE_TRANSLATION =  [
 21 | 		'TINYINT'    => 'SMALLINT',
 22 | 		'MEDIUMINT'  => 'INT',
 23 | 		'BIGINT'     => 'INT64',
 24 | 		'REAL'       => 'DOUBLE PRECISION',
 25 | 		'DOUBLE'     => 'DOUBLE PRECISION',
 26 | 		'BOOLEAN'    => 'CHAR(1)',
 27 | 		'BINARY'     => 'CHAR',
 28 | 		'VARBINARY'  => 'CHAR',
 29 | 		'TINYTEXT'   => 'VARCHAR(255)',
 30 | 		'DATETIME'   => 'TIMESTAMP',
 31 | 		'IMAGE'      => 'BLOB',
 32 | 		'TEXT'       => 'BLOB SUB_TYPE TEXT',
 33 | 		'MEDIUMTEXT' => 'BLOB SUB_TYPE TEXT',
 34 | 		'LONGTEXT'   => 'BLOB SUB_TYPE TEXT',
 35 | 	];
 36 | 
 37 | 	public function select(
 38 | 		array       $cols,
 39 | 		array       $from,
 40 | 		string|null $where = null,
 41 | 		mixed       $limit = null,
 42 | 		mixed       $offset = null,
 43 | 		bool|null   $distinct = null,
 44 | 		array|null  $groupby = null,
 45 | 		array|null  $orderby = null,
 46 | 	):array{
 47 | 		$sql = ['SELECT'];
 48 | 
 49 | 		if($limit !== null){
 50 | 			$sql[] = 'FIRST ? SKIP ?';
 51 | 		}
 52 | 
 53 | 		if($distinct){
 54 | 			$sql[] = 'DISTINCT';
 55 | 		}
 56 | 
 57 | 		!empty($cols)
 58 | 			? $sql[] = implode(', ', $cols)
 59 | 			: $sql[] = '*';
 60 | 
 61 | 		$sql[] = 'FROM';
 62 | 		$sql[] = implode(', ', $from);
 63 | 		$sql[] = $where;
 64 | 
 65 | 		if(!empty($groupby)){
 66 | 			$sql[] = 'GROUP BY';
 67 | 			$sql[] = implode(', ', $groupby);
 68 | 		}
 69 | 
 70 | 		if(!empty($orderby)){
 71 | 			$sql[] = 'ORDER BY';
 72 | 			$sql[] = implode(', ', $orderby);
 73 | 		}
 74 | 
 75 | 		return $sql;
 76 | 	}
 77 | 
 78 | 	public function createTable(
 79 | 		string      $table,
 80 | 		array       $cols,
 81 | 		string|null $primaryKey = null,
 82 | 		bool|null   $ifNotExists = null,
 83 | 		bool|null   $temp = null,
 84 | 		string|null $dir = null,
 85 | 	):array{
 86 | 		$sql = [$ifNotExists ? 'RECREATE' : 'CREATE']; // nasty
 87 | 
 88 | 		if($temp){
 89 | 			$sql[] = 'GLOBAL TEMPORARY';
 90 | 		}
 91 | 
 92 | 		$sql[] = 'TABLE';
 93 | 
 94 | 		$n = explode('.', $table);
 95 | 
 96 | 		$sql[] = $this->quote($n[count($n) - 1]);
 97 | 
 98 | 		$_cols = [];
 99 | 
100 | 		if(!empty($cols)){
101 | 
102 | 			foreach($cols as $name => $col){
103 | 
104 | 				if(strtolower($name) === strtolower($primaryKey ?? '')){
105 | 					$x = explode(' NOT NULL', $col, 2);
106 | 
107 | 					if(count($x) > 0){
108 | 						$col = $x[0].' NOT NULL PRIMARY KEY';
109 | 						$col .= $x[1] ?? '';
110 | 					}
111 | 
112 | 				}
113 | 
114 | 				$_cols[] = $col;
115 | 			}
116 | 
117 | 			$sql[] = '('.implode(', ', $_cols).')';
118 | 		}
119 | 
120 | 		return $sql;
121 | 	}
122 | 
123 | 	public function dropTable(string $table, bool $ifExists):array{
124 | /*
125 | 		if($ifExists){
126 | 			$sql[] = '
127 | EXECUTE BLOCK AS  BEGIN
128 |     IF  ( EXISTS ( SELECT 1 FROM RDB$RELATIONS WHERE RDB$RELATION_NAME = '.$this->quote($table).' ))
129 |     THEN  BEGIN
130 |         EXECUTE STATEMENT \'DROP TABLE '.$this->quote($table).';\' ;
131 |     END
132 | END ^
133 | ';
134 | 		}
135 | 		else{
136 | 
137 | 		}
138 | */
139 | 			$sql = ['DROP TABLE'];
140 | 			$sql[] = $this->quote($table);
141 | 
142 | 
143 | 		return $sql;
144 | 	}
145 | 
146 | 	public function fieldspec(
147 | 		string      $name,
148 | 		string      $type,
149 | 		mixed       $length = null,
150 | 		string|null $attribute = null,
151 | 		string|null $collation = null,
152 | 		bool|null   $isNull = null,
153 | 		string|null $defaultType = null,
154 | 		mixed       $defaultValue = null,
155 | 		string|null $extra = null,
156 | 	):string{
157 | 		$type  = strtoupper(trim($type));
158 | 		$field = [$this->quote(trim($name))];
159 | 
160 | 		$field[] = match(true){
161 | 			isset(self::TYPE_TRANSLATION[$type])                             => self::TYPE_TRANSLATION[$type],
162 | 			in_array($type, ['CHAR', 'VARCHAR', 'DECIMAL', 'NUMERIC'], true) => $type.'('.$length.')',
163 | 			default                                                          => $type,
164 | 		};
165 | 
166 | 		if($isNull === false && !in_array($type, ['DATE', 'TIME', 'TIMESTAMP'], true)){
167 | 			$field[] = 'NOT NULL';
168 | 		}
169 | 
170 | 		$defaultType = strtoupper($defaultType ?? '');
171 | 
172 | 		if($defaultType === 'USER_DEFINED'){
173 | 
174 | 			$field[] = match(true){
175 | 				$type === 'TIMESTAMP' && intval($defaultValue) === 0     => 'DEFAULT 0',
176 | 				strtoupper($defaultValue) === 'NULL' && $isNull === true => 'DEFAULT NULL',
177 | 				$type === 'BOOLEAN'                                      => 'DEFAULT '.(preg_match('/^1|T|TRUE|YES$/i', $defaultValue) ? '1' : '0'),
178 | 				default                                                  => 'DEFAULT \''.$defaultValue.'\'',
179 | 			};
180 | 
181 | 		}
182 | 		elseif($defaultType === 'CURRENT_TIMESTAMP'){
183 | 			$field[] = 'DEFAULT CURRENT_TIMESTAMP';
184 | 		}
185 | 		elseif($defaultType === 'NULL' && $isNull === true){
186 | 			$field[] = 'DEFAULT NULL';
187 | 		}
188 | 
189 | 		if($attribute){
190 | 			$field[] = $attribute;
191 | 		}
192 | 
193 | 		if($extra){
194 | 			$field[] = $extra;
195 | 		}
196 | 
197 | 		return implode(' ', $field);
198 | 	}
199 | 
200 | 	public function truncate(string $table):array{
201 | 		$sql = ['DELETE FROM'];// RECREATE TABLE [table spec] ...stupid firebird 2.5
202 | 		$sql[] = $this->quote($table);
203 | 
204 | 		return $sql;
205 | 	}
206 | 
207 | 	public function showDatabases():array{
208 | 		/** @noinspection SqlResolve, SqlDialectInspection */
209 | 		return ['SELECT TRIM(LOWER(MON$DATABASE_NAME)) AS "Database" FROM MON$DATABASE'];
210 | 	}
211 | 
212 | 
213 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
214 | 		/** @noinspection SqlResolve, SqlDialectInspection */
215 | 		return ['SELECT TRIM(RDB$RELATION_NAME) AS "tablename" FROM RDB$RELATIONS WHERE RDB$VIEW_BLR IS NULL AND (RDB$SYSTEM_FLAG IS NULL OR RDB$SYSTEM_FLAG = 0)'];
216 | 	}
217 | 
218 | }
219 | 


--------------------------------------------------------------------------------
/src/Dialects/MSSQL.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class MSSQL
  4 |  *
  5 |  * @filesource   MSSQL.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use function count, explode, implode, in_array, is_int, is_string, preg_match, strtolower, strtoupper, trim;
 17 | 
 18 | final class MSSQL extends DialectAbstract{
 19 | 
 20 | 	private const TYPE_TRANSLATION = [
 21 | 		'boolean'    => 'bit',
 22 | 		'bool   '    => 'bit',
 23 | 		'mediumint'  => 'int',
 24 | 		'double'     => 'float',
 25 | 		'tinytext'   => 'text',
 26 | 		'mediumtext' => 'text',
 27 | 		'longtext'   => 'text',
 28 | 		'timestamp'  => 'datetime2',
 29 | 	];
 30 | 
 31 | 	protected array $quotes = ['[', ']'];
 32 | 
 33 | 	public function dropTable(string $table, bool $ifExists):array{
 34 | 		// @todo: if exists
 35 | 		$sql = ['DROP TABLE'];
 36 | 
 37 | 		$sql[] = $this->quote($table);
 38 | 
 39 | 		return $sql;
 40 | 	}
 41 | 
 42 | 	public function select(
 43 | 		array       $cols,
 44 | 		array       $from,
 45 | 		string|null $where = null,
 46 | 		mixed       $limit = null,
 47 | 		mixed       $offset = null,
 48 | 		bool|null   $distinct = null,
 49 | 		array|null  $groupby = null,
 50 | 		array|null  $orderby = null,
 51 | 	):array{
 52 | 		$sql = ['SELECT'];
 53 | 
 54 | 		if($distinct){
 55 | 			$sql[] = 'DISTINCT';
 56 | 		}
 57 | 
 58 | 		!empty($cols)
 59 | 			? $sql[] = implode(', ', $cols)
 60 | 			: $sql[] = '*';
 61 | 
 62 | 		$sql[] = 'FROM';
 63 | 		$sql[] = implode(', ', $from);
 64 | 		$sql[] = $where;
 65 | 
 66 | 		if(!empty($groupby)){
 67 | 			$sql[] = 'GROUP BY';
 68 | 			$sql[] = implode(', ', $groupby);
 69 | 		}
 70 | 
 71 | 		if(!empty($orderby)){
 72 | 			$sql[] = 'ORDER BY';
 73 | 			$sql[] = implode(', ', $orderby);
 74 | 		}
 75 | 
 76 | 		if($limit !== null){
 77 | 
 78 | 			if(empty($orderby)){
 79 | 				$sql[] = 'ORDER BY 1';
 80 | 			}
 81 | 
 82 | 			$sql[] = 'OFFSET ? ROWS FETCH NEXT ? ROWS ONLY';
 83 | 		}
 84 | 
 85 | 		return $sql;
 86 | 	}
 87 | 
 88 | 	public function createDatabase(string $dbname, bool|null $ifNotExists = null, string|null $collate = null):array{
 89 | 		$sql = ['CREATE DATABASE'];
 90 | 		$sql[] = $this->quote($dbname);
 91 | 
 92 | 		if($collate){
 93 | 			$sql[] = 'COLLATE';
 94 | 			$sql[] = $collate;
 95 | 		}
 96 | 
 97 | 		return $sql;
 98 | 	}
 99 | 
100 | 	public function createTable(
101 | 		string      $table,
102 | 		array       $cols,
103 | 		string|null $primaryKey = null,
104 | 		bool|null   $ifNotExists = null,
105 | 		bool|null   $temp = null,
106 | 		string|null $dir = null,
107 | 	):array{
108 | 		$sql = [];
109 | 		// @todo
110 | #		if($ifNotExists){
111 | #			$sql[] = 'IF OBJECT_ID(N\''.str_replace(['[', ']'], '', $table).'\', N\'U\') IS NULL' ;
112 | #		}
113 | 
114 | 		$sql[] = 'CREATE TABLE';
115 | 		$sql[] = $this->quote($table);
116 | 
117 | 		if(!empty($cols)){
118 | 			$sql[] = '(';
119 | 			$sql[] = implode(',', $cols);
120 | 
121 | 			if($primaryKey){
122 | 				$sql[] = ', PRIMARY KEY ('.$this->quote($primaryKey).')';
123 | 			}
124 | 
125 | 			$sql[] = ')';
126 | 		}
127 | 
128 | 		return $sql;
129 | 	}
130 | 
131 | 	/**
132 | 	 * @see https://docs.microsoft.com/sql/t-sql/data-types/numeric-types
133 | 	 * @see https://docs.microsoft.com/sql/t-sql/data-types/string-and-binary-types
134 | 	 */
135 | 	public function fieldspec(
136 | 		string      $name,
137 | 		string      $type,
138 | 		mixed       $length = null,
139 | 		string|null $attribute = null,
140 | 		string|null $collation = null,
141 | 		bool|null   $isNull = null,
142 | 		string|null $defaultType = null,
143 | 		mixed       $defaultValue = null,
144 | 		string|null $extra = null,
145 | 	):string{
146 | 		$type             = strtolower(trim($type));
147 | 		$field            = [$this->quote(trim($name))];
148 | 		$type_translation = self::TYPE_TRANSLATION[$type] ?? $type;
149 | 
150 | 		if((is_int($length) || is_string($length) && (count(explode(',', $length)) === 2 || $length === 'max'))
151 | 		   && in_array($type, ['char', 'varchar', 'nchar', 'nvarchar', 'decimal', 'numeric', 'datetime2', 'time'], true)){
152 | 			$field[] = $type_translation.'('.$length.')';
153 | 		}
154 | 		else{
155 | 			$field[] = $type_translation;
156 | 		}
157 | 
158 | 		if($isNull !== null){
159 | 			$field[] = $isNull ? 'NULL' : 'NOT NULL';
160 | 		}
161 | 
162 | 		$defaultType = strtoupper($defaultType ?? '');
163 | 
164 | 		if($defaultType === 'USER_DEFINED'){
165 | 
166 | 			// @todo
167 | 			$field[] = match (true) {
168 | 				$type_translation === 'bit' => 'DEFAULT '.(preg_match('/^1|T|TRUE|YES$/i', $defaultValue) ? '1' : '0'),
169 | 				default                     => 'DEFAULT \''.$defaultValue.'\'',
170 | 			};
171 | 
172 | 		}
173 | 		elseif($defaultType === 'CURRENT_TIMESTAMP'){
174 | 			$field[] = 'DEFAULT CURRENT_TIMESTAMP';
175 | 		}
176 | 		elseif($defaultType === 'NULL' && $isNull === true){
177 | 			$field[] = 'DEFAULT NULL';
178 | 		}
179 | 
180 | 		if($extra){
181 | 			$field[] = $extra;
182 | 		}
183 | 
184 | 		return implode(' ', $field);
185 | 	}
186 | 
187 | 	public function showDatabases():array{
188 | 		// https://stackoverflow.com/questions/147659/get-list-of-databases-from-sql-server
189 | 		// EXEC sp_databases
190 | 		/** @noinspection SqlResolve, SqlDialectInspection */
191 | 		return ['SELECT name AS [Database] FROM master.dbo.sysdatabases WHERE name NOT IN (\'master\', \'tempdb\', \'model\', \'msdb\')'];
192 | 	}
193 | 
194 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
195 | 		/** @noinspection SqlResolve, SqlDialectInspection */
196 | 		return ['SELECT Distinct TABLE_NAME FROM information_schema.TABLES'];
197 | 	}
198 | 
199 | }
200 | 


--------------------------------------------------------------------------------
/src/Dialects/MySQL.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class MySQL
  4 |  *
  5 |  * @filesource   MySQL.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use function array_fill, count, explode, implode, in_array, intval, is_int, is_string,
 17 | 	preg_match, preg_replace, sodium_bin2hex, strtoupper, trim;
 18 | 
 19 | final class MySQL extends DialectAbstract{
 20 | 
 21 | 	private const nolengthtypes = [
 22 | 		'DATE', 'TINYBLOB', 'TINYTEXT', 'BLOB', 'TEXT', 'MEDIUMBLOB',
 23 | 		'MEDIUMTEXT', 'LONGBLOB', 'LONGTEXT', 'SERIAL', 'BOOLEAN', 'UUID',
 24 | 	];
 25 | 
 26 | 	private const collationtypes = [
 27 | 		'TINYTEXT', 'TEXT', 'MEDIUMTEXT', 'LONGTEXT', 'VARCHAR', 'CHAR', 'ENUM', 'SET',
 28 | 	];
 29 | 
 30 | 	protected array $quotes = ['`', '`'];
 31 | 	// https://dev.mysql.com/doc/refman/8.0/en/charset-unicode-sets.html
 32 | 	protected string $charset = 'utf8mb4_bin'; // utf8mb4_0900_bin
 33 | 
 34 | 	public function insert(
 35 | 		string      $table,
 36 | 		array       $fields,
 37 | 		string|null $onConflict = null,
 38 | 		string|null $conflictTarget = null,
 39 | 	):array{
 40 | 
 41 | 		$sql = match(strtoupper($onConflict ?? '')){
 42 | 			'IGNORE'  => ['INSERT IGNORE'],
 43 | 			'REPLACE' => ['REPLACE'],
 44 | 			default   => ['INSERT'],
 45 | 		};
 46 | 
 47 | 		$sql[] = 'INTO';
 48 | 		$sql[] = $this->quote($table);
 49 | 		$sql[] = '('.$this->quotes[0].implode($this->quotes[1].', '.$this->quotes[0], $fields).$this->quotes[1].')';
 50 | 		$sql[] = 'VALUES';
 51 | 		$sql[] = '('.implode(',', array_fill(0, count($fields), '?')).')';
 52 | 
 53 | 		return $sql;
 54 | 	}
 55 | 
 56 | 	public function createDatabase(string $dbname, bool|null $ifNotExists = null, string|null $collate = null):array{
 57 | 		$collate = $collate ?? $this->charset;
 58 | 
 59 | 		$sql = ['CREATE DATABASE'];
 60 | 
 61 | 		if($ifNotExists){
 62 | 			$sql[] = 'IF NOT EXISTS';
 63 | 		}
 64 | 
 65 | 		$sql[] = $this->quote($dbname);
 66 | 
 67 | 		if(!empty($collate)){
 68 | 			[$charset] = explode('_', $collate);
 69 | 
 70 | 			$sql[] = 'CHARACTER SET';
 71 | 			$sql[] = $charset;
 72 | 
 73 | 			if($collate !== $charset){
 74 | 				$sql[] = 'COLLATE';
 75 | 				$sql[] = $collate;
 76 | 			}
 77 | 
 78 | 		}
 79 | 
 80 | 		return $sql;
 81 | 	}
 82 | 
 83 | 	public function createTable(
 84 | 		string      $table,
 85 | 		array       $cols,
 86 | 		string|null $primaryKey = null,
 87 | 		bool|null   $ifNotExists = null,
 88 | 		bool|null   $temp = null,
 89 | 		string|null $dir = null,
 90 | 	):array{
 91 | 		$sql = ['CREATE'];
 92 | 
 93 | 		if($temp){
 94 | 			$sql[] = 'TEMPORARY';
 95 | 		}
 96 | 
 97 | 		$sql[] = 'TABLE' ;
 98 | 
 99 | 		if($ifNotExists){
100 | 			$sql[] =  'IF NOT EXISTS' ;
101 | 		}
102 | 
103 | 		$sql[] =  $this->quote($table);
104 | 
105 | 		if(!empty($cols)){
106 | 			$sql[] = '(';
107 | 			$sql[] = implode(', ', $cols);
108 | 
109 | 			if(!empty($primaryKey)){
110 | 				$sql[] = ', PRIMARY KEY ('.$this->quote($primaryKey).')';
111 | 			}
112 | 
113 | 			$sql[] = ')';
114 | 		}
115 | 
116 | 		if(!empty($this->charset)){
117 | 			[$charset] = explode('_', $this->charset);
118 | 
119 | 			$sql[] = 'CHARACTER SET';
120 | 			$sql[] = $charset;
121 | 
122 | 			if($charset !== $this->charset){
123 | 				$sql[] = 'COLLATE';
124 | 				$sql[] = $this->charset;
125 | 			}
126 | 
127 | 		}
128 | 
129 | 		return $sql;
130 | 	}
131 | 
132 | 	/**
133 | 	 * @see https://dev.mysql.com/doc/refman/8.0/en/data-types.html
134 | 	 */
135 | 	public function fieldspec(
136 | 		string      $name,
137 | 		string      $type,
138 | 		mixed       $length = null,
139 | 		string|null $attribute = null,
140 | 		string|null $collation = null,
141 | 		bool|null   $isNull = null,
142 | 		string|null $defaultType = null,
143 | 		mixed       $defaultValue = null,
144 | 		string|null $extra = null,
145 | 	):string{
146 | 		$type        = strtoupper(trim($type));
147 | 		$defaultType = strtoupper($defaultType ?? '');
148 | 		$field       = [$this->quote(trim($name))];
149 | 
150 | 		$field[] = (is_int($length) || (is_string($length) && count(explode(',', $length)) === 2)) && !in_array($type, self::nolengthtypes, true)
151 | 			? $type.'('. $length . ')'
152 | 			: $type;
153 | 
154 | 		if($attribute){
155 | 			$field[] = strtoupper($attribute);
156 | 		}
157 | 
158 | 		if($collation !== null && in_array($type, self::collationtypes, true)){
159 | 			[$charset] = explode('_', $collation);
160 | 
161 | 			$field[] = 'CHARACTER SET '.$charset;
162 | 
163 | 			if($charset !== $collation){
164 | 				$field[] = 'COLLATE '.$collation;
165 | 			}
166 | 
167 | 		}
168 | 
169 | 		if($isNull !== null){
170 | 			$field[] = $isNull ? 'NULL' : 'NOT NULL';
171 | 		}
172 | 
173 | 		if($defaultType === 'USER_DEFINED'){
174 | 
175 | 			$field[] = match(true){
176 | 				$type === 'TIMESTAMP' && intval($defaultValue) === 0             => 'DEFAULT 0',
177 | 				$type === 'BIT'                                                  => 'DEFAULT b\''.preg_replace('/[^01]/', '0', $defaultValue).'\'',
178 | 				$type === 'BOOLEAN'                                              => 'DEFAULT '.(preg_match('/^1|T|TRUE|YES$/i', $defaultValue) ? 'TRUE' : 'FALSE'),
179 | 				$type === 'BINARY' || $type === 'VARBINARY'                      => 'DEFAULT 0x'.sodium_bin2hex($defaultValue),
180 | 				strtoupper((string)$defaultValue) === 'NULL' && $isNull === true => 'DEFAULT NULL',
181 | 				default                                                          => 'DEFAULT \''.$defaultValue.'\'',
182 | 			};
183 | 
184 | 		}
185 | 		else if($defaultType === 'CURRENT_TIMESTAMP'){
186 | 			$field[] = 'DEFAULT CURRENT_TIMESTAMP';
187 | 		}
188 | 		else if($defaultType === 'NULL' && $isNull === true){
189 | 			$field[] = 'DEFAULT NULL';
190 | 		}
191 | 
192 | 
193 | 		if($extra){
194 | 			$field[] = $extra;
195 | 		}
196 | 
197 | 		return implode(' ', $field);
198 | 	}
199 | 
200 | 	public function showDatabases():array{
201 | 		return ['SHOW DATABASES'];
202 | 	}
203 | 
204 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
205 | 		return ['SHOW TABLES'];
206 | 	}
207 | 
208 | 	public function showCreateTable(string $table):array{
209 | 		$sql = ['SHOW CREATE TABLE'];
210 | 		$sql[] = $this->quote($table);
211 | 
212 | 		return $sql;
213 | 	}
214 | 
215 | }
216 | 


--------------------------------------------------------------------------------
/src/Dialects/Postgres.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class Postgres
  4 |  *
  5 |  * @filesource   Postgres.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use chillerlan\Database\Query\QueryException;
 17 | use function count, explode, implode, in_array, intval, is_int, is_string,
 18 | 	preg_match, preg_replace, strtolower, strtoupper, trim;
 19 | 
 20 | final class Postgres extends DialectAbstract{
 21 | 
 22 | 	private const TYPE_TRANSLATION = [
 23 | 		'TINYINT'    => 'SMALLINT',
 24 | 		'MEDIUMINT'  => 'INT',
 25 | 		'DOUBLE'     => 'DOUBLE PRECISION',
 26 | 		'TINYTEXT'   => 'TEXT',
 27 | 		'DATETIME'   => 'TIMESTAMP',
 28 | 		'IMAGE'      => 'BLOB',
 29 | 		'MEDIUMTEXT' => 'TEXT',
 30 | 		'LONGTEXT'   => 'TEXT',
 31 | 	];
 32 | 
 33 | 	public function select(
 34 | 		array       $cols,
 35 | 		array       $from,
 36 | 		string|null $where = null,
 37 | 		mixed       $limit = null,
 38 | 		mixed       $offset = null,
 39 | 		bool|null   $distinct = null,
 40 | 		array|null  $groupby = null,
 41 | 		array|null  $orderby = null,
 42 | 	):array{
 43 | 		$sql = ['SELECT'];
 44 | 
 45 | 		if($distinct){
 46 | 			$sql[] = 'DISTINCT';
 47 | 		}
 48 | 
 49 | 		!empty($cols)
 50 | 			? $sql[] = implode(', ', $cols)
 51 | 			: $sql[] = '*';
 52 | 
 53 | 		$sql[] = 'FROM';
 54 | 		$sql[] = implode(', ', $from);
 55 | 		$sql[] = $where;
 56 | 
 57 | 		if(!empty($groupby)){
 58 | 			$sql[] = 'GROUP BY';
 59 | 			$sql[] = implode(', ', $groupby);
 60 | 		}
 61 | 
 62 | 		if(!empty($orderby)){
 63 | 			$sql[] = 'ORDER BY';
 64 | 			$sql[] = implode(', ', $orderby);
 65 | 		}
 66 | 
 67 | 		if($offset !== null){
 68 | 			$sql[] = 'OFFSET ?';
 69 | 		}
 70 | 
 71 | 		if($limit !== null){
 72 | 			$sql[] = 'LIMIT ?';
 73 | 		}
 74 | 
 75 | 		return $sql;
 76 | 	}
 77 | 
 78 | 	/**
 79 | 	 * @link https://www.postgresql.org/docs/9.5/static/sql-insert.html#SQL-ON-CONFLICT
 80 | 	 *
 81 | 	 * @throws \chillerlan\Database\Query\QueryException
 82 | 	 */
 83 | 	public function insert(
 84 | 		string      $table,
 85 | 		array       $fields,
 86 | 		string|null $onConflict = null,
 87 | 		string|null $conflictTarget = null,
 88 | 	):array{
 89 | 		$sql = parent::insert($table, $fields);
 90 | 
 91 | 		if(in_array($onConflict, ['IGNORE', 'REPLACE'], true)){
 92 | 
 93 | 			if(empty($conflictTarget)){
 94 | 				throw new QueryException('postgres insert on conflict: no conflict target given');
 95 | 			}
 96 | 
 97 | 			$sql[] =  'ON CONFLICT ('.$this->quote($conflictTarget).') DO';
 98 | 
 99 | 			switch($onConflict){
100 | 				case 'IGNORE':
101 | 					$sql[] = 'NOTHING';
102 | 					break;
103 | 				case 'REPLACE':
104 | 					$sql[] = $this->onConflictUpdate($fields);
105 | 					break;
106 | 			}
107 | 
108 | 		}
109 | 
110 | 		return $sql;
111 | 	}
112 | 
113 | 	protected function onConflictUpdate(array $fields):string{
114 | 		$onConflictUpdate = [];
115 | 
116 | 		foreach($fields as $f){
117 | 			$onConflictUpdate[] = $this->quote($f).' = EXCLUDED.'.$this->quote($f);
118 | 		}
119 | 
120 | 		return 'UPDATE SET '.implode(', ', $onConflictUpdate);
121 | 	}
122 | 
123 | 	public function createDatabase(string $dbname, bool|null $ifNotExists = null, string|null $collate = null):array{
124 | 		$sql = ['CREATE DATABASE'];
125 | 		$sql[] = $this->quote($dbname);
126 | 
127 | 		if($collate){
128 | 			$charset = explode(',', $collate, 3);
129 | 
130 | 			$count = count($charset);
131 | 
132 | 			if($count > 0){
133 | 				$sql[] = 'ENCODING \''.strtoupper($charset[0]).'\'';
134 | 			}
135 | 
136 | 			if($count > 1){
137 | 				$sql[] = 'LC_COLLATE=\''.$charset[1].'\'';
138 | 			}
139 | 
140 | 			if($count > 2){
141 | 				$sql[] = 'LC_CTYPE=\''.$charset[2].'\'';
142 | 			}
143 | 
144 | 		}
145 | 
146 | 		return $sql;
147 | 	}
148 | 
149 | 	/**
150 | 	 * @see https://www.postgresql.org/docs/9.5/datatype.html
151 | 	 */
152 | 	public function fieldspec(
153 | 		string      $name,
154 | 		string      $type,
155 | 		mixed       $length = null,
156 | 		string|null $attribute = null,
157 | 		string|null $collation = null,
158 | 		bool|null   $isNull = null,
159 | 		string|null $defaultType = null,
160 | 		mixed       $defaultValue = null,
161 | 		string|null $extra = null,
162 | 	):string{
163 | 		$name             = trim($name);
164 | 		$type             = strtoupper(trim($type));
165 | 		$field            = [$this->quote($name)];
166 | 		$type_translation = self::TYPE_TRANSLATION[$type] ?? $type;
167 | 
168 | 		if((is_int($length) || is_string($length) && count(explode(',', $length)) === 2)
169 | 		   && in_array($type, ['BIT', 'VARBIT', 'CHAR', 'VARCHAR', 'DECIMAL', 'NUMERIC', 'TIME', 'TIMESTAMP', 'INTERVAL'], true)){
170 | 			$field[] = $type_translation.'('.$length.')';
171 | 		}
172 | 		else{
173 | 			$field[] = $type_translation;
174 | 		}
175 | 
176 | 		if($collation && in_array($type, ['TINYTEXT', 'TEXT', 'MEDIUMTEXT', 'LONGTEXT', 'VARCHAR', 'CHAR'], true)
177 | 		   && !in_array(strtolower($collation), ['utf8'], true)){
178 | 			$field[] = 'COLLATE '.$collation;
179 | 		}
180 | 
181 | 		if($isNull !== true){
182 | 			$field[] = 'NOT NULL';
183 | 		}
184 | 
185 | 		if($attribute){
186 | 			$field[] = strtoupper($attribute);
187 | 		}
188 | 
189 | 		$defaultType = strtoupper($defaultType ?? '');
190 | 
191 | 		if($defaultType === 'USER_DEFINED'){
192 | 
193 | 			$field[] = match (true) {
194 | 				$type === 'TIMESTAMP' && intval($defaultValue) === 0             => 'DEFAULT 0',
195 | 				$type === 'BIT' || $type === 'VARBIT'                            => 'DEFAULT b\''.preg_replace('/[^01]/', '0', $defaultValue).'\'',
196 | 				$type === 'BOOLEAN'                                              => 'DEFAULT '.(preg_match('/^1|T|TRUE|YES$/i', $defaultValue) ? 'TRUE' : 'FALSE'),
197 | 				strtoupper((string)$defaultValue) === 'NULL' && $isNull === true => 'DEFAULT NULL',
198 | 				default                                                          => 'DEFAULT \''.$defaultValue.'\'',
199 | 			};
200 | 
201 | 		}
202 | 		elseif($defaultType === 'CURRENT_TIMESTAMP'){
203 | 			$field[] = 'DEFAULT CURRENT_TIMESTAMP';
204 | 		}
205 | 		elseif($defaultType === 'NULL' && $isNull === true){
206 | 			$field[] = 'DEFAULT NULL';
207 | 		}
208 | 
209 | 		if($extra){
210 | 			$field[] = $extra;
211 | 		}
212 | 
213 | 		return implode(' ', $field);
214 | 	}
215 | 
216 | 	public function createTable(
217 | 		string      $table,
218 | 		array       $cols,
219 | 		string|null $primaryKey = null,
220 | 		bool|null   $ifNotExists = null,
221 | 		bool|null   $temp = null,
222 | 		string|null $dir = null,
223 | 	):array{
224 | 		$sql = ['CREATE'];
225 | 
226 | 		if($temp){
227 | 			$sql[] = 'TEMPORARY';
228 | 		}
229 | 
230 | 		$sql[] = 'TABLE';
231 | 
232 | 		if($ifNotExists){
233 | 			$sql[] = 'IF NOT EXISTS';
234 | 		}
235 | 
236 | 		$n = explode('.', $table);
237 | 
238 | 		$sql[] = $this->quote($n[count($n) - 1]);
239 | 
240 | 		if(!empty($cols)){
241 | 			$sql[] = ' (';
242 | 			$sql[] = implode(', ', $cols);
243 | 
244 | 			if($primaryKey){
245 | 				$sql[] = ','.'PRIMARY KEY ('.$this->quote($primaryKey).')';
246 | 			}
247 | 
248 | 			$sql[] = ')';
249 | 		}
250 | 
251 | 		return $sql;
252 | 	}
253 | 
254 | 	public function showDatabases():array{
255 | 		/** @noinspection SqlResolve, SqlDialectInspection */
256 | 		return ['SELECT datname AS "Database" FROM pg_database'];
257 | 	}
258 | 
259 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
260 | 		/** @noinspection SqlResolve, SqlDialectInspection */
261 | 		return ['SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != \'pg_catalog\'AND schemaname != \'information_schema\' '];
262 | 	}
263 | 
264 | }
265 | 


--------------------------------------------------------------------------------
/src/Dialects/SQLite.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class SQLite
  4 |  *
  5 |  * @filesource   SQLite.php
  6 |  * @created      11.01.2018
  7 |  * @package      chillerlan\Database\Dialects
  8 |  * @author       Smiley <smiley@chillerlan.net>
  9 |  * @copyright    2018 Smiley
 10 |  * @license      MIT
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Dialects;
 15 | 
 16 | use function count, explode, implode, in_array, is_bool, is_string, strtoupper, trim;
 17 | 
 18 | final class SQLite extends DialectAbstract{
 19 | 
 20 | 	private const TYPE_TRANSLATION = [
 21 | 		'TINYINT'    => 'INTEGER',
 22 | 		'SMALLINT'   => 'INTEGER',
 23 | 		'MEDIUMINT'  => 'INTEGER',
 24 | 		'BIGINT'     => 'INTEGER',
 25 | 		'TINYTEXT'   => 'TEXT',
 26 | 		'MEDIUMTEXT' => 'TEXT',
 27 | 		'LONGTEXT'   => 'TEXT',
 28 | 		'DOUBLE'     => 'REAL',
 29 | 		'DECIMAL'    => 'REAL',
 30 | 	];
 31 | 
 32 | 	/**
 33 | 	 * @see https://www.sqlite.org/datatype3.html
 34 | 	 */
 35 | 	public function fieldspec(
 36 | 		string      $name,
 37 | 		string      $type,
 38 | 		mixed       $length = null,
 39 | 		string|null $attribute = null,
 40 | 		string|null $collation = null,
 41 | 		bool|null   $isNull = null,
 42 | 		string|null $defaultType = null,
 43 | 		mixed       $defaultValue = null,
 44 | 		string|null $extra = null,
 45 | 	):string{
 46 | 		$type             = strtoupper(trim($type));
 47 | 		$collation        = strtoupper($collation ?? '');
 48 | 		$field            = [$this->quote(trim($name))];
 49 | 		$type_translation = self::TYPE_TRANSLATION[$type] ?? $type;
 50 | 
 51 | 		if($length !== null && (in_array($type, ['CHAR', 'NCHAR', 'VARCHAR', 'NVARCHAR', 'CHARACTER'], true) || (is_string($length) && count(explode(',', $length)) === 2 && $type === 'DECIMAL'))){
 52 | 			$field[] = $type_translation.'('.$length.')';
 53 | 		}
 54 | 		else{
 55 | 			$field[] = $type_translation;
 56 | 		}
 57 | 
 58 | 		if(is_bool($isNull)){
 59 | 			$field[] = $isNull ? 'NULL' : 'NOT NULL';
 60 | 		}
 61 | 
 62 | 		if(in_array($collation, ['BINARY', 'NOCASE', 'RTRIM'], true)){
 63 | 			$field[] = 'COLLATE '.$collation;
 64 | 		}
 65 | 
 66 | 		$defaultType = strtoupper($defaultType ?? '');
 67 | 
 68 | 		if($defaultType === 'USER_DEFINED'){
 69 | 			$field[] = 'DEFAULT \''.$defaultValue.'\'';
 70 | 		}
 71 | 		elseif(in_array($defaultType, ['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP'], true)){
 72 | 			$field[] = 'DEFAULT '.$defaultType;
 73 | 		}
 74 | 		elseif($defaultType === 'NULL' && $isNull === true){
 75 | 			$field[] = 'DEFAULT NULL';
 76 | 		}
 77 | 
 78 | 		if($attribute){
 79 | 			$field[] = $attribute;
 80 | 		}
 81 | 
 82 | 		if($extra){
 83 | 			$field[] = $extra;
 84 | 		}
 85 | 
 86 | 		return implode(' ', $field);
 87 | 	}
 88 | 
 89 | 	public function createTable(
 90 | 		string      $table,
 91 | 		array       $cols,
 92 | 		string|null $primaryKey = null,
 93 | 		bool|null   $ifNotExists = null,
 94 | 		bool|null   $temp = null,
 95 | 		string|null $dir = null,
 96 | 	):array{
 97 | 		$sql = ['CREATE'];
 98 | 
 99 | 		if($temp){
100 | 			$sql[] = 'TEMPORARY';
101 | 		}
102 | 
103 | 		$sql[] = 'TABLE';
104 | 
105 | 		if($ifNotExists){
106 | 			$sql[] = 'IF NOT EXISTS';
107 | 		}
108 | 
109 | 		$n = explode('.', $table);
110 | 
111 | 		$sql[] = $this->quote($n[count($n) - 1]);
112 | 
113 | 		if(!empty($cols)){
114 | 			$sql[] = '(';
115 | 			$sql[] = implode(', ', $cols);
116 | 
117 | 			if($primaryKey){
118 | 				$sql[] = ', PRIMARY KEY';
119 | 				$sql[] = '(';
120 | 				$sql[] = $this->quote($primaryKey);
121 | 
122 | 				if(in_array($dir, ['ASC', 'DESC'], true)){
123 | 					$sql[] = ($dir);
124 | 				}
125 | 
126 | 				$sql[] = ')';
127 | 			}
128 | 
129 | 			$sql[] = ')';
130 | 		}
131 | 
132 | 		return $sql;
133 | 	}
134 | 
135 | 	public function truncate(string $table):array{
136 | 		$sql = ['DELETE FROM'];// ??? sqlite
137 | 		$sql[] = $this->quote($table);
138 | 
139 | 		return $sql;
140 | 	}
141 | 
142 | 	public function showTables(string|null $database = null, string|null $pattern = null, string|null $where = null):array{
143 | 		/** @noinspection SqlResolve, SqlDialectInspection */
144 | 		return ['SELECT "name" AS "tablename" FROM sqlite_master'];
145 | 	}
146 | 
147 | 	public function showCreateTable(string $table):array{
148 | 		/** @noinspection SqlResolve, SqlDialectInspection */
149 | 		$sql = ['SELECT "name" AS "Table", "sql" AS "Create Table" FROM sqlite_master WHERE name ='];
150 | 		$sql[] = $this->quote($table);
151 | 
152 | 		return $sql;
153 | 	}
154 | 
155 | }
156 | 


--------------------------------------------------------------------------------
/src/Drivers/DriverAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class DriverAbstract
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database\Drivers;
 13 | 
 14 | use chillerlan\Database\{DatabaseOptions, Result};
 15 | use chillerlan\Database\Dialects\Dialect;
 16 | use chillerlan\Database\Query\{Alter, Create, Delete, Drop, Insert, QueryException, Select, Show, Statement, Truncate, Update};
 17 | use chillerlan\Settings\SettingsContainerInterface;
 18 | use Psr\Log\{LoggerInterface, NullLogger};
 19 | use Psr\SimpleCache\CacheInterface;
 20 | use Closure, Throwable;
 21 | use function count, hash, is_array, is_bool, is_callable, is_float, is_int,
 22 | 	is_numeric, serialize, sodium_bin2hex, strtolower, trim;
 23 | 
 24 | /**
 25 |  * The abstract database driver
 26 |  *
 27 |  * @property \chillerlan\Database\Query\Alter    $alter
 28 |  * @property \chillerlan\Database\Query\Create   $create
 29 |  * @property \chillerlan\Database\Query\Delete   $delete
 30 |  * @property \chillerlan\Database\Query\Drop     $drop
 31 |  * @property \chillerlan\Database\Query\Insert   $insert
 32 |  * @property \chillerlan\Database\Query\Select   $select
 33 |  * @property \chillerlan\Database\Query\Show     $show
 34 |  * @property \chillerlan\Database\Query\Truncate $truncate
 35 |  * @property \chillerlan\Database\Query\Update   $update
 36 |  */
 37 | abstract class DriverAbstract implements DriverInterface{
 38 | 
 39 | 	protected const STATEMENTS = [
 40 | 		'alter'    => Alter::class,
 41 | 		'create'   => Create::class,
 42 | 		'delete'   => Delete::class,
 43 | 		'drop'     => Drop::class,
 44 | 		'insert'   => Insert::class,
 45 | 		'select'   => Select::class,
 46 | 		'show'     => Show::class,
 47 | 		'truncate' => Truncate::class,
 48 | 		'update'   => Update::class,
 49 | 	];
 50 | 
 51 | 	/**
 52 | 	 * The SQL dialect class for the current driver (FQCN)
 53 | 	 */
 54 | 	protected const DIALECT = '';
 55 | 
 56 | 	protected SettingsContainerInterface|DatabaseOptions $options;
 57 | 	protected LoggerInterface                            $logger;
 58 | 	protected CacheInterface|null                        $cache = null;
 59 | 	protected Dialect                                    $dialect;
 60 | 	protected string                                     $cachekey_hash_algo;
 61 | 	protected string|null                                $convert_encoding_src;
 62 | 	protected string|null                                $convert_encoding_dest;
 63 | 
 64 | 	/**
 65 | 	 * Constructor.
 66 | 	 */
 67 | 	public function __construct(
 68 | 		SettingsContainerInterface|DatabaseOptions $options,
 69 | 		CacheInterface|null                        $cache = null,
 70 | 		LoggerInterface                            $logger = new NullLogger,
 71 | 	){
 72 | 		$this->options = $options;
 73 | 		$this->cache   = $cache;
 74 | 		/** @phan-suppress-next-line PhanEmptyFQSENInClasslike, PhanTypeExpectedObjectOrClassName */
 75 | 		$this->dialect = new (static::DIALECT);
 76 | 
 77 | 		$this->setLogger($logger);
 78 | 
 79 | 		// avoid unnecessary getter calls in long loops
 80 | 		$this->cachekey_hash_algo    = $this->options->cachekey_hash_algo;
 81 | 		$this->convert_encoding_src  = $this->options->convert_encoding_src;
 82 | 		$this->convert_encoding_dest = $this->options->convert_encoding_dest;
 83 | 	}
 84 | 
 85 | 	/**
 86 | 	 * disconnect on exit
 87 | 	 */
 88 | 	public function __destruct(){
 89 | 		$this->disconnect();
 90 | 	}
 91 | 
 92 | 	/**
 93 | 	 * @throws \chillerlan\Database\Query\QueryException
 94 | 	 */
 95 | 	public function __get(string $name):Statement{
 96 | 		$name = strtolower($name);
 97 | 
 98 | 		if(isset(static::STATEMENTS[$name])){
 99 | 			return new (static::STATEMENTS[$name])($this, $this->dialect, $this->logger);
100 | 		}
101 | 
102 | 		throw new QueryException('invalid statement');
103 | 	}
104 | 
105 | 	/**
106 | 	 * Executes a raw sql query.
107 | 	 */
108 | 	abstract protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result;
109 | 
110 | 	/**
111 | 	 * Prepares and executes a query.
112 | 	 */
113 | 	abstract protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result;
114 | 
115 | 	/**
116 | 	 * Prepares a query and executes it for each row in the given array.
117 | 	 */
118 | 	abstract protected function multi_query(string $sql, array $values):bool;
119 | 
120 | 	/**
121 | 	 * Prepares a query and executes it for each row in the given array, using the value returned from the given callback.
122 | 	 * The given closure is called with 2 parameters:
123 | 	 *
124 | 	 *   - `$row`: the content of the current row (`mixed`, depends on the input)
125 | 	 *   - `$i`: the current row index (`int|string`)
126 | 	 *
127 | 	 * The callback must return an array that matches the placeholders in the given SQL query.
128 | 	 *
129 | 	 * e.g.: `$callback = function(array $row, int $i){ return [$i, $row['value0'], ...] }`
130 | 	 */
131 | 	abstract protected function multi_callback_query(string $sql, array $data, Closure $callback):bool;
132 | 
133 | 	public function setLogger(LoggerInterface $logger):static{
134 | 		$this->logger = $logger;
135 | 
136 | 		return $this;
137 | 	}
138 | 
139 | 	public function escape(bool|float|int|string|null $data = null):float|int|string{
140 | 
141 | 		if($data === null){
142 | 			return 'null';
143 | 		}
144 | 
145 | 		if(is_bool($data)){
146 | 			return (int)$data;
147 | 		}
148 | 
149 | 		if(is_numeric($data)){
150 | 			$data = ($data + 0);
151 | 
152 | 			if(is_int($data) || is_float($data)){
153 | 				return $data;
154 | 			}
155 | 		}
156 | 
157 | 		return $this->escape_string($data);
158 | 	}
159 | 
160 | 	/**
161 | 	 * Escape a string by converting it to a binary hex literal instead of relying on quotes
162 | 	 *
163 | 	 * @see https://stackoverflow.com/a/12710285
164 | 	 * @see https://dev.mysql.com/doc/refman/5.7/en/hexadecimal-literals.html
165 | 	 * @see https://mariadb.com/kb/en/hexadecimal-literals/
166 | 	 * @see https://firebirdsql.org/refdocs/langrefupd25-hexbinstrings.html
167 | 	 */
168 | 	protected function escape_string(string $string):string{
169 | 
170 | 		if($string === ''){
171 | 			return "''";
172 | 		}
173 | 
174 | 		// convert to hex literal
175 | 		return "x'".sodium_bin2hex($string)."'";
176 | 	}
177 | 
178 | 	/**
179 | 	 * @inheritdoc
180 | 	 */
181 | 	public function raw(string $sql, string|null $index = null, bool|null $assoc = null):Result{
182 | 		$this->checkSQL($sql);
183 | 
184 | 		$this->logger->debug(
185 | 			'DriverAbstract::raw()',
186 | 			['method' => __METHOD__, 'sql' => $sql, 'index' => $index, 'assoc' => $assoc]
187 | 		);
188 | 
189 | 		try{
190 | 			return $this->raw_query($sql, $index, $assoc !== null ? $assoc : true);
191 | 		}
192 | 		catch(Throwable $e){
193 | 			throw new DriverException('sql error: ['.static::class.'::raw()] '.$e->getMessage());
194 | 		}
195 | 
196 | 	}
197 | 
198 | 	/**
199 | 	 * @inheritdoc
200 | 	 */
201 | 	public function prepared(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
202 | 		$this->checkSQL($sql);
203 | 
204 | 		$this->logger->debug(
205 | 			'DriverAbstract::prepared()',
206 | 			['method' => __METHOD__, 'sql' => $sql, 'val' => $values, 'index' => $index, 'assoc' => $assoc]
207 | 		);
208 | 
209 | 		try{
210 | 			return $this->prepared_query($sql, ($values ?? []), $index, ($assoc ?? true));
211 | 		}
212 | 		catch(Throwable $e){
213 | 			throw new DriverException('sql error: ['.static::class.'::prepared()] '.$e->getMessage());
214 | 		}
215 | 
216 | 	}
217 | 
218 | 	/**
219 | 	 * @inheritdoc
220 | 	 * @todo: return array of results
221 | 	 */
222 | 	public function multi(string $sql, array $values):bool{
223 | 		$this->checkSQL($sql);
224 | 
225 | 		if(count($values) < 1 || !is_array($values[0]) || count($values[0]) < 1){
226 | 			throw new DriverException('invalid data');
227 | 		}
228 | 
229 | 		try{
230 | 			return $this->multi_query($sql, $values);
231 | 		}
232 | 		catch(Throwable $e){
233 | 			throw new DriverException('sql error: ['.static::class.'::multi()] '.$e->getMessage());
234 | 		}
235 | 
236 | 	}
237 | 
238 | 	/**
239 | 	 * @inheritdoc
240 | 	 * @todo: return array of results
241 | 	 * @see determine callable type? http://php.net/manual/en/language.types.callable.php#118032
242 | 	 */
243 | 	public function multiCallback(string $sql, array $data, Closure $callback):bool{
244 | 		$this->checkSQL($sql);
245 | 
246 | 		if(count($data) < 1){
247 | 			throw new DriverException('invalid data');
248 | 		}
249 | 
250 | 		if(!is_callable($callback)){
251 | 			throw new DriverException('invalid callback');
252 | 		}
253 | 
254 | 		try{
255 | 			return $this->multi_callback_query($sql, $data, $callback);
256 | 		}
257 | 		catch(Throwable $e){
258 | 			throw new DriverException('sql error: ['.static::class.'::multiCallback()] '.$e->getMessage());
259 | 		}
260 | 
261 | 	}
262 | 
263 | 	/**
264 | 	 * @inheritdoc
265 | 	 */
266 | 	public function rawCached(string $sql, string|null $index = null, bool|null $assoc = null, int|null $ttl = null):Result{
267 | 		$result = $this->cacheGet($sql, [], $index);
268 | 
269 | 		if(!$result){
270 | 			$result = $this->raw($sql, $index, $assoc !== null ? $assoc : true);
271 | 
272 | 			$this->cacheSet($sql, $result, [], $index, $ttl);
273 | 		}
274 | 
275 | 		return $result;
276 | 	}
277 | 
278 | 	/**
279 | 	 * @inheritdoc
280 | 	 */
281 | 	public function preparedCached(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null, int|null $ttl = null):Result{
282 | 		$result = $this->cacheGet($sql, $values, $index);
283 | 
284 | 		if(!$result){
285 | 			$result = $this->prepared($sql, $values, $index, $assoc);
286 | 
287 | 			$this->cacheSet($sql, $result, $values, $index, $ttl);
288 | 		}
289 | 
290 | 		return $result;
291 | 	}
292 | 
293 | 	/**
294 | 	 * @inheritdoc
295 | 	 */
296 | 	protected function getResult(Closure $callable, array $args, string|null $index = null, bool|null $assoc = null):Result{
297 | 		$out = new Result(null, $this->convert_encoding_src, $this->convert_encoding_dest);
298 | 		$i   = 0;
299 | 
300 | 		/** @noinspection PhpAssignmentInConditionInspection */
301 | 		while($row = $callable(...$args)){
302 | 			$key = $assoc && !empty($index) ? $row[$index] : $i;
303 | 
304 | 			$out[$key] = $row;
305 | 			$i++;
306 | 		}
307 | 
308 | 		return $out;
309 | 	}
310 | 
311 | 	/**
312 | 	 *
313 | 	 */
314 | 	protected function cacheKey(string $sql, array|null $values = null, string|null $index = null):string{
315 | 		return hash($this->cachekey_hash_algo, serialize([$sql, $values, $index]));
316 | 	}
317 | 
318 | 	/**
319 | 	 *
320 | 	 */
321 | 	protected function cacheGet(string $sql, array|null $values = null, string|null $index = null):mixed{
322 | 
323 | 		if($this->cache instanceof CacheInterface){
324 | 			return $this->cache->get($this->cacheKey($sql, $values, $index));
325 | 		}
326 | 
327 | 		return false; // @codeCoverageIgnore
328 | 	}
329 | 
330 | 	/**
331 | 	 *
332 | 	 */
333 | 	protected function cacheSet(string $sql, $result, array|null $values = null, string|null $index = null, int|null $ttl = null):bool{
334 | 
335 | 		if($this->cache instanceof CacheInterface){
336 | 			return $this->cache->set($this->cacheKey($sql, $values, $index), $result, $ttl);
337 | 		}
338 | 
339 | 		return false; // @codeCoverageIgnore
340 | 	}
341 | 
342 | 	/**
343 | 	 * @throws \chillerlan\Database\Drivers\DriverException
344 | 	 */
345 | 	protected function checkSQL(string $sql):void{
346 | 
347 | 		if(empty(trim($sql))){
348 | 			throw new DriverException('sql error: empty sql');
349 | 		}
350 | 
351 | 	}
352 | 
353 | }
354 | 


--------------------------------------------------------------------------------
/src/Drivers/DriverException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class DriverException
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Drivers;
13 | 
14 | use chillerlan\Database\DatabaseException;
15 | 
16 | class DriverException extends DatabaseException{}
17 | 


--------------------------------------------------------------------------------
/src/Drivers/DriverInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Interface DriverInterface
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database\Drivers;
 13 | 
 14 | use chillerlan\Database\Result;
 15 | use chillerlan\Settings\SettingsContainerInterface;
 16 | use Closure;
 17 | use Psr\Log\LoggerInterface;
 18 | use Psr\Log\NullLogger;
 19 | use Psr\SimpleCache\CacheInterface;
 20 | 
 21 | interface DriverInterface{
 22 | 
 23 | 	/**
 24 | 	 * Constructor.
 25 | 	 */
 26 | 	public function __construct(SettingsContainerInterface $options, CacheInterface|null $cache = null, LoggerInterface $logger = new NullLogger);
 27 | 
 28 | 	/**
 29 | 	 * Sets a PSR-3 logger instance
 30 | 	 */
 31 | 	public function setLogger(LoggerInterface $logger):static;
 32 | 
 33 | 	/**
 34 | 	 * Establishes a database connection
 35 | 	 *
 36 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 37 | 	 */
 38 | 	public function connect():DriverInterface;
 39 | 
 40 | 	/**
 41 | 	 * Closes a database connection
 42 | 	 */
 43 | 	public function disconnect():bool;
 44 | 
 45 | 	/**
 46 | 	 * Returns the database resource object
 47 | 	 *
 48 | 	 * @return mixed (resource, PDO, mysqli, ...)
 49 | 	 */
 50 | 	public function getDBResource():mixed;
 51 | 
 52 | 	/**
 53 | 	 * Returns info about the used php client
 54 | 	 */
 55 | 	public function getClientInfo():string;
 56 | 
 57 | 	/**
 58 | 	 * Returns info about the database server
 59 | 	 */
 60 | 	public function getServerInfo():string;
 61 | 
 62 | 	/**
 63 | 	 * Sanitizer.
 64 | 	 *
 65 | 	 * @param bool|float|int|string|null $data string to escape
 66 | 	 *
 67 | 	 * @return float|int|string escaped. obviously. (hopefully)
 68 | 	 */
 69 | 	public function escape(bool|float|int|string|null $data = null):float|int|string;
 70 | 
 71 | 	/**
 72 | 	 * Basic SQL query for non-repared statements
 73 | 	 *
 74 | 	 * There is no escaping in here, so make sure, your SQL is clean/escaped.
 75 | 	 * Also, your SQL should NEVER contain user input, use prepared statements in this case.
 76 | 	 *
 77 | 	 * If the query was successful it returns either an array of results or true
 78 | 	 * if it was a void query. On errors, a false will be returned, obviously.
 79 | 	 *
 80 | 	 * @param string      $sql    The SQL statement
 81 | 	 * @param string|null $index  [optional] an index column to assingn as the result's keys
 82 | 	 * @param bool|null   $assoc  [optional] If true, the fields are named with the respective column names, otherwise numbered
 83 | 	 *
 84 | 	 * @return \chillerlan\Database\Result array with results
 85 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 86 | 	 */
 87 | 	public function raw(string $sql, string|null $index = null, bool|null $assoc = null):Result;
 88 | 
 89 | 	/**
 90 | 	 * same as DriverInterface::raw(), but cached.
 91 | 	 *
 92 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 93 | 	 */
 94 | 	public function rawCached(string $sql, string|null $index = null, bool|null $assoc = null, int|null $ttl = null):Result;
 95 | 
 96 | 	/**
 97 | 	 * Prepared statements wrapper
 98 | 	 *
 99 | 	 * Does everything for you: prepares the statement and fetches the results as an object or array
100 | 	 * just pass a query along with values and you're done. Not meant for multi-inserts.
101 | 	 *
102 | 	 * @param string      $sql     The SQL statement to prepare
103 | 	 * @param array|null  $values  [optional] the value for each parameter in the statement - in the respective order, of course
104 | 	 * @param string|null $index   [optional] an index column to assingn as the result's keys
105 | 	 * @param bool|null   $assoc   [optional] If true, the fields are named with the respective column names, otherwise numbered
106 | 	 *
107 | 	 * @return \chillerlan\Database\Result Array with results
108 | 	 * @throws \chillerlan\Database\Drivers\DriverException
109 | 	 */
110 | 	public function prepared(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result;
111 | 
112 | 	/**
113 | 	 * same as DriverInterface::prepared(), but cached.
114 | 	 *
115 | 	 * @throws \chillerlan\Database\Drivers\DriverException
116 | 	 */
117 | 	public function preparedCached(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null, int|null $ttl = null):Result;
118 | 
119 | 	/**
120 | 	 * Prepared multi line insert
121 | 	 *
122 | 	 * Prepared statement multi insert/update
123 | 	 *
124 | 	 * @param string   $sql    The SQL statement to prepare
125 | 	 * @param array    $values a multidimensional array with the values, each row represents one line to insert.
126 | 	 *
127 | 	 * @return bool true query success, otherwise false
128 | 	 * @throws \chillerlan\Database\Drivers\DriverException
129 | 	 */
130 | 	public function multi(string $sql, array $values):bool;
131 | 
132 | 	/**
133 | 	 * Prepared multi line insert/update with callback
134 | 	 *
135 | 	 * multi threading? - conclusion after 2 years: nah, mysql is the bottleneck.
136 | 	 * @link https://gist.github.com/krakjoe/6437782
137 | 	 * @link https://gist.github.com/krakjoe/9384409
138 | 	 *
139 | 	 * @param string  $sql      The SQL statement to prepare
140 | 	 * @param array   $data     an array with the (raw) data to insert, each row represents one line to insert.
141 | 	 * @param Closure $callback a callback that processes the values for each row.
142 | 	 *
143 | 	 * @return bool true query success, otherwise false
144 | 	 * @throws \chillerlan\Database\Drivers\DriverException
145 | 	 */
146 | 	public function multiCallback(string $sql, array $data, Closure $callback):bool;
147 | 
148 | }
149 | 


--------------------------------------------------------------------------------
/src/Drivers/MSSqlSrv.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class MSSqlSrv
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Dialects\MSSQL;
 17 | use chillerlan\Database\Result;
 18 | use Closure;
 19 | use function array_values, gettype, implode, is_bool, is_numeric, sprintf, sodium_bin2hex, sqlsrv_client_info,
 20 | 	sqlsrv_close, sqlsrv_connect, sqlsrv_errors, sqlsrv_fetch_array, sqlsrv_free_stmt, sqlsrv_query, sqlsrv_server_info;
 21 | use const PHP_OS, SQLSRV_FETCH_ASSOC, SQLSRV_FETCH_NUMERIC;
 22 | 
 23 | /**
 24 |  * Microsoft SQL Server (native)
 25 |  *
 26 |  * @link https://github.com/Microsoft/msphpsql
 27 |  */
 28 | final class MSSqlSrv extends DriverAbstract{
 29 | 
 30 | 	protected const DIALECT = MSSQL::class;
 31 | 
 32 | 	/**
 33 | 	 * Holds the database resource object
 34 | 	 *
 35 | 	 * @var resource|null
 36 | 	 */
 37 | 	private $db = null;
 38 | 
 39 | 	public function connect():DriverInterface{
 40 | 
 41 | 		if(gettype($this->db) === 'resource'){
 42 | 			return $this;
 43 | 		}
 44 | 
 45 | 		$options = [];
 46 | 		$host    = $this->options->host;
 47 | 
 48 | 		if(is_numeric($this->options->port)){
 49 | 			$host .= ', '.$this->options->port;
 50 | 		}
 51 | 
 52 | 		if($this->options->database){
 53 | 			$options['Database'] = $this->options->database;
 54 | 		}
 55 | 
 56 | 		if($this->options->username){
 57 | 			$options['UID'] = $this->options->username;
 58 | 		}
 59 | 
 60 | 		if($this->options->password){
 61 | 			$options['PWD'] = $this->options->password;
 62 | 		}
 63 | 
 64 | 		if($this->options->mssql_timeout){
 65 | 			$options['LoginTimeout'] = $this->options->mssql_timeout;
 66 | 		}
 67 | 
 68 | 		if($this->options->mssql_charset){
 69 | 			$options['CharacterSet'] = $this->options->mssql_charset;
 70 | 		}
 71 | 
 72 | 		if($this->options->mssql_encrypt){
 73 | 			$options['Encrypt'] = $this->options->mssql_encrypt;
 74 | 		}
 75 | 
 76 | 		$this->db = sqlsrv_connect($host, $options);
 77 | 
 78 | 		if(!$this->db){
 79 | 			throw new DriverException('db error: [MSSqlSrv]: could not connect: '.$this->parseErrors(sqlsrv_errors() ?? []));
 80 | 		}
 81 | 
 82 | 		return $this;
 83 | 	}
 84 | 
 85 | 	public function disconnect():bool{
 86 | 
 87 | 		if(gettype($this->db) === 'resource'){
 88 | 			return sqlsrv_close($this->db);
 89 | 		}
 90 | 
 91 | 		return true;
 92 | 	}
 93 | 
 94 | 	public function getDBResource():mixed{
 95 | 		return $this->db;
 96 | 	}
 97 | 
 98 | 	public function getClientInfo():string{
 99 | 
100 | 		if(gettype($this->db) === 'resource'){
101 | 			$info = sqlsrv_client_info($this->db);
102 | 
103 | 			return $info['DriverVer'].' - '.$info['ExtensionVer'].' - '.$info['DriverODBCVer'];
104 | 		}
105 | 
106 | 		return 'disconnected, no info available';
107 | 	}
108 | 
109 | 	public function getServerInfo():string{
110 | 
111 | 		if(gettype($this->db) === 'resource'){
112 | 			$info = sqlsrv_server_info($this->db);
113 | 
114 | 			return PHP_OS.' - '.$info['SQLServerVersion'].' - '.$info['SQLServerName'].'/'.$info['CurrentDatabase'];
115 | 		}
116 | 
117 | 		return 'disconnected, no info available';
118 | 	}
119 | 
120 | 	/**
121 | 	 * @see https://docs.microsoft.com/sql/t-sql/data-types/constants-transact-sql?view=sql-server-ver15
122 | 	 */
123 | 	protected function escape_string(string $string):string{
124 | 
125 | 		if($string === ''){
126 | 			return "''";
127 | 		}
128 | 
129 | 		// convert to hex literal, sql server only accepts the 0x... format
130 | 		return '0x'.sodium_bin2hex($string);
131 | 	}
132 | 
133 | 	protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result{
134 | 		return $this->get_result(sqlsrv_query($this->db, $sql), $index, $assoc);
135 | 	}
136 | 
137 | 	protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
138 | 
139 | 		// [SQLSTATE IMSSP] (-57) String keys are not allowed in parameters arrays.
140 | 		if($values !== null){
141 | 			$values = array_values($values);
142 | 		}
143 | 
144 | 		return $this->get_result(sqlsrv_query($this->db, $sql, $values ?? []), $index, $assoc);
145 | 	}
146 | 
147 | 	protected function multi_query(string $sql, array $values):bool{
148 | 		$r = [];
149 | 
150 | 		// @todo: sqlsrv_prepare/sqlsrv_execute
151 | 		foreach($values as $row){
152 | 			$r[] = $this->prepared_query($sql, $row);
153 | 		}
154 | 
155 | 		foreach($r as $result){
156 | 
157 | 			if(!$result){
158 | 				return false;
159 | 			}
160 | 
161 | 		}
162 | 
163 | 		return true;
164 | 	}
165 | 
166 | 	protected function multi_callback_query(string $sql, array $data, Closure $callback):bool{
167 | 		$r = [];
168 | 
169 | 		// @todo: sqlsrv_prepare/sqlsrv_execute
170 | 		foreach($data as $i => $row){
171 | 			$r[] = $this->prepared_query($sql, $callback($row, $i));
172 | 		}
173 | 
174 | 		foreach($r as $result){
175 | 
176 | 			if(!$result){
177 | 				return false;
178 | 			}
179 | 
180 | 		}
181 | 
182 | 		return true;
183 | 	}
184 | 
185 | 	/**
186 | 	 * @throws \chillerlan\Database\Drivers\DriverException
187 | 	 */
188 | 	private function get_result($result, string|null $index = null, bool|null $assoc = null):Result{
189 | 
190 | 		if(is_bool($result)){
191 | 			$errors = sqlsrv_errors();
192 | 
193 | 			if(!$result && !empty($errors)){
194 | 				throw new DriverException('sql error: '.$this->parseErrors($errors));
195 | 			}
196 | 
197 | 			return new Result(null, null, null, true, $result);
198 | 		}
199 | 
200 | 		$r = parent::getResult(
201 | 			sqlsrv_fetch_array(...),
202 | 			/** @phan-suppress-next-line PhanUndeclaredConstant */
203 | 			[$result, ($assoc ?? true) ? SQLSRV_FETCH_ASSOC : SQLSRV_FETCH_NUMERIC],
204 | 			$index,
205 | 			$assoc
206 | 		);
207 | 
208 | 		sqlsrv_free_stmt($result);
209 | 
210 | 		return $r;
211 | 	}
212 | 
213 | 	private function parseErrors(array $errors):string{
214 | 		$tpl = '[SQLSTATE %s] (%s) %s';
215 | 
216 | 		if(isset($errors['SQLSTATE'], $errors['code'], $errors['message'])){
217 | 			return sprintf($tpl, $errors['SQLSTATE'], $errors['code'], $errors['message']);
218 | 		}
219 | 
220 | 		$msg = [];
221 | 
222 | 		foreach($errors as $error){
223 | 			$msg[] = sprintf($tpl, $error['SQLSTATE'], $error['code'], $error['message']);
224 | 		}
225 | 
226 | 		return implode("\n", $msg);
227 | 	}
228 | 
229 | }
230 | 


--------------------------------------------------------------------------------
/src/Drivers/MySQLiDrv.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class MySQLiDrv
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Dialects\MySQL;
 17 | use chillerlan\Database\Result;
 18 | use Closure, Throwable, mysqli;
 19 | use function array_unshift, count, gettype, implode, is_array, is_bool, mysqli_init;
 20 | use const MYSQLI_OPT_CONNECT_TIMEOUT;
 21 | 
 22 | /**
 23 |  *
 24 |  */
 25 | final class MySQLiDrv extends DriverAbstract{
 26 | 
 27 | 	protected const DIALECT = MySQL::class;
 28 | 
 29 | 	/**
 30 | 	 * Holds the database resource object
 31 | 	 *
 32 | 	 * @var mysqli|null
 33 | 	 */
 34 | 	private mysqli|null $db = null;
 35 | 
 36 | 	public function connect():DriverInterface{
 37 | 
 38 | 		if($this->db instanceof mysqli){
 39 | 			return $this;
 40 | 		}
 41 | 
 42 | 		try{
 43 | 			$this->db = mysqli_init();
 44 | 
 45 | 			$this->db->options(MYSQLI_OPT_CONNECT_TIMEOUT, $this->options->mysqli_timeout);
 46 | 
 47 | 			// @codeCoverageIgnoreStart
 48 | 			if($this->options->use_ssl){
 49 | 				$this->db->ssl_set(
 50 | 					$this->options->ssl_key,
 51 | 					$this->options->ssl_cert,
 52 | 					$this->options->ssl_ca,
 53 | 					$this->options->ssl_capath,
 54 | 					$this->options->ssl_cipher
 55 | 				);
 56 | 			}
 57 | 			// @codeCoverageIgnoreEnd
 58 | 
 59 | 			$this->db->real_connect(
 60 | 				$this->options->host,
 61 | 				$this->options->username,
 62 | 				$this->options->password,
 63 | 				$this->options->database,
 64 | 				!empty($this->options->port) ? (int)$this->options->port : null,
 65 | 				$this->options->socket
 66 | 			);
 67 | 
 68 | 			/**
 69 | 			 * @see https://mathiasbynens.be/notes/mysql-utf8mb4 How to support full Unicode in MySQL
 70 | 			 */
 71 | 			$this->db->set_charset($this->options->mysql_charset);
 72 | 
 73 | 			return $this;
 74 | 		}
 75 | 		catch(Throwable $e){
 76 | 			throw new DriverException('db error: [MySQLiDrv]: '.$e->getMessage());
 77 | 		}
 78 | 
 79 | 	}
 80 | 
 81 | 	public function disconnect():bool{
 82 | 
 83 | 		if($this->db instanceof mysqli){
 84 | 			$this->db->close();
 85 | 
 86 | 			$this->db = null;
 87 | 		}
 88 | 
 89 | 		return true;
 90 | 	}
 91 | 
 92 | 	public function getDBResource():mysqli|null{
 93 | 		return $this->db;
 94 | 	}
 95 | 
 96 | 	public function getClientInfo():string{
 97 | 
 98 | 		if(!$this->db instanceof mysqli){
 99 | 			return 'disconnected, no info available';
100 | 		}
101 | 
102 | 		return $this->db->client_info;
103 | 	}
104 | 
105 | 	public function getServerInfo():string{
106 | 
107 | 		if(!$this->db instanceof mysqli){
108 | 			return 'disconnected, no info available';
109 | 		}
110 | 
111 | 		return $this->db->server_info;
112 | 	}
113 | 
114 | 	protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result{
115 | 		$result = $this->db->query($sql);
116 | 
117 | 		if(is_bool($result)){
118 | 
119 | 			if($this->db->errno !== 0){
120 | 				throw new DriverException($this->db->error, $this->db->errno);
121 | 			}
122 | 
123 | 			return new Result(null, null, null, true, $result);
124 | 		}
125 | 
126 | 		$r = $this->getResult((($assoc ?? true) ? $result->fetch_assoc(...) : $result->fetch_row(...)), [], $index, $assoc);
127 | 
128 | 		$result->free();
129 | 
130 | 		return $r;
131 | 	}
132 | 
133 | 	protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
134 | 		$values ??= [];
135 | 		$assoc  ??= true;
136 | 		$stmt     = $this->db->stmt_init();
137 | 
138 | 		$stmt->prepare($sql);
139 | 		$this->stmtError($this->db->errno, $this->db->error);
140 | 
141 | 		if(count($values) > 0){
142 | 			/** @phan-suppress-next-line PhanParamTooFewInternalUnpack, PhanTypeNonVarPassByRef */
143 | 			$stmt->bind_param(...$this->getReferences($values));
144 | 		}
145 | 
146 | 		$stmt->execute();
147 | 
148 | 		$result = $stmt->result_metadata();
149 | 
150 | 		if(is_bool($result)){
151 | 			// https://www.php.net/manual/mysqli-stmt.result-metadata.php#97338
152 | 			// the query did not produce a result, everything ok.
153 | 			return new Result(null, null, null, true, true);
154 | 		}
155 | 
156 | 		// get the columns and their references
157 | 		// http://php.net/manual/mysqli-stmt.bind-result.php
158 | 		$cols = [];
159 | 		$refs = [];
160 | 
161 | 		foreach($result->fetch_fields() as $k => $field){
162 | 			/** @phan-suppress-next-line PhanTypeInvalidDimOffset */
163 | 			$refs[] = &$cols[$assoc ? $field->name : $k];
164 | 		}
165 | 
166 | 		/** @phan-suppress-next-line PhanParamTooFewInternalUnpack */
167 | 		$stmt->bind_result(...$refs);
168 | 
169 | 		// fetch the data
170 | 		$output = new Result(null, $this->convert_encoding_src, $this->convert_encoding_dest);
171 | 		$i      = 0;
172 | 
173 | 		while($stmt->fetch()){
174 | 			$row = [];
175 | 			$key = $i;
176 | 
177 | 			/** @phan-suppress-next-line PhanEmptyForeach */
178 | 			foreach($cols as $field => $data){
179 | 				$row[$field] = $data;
180 | 			}
181 | 
182 | 			if($assoc && !empty($index)){
183 | 				$key = $row[$index] ?? $i;
184 | 			}
185 | 
186 | 			$output[$key] = $row;
187 | 			$i++;
188 | 		}
189 | 
190 | 		// KTHXBYE!
191 | 		$stmt->free_result();
192 | 		$stmt->close();
193 | 
194 | 		return $output;
195 | 	}
196 | 
197 | 	protected function multi_query(string $sql, array $values):bool{
198 | 		$stmt = $this->db->stmt_init();
199 | 		$stmt->prepare($sql);
200 | 		$this->stmtError($this->db->errno, $this->db->error);
201 | 
202 | 		foreach($values as $row){
203 | 			/** @phan-suppress-next-line PhanParamTooFewInternalUnpack, PhanTypeNonVarPassByRef */
204 | 			$stmt->bind_param(...$this->getReferences($row));
205 | 
206 | 			$stmt->execute();
207 | 		}
208 | 
209 | 		$stmt->close();
210 | 
211 | 		return true;
212 | 	}
213 | 
214 | 	protected function multi_callback_query(string $sql, array $data, Closure $callback):bool{
215 | 		$stmt = $this->db->stmt_init();
216 | 		$stmt->prepare($sql);
217 | 		$this->stmtError($this->db->errno, $this->db->error);
218 | 
219 | 		foreach($data as $k => $row){
220 | 			$row = $callback($row, $k);
221 | 
222 | 			if(is_array($row) && !empty($row)){
223 | 				/** @phan-suppress-next-line PhanParamTooFewInternalUnpack, PhanTypeNonVarPassByRef */
224 | 				$stmt->bind_param(...$this->getReferences($row));
225 | 
226 | 				$stmt->execute();
227 | 			}
228 | 		}
229 | 
230 | 		$stmt->close();
231 | 
232 | 		return true;
233 | 	}
234 | 
235 | 	/**
236 | 	 * @throws \chillerlan\Database\Drivers\DriverException
237 | 	 */
238 | 	private function stmtError(int $errno, string $errstr):void{
239 | 
240 | 		if($errno !== 0){
241 | 			throw new DriverException($errstr, $errno);
242 | 		}
243 | 
244 | 	}
245 | 
246 | 	/**
247 | 	 * Copies an array to an array of referenced values
248 | 	 *
249 | 	 * @see http://php.net/manual/mysqli-stmt.bind-param.php
250 | 	 */
251 | 	private function getReferences(array $row):array{
252 | 		$references = [];
253 | 		$types      = [];
254 | 
255 | 		foreach($row as &$field){
256 | 			$type = gettype($field);
257 | 
258 | 			if($type === 'integer'){
259 | 				$types[] = 'i';
260 | 			}
261 | 			elseif($type === 'double'){
262 | 				$types[] = 'd';
263 | 			}
264 | 			else{
265 | 				$types[] = 's';
266 | 			}
267 | 
268 | 			$references[] = &$field;
269 | 		}
270 | 
271 | 		array_unshift($references, implode('', $types));
272 | 
273 | 		return $references;
274 | 	}
275 | 
276 | }
277 | 


--------------------------------------------------------------------------------
/src/Drivers/PDODriverAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class PDODriverAbstract
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Result;
 17 | use Closure, PDO, PDOStatement, Throwable;
 18 | use function gettype, is_bool;
 19 | 
 20 | /**
 21 |  *
 22 |  */
 23 | abstract class PDODriverAbstract extends DriverAbstract{
 24 | 
 25 | 	/**
 26 | 	 * Holds the database resource object
 27 | 	 */
 28 | 	protected PDO|null $db = null;
 29 | 
 30 | 	/**
 31 | 	 * Some basic PDO options
 32 | 	 *
 33 | 	 * @link http://php.net/manual/pdo.getattribute.php
 34 | 	 * @link http://php.net/manual/pdo.constants.php
 35 | 	 */
 36 | 	protected array $pdo_options = [
 37 | 		PDO::ATTR_CASE              => PDO::CASE_NATURAL,
 38 | 		PDO::ATTR_ERRMODE           => PDO::ERRMODE_EXCEPTION,
 39 | 		PDO::ATTR_STRINGIFY_FETCHES => false,
 40 | 		PDO::ATTR_EMULATE_PREPARES  => false, // will break mssql
 41 | 	];
 42 | 
 43 | 	protected array $pdo_stmt_options = [];
 44 | 
 45 | 	/**
 46 | 	 * Returns a DSN string using the given options
 47 | 	 */
 48 | 	abstract protected function getDSN():string;
 49 | 
 50 | 	public function connect():DriverInterface{
 51 | 
 52 | 		if($this->db instanceof PDO){
 53 | 			return $this;
 54 | 		}
 55 | 
 56 | 		try{
 57 | 			$this->db = new PDO($this->getDSN(), $this->options->username, $this->options->password, $this->pdo_options);
 58 | 
 59 | 			return $this;
 60 | 		}
 61 | 		catch(Throwable $e){
 62 | 			throw new DriverException('db error: [PDODriver '.static::class.']: '.$e->getMessage());
 63 | 		}
 64 | 
 65 | 	}
 66 | 
 67 | 	public function disconnect():bool{
 68 | 		$this->db = null;
 69 | 
 70 | 		return true;
 71 | 	}
 72 | 
 73 | 	public function getDBResource():PDO|null{
 74 | 		return $this->db;
 75 | 	}
 76 | 
 77 | 	public function getClientInfo():string{
 78 | 
 79 | 		if(!$this->db instanceof PDO){
 80 | 			return 'disconnected, no info available';
 81 | 		}
 82 | 
 83 | 		return $this->db->getAttribute(PDO::ATTR_CLIENT_VERSION);
 84 | 	}
 85 | 
 86 | 	public function getServerInfo():string{
 87 | 
 88 | 		if(!$this->db instanceof PDO){
 89 | 			return 'disconnected, no info available';
 90 | 		}
 91 | 
 92 | 		return (string)$this->db->getAttribute(PDO::ATTR_SERVER_INFO);
 93 | 	}
 94 | 
 95 | 	protected function get_result($stmt, string|null $index = null, bool|null $assoc = null):Result{
 96 | 		$assoc = $assoc ?? true;
 97 | 
 98 | 		if(is_bool($stmt)){
 99 | 			return new Result(null, null, null, true, $stmt);
100 | 		}
101 | 
102 | 		return parent::getResult($stmt->fetch(...), [$assoc ? PDO::FETCH_ASSOC : PDO::FETCH_NUM], $index, $assoc);
103 | 	}
104 | 
105 | 	protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result{
106 | 		return $this->get_result($this->db->query($sql), $index, $assoc);
107 | 	}
108 | 
109 | 	protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
110 | 		$stmt = $this->db->prepare($sql, $this->pdo_stmt_options);
111 | 
112 | 		if(!empty($values)){
113 | 			$this->bindParams($stmt, $values);
114 | 		}
115 | 
116 | 		$stmt->execute();
117 | 
118 | 		return $this->get_result($stmt, $index, $assoc);
119 | 	}
120 | 
121 | 	protected function multi_query(string $sql, array $values):bool{
122 | 		$stmt = $this->db->prepare($sql, $this->pdo_stmt_options);
123 | 
124 | 		foreach($values as $row){
125 | 			$this->bindParams($stmt, $row);
126 | 			$stmt->execute();
127 | 		}
128 | 
129 | 		unset($stmt);
130 | 
131 | 		return true;
132 | 	}
133 | 
134 | 	protected function multi_callback_query(string $sql, array $data, Closure $callback):bool{
135 | 		$stmt = $this->db->prepare($sql, $this->pdo_stmt_options);
136 | 
137 | 		foreach($data as $k => $row){
138 | 			$this->bindParams($stmt, $callback($row, $k));
139 | 			$stmt->execute();
140 | 		}
141 | 
142 | 		unset($stmt);
143 | 
144 | 		return true;
145 | 	}
146 | 
147 | 	/**
148 | 	 * Returns the last insert id (if present)
149 | 	 * @link http://php.net/manual/pdo.lastinsertid.php
150 | 	 */
151 | 	protected function insertID():string{
152 | 		return $this->db->lastInsertId();
153 | 	}
154 | 
155 | 	protected function bindParams(PDOStatement $stmt, array $values):void{
156 | 		$param_no = 1;
157 | 
158 | 		foreach($values as $v){
159 | 			// https://wiki.php.net/rfc/pdo_float_type ???
160 | 			$type = match(gettype($v)){
161 | 				'boolean' => PDO::PARAM_BOOL,
162 | 				'integer' => PDO::PARAM_INT,
163 | 				'NULL'    => PDO::PARAM_NULL,
164 | 				default   => PDO::PARAM_STR,
165 | 			};
166 | 
167 | 			$stmt->bindValue($param_no, $v, $type);
168 | 			$param_no++;
169 | 		}
170 | 	}
171 | 
172 | }
173 | 


--------------------------------------------------------------------------------
/src/Drivers/PDOFirebird.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class PDOFirebird
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Dialects\Firebird;
 17 | use Exception, Throwable, PDO;
 18 | use function is_file, is_numeric, is_readable, is_writable;
 19 | 
 20 | /**
 21 |  *
 22 |  */
 23 | final class PDOFirebird extends PDODriverAbstract{
 24 | 
 25 | 	protected const DIALECT = Firebird::class;
 26 | 
 27 | 	/**
 28 | 	 * @see https://www.php.net/manual/ref.pdo-firebird.connection.php
 29 | 	 *
 30 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 31 | 	 */
 32 | 	protected function getDSN():string{
 33 | 
 34 | 		if(empty($this->options->database)){
 35 | 			// technically covered by is_file() in $this::connect()
 36 | 			throw new DriverException('no database given');
 37 | 		}
 38 | 
 39 | 		$dsn = 'firebird:dbname=';
 40 | 
 41 | 		if($this->options->host){
 42 | 			$dsn .= $this->options->host;
 43 | 
 44 | 			if(is_numeric($this->options->port)){
 45 | 				$dsn .= '/'.$this->options->port;
 46 | 			}
 47 | 
 48 | 			$dsn .= ':';
 49 | 		}
 50 | 
 51 | 		$dsn .= $this->options->database;
 52 | 
 53 | 		if($this->options->firebird_encoding !== null){
 54 | 			$dsn .= ';encoding='.$this->options->firebird_encoding;
 55 | 		}
 56 | 
 57 | 		return $dsn;
 58 | 	}
 59 | 
 60 | 	public function connect():DriverInterface{
 61 | 
 62 | 		if($this->db instanceof PDO){
 63 | 			return $this;
 64 | 		}
 65 | 
 66 | 		$db = $this->options->database;
 67 | 
 68 | 		try{
 69 | 
 70 | 			if(!is_file($db) || !is_readable($db) || !is_writable($db)){
 71 | 				throw new Exception('invalid database file');
 72 | 			}
 73 | 
 74 | 			$this->db = new PDO($this->getDSN(), $this->options->username, $this->options->password, $this->pdo_options);
 75 | 
 76 | 			return $this;
 77 | 		}
 78 | 		catch(Throwable $e){
 79 | 			throw new DriverException('db error: [PDOFirebird]: '.$e->getMessage());
 80 | 		}
 81 | 
 82 | 	}
 83 | 
 84 | 	/**
 85 | 	 * @codeCoverageIgnore Firebird -> SQLSTATE[IM001]: driver does not support lastInsertId()
 86 | 	 */
 87 | 	protected function insertID():string{
 88 | 		return '';
 89 | 	}
 90 | 
 91 | 	public function getServerInfo():string{
 92 | 
 93 | 		if(!$this->db instanceof PDO){
 94 | 			return 'disconnected, no info available';
 95 | 		}
 96 | 
 97 | 		return $this->db->getAttribute(PDO::ATTR_SERVER_INFO).', connected to: '.$this->options->database;
 98 | 	}
 99 | 
100 | }
101 | 


--------------------------------------------------------------------------------
/src/Drivers/PDOMSSqlSrv.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class PDOMSSqlSrv
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Result;
 17 | use chillerlan\Database\Dialects\MSSQL;
 18 | use chillerlan\Settings\SettingsContainerInterface;
 19 | use Psr\Log\{LoggerInterface, NullLogger};
 20 | use Psr\SimpleCache\CacheInterface;
 21 | use PDO, Throwable;
 22 | use function explode, is_array, is_numeric, sodium_bin2hex, strpos, strtolower, trim;
 23 | use const PHP_OS;
 24 | 
 25 | /**
 26 |  *
 27 |  */
 28 | final class PDOMSSqlSrv extends PDODriverAbstract{
 29 | 
 30 | 	protected const DIALECT = MSSQL::class;
 31 | 
 32 | 	/**
 33 | 	 * PDOMSSqlSrv constructor.
 34 | 	 *
 35 | 	 * @phan-suppress PhanUndeclaredConstantOfClass
 36 | 	 */
 37 | 	public function __construct(SettingsContainerInterface $options, CacheInterface|null $cache = null, LoggerInterface $logger = new NullLogger){
 38 | 		// setting this with any value breaks
 39 | 		unset($this->pdo_options[PDO::ATTR_EMULATE_PREPARES]);
 40 | 
 41 | 		$this->pdo_options[PDO::SQLSRV_ATTR_QUERY_TIMEOUT]        = $options->mssql_timeout; // doesn't seem to have an effect
 42 | 		$this->pdo_options[PDO::SQLSRV_ATTR_FETCHES_NUMERIC_TYPE] = true;
 43 | 		$this->pdo_options[PDO::SQLSRV_ATTR_ENCODING]             = PDO::SQLSRV_ENCODING_UTF8;
 44 | 
 45 | 		parent::__construct($options, $cache, $logger);
 46 | 	}
 47 | 
 48 | 	/**
 49 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 50 | 	 */
 51 | 	public function getClientInfo():string{
 52 | 
 53 | 		if(!$this->db instanceof PDO){
 54 | 			return 'disconnected, no info available';
 55 | 		}
 56 | 
 57 | 		$info = $this->db->getAttribute(PDO::ATTR_CLIENT_VERSION);
 58 | 
 59 | 		if(is_array($info) && !empty($info)){
 60 | 			return $info['DriverVer'].' - '.$info['ExtensionVer'].' - '.$info['DriverODBCVer'];
 61 | 		}
 62 | 
 63 | 		throw new DriverException('error retrieving client info'); // @codeCoverageIgnore
 64 | 	}
 65 | 
 66 | 	/**
 67 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 68 | 	 */
 69 | 	public function getServerInfo():string{
 70 | 
 71 | 		if(!$this->db instanceof PDO){
 72 | 			return 'disconnected, no info available';
 73 | 		}
 74 | 
 75 | 		$info = $this->db->getAttribute(PDO::ATTR_SERVER_INFO);
 76 | 
 77 | 		if(is_array($info) && !empty($info)){
 78 | 			return PHP_OS.' - '.$info['SQLServerVersion'].' - '.$info['SQLServerName'].'/'.$info['CurrentDatabase'];
 79 | 		}
 80 | 
 81 | 		throw new DriverException('error retrieving server info'); // @codeCoverageIgnore
 82 | 	}
 83 | 
 84 | 	/**
 85 | 	 * @see https://www.php.net/manual/ref.pdo-sqlsrv.connection.php
 86 | 	 *
 87 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 88 | 	 */
 89 | 	protected function getDSN():string{
 90 | 
 91 | 		/*
 92 | 		//use any of these or check exact MSSQL ODBC drivername in "ODBC Data Source Administrator"
 93 | 		$mssqldriver = '{SQL Server}';
 94 | 		$mssqldriver = '{SQL Server Native Client 11.0}';
 95 | 		$mssqldriver = '{ODBC Driver 11 for SQL Server}';
 96 | 
 97 | 		$hostname='127.0.0.1';
 98 | 		$dbname='test';
 99 | 		$username='user';
100 | 		$password='pw';
101 | 		$dbDB = new PDO("odbc:Driver=$mssqldriver;Server=$hostname;Database=$dbname", $username, $password);
102 | 		*/
103 | 
104 | 		if(empty($this->options->host)){
105 | 			throw new DriverException('no host given');
106 | 		}
107 | 
108 | 		if(empty($this->options->database)){
109 | 			throw new DriverException('no database given');
110 | 		}
111 | 
112 | 		$dsn = 'sqlsrv:Server='.$this->options->host;
113 | 
114 | 		if(is_numeric($this->options->port)){
115 | 			$dsn .= ','.$this->options->port;
116 | 		}
117 | 
118 | 		$dsn .= ';Database='.$this->options->database;
119 | 
120 | 		return $dsn;
121 | 	}
122 | 
123 | 	public function connect():DriverInterface{
124 | 
125 | 		if($this->db instanceof PDO){
126 | 			return $this;
127 | 		}
128 | 
129 | 		try{
130 | 			$this->db = new PDO($this->getDSN(), $this->options->username, $this->options->password, $this->pdo_options);
131 | 
132 | 			return $this;
133 | 		}
134 | 		catch(Throwable $e){
135 | 
136 | 			// PDOMSSQL workaround
137 | 			if(trim(explode(':', $e->getMessage(), 2)[0]) === 'SQLSTATE[IMSSP]'){
138 | 				return $this;
139 | 			}
140 | 
141 | 			throw new DriverException('db error: [PDOMSSqlSrv]: '.$e->getMessage());
142 | 		}
143 | 	}
144 | 
145 | 
146 | 	/**
147 | 	 * @see https://docs.microsoft.com/sql/t-sql/data-types/constants-transact-sql?view=sql-server-ver15
148 | 	 */
149 | 	protected function escape_string(string $string):string{
150 | 
151 | 		if($string === ''){
152 | 			return "''";
153 | 		}
154 | 
155 | 		// convert to hex literal, sql server only accepts the 0x... format
156 | 		return '0x'.sodium_bin2hex($string);
157 | 	}
158 | 
159 | 	protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result{
160 | 
161 | 		try{
162 | 			return parent::raw_query($sql, $index, $assoc);
163 | 		}
164 | 		catch(Throwable $e){
165 | 			return new Result(null, null, null, true, $this->silenceNonErrorException($e));
166 | 		}
167 | 
168 | 	}
169 | 
170 | 	/**
171 | 	 * @throws \chillerlan\Database\Drivers\DriverException
172 | 	 */
173 | 	private function silenceNonErrorException(Throwable $e):bool{
174 | 		$message = $e->getMessage();
175 | 
176 | 		// @todo silence.
177 | 		$x = explode(':', $message, 2);
178 | 
179 | 		if(trim($x[0]) === 'SQLSTATE[IMSSP]'){
180 | 
181 | 			if(strpos(strtolower($x[1]), 'no fields') > 0){
182 | 				return true;
183 | 			}
184 | 
185 | 		}
186 | 
187 | 		throw new DriverException('sql error: ['.static::class.'::raw()]'.$message);
188 | 	}
189 | 
190 | 	protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
191 | 
192 | 		try{
193 | 			return parent::prepared_query($sql, $values, $index, $assoc);
194 | 		}
195 | 		catch(Throwable $e){
196 | 			return new Result(null, null, null, true, $this->silenceNonErrorException($e));
197 | 		}
198 | 
199 | 	}
200 | 
201 | }
202 | 


--------------------------------------------------------------------------------
/src/Drivers/PDOMySQL.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class PDOMySQL
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  *
10 |  * @noinspection PhpComposerExtensionStubsInspection
11 |  */
12 | declare(strict_types=1);
13 | 
14 | namespace chillerlan\Database\Drivers;
15 | 
16 | use chillerlan\Database\Dialects\MySQL;
17 | use PDO;
18 | use function is_numeric;
19 | 
20 | /**
21 |  *
22 |  */
23 | final class PDOMySQL extends PDODriverAbstract{
24 | 
25 | 	protected const DIALECT = MySQL::class;
26 | 
27 | 	/**
28 | 	 * @see https://www.php.net/manual/ref.pdo-mysql.connection.php
29 | 	 *
30 | 	 * @throws \chillerlan\Database\Drivers\DriverException
31 | 	 */
32 | 	protected function getDSN():string{
33 | 
34 | 		if(empty($this->options->database)){
35 | 			throw new DriverException('no database given');
36 | 		}
37 | 
38 | 		$dsn = 'mysql';
39 | 
40 | 		if($this->options->socket){
41 | 			$dsn .= ':unix_socket='.$this->options->socket;
42 | 		}
43 | 		else{
44 | 
45 | 			if(empty($this->options->host)){
46 | 				throw new DriverException('no host given');
47 | 			}
48 | 
49 | 			$dsn .= ':host='.$this->options->host;
50 | 
51 | 			if(is_numeric($this->options->port)){
52 | 				$dsn .= ';port='.$this->options->port;
53 | 			}
54 | 
55 | 		}
56 | 
57 | 		$dsn .= ';dbname='.$this->options->database;
58 | 
59 | 		// the charset option is specific to mysql
60 | 		if($this->options->mysql_charset){
61 | 			$dsn .= ';charset='.$this->options->mysql_charset;
62 | 		}
63 | 
64 | 		return $dsn;
65 | 	}
66 | 
67 | 	public function connect():DriverInterface{
68 | 
69 | 		if($this->options->use_ssl){
70 | 			$this->pdo_options += [
71 | 				PDO::MYSQL_ATTR_SSL_KEY    => $this->options->ssl_key,
72 | 				PDO::MYSQL_ATTR_SSL_CERT   => $this->options->ssl_cert,
73 | 				PDO::MYSQL_ATTR_SSL_CA     => $this->options->ssl_ca,
74 | 				PDO::MYSQL_ATTR_SSL_CAPATH => $this->options->ssl_capath,
75 | 				PDO::MYSQL_ATTR_SSL_CIPHER => $this->options->ssl_cipher,
76 | 			];
77 | 		}
78 | 
79 | 		return parent::connect();
80 | 	}
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Drivers/PDOPostgreSQL.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class PDOPostgreSQL
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  *
10 |  * @noinspection PhpComposerExtensionStubsInspection
11 |  */
12 | declare(strict_types=1);
13 | 
14 | namespace chillerlan\Database\Drivers;
15 | 
16 | use chillerlan\Database\Dialects\Postgres;
17 | use function is_numeric, sodium_bin2hex;
18 | 
19 | /**
20 |  *
21 |  */
22 | final class PDOPostgreSQL extends PDODriverAbstract{
23 | 
24 | 	protected const DIALECT = Postgres::class;
25 | 
26 | 	/**
27 | 	 * Returns a DSN string using the given options
28 | 	 *
29 | 	 * @see https://www.php.net/manual/ref.pdo-pgsql.connection.php
30 | 	 *
31 | 	 * @throws \chillerlan\Database\Drivers\DriverException
32 | 	 */
33 | 	protected function getDSN():string{
34 | 
35 | 		if(empty($this->options->database)){
36 | 			throw new DriverException('no database given');
37 | 		}
38 | 
39 | 		$dsn = 'pgsql';
40 | 
41 | 		if($this->options->socket){
42 | 			$dsn .= ':unix_socket='.$this->options->socket;
43 | 		}
44 | 		else{
45 | 
46 | 			if(empty($this->options->host)){
47 | 				throw new DriverException('no host given');
48 | 			}
49 | 
50 | 			$dsn .= ':host='.$this->options->host;
51 | 
52 | 			if(is_numeric($this->options->port)){
53 | 				$dsn .= ';port='.$this->options->port;
54 | 			}
55 | 
56 | 		}
57 | 
58 | 		$dsn .= ';dbname='.$this->options->database;
59 | 
60 | 		return $dsn;
61 | 	}
62 | 
63 | 	/**
64 | 	 * @see https://stackoverflow.com/a/44814220
65 | 	 */
66 | 	protected function escape_string(string $string):string{
67 | 
68 | 		if($string === ''){
69 | 			return "''";
70 | 		}
71 | 
72 | 		// convert to hex literal, emulating mysql's UNHEX() (seriously pgsql??)
73 | 		return "encode(decode('".sodium_bin2hex($string)."', 'hex'), 'escape')";
74 | 	}
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Drivers/PDOSQLite.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class PDOSQLite
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2018 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Dialects\SQLite;
 17 | use Throwable, PDO;
 18 | use function is_file, is_readable, is_writable;
 19 | 
 20 | /**
 21 |  *
 22 |  */
 23 | final class PDOSQLite extends PDODriverAbstract{
 24 | 
 25 | 	protected const DIALECT = SQLite::class;
 26 | 
 27 | 	public function connect():DriverInterface{
 28 | 
 29 | 		if($this->db instanceof PDO){
 30 | 			return $this;
 31 | 		}
 32 | 
 33 | 		$db = $this->options->database;
 34 | 
 35 | 		if($db !== ':memory:' && (!is_file($db) || !is_readable($db) || !is_writable($db))){
 36 | 			throw new DriverException('database file not found');
 37 | 		}
 38 | 
 39 | 		try{
 40 | 
 41 | 			if($db === ':memory:'){
 42 | 				$this->pdo_options += [PDO::ATTR_PERSISTENT => true];
 43 | 			}
 44 | 
 45 | 			$this->db = new PDO($this->getDSN(), null, null, $this->pdo_options);
 46 | 
 47 | 			return $this;
 48 | 		}
 49 | 		catch(Throwable $e){
 50 | 			throw new DriverException('db error: [PDOSQLite]: '.$e->getMessage());
 51 | 		}
 52 | 	}
 53 | 
 54 | 	public function getServerInfo():string{
 55 | 
 56 | 		if(!$this->db instanceof PDO){
 57 | 			return 'disconnected, no info available';
 58 | 		}
 59 | 
 60 | 		return static::class.', connected to: '.$this->options->database;
 61 | 	}
 62 | 
 63 | 	/**
 64 | 	 * @see https://www.php.net/manual/ref.pdo-sqlite.connection.php
 65 | 	 *
 66 | 	 * @throws \chillerlan\Database\Drivers\DriverException
 67 | 	 */
 68 | 	protected function getDSN():string{
 69 | 
 70 | 		if(empty($this->options->database)){
 71 | 			throw new DriverException('no database given');
 72 | 		}
 73 | 
 74 | 		return 'sqlite:'.$this->options->database;
 75 | 	}
 76 | 
 77 | /*
 78 | 	private function get_result(callable $callable, array $args, string $index = null, bool $assoc = null){
 79 | 		$out = new Result(null, $this->convert_encoding_src, $this->convert_encoding_dest);
 80 | 		$i   = 0;
 81 | 
 82 | 		while($row = call_user_func_array($callable, $args)){
 83 | 			$key = $assoc && !empty($index) ? $row[$index] : $i;
 84 | 
 85 | 			foreach($row as $k => $v){
 86 | 				switch(true){
 87 | 					case is_numeric($v): $row[$k] = $v + 0; break;
 88 | 				}
 89 | 			}
 90 | 
 91 | 			$out[$key] = $row;
 92 | 			$i++;
 93 | 		}
 94 | 
 95 | 		return $i === 0 ? true : $out;
 96 | 	}
 97 | */
 98 | 
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Drivers/PostgreSQL.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class PostgreSQL
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  *
 10 |  * @noinspection PhpComposerExtensionStubsInspection
 11 |  */
 12 | declare(strict_types=1);
 13 | 
 14 | namespace chillerlan\Database\Drivers;
 15 | 
 16 | use chillerlan\Database\Dialects\Postgres;
 17 | use chillerlan\Database\Result;
 18 | use PgSql\Connection as PgSqlConnection;
 19 | use PgSql\Result as PgSqlResult;
 20 | use Closure, Throwable;
 21 | use function implode, in_array, pg_close, pg_connect, pg_execute, pg_fetch_assoc, pg_fetch_row, pg_field_type,
 22 | 	pg_free_result, pg_last_error, pg_prepare, pg_query, pg_version, preg_replace_callback, sodium_bin2hex;
 23 | 
 24 | /**
 25 |  *
 26 |  */
 27 | final class PostgreSQL extends DriverAbstract{
 28 | 
 29 | 	protected const DIALECT = Postgres::class;
 30 | 	/**
 31 | 	 * Holds the database resource object
 32 | 	 */
 33 | 	private PgSqlConnection|null $db = null;
 34 | 
 35 | 	public function connect():DriverInterface{
 36 | 
 37 | 		if($this->db !== null){
 38 | 			return $this;
 39 | 		}
 40 | 
 41 | 		$options = [
 42 | 			'--client_encoding='.$this->options->pgsql_charset,
 43 | 		];
 44 | 
 45 | 		$conn_str = [
 46 | 			'host=\''.$this->options->host.'\'',
 47 | 			'port=\''.(int)$this->options->port.'\'',
 48 | 			'dbname=\''.$this->options->database.'\'',
 49 | 			'user=\''.$this->options->username.'\'',
 50 | 			'password=\''.$this->options->password.'\'',
 51 | 			'options=\''.implode(' ', $options).'\'',
 52 | 		];
 53 | 
 54 | 		try{
 55 | 			$this->db = pg_connect(implode(' ', $conn_str));
 56 | 
 57 | 			return $this;
 58 | 		}
 59 | 		catch(Throwable $e){
 60 | 			throw new DriverException('db error: [PostgreSQL]: '.$e->getMessage());
 61 | 		}
 62 | 
 63 | 	}
 64 | 
 65 | 	public function disconnect():bool{
 66 | 
 67 | 		if($this->db !== null){
 68 | 			$ret = pg_close($this->db);
 69 | 
 70 | 			if($ret === true){
 71 | 				$this->db = null;
 72 | 			}
 73 | 
 74 | 			return $ret;
 75 | 		}
 76 | 
 77 | 		return true;
 78 | 	}
 79 | 
 80 | 	public function getDBResource():PgSqlConnection|null{
 81 | 		return $this->db;
 82 | 	}
 83 | 
 84 | 	public function getClientInfo():string{
 85 | 
 86 | 		if($this->db === null){
 87 | 			return 'disconnected, no info available';
 88 | 		}
 89 | 
 90 | 		$ver = pg_version($this->db);
 91 | 
 92 | 		return 'PostgreSQL '.$ver['client'].' ('.$ver['client_encoding'].')';
 93 | 	}
 94 | 
 95 | 	public function getServerInfo():string{
 96 | 
 97 | 		if($this->db === null){
 98 | 			return 'disconnected, no info available';
 99 | 		}
100 | 
101 | 		$ver = pg_version($this->db);
102 | 
103 | 		return 'PostgreSQL '.$ver['server'].' ('.$ver['server_encoding'].', date style: '
104 | 		       .$ver['DateStyle'].', time zone: '.$ver['TimeZone'].')';
105 | 	}
106 | 
107 | 	/**
108 | 	 * @see https://stackoverflow.com/a/44814220
109 | 	 */
110 | 	protected function escape_string(string $string):string{
111 | 
112 | 		if($string === ''){
113 | 			return "''";
114 | 		}
115 | 
116 | 		// convert to hex literal, emulating mysql's UNHEX() (seriously pgsql??)
117 | 		return "encode(decode('".sodium_bin2hex($string)."', 'hex'), 'escape')";
118 | 	}
119 | 
120 | 	protected function raw_query(string $sql, string|null $index = null, bool|null $assoc = null):Result{
121 | 		return $this->get_result(pg_query($this->db, $sql), $index, $assoc);
122 | 	}
123 | 
124 | 	protected function prepared_query(string $sql, array|null $values = null, string|null $index = null, bool|null $assoc = null):Result{
125 | 		pg_prepare($this->db, '', $this->replaceParams($sql));
126 | 
127 | 		return $this->get_result(pg_execute($this->db, '', $values ?? []), $index, $assoc);
128 | 	}
129 | 
130 | 	protected function multi_query(string $sql, array $values):bool{
131 | 		$p = pg_prepare($this->db, '', $this->replaceParams($sql));
132 | 
133 | 		if($p === false){
134 | 			throw new DriverException(pg_last_error($this->db));
135 | 		}
136 | 
137 | 		foreach($values as $row){
138 | 			pg_execute($this->db, '', $row);
139 | 		}
140 | 
141 | 		return true;
142 | 	}
143 | 
144 | 	protected function multi_callback_query(string $sql, array $data, Closure $callback):bool{
145 | 		$p = pg_prepare($this->db, '', $this->replaceParams($sql));
146 | 
147 | 		if($p === false){
148 | 			throw new DriverException(pg_last_error($this->db));
149 | 		}
150 | 
151 | 		foreach($data as $k => $row){
152 | 			pg_execute($this->db, '', $callback($row, $k));
153 | 		}
154 | 
155 | 		return true;
156 | 	}
157 | 
158 | 	private function get_result(PgSqlResult|false $result, string|null $index = null, bool|null $assoc = null):Result{
159 | 
160 | 		if($result === false){
161 | 			throw new DriverException(pg_last_error($this->db));
162 | 		}
163 | 
164 | 		$out = new Result(null, $this->convert_encoding_src, $this->convert_encoding_dest);
165 | 		$i   = 0;
166 | 
167 | 		/** @noinspection PhpAssignmentInConditionInspection */
168 | 		while($row = ($assoc ? pg_fetch_assoc($result) : pg_fetch_row($result))){
169 | 			$key = $i;
170 | 
171 | 			$j = 0;
172 | 			foreach($row as &$value){
173 | 				// https://gitter.im/arenanet/api-cdi?at=594326ba31f589c64fafe554
174 | 				$fieldType = pg_field_type($result, $j);
175 | 
176 | 				if($fieldType === 'bool'){
177 | 					$value = $value === 't';
178 | 				}
179 | 				elseif(in_array($fieldType, ['int2', 'int4', 'int8'], true)){
180 | 					$value = (int)$value;
181 | 				}
182 | 				elseif(in_array($fieldType, ['float4', 'float8'], true)){
183 | 					$value = (float)$value; // @codeCoverageIgnore
184 | 				}
185 | 
186 | 				$j++;
187 | 			}
188 | 
189 | 			if($assoc && !empty($index)){
190 | 				$key = $row[$index];
191 | 			}
192 | 
193 | 			$out[$key] = $row;
194 | 			$i++;
195 | 		}
196 | 
197 | 		pg_free_result($result);
198 | 
199 | 		return $out;
200 | 	}
201 | 
202 | 	private function replaceParams(string $sql):string{
203 | 		$i = 1;
204 | 
205 | 		/** @phan-suppress-next-line PhanTypeMismatchArgumentInternal */
206 | 		return preg_replace_callback(pattern: '/(\?)/', callback: function() use (&$i){
207 | 			return '$'.$i++;
208 | 		}, subject: $sql);
209 | 	}
210 | 
211 | }
212 | 


--------------------------------------------------------------------------------
/src/Query/Alter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Alter
 4 |  *
 5 |  * @created      15.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | class Alter extends StatementAbstract{
15 | 
16 | 	public function table(string $tablename):AlterTable{
17 | 		return (new AlterTable($this->db, $this->dialect, $this->logger))->name($tablename);
18 | 	}
19 | 
20 | 	public function database(string $dbname):AlterDatabase{
21 | 		return (new AlterDatabase($this->db, $this->dialect, $this->logger))->name($dbname);
22 | 	}
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/AlterDatabase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class AlterDatabase
 4 |  *
 5 |  * @created      09.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/alter-database.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-alterdatabase.html
17 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/alter-database-transact-sql
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-db.html#fblangref25-ddl-db-alter
19 |  */
20 | class AlterDatabase extends StatementAbstract implements Query{
21 | 
22 | 	public function name(string $dbname):static{
23 | 		return $this->setName($dbname);
24 | 	}
25 | 
26 | 	protected function sql():array{
27 | 		return []; // @todo
28 | 	}
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Query/AlterTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class AlterTable
 4 |  *
 5 |  * @created      09.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-altertable.html
17 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/alter-table-transact-sql
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-tbl.html#fblangref25-ddl-tbl-alter
19 |  * @link https://www.sqlite.org/lang_altertable.html
20 |  */
21 | class AlterTable extends StatementAbstract implements Query{
22 | 
23 | 	public function name(string $tablename):static{
24 | 		return $this->setName($tablename);
25 | 	}
26 | 
27 | 	protected function sql():array{
28 | 		return []; // @todo
29 | 	}
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Query/BindValues.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface BindValues
 4 |  *
 5 |  * @created      10.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface BindValues extends Statement{
15 | 
16 | 	public function getBindValues():array;
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Query/CachedQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface CachedQuery
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface CachedQuery extends Query{
15 | 
16 | 	public function cached(int|null $ttl = null):static;
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Query/Create.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Create
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | class Create extends StatementAbstract{
15 | 
16 | #	public function index():CreateIndex;
17 | #	public function view():CreateView;
18 | #	public function trigger():CreateTrigger;
19 | 
20 | 	public function database(string $dbname):CreateDatabase{
21 | 		return (new CreateDatabase($this->db, $this->dialect, $this->logger))->name($dbname);
22 | 	}
23 | 
24 | 	public function table(string $tablename):CreateTable{
25 | 		return (new CreateTable($this->db, $this->dialect, $this->logger))->name($tablename);
26 | 	}
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/CreateDatabase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class CreateDatabase
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/create-database.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-createdatabase.html
17 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/create-database-sql-server-transact-sql
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-db.html#fblangref25-ddl-db-create
19 |  */
20 | class CreateDatabase extends StatementAbstract implements Query, IfNotExists{
21 | 
22 | 	public function name(string $dbname):static{
23 | 		return $this->setName($dbname);
24 | 	}
25 | 
26 | 	public function charset(string $collation):static{
27 | 		return $this->setCharset($collation);
28 | 	}
29 | 
30 | 	public function ifNotExists():static{
31 | 		return $this->setIfNotExists();
32 | 	}
33 | 
34 | 	/** @inheritdoc */
35 | 	protected function sql():array{
36 | 		return $this->dialect->createDatabase($this->name, $this->ifNotExists, $this->charset);
37 | 	}
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Query/CreateTable.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class CreateTable
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database\Query;
 13 | 
 14 | use function is_scalar, strtoupper, trim;
 15 | 
 16 | /**
 17 |  * @link https://www.sqlite.org/lang_createtable.html
 18 |  * @link https://dev.mysql.com/doc/refman/5.7/en/create-table.html
 19 |  * @link https://www.postgresql.org/docs/current/static/sql-createtable.html
 20 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/create-table-transact-sql
 21 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-tbl.html#fblangref25-ddl-tbl-create
 22 |  *
 23 |  * @link https://www.postgresql.org/docs/current/static/datatype.html
 24 |  * @link https://docs.microsoft.com/sql/t-sql/data-types/data-types-transact-sql
 25 |  */
 26 | class CreateTable extends StatementAbstract implements Query, IfNotExists{
 27 | 
 28 | 	protected bool        $temp       = false;
 29 | 	protected string|null $primaryKey = null;
 30 | 	protected array       $cols       = [];
 31 | 	protected string|null $dir        = null;
 32 | 
 33 | 	public function name(string $name):static{
 34 | 		return $this->setName($name);
 35 | 	}
 36 | 
 37 | 	public function charset(string $charset):static{
 38 | 		return $this->setCharset($charset);
 39 | 	}
 40 | 
 41 | 	public function ifNotExists():static{
 42 | 		return $this->setIfNotExists();
 43 | 	}
 44 | 
 45 | 	protected function sql():array{
 46 | 		return $this->dialect->createTable($this->name, $this->cols, $this->primaryKey, $this->ifNotExists, $this->temp, $this->dir);
 47 | 	}
 48 | 
 49 | 	public function temp():static{
 50 | 		$this->temp = true;
 51 | 
 52 | 		return $this;
 53 | 	}
 54 | 
 55 | 	public function primaryKey(string $field, string|null $dir = null):static{
 56 | 		$this->primaryKey = trim($field);
 57 | 		$this->dir        = strtoupper($dir ?? '');
 58 | 
 59 | 		return $this;
 60 | 	}
 61 | 
 62 | 	public function field(
 63 | 		string      $name,
 64 | 		string      $type,
 65 | 		mixed       $length = null,
 66 | 		string|null $attribute = null,
 67 | 		string|null $collation = null,
 68 | 		bool|null   $isNull = null,
 69 | 		string|null $defaultType = null,
 70 | 		mixed       $defaultValue = null,
 71 | 		string|null $extra = null,
 72 | 	):static{
 73 | 
 74 | 		if(is_scalar($defaultValue) && $defaultType === null){
 75 | 			$defaultType = 'USER_DEFINED';
 76 | 		}
 77 | 
 78 | 		$this->cols[$name] = $this->dialect->fieldspec($name, $type, $length, $attribute, $collation, $isNull, $defaultType, $defaultValue, $extra);
 79 | 
 80 | 		return $this;
 81 | 	}
 82 | 
 83 | 	public function enum(string $name, array $values, mixed $defaultValue = null, bool|null $isNull = null):static{
 84 | 		$this->cols[$name] = $this->dialect->enum($name, $values, $defaultValue, $isNull);
 85 | 
 86 | 		return $this;
 87 | 	}
 88 | 
 89 | 	public function tinyint(string $name, int|null $length = null, mixed $defaultValue = null, bool|null $isNull = null, string|null $attribute = null):static{
 90 | 		return $this->field(name: $name, type: 'TINYINT', length: $length, attribute: $attribute, isNull: $isNull, defaultValue: $defaultValue);
 91 | 	}
 92 | 
 93 | 	public function int(string $name, int|null $length = null, mixed $defaultValue = null, bool|null $isNull = null, string|null $attribute = null):static{
 94 | 		return $this->field(name: $name, type: 'INT', length: $length, attribute: $attribute, isNull: $isNull, defaultValue: $defaultValue);
 95 | 	}
 96 | 
 97 | 	public function bigint(string $name, int|null $length = null, mixed $defaultValue = null, bool|null $isNull = null, string|null $attribute = null):static{
 98 | 		return $this->field(name: $name, type: 'BIGINT', length: $length, attribute: $attribute, isNull: $isNull, defaultValue: $defaultValue);
 99 | 	}
100 | 
101 | 	public function varchar(string $name, int $length, mixed $defaultValue = null, bool|null $isNull = null):static{
102 | 		return $this->field(name: $name, type: 'VARCHAR', length: $length, isNull: $isNull, defaultValue: $defaultValue);
103 | 	}
104 | 
105 | 	public function decimal(string $name, string $length, mixed $defaultValue = null, bool|null $isNull = null):static{
106 | 		return $this->field(name: $name, type: 'DECIMAL', length: $length, isNull: $isNull, defaultValue: $defaultValue);
107 | 	}
108 | 
109 | 	public function tinytext(string $name, mixed $defaultValue = null, bool|null $isNull = null):static{
110 | 		return $this->field(name: $name, type: 'TINYTEXT', isNull: $isNull, defaultValue: $defaultValue);
111 | 	}
112 | 
113 | 	public function text(string $name, mixed $defaultValue = null, bool|null $isNull = null):static{
114 | 		return $this->field(name: $name, type: 'TEXT', isNull: $isNull, defaultValue: $defaultValue);
115 | 	}
116 | 
117 | 	public function mediumtext(string $name, mixed $defaultValue = null, bool|null $isNull = null):static{
118 | 		return $this->field(name: $name, type: 'MEDIUMTEXT', isNull: $isNull, defaultValue: $defaultValue);
119 | 	}
120 | 
121 | 	public function longtext(string $name, mixed $defaultValue = null, bool|null $isNull = null):static{
122 | 		return $this->field(name: $name, type: 'LONGTEXT', isNull: $isNull, defaultValue: $defaultValue);
123 | 	}
124 | 
125 | }
126 | 


--------------------------------------------------------------------------------
/src/Query/Delete.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Delete
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/delete.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-delete.html
17 |  * @link https://msdn.microsoft.com/de-de/library/ms189835(v=sql.110).aspx
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-dml-delete.html
19 |  * @link https://www.sqlite.org/lang_delete.html
20 |  */
21 | class Delete extends StatementAbstract implements Where, Limit, BindValues, Query{
22 | 
23 | 	public function from(string $name):static{
24 | 		return $this->setName($name);
25 | 	}
26 | 
27 | 	public function where(mixed $val1, mixed $val2 = null, string|null $operator = null, bool|null $bind = null, string|null $join = null):static{
28 | 		return $this->setWhere($val1, $val2, $operator, $bind, $join);
29 | 	}
30 | 
31 | 	public function openBracket(string|null $join = null):static{
32 | 		return $this->setOpenBracket($join);
33 | 	}
34 | 
35 | 	public function closeBracket():static{
36 | 		return $this->setCloseBracket();
37 | 	}
38 | 
39 | 	public function limit(int $limit):static{
40 | 		return $this->setLimit($limit);
41 | 	}
42 | 
43 | 	public function offset(int $offset):static{
44 | 		return $this->setOffset($offset);
45 | 	}
46 | 
47 | 	protected function sql():array{
48 | 		return $this->dialect->delete($this->name, $this->getWhere());
49 | 	}
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Query/Drop.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Drop
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | class Drop extends StatementAbstract{
15 | 
16 | 	public function database(string $dbname):DropDatabase{
17 | 		return (new DropDatabase($this->db, $this->dialect, $this->logger))->name($dbname);
18 | 	}
19 | 
20 | 	public function table(string $tablename):DropTable{
21 | 		return (new DropTable($this->db, $this->dialect, $this->logger))->name($tablename);
22 | 	}
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/DropDatabase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class DropDatabase
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/drop-database.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-dropdatabase.html
17 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/drop-database-transact-sql
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-db.html#fblangref25-ddl-db-drop
19 |  */
20 | class DropDatabase extends StatementAbstract implements Query, IfExists{
21 | 
22 | 	public function name(string $dbname):static{
23 | 		return $this->setName($dbname);
24 | 	}
25 | 
26 | 	public function ifExists():static{
27 | 		return $this->setIfExists();
28 | 	}
29 | 
30 | 	/** @inheritdoc */
31 | 	protected function sql():array{
32 | 		return $this->dialect->dropDatabase($this->name, $this->ifExists);
33 | 	}
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Query/DropTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class DropTable
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/drop-table.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-droptable.html
17 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/drop-table-transact-sql
18 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-ddl-tbl.html#fblangref25-ddl-tbl-drop
19 |  * @link https://www.sqlite.org/lang_droptable.html
20 |  */
21 | class DropTable extends StatementAbstract implements Query, IfExists{
22 | 
23 | 	public function name(string $name):static{
24 | 		return $this->setName($name);
25 | 	}
26 | 
27 | 	public function ifExists():static{
28 | 		return $this->setIfExists();
29 | 	}
30 | 
31 | 	/** @inheritdoc */
32 | 	protected function sql():array{
33 | 		return $this->dialect->dropTable($this->name, $this->ifExists);
34 | 	}
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Query/IfExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface IfExists
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface IfExists{
15 | 
16 | 	public function ifExists():static;
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Query/IfNotExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface IfNotExists
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface IfNotExists{
15 | 
16 | 	public function ifNotExists():static;
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Query/Insert.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Insert
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use chillerlan\Database\ResultInterface;
15 | use function array_keys;
16 | 
17 | /**
18 |  * @link https://dev.mysql.com/doc/refman/5.7/en/insert.html
19 |  * @link https://www.postgresql.org/docs/current/static/sql-insert.html
20 |  * @link https://docs.microsoft.com/en-gb/sql/t-sql/statements/insert-transact-sql
21 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-dml-insert.html
22 |  * @link https://www.sqlite.org/lang_insert.html
23 |  */
24 | class Insert extends StatementAbstract implements BindValues, MultiQuery{
25 | 
26 | 	public function into(string $table, string|null $on_conflict = null, string|null $conflict_target = null):static{
27 | 		return $this->setOnConflict($table, $on_conflict, $conflict_target);
28 | 	}
29 | 
30 | 	public function values(iterable $values):static{
31 | 
32 | 		if($values instanceof ResultInterface){
33 | 			$this->bindValues = $values->toArray();
34 | 
35 | 			return $this;
36 | 		}
37 | 
38 | 		foreach($values as $key => $value){
39 | 			$this->addBindValue($key, $value);
40 | 		}
41 | 
42 | 		return $this;
43 | 	}
44 | 
45 | 	protected function sql():array{
46 | 
47 | 		if(empty($this->bindValues)){
48 | 			throw new QueryException('no values given');
49 | 		}
50 | 
51 | 		return $this->dialect->insert(
52 | 			$this->name,
53 | 			array_keys($this->multi ? $this->bindValues[0] : $this->bindValues),
54 | 			$this->on_conflict,
55 | 			$this->conflict_target
56 | 		);
57 | 	}
58 | 
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Query/Limit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface Limit
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface Limit{
15 | 
16 | 	public function limit(int $limit):static;
17 | 
18 | 	public function offset(int $offset):static;
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Query/MultiQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface MultiQuery
 4 |  *
 5 |  * @created      13.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use Closure;
15 | 
16 | interface MultiQuery extends Query{
17 | 
18 | 	/**
19 | 	 * @throws \chillerlan\Database\Query\QueryException
20 | 	 */
21 | 	public function executeMultiQuery(array|null $values = null, Closure|null $callback = null):bool;
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Query/Query.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface Query
 4 |  *
 5 |  * @created      10.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | interface Query extends Statement{
15 | 
16 | 	/**
17 | 	 * @throws \chillerlan\Database\Query\QueryException
18 | 	 */
19 | 	public function executeQuery(string|null $index = null);
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Query/QueryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class QueryException
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use chillerlan\Database\DatabaseException;
15 | 
16 | class QueryException extends DatabaseException{}
17 | 


--------------------------------------------------------------------------------
/src/Query/Select.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class Select
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database\Query;
 13 | 
 14 | use function implode;
 15 | 
 16 | /**
 17 |  * @link https://dev.mysql.com/doc/refman/5.7/en/select.html
 18 |  * @link https://www.postgresql.org/docs/current/static/sql-select.html
 19 |  * @link https://docs.microsoft.com/de-de/sql/t-sql/queries/select-clause-transact-sql
 20 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-dml-select.html
 21 |  * @link https://www.sqlite.org/lang_select.html
 22 |  */
 23 | class Select extends StatementAbstract implements Where, Limit, BindValues, CachedQuery{
 24 | 
 25 | 	protected bool  $distinct = false;
 26 | 	protected array $cols     = [];
 27 | 	protected array $from     = [];
 28 | 	protected array $orderby  = [];
 29 | 	protected array $groupby  = [];
 30 | 
 31 | 	public function where(mixed $val1, mixed $val2 = null, string|null $operator = null, bool|null $bind = null, string|null $join = null):static{
 32 | 		return $this->setWhere($val1, $val2, $operator, $bind, $join);
 33 | 	}
 34 | 
 35 | 	public function openBracket(string|null $join = null):static{
 36 | 		return $this->setOpenBracket($join);
 37 | 	}
 38 | 
 39 | 	public function closeBracket():static{
 40 | 		return $this->setCloseBracket();
 41 | 	}
 42 | 
 43 | 	public function limit(int $limit):static{
 44 | 		return $this->setLimit($limit);
 45 | 	}
 46 | 
 47 | 	public function offset(int $offset):static{
 48 | 		return $this->setOffset($offset);
 49 | 	}
 50 | 
 51 | 	public function cached(int|null $ttl = null):static{
 52 | 		return $this->setCached($ttl);
 53 | 	}
 54 | 
 55 | 	protected function sql():array{
 56 | 
 57 | 		if(empty($this->from)){
 58 | 			throw new QueryException('no FROM expression specified');
 59 | 		}
 60 | 
 61 | 		return $this->dialect->select($this->cols, $this->from, $this->getWhere(), $this->limit, $this->offset, $this->distinct, $this->groupby, $this->orderby);
 62 | 	}
 63 | 
 64 | 	public function distinct():static{
 65 | 		$this->distinct = true;
 66 | 
 67 | 		return $this;
 68 | 	}
 69 | 
 70 | 	public function cols(array $expressions):static{
 71 | 		$this->cols = $this->dialect->cols($expressions);
 72 | 
 73 | 		return $this;
 74 | 	}
 75 | 
 76 | 	public function from(array $expressions):static{
 77 | 		$this->from = $this->dialect->from($expressions);
 78 | 
 79 | 		return $this;
 80 | 	}
 81 | 
 82 | 	public function orderBy(array $expressions):static{
 83 | 		$this->orderby = $this->dialect->orderby($expressions);
 84 | 
 85 | 		return $this;
 86 | 	}
 87 | 
 88 | 	public function groupBy(array $expressions):static{
 89 | 
 90 | 		foreach($expressions as $expression){
 91 | 			$this->groupby[] = $this->dialect->quote($expression);
 92 | 		}
 93 | 
 94 | 		return $this;
 95 | 	}
 96 | 
 97 | 	public function count():int{
 98 | 
 99 | 		if(empty($this->from)){
100 | 			throw new QueryException('no FROM expression specified');
101 | 		}
102 | 
103 | 		$sql    = $this->dialect->selectCount($this->from, $this->getWhere(), $this->distinct, $this->groupby);
104 | 		$result = $this->db->prepared(implode(' ', $sql), $this->bindValues);
105 | 
106 | 		if($result->count() > 0){
107 | 			return (int)$result[0]->count;
108 | 		}
109 | 
110 | 		return -1;
111 | 	}
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/src/Query/Show.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Show
 4 |  *
 5 |  * @created      09.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/show.html
16 |  */
17 | class Show extends StatementAbstract{
18 | 
19 | 	public function createTable(string $tablename):ShowCreateTable{
20 | 		return (new ShowCreateTable($this->db, $this->dialect, $this->logger))->name($tablename);
21 | 	}
22 | 
23 | 	public function databases():ShowDatabases{
24 | 		return new ShowDatabases($this->db, $this->dialect, $this->logger);
25 | 	}
26 | 
27 | 	public function tables(string|null $from = null):ShowTables{
28 | 		$showTables = new ShowTables($this->db, $this->dialect, $this->logger);
29 | 
30 | 		if(!empty($from)){
31 | 			$showTables->from($from);
32 | 		}
33 | 
34 | 		return $showTables;
35 | 	}
36 | 
37 | #	public function columns():ShowColumns;
38 | #	public function index():ShowIndex;
39 | #	public function collation():ShowCollation;
40 | #	public function characterSet():ShowCharacterSet;
41 | #	public function tableStatus():ShowTableStatus;
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Query/ShowCreateTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class ShowCreateTable
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | class ShowCreateTable extends StatementAbstract implements Query{
15 | 
16 | 	public function name(string $name):static{
17 | 		return $this->setName($name);
18 | 	}
19 | 
20 | 	protected function sql():array{
21 | 		return $this->dialect->showCreateTable($this->name);
22 | 	}
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/ShowDatabases.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class ShowDatabases
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | class ShowDatabases extends StatementAbstract implements Query{
15 | 
16 | 	protected function sql():array{
17 | 		return $this->dialect->showDatabases(); // @todo? WHERE
18 | 	}
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Query/ShowTables.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class ShowTables
 4 |  *
 5 |  * @created      01.11.2021
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2021 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use function trim;
15 | 
16 | class ShowTables extends StatementAbstract implements Where, Query{
17 | 
18 | 	protected string|null $pattern = null;
19 | 
20 | 	public function from(string $name):static{
21 | 		return $this->setName($name);
22 | 	}
23 | 
24 | 	public function where(mixed $val1, mixed $val2 = null, string|null $operator = null, bool|null $bind = null, string|null $join = null):static{
25 | 		return $this->setWhere($val1, $val2, $operator, $bind, $join);
26 | 	}
27 | 
28 | 	public function openBracket(string|null $join = null):static{
29 | 		return $this->setOpenBracket($join);
30 | 	}
31 | 
32 | 	public function closeBracket():static{
33 | 		return $this->setCloseBracket();
34 | 	}
35 | 
36 | 	protected function sql():array{
37 | 		return $this->dialect->showTables($this->name, $this->pattern, $this->getWhere());
38 | 	}
39 | 
40 | 	public function pattern(string $pattern):static{
41 | 		$pattern = trim($pattern);
42 | 
43 | 		if(!empty($pattern)){
44 | 			$this->pattern = $pattern;
45 | 		}
46 | 
47 | 		return $this;
48 | 	}
49 | 
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Query/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface Statement
 4 |  *
 5 |  * @created      27.08.2024
 6 |  * @author       smiley <smiley@chillerlan.net>
 7 |  * @copyright    2024 smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use Psr\Log\LoggerInterface;
15 | 
16 | /**
17 |  *
18 |  */
19 | interface Statement{
20 | 
21 | 	/**
22 | 	 * Sets a logger instance on the object.
23 | 	 */
24 | 	public function setLogger(LoggerInterface $logger):static;
25 | 
26 | 	public function getSQL(bool|null $multi = null):string;
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/StatementAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class Statement
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database\Query;
 13 | 
 14 | use chillerlan\Database\Result;
 15 | use Closure;
 16 | use chillerlan\Database\Dialects\{Dialect, Firebird, MSSQL};
 17 | use chillerlan\Database\Drivers\DriverInterface;
 18 | use Psr\Log\{LoggerInterface, NullLogger};
 19 | 
 20 | use function array_fill, array_map, array_merge, count, implode, in_array, is_array,
 21 | 	is_bool, is_null, max, strtolower, strtoupper, trim;
 22 | 
 23 | /**
 24 |  * https://xkcd.com/1409/
 25 |  */
 26 | abstract class StatementAbstract implements Statement{
 27 | 
 28 | 	protected DriverInterface $db;
 29 | 	protected Dialect         $dialect;
 30 | 	protected LoggerInterface $logger;
 31 | 	protected string|null     $name            = null;
 32 | 	protected string|null     $on_conflict     = null;
 33 | 	protected string|null     $conflict_target = null;
 34 | 	protected string|null     $charset         = null;
 35 | 	protected bool            $ifExists        = false;
 36 | 	protected bool            $ifNotExists     = false;
 37 | 	protected array           $where           = [];
 38 | 	protected array           $sql             = [];
 39 | 	protected bool            $multi           = false;
 40 | 	protected bool            $cached          = false;
 41 | 	protected int             $ttl             = 300;
 42 | 	protected int|null        $limit           = null;
 43 | 	protected int|null        $offset          = null;
 44 | 	protected array           $bindValues      = [];
 45 | 
 46 | 	private array $joinArgs  = ['AND', 'OR', 'XOR'];
 47 | 	private array $operators = [
 48 | 		'=', '>=', '>', '<=', '<', '<>', '!=',
 49 | 		'|', '&', '<<', '>>', '+', '-', '*', '/',
 50 | 		'%', '^', '<=>', '~', '!', 'DIV', 'MOD',
 51 | 		'IS', 'IS NOT', 'IN', 'NOT IN', 'LIKE',
 52 | 		'NOT LIKE', 'REGEXP', 'NOT REGEXP',
 53 | 		'EXISTS', 'ANY', 'SOME',
 54 | #		'BETWEEN', 'NOT BETWEEN',
 55 | 	];
 56 | 
 57 | 	public function __construct(DriverInterface $db, Dialect $dialect, LoggerInterface $logger = new NullLogger){
 58 | 		$this->db      = $db;
 59 | 		$this->dialect = $dialect;
 60 | 
 61 | 		$this->setLogger($logger);
 62 | 	}
 63 | 
 64 | 	public function setLogger(LoggerInterface $logger):static{
 65 | 		$this->logger  = $logger;
 66 | 
 67 | 		return $this;
 68 | 	}
 69 | 
 70 | 	protected function setName(string $name):static{
 71 | 		$this->name = trim($name);
 72 | 
 73 | 		if(empty($this->name)){
 74 | 			throw new QueryException('no name specified');
 75 | 		}
 76 | 
 77 | 		return $this;
 78 | 	}
 79 | 
 80 | 	protected function setOnConflict(string $name, string|null $on_conflict = null, string|null $conflict_target = null):static{
 81 | 		$this->name      = trim($name);
 82 | 		$on_conflict     = trim(strtoupper($on_conflict ?? ''));
 83 | 		$conflict_target = trim($conflict_target ?? '');
 84 | 
 85 | 		if(empty($this->name)){
 86 | 			throw new QueryException('no name specified');
 87 | 		}
 88 | 
 89 | 		if(!empty($on_conflict)){
 90 | 			$this->on_conflict = $on_conflict;
 91 | 		}
 92 | 
 93 | 		if(!empty($conflict_target)){
 94 | 			$this->conflict_target = $conflict_target;
 95 | 		}
 96 | 
 97 | 		return $this;
 98 | 	}
 99 | 
100 | 	protected function setCharset(string $charset):static{
101 | 		$this->charset = trim($charset);
102 | 
103 | 		return $this;
104 | 	}
105 | 
106 | 	protected function setIfExists():static{
107 | 		$this->ifExists = true;
108 | 
109 | 		return $this;
110 | 	}
111 | 
112 | 	protected function setIfNotExists():static{
113 | 		$this->ifNotExists = true;
114 | 
115 | 		return $this;
116 | 	}
117 | 
118 | 	protected function setWhere(mixed $val1, mixed $val2, string|null $operator = null, bool|null $bind = null, string|null $join = null):static{
119 | 		$operator = $operator !== null ? strtoupper(trim($operator)) : '=';
120 | 		$bind     ??= true;
121 | 
122 | 		$join = strtoupper(trim($join ?? ''));
123 | 		$join = in_array($join, $this->joinArgs, true) ? $join : 'AND';
124 | 
125 | 		if(in_array($operator, $this->operators, true)){
126 | 			$where = [
127 | 				is_array($val1)
128 | 					? strtoupper($val1[1]).'('.$this->dialect->quote($val1[0]).')'
129 | 					: $this->dialect->quote($val1)
130 | 			];
131 | 
132 | 			if(in_array($operator, ['IN', 'NOT IN', 'ANY', 'SOME',], true)){
133 | 
134 | 				if(is_array($val2)){
135 | 
136 | 					if($bind){
137 | 						$where[] = $operator.'('.implode(',', array_fill(0, count($val2), '?')).')';
138 | 						$this->bindValues = array_merge($this->bindValues, $val2);
139 | 					}
140 | 					else{
141 | 						$where[] = $operator.'('.implode(',', array_map($this->db->escape(...), $val2)).')'; // @todo: quote
142 | 					}
143 | 
144 | 				}
145 | 				else if($val2 instanceof Query){
146 | 					$where[] = $operator.'('.$val2->getSQL().')';
147 | 
148 | 					if($val2 instanceof BindValues){
149 | 						$this->bindValues = array_merge($this->bindValues, $val2->getBindValues());
150 | 					}
151 | 				}
152 | 
153 | 			}
154 | 			// @todo
155 | #			else if(in_array($operator, ['BETWEEN', 'NOT BETWEEN'], true)){}
156 | 			else{
157 | 				$where[] = $operator;
158 | 
159 | 				if($val2 instanceof Query){
160 | 					$where[] = '('.$val2->getSQL().')';
161 | 
162 | 					if($val2 instanceof BindValues){
163 | 						$this->bindValues = array_merge($this->bindValues, $val2->getBindValues());
164 | 					}
165 | 				}
166 | 				elseif(is_null($val2)){
167 | 					$where[] = 'NULL';
168 | 				}
169 | 				elseif(is_bool($val2)){
170 | 					$where[] = $val2 ? 'TRUE' : 'FALSE';
171 | 				}
172 | 				elseif(in_array(strtolower((string)$val2), ['null', 'false', 'true', 'unknown'], true)){
173 | 					$where[] = strtoupper($val2);
174 | 				}
175 | 				else {
176 | 
177 | 					if($bind){
178 | 						$where[] = '?';
179 | 						$this->bindValues[] = $val2;
180 | 					}
181 | 					else{
182 | 						if(!empty($val2)){
183 | 							$where[] = $val2;
184 | 						}
185 | 					}
186 | 
187 | 				}
188 | 
189 | 			}
190 | 
191 | 			$this->where[] = [
192 | 				'join' => $join,
193 | 				'stmt' => implode(' ', $where),
194 | 			];
195 | 
196 | 		}
197 | 
198 | 		return $this;
199 | 	}
200 | 
201 | 	protected function setOpenBracket(string|null $join = null):static{
202 | 		$join = strtoupper(trim($join ?? ''));
203 | 
204 | 		if(in_array($join, $this->joinArgs, true)){
205 | 			$this->where[] = $join;
206 | 		}
207 | 
208 | 		$this->where[] = '(';
209 | 
210 | 		return $this;
211 | 	}
212 | 
213 | 	protected function setCloseBracket():static{
214 | 		$this->where[] = ')';
215 | 
216 | 		return $this;
217 | 	}
218 | 
219 | 	protected function getWhere():string{
220 | 		$where    = [];
221 | 		$joinArgs = array_merge($this->joinArgs, ['(', ')']);
222 | 
223 | 		foreach($this->where as $k => $v){
224 | 			$last = $this->where[$k-1] ?? false;
225 | 
226 | 			if(in_array($v, $joinArgs, true)){
227 | 				$where[] = $v;
228 | 
229 | 				continue;
230 | 			}
231 | 
232 | 			if(!is_array($v)){
233 | 				continue;
234 | 			}
235 | 
236 | 			$where[] = $last === false || $last === '('
237 | 				? $v['stmt']
238 | 				: $v['join'].' '.$v['stmt'];
239 | 		}
240 | 
241 | 		return !empty($where)
242 | 			? 'WHERE '.implode(' ', $where)
243 | 			: '';
244 | 	}
245 | 
246 | 	/**
247 | 	 * @throws \chillerlan\Database\Query\QueryException
248 | 	 */
249 | 	protected function sql():array{
250 | 		throw new QueryException('sql() not supported/implemented');
251 | 	}
252 | 
253 | 	/**
254 | 	 * @throws \chillerlan\Database\Query\QueryException
255 | 	 */
256 | 	public function getSQL(bool|null $multi = null):string{
257 | 
258 | 		if(!$this instanceof Query){
259 | 			throw new QueryException('Query not supported');
260 | 		}
261 | 
262 | 		$this->multi = $multi ?? false;
263 | 
264 | 		$sql = trim(implode(' ', $this->sql()));
265 | 
266 | 		// this should only happen on a corrupt dialect implementation
267 | 		if(empty($sql)){
268 | 			throw new QueryException('empty sql'); // @codeCoverageIgnore
269 | 		}
270 | 
271 | 		return $sql;
272 | 	}
273 | 
274 | 	/**
275 | 	 * @throws \chillerlan\Database\Query\QueryException
276 | 	 */
277 | 	public function getBindValues():array{
278 | 
279 | 		if(!$this instanceof BindValues){
280 | 			throw new QueryException('BindValues not supported');
281 | 		}
282 | 
283 | 		// @todo: cleanup/simplify
284 | 		if($this->dialect instanceof Firebird){
285 | 
286 | 			if($this->limit !== null){
287 | 				$this->bindValues = array_merge([
288 | 					'limit'  => $this->limit,
289 | 					'offset' => $this->offset ?? 0,
290 | 				], $this->bindValues);
291 | 			}
292 | 
293 | 		}
294 | 		elseif($this->dialect instanceof MSSQL){
295 | 
296 | 			if($this->limit !== null){
297 | 				$this->bindValues = array_merge([
298 | 					'offset' => $this->offset ?? 0,
299 | 					'limit'  => $this->limit,
300 | 				], $this->bindValues);
301 | 			}
302 | 
303 | 		}
304 | 		else{
305 | 
306 | 			if($this->offset !== null){
307 | 				$this->bindValues['offset'] = $this->offset;
308 | 			}
309 | 
310 | 			if($this->limit !== null){
311 | 				$this->bindValues['limit'] = $this->limit;
312 | 			}
313 | 
314 | 		}
315 | 
316 | 		return $this->bindValues;
317 | 	}
318 | 
319 | 	protected function addBindValue(int|string $key, mixed $value):void{
320 | 		$this->bindValues[$key] = $value;
321 | 	}
322 | 
323 | 	protected function setLimit(int $limit):static{
324 | 		$this->limit = max($limit, 0);
325 | 
326 | 		return $this;
327 | 	}
328 | 
329 | 	protected function setOffset(int $offset):static{
330 | 		$this->offset = max($offset, 0);
331 | 
332 | 		return $this;
333 | 	}
334 | 
335 | 	protected function setCached(int|null $ttl = null):static{
336 | 		$this->cached = true;
337 | 
338 | 		if($ttl > 0){
339 | 			$this->ttl = $ttl;
340 | 		}
341 | 
342 | 		return $this;
343 | 	}
344 | 
345 | 	/**
346 | 	 * @throws \chillerlan\Database\Query\QueryException
347 | 	 */
348 | 	public function executeQuery(string|null $index = null):Result{
349 | 
350 | 		if(!$this instanceof Query){
351 | 			throw new QueryException('Query not supported');
352 | 		}
353 | 
354 | 		$sql    = $this->getSQL(false);
355 | 		$values = $this instanceof BindValues ? $this->getBindValues() : null;
356 | 
357 | 		$this->logger->debug('QueryTrait::executeQuery()', ['method' => __METHOD__, 'sql' => $sql, 'val' => $values, 'index' => $index]);
358 | 
359 | 		if($this->cached && $this instanceof CachedQuery){
360 | 			return $this->db->preparedCached($sql, $values, $index, true, $this->ttl);
361 | 		}
362 | 
363 | 		return $this->db->prepared($sql, $values, $index);
364 | 	}
365 | 
366 | 	/**
367 | 	 * @throws \chillerlan\Database\Query\QueryException
368 | 	 */
369 | 	public function executeMultiQuery(array|null $values = null, Closure|null $callback = null):bool{
370 | 
371 | 		if(!$this instanceof MultiQuery){
372 | 			throw new QueryException('MultiQuery not supported');
373 | 		}
374 | 
375 | 		$sql = $this->getSQL(true);
376 | 
377 | 		if($values !== null && $callback !== null){
378 | 			$this->logger->debug('MultiQueryTrait::executeMultiQuery()', ['method' => __METHOD__, 'sql' => $sql, 'val' => $values]);
379 | 
380 | 			return $this->db->multiCallback($sql, $values, $callback);
381 | 		}
382 | 
383 | 		// @todo: fix values/bindvalues
384 | 		$values = $values ?? ($this instanceof BindValues ? $this->getBindValues() : []);
385 | 
386 | 		$this->logger->debug('MultiQueryTrait::executeMultiQuery()', ['method' => __METHOD__, 'sql' => $sql, 'val' => $values]);
387 | 
388 | 		return $this->db->multi($sql, $values);
389 | 	}
390 | 
391 | }
392 | 


--------------------------------------------------------------------------------
/src/Query/Truncate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Truncate
 4 |  *
 5 |  * @created      09.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/truncate-table.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-truncate.html
17 |  * @link https://docs.microsoft.com/en-us/sql/t-sql/statements/truncate-table-transact-sql
18 |  */
19 | class Truncate extends StatementAbstract implements Query{
20 | 
21 | 	public function table(string $name):static{
22 | 		return $this->setName($name);
23 | 	}
24 | 
25 | 	protected function sql():array{
26 | 		return $this->dialect->truncate($this->name);
27 | 	}
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/Update.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class Update
 4 |  *
 5 |  * @created      03.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | use function array_merge, is_bool, is_int, is_scalar;
15 | 
16 | /**
17 |  * @link https://dev.mysql.com/doc/refman/5.7/en/update.html
18 |  * @link https://www.postgresql.org/docs/current/static/sql-update.html
19 |  * @link https://docs.microsoft.com/de-de/sql/t-sql/queries/update-transact-sql
20 |  * @link https://www.firebirdsql.org/file/documentation/reference_manuals/fblangref25-en/html/fblangref25-dml-update.html
21 |  * @link https://www.sqlite.org/lang_update.html
22 |  */
23 | class Update extends StatementAbstract implements Where, Limit, BindValues, MultiQuery{
24 | 
25 | 	protected array $set = [];
26 | 
27 | 	public function table(string $name):static{
28 | 		return $this->setName($name);
29 | 	}
30 | 
31 | 	public function where(mixed $val1, mixed $val2 = null, string|null $operator = null, bool|null $bind = null, string|null $join = null):static{
32 | 		return $this->setWhere($val1, $val2, $operator, $bind, $join);
33 | 	}
34 | 
35 | 	public function openBracket(string|null $join = null):static{
36 | 		return $this->setOpenBracket($join);
37 | 	}
38 | 
39 | 	public function closeBracket():static{
40 | 		return $this->setCloseBracket();
41 | 	}
42 | 
43 | 	public function limit(int $limit):static{
44 | 		return $this->setLimit($limit);
45 | 	}
46 | 
47 | 	public function offset(int $offset):static{
48 | 		return $this->setOffset($offset);
49 | 	}
50 | 
51 | 	protected function sql():array{
52 | 
53 | 		if(empty($this->set)){
54 | 			throw new QueryException('no fields to update specified');
55 | 		}
56 | 
57 | 		return $this->dialect->update($this->name, $this->set, $this->getWhere());
58 | 	}
59 | 
60 | 	public function set(array $set, bool|null $bind = null):static{
61 | 
62 | 		foreach($set as $k => $v){
63 | 
64 | 			if($v instanceof Statement){
65 | 				$this->set[] = $this->dialect->quote($k).' = ('.$v->getSQL().')';
66 | 
67 | 				if($v instanceof BindValues){
68 | 					$this->bindValues = array_merge($this->bindValues, $v->getBindValues());
69 | 				}
70 | 			}
71 | 			elseif(!is_scalar($v)){ // is_array($v)
72 | 				// @todo: [expr, bindval1, bindval2, ...]
73 | 				continue;
74 | 			}
75 | 			else{
76 | 				if($bind === false){
77 | 					// here be dragons
78 | 					$this->set[] = is_int($k)
79 | 						? $this->dialect->quote($v).' = ?'
80 | 						: $this->dialect->quote($k).' = '.$v; //$this->db->escape($v)
81 | 				}
82 | 				else{
83 | 					$this->set[] = $this->dialect->quote($k).' = ?';
84 | 					$this->addBindValue($k, is_bool($v) ? (int)$v : $v);// avoid errors with PDO firebird & mysql
85 | 				}
86 | 			}
87 | 		}
88 | 
89 | 		return $this;
90 | 	}
91 | 
92 | }
93 | 


--------------------------------------------------------------------------------
/src/Query/Where.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface Where
 4 |  *
 5 |  * @created      09.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database\Query;
13 | 
14 | /**
15 |  * @link https://dev.mysql.com/doc/refman/5.7/en/where-optimization.html
16 |  * @link https://www.postgresql.org/docs/current/static/sql-select.html#SQL-WHERE
17 |  * @link https://docs.microsoft.com/de-de/sql/t-sql/queries/where-transact-sql
18 |  */
19 | interface Where{
20 | 
21 | 	public function where(mixed $val1, mixed $val2 = null, string|null $operator = null, bool|null $bind = null, string|null $join = null):static;
22 | 
23 | 	public function openBracket(string|null $join = null):static;
24 | 
25 | 	public function closeBracket():static;
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Result.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Class Result
  4 |  *
  5 |  * @created      28.06.2017
  6 |  * @author       Smiley <smiley@chillerlan.net>
  7 |  * @copyright    2017 Smiley
  8 |  * @license      MIT
  9 |  */
 10 | declare(strict_types=1);
 11 | 
 12 | namespace chillerlan\Database;
 13 | 
 14 | use Closure;
 15 | use OutOfBoundsException;
 16 | 
 17 | use function array_chunk, array_column, array_key_exists, array_keys, array_merge, array_reverse,
 18 | 	array_values, count, next, print_r;
 19 | 
 20 | class Result implements ResultInterface{
 21 | 
 22 | 	protected string|null $sourceEncoding = null;
 23 | 	protected string      $destEncoding;
 24 | 	protected bool        $isBool;
 25 | 	protected bool        $isSuccess;
 26 | 	/** @var  \chillerlan\Database\ResultRow[] */
 27 | 	protected array       $array  = [];
 28 | 	protected int         $offset = 0;
 29 | 
 30 | 	/** @todo */
 31 | #	protected array $metadata = [];
 32 | 
 33 | 	public function __construct(
 34 | 		iterable|null $data = null,
 35 | 		string|null   $sourceEncoding = null,
 36 | 		string|null   $destEncoding = null,
 37 | 		bool|null     $isBool = null,
 38 | 		bool|null     $isSuccess = null
 39 | 	){
 40 | 		$this->sourceEncoding = $sourceEncoding;
 41 | 		$this->destEncoding   = $destEncoding ?? 'UTF-8';
 42 | 		$this->isBool         = $isBool ?? false;
 43 | 		$this->isSuccess      = $isSuccess ?? true;
 44 | 
 45 | 		if($data !== null){
 46 | 
 47 | 			foreach($data as $k => $v){
 48 | 				$this->offsetSet($k, $v);
 49 | 			}
 50 | 
 51 | 		}
 52 | 
 53 | 		$this->offset = 0;
 54 | 	}
 55 | 
 56 | 	public function isBool():bool{
 57 | 		return $this->isBool;
 58 | 	}
 59 | 
 60 | 	public function isSuccess():bool{
 61 | 		return $this->isSuccess;
 62 | 	}
 63 | 
 64 | 	/**
 65 | 	 * @link http://api.prototypejs.org/language/Enumerable/prototype/each/
 66 | 	 */
 67 | 	public function each(Closure $callback):ResultInterface{
 68 | 		$this->map($callback);
 69 | 
 70 | 		return $this;
 71 | 	}
 72 | 
 73 | 	/**
 74 | 	 * @link http://api.prototypejs.org/language/Enumerable/prototype/collect/
 75 | 	 * @link http://api.prototypejs.org/language/Enumerable/prototype/map/
 76 | 	 *
 77 | 	 * @throws \chillerlan\Database\DatabaseException
 78 | 	 */
 79 | 	public function map(Closure $callback):array{
 80 | 		$return = [];
 81 | 
 82 | 		foreach($this->array as $index => $element){
 83 | 			$return[$index] = $callback($element, $index);
 84 | 		}
 85 | 
 86 | 		return $return;
 87 | 	}
 88 | 
 89 | 	/**
 90 | 	 * @link http://api.prototypejs.org/language/Array/prototype/reverse/
 91 | 	 */
 92 | 	public function reverse():ResultInterface{
 93 | 		$this->array  = array_reverse($this->array);
 94 | 		$this->offset = 0;
 95 | 
 96 | 		return $this;
 97 | 	}
 98 | 
 99 | 	public function first():mixed{
100 | 		return $this->array[0] ?? null;
101 | 	}
102 | 
103 | 	public function last():mixed{
104 | 		return $this->array[count($this->array) - 1] ?? null;
105 | 	}
106 | 
107 | 	public function clear():ResultInterface{
108 | 		$this->array = [];
109 | 
110 | 		return $this;
111 | 	}
112 | 
113 | 	/**
114 | 	 * @link http://api.prototypejs.org/language/Array/prototype/inspect/
115 | 	 */
116 | 	public function inspect():string{
117 | 		return print_r($this->array, true);
118 | 	}
119 | 
120 | 	/**
121 | 	 * @link http://api.prototypejs.org/language/Enumerable/prototype/findAll/
122 | 	 *
123 | 	 * @throws \chillerlan\Database\DatabaseException
124 | 	 */
125 | 	public function findAll(Closure $callback):array{
126 | 		$return = [];
127 | 
128 | 		foreach($this->array as $index => $element){
129 | 
130 | 			if($callback($element, $index) === true){
131 | 				$return[] = $element;
132 | 			}
133 | 
134 | 		}
135 | 
136 | 		return $return;
137 | 	}
138 | 
139 | 	/**
140 | 	 * @link http://api.prototypejs.org/language/Enumerable/prototype/reject/
141 | 	 *
142 | 	 * @throws \chillerlan\Database\DatabaseException
143 | 	 */
144 | 	public function reject(Closure $callback):array{
145 | 		$return = [];
146 | 
147 | 		foreach($this->array as $index => $element){
148 | 
149 | 			if($callback($element, $index) !== true){
150 | 				$return[] = $element;
151 | 			}
152 | 
153 | 		}
154 | 
155 | 		return $return;
156 | 	}
157 | 
158 | 	/**
159 | 	 * @link https://www.php.netmanual/arrayaccess.offsetexists.php
160 | 	 */
161 | 	public function offsetExists($offset):bool{
162 | 		return array_key_exists($offset, $this->array);
163 | 	}
164 | 
165 | 	/**
166 | 	 * @link https://www.php.netmanual/arrayaccess.offsetget.php
167 | 	 */
168 | 	public function offsetGet($offset):mixed{
169 | 		return $this->array[$offset] ?? null;
170 | 	}
171 | 
172 | 	/**
173 | 	 * @link https://www.php.netmanual/arrayaccess.offsetunset.php
174 | 	 */
175 | 	public function offsetUnset($offset):void{
176 | 		unset($this->array[$offset]);
177 | 	}
178 | 
179 | 
180 | 	/**
181 | 	 * @link https://www.php.netmanual/countable.count.php
182 | 	 */
183 | 	public function count():int{
184 | 		return count($this->array);
185 | 	}
186 | 
187 | 	/**
188 | 	 * @link https://www.php.netmanual/iterator.current.php
189 | 	 */
190 | 	public function current():mixed{
191 | 		return $this->array[$this->offset] ?? null;
192 | 	}
193 | 
194 | 	/**
195 | 	 * @link https://www.php.netmanual/iterator.next.php
196 | 	 */
197 | 	public function next():void{
198 | 		$this->offset++;
199 | 	}
200 | 
201 | 	/**
202 | 	 * @link https://www.php.netmanual/iterator.key.php
203 | 	 */
204 | 	public function key():int{
205 | 		return $this->offset;
206 | 	}
207 | 
208 | 	/**
209 | 	 * @link https://www.php.netmanual/iterator.valid.php
210 | 	 */
211 | 	public function valid():bool{
212 | 		return array_key_exists($this->offset, $this->array);
213 | 	}
214 | 
215 | 	/**
216 | 	 * @link https://www.php.netmanual/iterator.rewind.php
217 | 	 */
218 | 	public function rewind():void{
219 | 		$this->offset = 0;
220 | 	}
221 | 
222 | 	/**
223 | 	 * @link https://www.php.netmanual/seekableiterator.seek.php
224 | 	 */
225 | 	public function seek($offset):void{
226 | 		$this->rewind();
227 | 
228 | 		for( ; $this->offset < $offset; ){
229 | 
230 | 			if(!next($this->array)) {
231 | 				throw new OutOfBoundsException('invalid seek position: '.$offset);
232 | 			}
233 | 
234 | 			$this->offset++;
235 | 		}
236 | 
237 | 	}
238 | 
239 | 	public function merge(ResultInterface $Result):ResultInterface{
240 | 		/** @phan-suppress-next-line PhanUndeclaredProperty */
241 | 		$this->array = array_merge($this->array, $Result->array);
242 | 
243 | 		return $this;
244 | 	}
245 | 
246 | 	public function chunk(int $size):array{
247 | 		return array_chunk($this->toArray(), $size, true);
248 | 	}
249 | 
250 | 	public function toArray():array{
251 | 		$arr = [];
252 | 
253 | 		foreach($this->array as $key => $item){
254 | 			$arr[$key] = $item->toArray();
255 | 		}
256 | 
257 | 		return $arr;
258 | 	}
259 | 
260 | 	public function fields():array{
261 | 		return array_keys($this->array);
262 | 	}
263 | 
264 | 	public function values(bool|null $to_array = null):array{
265 | 		return array_values($to_array === true ? $this->toArray() : $this->array);
266 | 	}
267 | 
268 | 	public function column(string $column, string|null $index_key = null):array{
269 | 		return array_column($this->toArray(), $column, $index_key);
270 | 	}
271 | 
272 | 	/***************
273 | 	 * ArrayAccess *
274 | 	 ***************/
275 | 
276 | 	public function offsetSet($offset, $value):void{
277 | 
278 | 		$row = new ResultRow($value, $this->sourceEncoding, $this->destEncoding);
279 | 
280 | 		$offset !== null
281 | 			? $this->array[$offset] = $row
282 | 			: $this->array[] = $row;
283 | 	}
284 | 
285 | 	/********************
286 | 	 * JsonSerializable *
287 | 	 ********************/
288 | 
289 | 	public function jsonSerialize():array{
290 | 		return $this->toArray();
291 | 	}
292 | 
293 | }
294 | 


--------------------------------------------------------------------------------
/src/ResultInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Interface ResultInterface
 4 |  *
 5 |  * @created      13.01.2018
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2018 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database;
13 | 
14 | use ArrayAccess, Countable, JsonSerializable, SeekableIterator;
15 | use Closure;
16 | 
17 | interface ResultInterface extends SeekableIterator, ArrayAccess, Countable, JsonSerializable{
18 | 
19 | 	/** */
20 | 	public function isBool():bool;
21 | 
22 | 	/** */
23 | 	public function isSuccess():bool;
24 | 
25 | 	/** */
26 | 	public function toArray():array;
27 | 
28 | 	/** */
29 | 	public function each(Closure $callback);
30 | 
31 | 	/** */
32 | 	public function map(Closure $callback):array;
33 | 
34 | 	/** */
35 | 	public function reverse():ResultInterface;
36 | 
37 | 	/** */
38 | 	public function first():mixed;
39 | 
40 | 	/** */
41 | 	public function last():mixed;
42 | 
43 | 	/** */
44 | 	public function clear():ResultInterface;
45 | 
46 | 	/** */
47 | 	public function inspect():string;
48 | 
49 | 	/** */
50 | 	public function findAll(Closure $callback):array;
51 | 
52 | 	/** */
53 | 	public function reject(Closure $callback):array;
54 | 
55 | 	/** */
56 | 	public function merge(ResultInterface $Result):ResultInterface;
57 | 
58 | 	/** */
59 | 	public function chunk(int $size):array;
60 | 
61 | 	/** */
62 | 	public function fields():array;
63 | 
64 | 	/** */
65 | 	public function values(bool|null $to_array = null):array;
66 | 
67 | 	/** */
68 | 	public function column(string $column, string|null $index_key = null):array;
69 | 
70 | }
71 | 


--------------------------------------------------------------------------------
/src/ResultRow.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Class ResultRow
 4 |  *
 5 |  * @created      28.06.2017
 6 |  * @author       Smiley <smiley@chillerlan.net>
 7 |  * @copyright    2017 Smiley
 8 |  * @license      MIT
 9 |  */
10 | declare(strict_types=1);
11 | 
12 | namespace chillerlan\Database;
13 | 
14 | use Closure;
15 | use function is_string, mb_convert_encoding;
16 | 
17 | /**
18 |  *
19 |  */
20 | class ResultRow extends Result{
21 | 
22 | 	public function __call(string $name, array $arguments):mixed{
23 | 		$value = $this->array[$name] ?? null;
24 | 
25 | 		if($value !== null){
26 | 			$func = $arguments[0] ?? null;
27 | 
28 | 			if($func instanceof Closure){
29 | 				return $func($value);
30 | 			}
31 | 
32 | 		}
33 | 
34 | 		return $value;
35 | 	}
36 | 
37 | 	public function __get(string $name):mixed{
38 | 		return $this->array[$name] ?? null;
39 | 	}
40 | 
41 | 	public function toArray():array{
42 | 		return $this->array;
43 | 	}
44 | 
45 | 	public function offsetSet($offset, $value):void{
46 | 
47 | 		if($this->sourceEncoding !== null && is_string($value)){
48 | 			$value = mb_convert_encoding($value, $this->destEncoding, $this->sourceEncoding);
49 | 		}
50 | 
51 | 		$offset !== null
52 | 			? $this->array[$offset] = $value
53 | 			: $this->array[] = $value;
54 | 
55 | 	}
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------