vlw/php-mysql
1
0
Fork 0
mirror of https://codeberg.org/vlw/php-mysql.git synced 2025-09-14 16:43:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: vlw:master
Branches Tags
vlw:master
vlw:3.5.11
vlw:3.5.10
vlw:3.5.9
vlw:3.5.8
vlw:3.5.7
vlw:3.5.6
vlw:3.5.5
vlw:3.5.4
vlw:3.5.3
vlw:3.5.2
vlw:3.5.1
vlw:3.5.0
vlw:3.4.0
vlw:3.3.0
vlw:3.2.1
vlw:3.2.0
vlw:3.1.7
vlw:3.1.6
vlw:3.1.5
vlw:3.1.4
vlw:3.1.3
vlw:3.1.2
vlw:3.1.1
vlw:3.1.0
vlw:3.0.1
vlw:3.0.0
vlw:2.1.0
vlw:2.0.1
vlw:2.0.0
vlw:1.1.1
vlw:1.1.0
vlw:1.0.2
vlw:1.0.1
vlw:1.0.0
..
compare: vlw:2.1.0
Branches Tags
vlw:master
vlw:3.5.11
vlw:3.5.10
vlw:3.5.9
vlw:3.5.8
vlw:3.5.7
vlw:3.5.6
vlw:3.5.5
vlw:3.5.4
vlw:3.5.3
vlw:3.5.2
vlw:3.5.1
vlw:3.5.0
vlw:3.4.0
vlw:3.3.0
vlw:3.2.1
vlw:3.2.0
vlw:3.1.7
vlw:3.1.6
vlw:3.1.5
vlw:3.1.4
vlw:3.1.3
vlw:3.1.2
vlw:3.1.1
vlw:3.1.0
vlw:3.0.1
vlw:3.0.0
vlw:2.1.0
vlw:2.0.1
vlw:2.0.0
vlw:1.1.1
vlw:1.1.0
vlw:1.0.2
vlw:1.0.1
vlw:1.0.0

No commits in common. "master" and "2.1.0" have entirely different histories.
master ... 2.1.0

7 changed files with 343 additions and 579 deletions
Show stats Expand all files Collapse all files

388
README.md
View file

@ -1,49 +1,19 @@
# php-mysql # php-libmysqldriver
This is a simple abstraction library for MySQL DML operations. This library provides abstraction methods for common operations on MySQL-like databases like `SELECT`, `UPDATE`, and `INSERT`.
For example: This library is built on top of the PHP [`MySQL Improved`](https://www.php.net/manual/en/book.mysqli.php) extension.
```php
MySQL->from(string $table)
->where(?array ...$conditions)
->order(?array $order_by)
->limit(?int $limit = null, ?int $offset = null)
->select(string|array|null $columns = null): mysqli_result|bool;
```
which would be equivalent to the following in MySQL:
```sql
SELECT `columns` FROM `table` WHERE `filter` ORDER BY `order_by` LIMIT `limit`;
```
- All methods can be chained in any order (even multiple times) after a [`from()`](#from) as long as a [`select()`](#select), [`insert()`](#insert), [`update()`](#update), or [`delete()`](#delete) is the last method.
- Chaining the same method more than once will override its previous value. Passing `null` to any method that accepts it will unset its value completely.
## Install from composer ## Install from composer
``` ```
composer require vlw/mysql composer require victorwesterlund/libmysqldriver
``` ```
```php ```php
use vlw\MySQL\MySQL; use libmysqldriver/MySQL;
``` ```
> [!IMPORTANT]
> This library requires the [`MySQL Improved`](https://www.php.net/manual/en/book.mysqli.php) extension and PHP 8.0 or newer.
# Example / Documentation
Available statements
Statement|Method
--|--
`SELECT`|[`select()`](#select)
`UPDATE`|[`update()`](#update)
`INSERT`|[`insert()`](#insert)
`DELETE`|[`delete()`](#delete)
`WHERE`|[`where()`](#where)
`ORDER BY`|[`order()`](#order-by)
`LIMIT`|[`limit()`](#limit)
---- ----
`Example table name: beverages` `Example table name: beverages`
@ -55,46 +25,39 @@ id|beverage_type|beverage_name|beverage_size
3|tea|black|15 3|tea|black|15
```php ```php
use vlw\MySQL\MySQL; use libmysqldriver\MySQL;
// Pass through: https://www.php.net/manual/en/mysqli.construct.php // Pass through: https://www.php.net/manual/en/mysqli.construct.php
$db = new MySQL($host, $user, $pass, $db); $db = new MySQL($host, $user, $pass, $db);
``` ```
All executor methods [`select()`](#select), [`update()`](#update), and [`insert()`](#insert) will return a [`mysqli_result`](https://www.php.net/manual/en/class.mysqli-result.php) object or boolean.
# FROM
```php
MySQL->from(
string $table
): self;
```
All queries start by chaining the `from(string $table)` method. This will define which database table the current query should be executed on.
*Example:*
```php
MySQL->from("beverages")->select("beverage_type");
```
# SELECT # SELECT
Chain `MySQL->select()` anywhere after a [`MySQL->from()`](#from) to retrieve columns from a database table. Use `MySQL->get()` to retrieve columns from a database table
Pass an associative array of strings, CSV string, or null to this method to filter columns.
```php ```php
MySQL->select( $db->get(
string|array|null $columns // Name of the database table
): mysqli_result|bool; string $table,
// (Optional) array or string of column(s) names to SELECT
array|string $columns,
// (Optional) key, value array of column names and values to filter with WHERE <column> = <value>
?array $filter = null,
// (Optional) order by columns name => direction ("ASC"|"DESC")
?array $order_by = null,
// (Optional) max number of rows to return
int|array|null $limit = null
): array|bool;
// Returns array of arrays for each row, or bool if $columns = null
``` ```
In most cases you probably want to select with a constraint. Chain the [`where()`](#where) method before `select()` to filter the query
### Example ### Example
```php ```php
$`beverages` = MySQL->from("beverages")->select(["beverage_name", "beverage_size"]); // SELECT `beverage_name`, `beverage_size` FROM beverages // (Optional) array of columns to return from table. Passing null will return a bool if rows were matched
$columns = ["beverage_name", "beverage_size"];
$beverages = $db->get("beverages", $columns);
// SELECT beverage_name, beverage_size FROM beverages
``` ```
``` ```
[ [
@ -110,14 +73,100 @@ $`beverages` = MySQL->from("beverages")->select(["beverage_name", "beverage_size
] ]
``` ```
# INSERT ## WHERE
Chain `MySQL->insert()` anywhere after a [`MySQL->from()`](#from) to append a new row to a database table.
Passing a sequential array to `insert()` will assume that you wish to insert data for all defined columns in the table. Pass an associative array of `[column_name => value]` to INSERT data for specific columns (assuming the other columns have a [DEFAULT](https://dev.mysql.com/doc/refman/8.0/en/data-type-defaults.html) value defined).
```php ```php
MySQL->insert( // (Optional) associative array of filters where "<column_name> = <value>"
$filter = ["beverage_type" => "coffee"];
$coffee = $db->get("beverages", $columns, $filter);
// SELECT beverage_name, beverage_size FROM beverages WHERE beverage_type = "coffee"
```
```php
[
[
"beverage_name" => "cappuccino",
"beverage_size" => 10
],
[
"beverage_name" => "black",
"beverage_size" => 15
]
]
```
## ORDER BY
You can also pass an associative array as the 4:th argument to `MySQL->get()` to `ORDER BY` a column or multiple columns
```php
$coffee = $db->get("beverages", $columns, $filter, ["beverage_name" => "ASC"], 2);
// SELECT beverage_name, beverage_size FROM beverages ORDER BY beverage_name ASC LIMIT 2
```
```php
[
[
"beverage_name" => "tea",
"beverage_size" => 10
],
[
"beverage_name" => "tea",
"beverage_size" => 15
],
// ...etc for "beverage_name = coffee"
]
```
## LIMIT
You can also pass an optional integer or associative array as the 5:th argument to `MySQL->get()` and `LIMIT` the rows to match.
> **Note**
> Passing (int) `1` will flatten the returned array from `get()` to two dimensions (k => v)
### Passing an integer to LIMIT
This will simply `LIMIT` the results returned to the integer passed
```php
$coffee = $db->get("beverages", $columns, $filter, null, 1);
// SELECT beverage_name, beverage_size FROM beverages WHERE beverage_type = "coffee" LIMIT 1
```
```php
[
"beverage_name" => "cappuccino",
"beverage_size" => 10
]
```
### Passing an associative array to LIMIT
This will `OFFSET` and `LIMIT` the results returned from the first key of the array as `OFFSET` and the value of that key as `LIMIT`
```php
$coffee = $db->get("beverages", $columns, $filter, null, [3 => 2]);
// SELECT beverage_name, beverage_size FROM beverages LIMIT 3 OFFSET 2
```
```php
[
[
"beverage_name" => "tea",
"beverage_size" => 10
],
[
"beverage_name" => "tea",
"beverage_size" => 15
],
// ...etc
]
```
# INSERT
Use `MySQL->insert()` to append a new row to a database table
```php
$db->insert(
// Name of the database table
string $table,
// Array of values to INSERT // Array of values to INSERT
array $values array $values
): bool ): bool
@ -127,38 +176,13 @@ MySQL->insert(
#### Example #### Example
```php ```php
MySQL->from("beverages")->insert([ $db->insert("beverages", [
null, null,
"coffee", "coffee",
"latte", "latte",
10 10
]); ]);
// INSERT INTO `beverages` VALUES (null, "coffee", "latte", 10); // INSERT INTO beverages VALUES (null, "coffee", "latte", 10)
```
```
true
```
# DELETE
Chain `MySQL->delete()` anywhere after a [`MySQL->from()`](#from) to remove a row or rows from the a database table.
```php
MySQL->delete(
array ...$conditions
): bool
// Returns true if at least one row was deleted
```
This method takes at least one [`MySQL->where()`](#where)-syntaxed argument to determine which row or rows to delete. Refer to the [`MySQL->where()`](#where) section for more information.
#### Example
```php
MySQL->from("beverages")->delete([
"beverage_name" => "coffee",
]);
// DELETE FROM `beverages` WHERE `beverage_name` = "coffee";
``` ```
``` ```
true true
@ -166,182 +190,40 @@ true
# UPDATE # UPDATE
Chain `MySQL->update()` anywhere after a [`MySQL->from()`](#from) to modify existing rows in a database table. Modify existing rows with `MySQL->update()`
```php ```php
MySQL->update( $db->get(
// Name of the database table
string $table,
// Key, value array of column names and values to update // Key, value array of column names and values to update
array $fields, array $fields,
): mysqli_result|bool; // (Optional) key, value array of column names and values to limit UPDATE to with WHERE <column> = <value>
?array $filter = null,
): bool;
// Returns true if at least 1 row was changed // Returns true if at least 1 row was changed
``` ```
### Example ### Example
```php ```php
MySQL->from("beverages")->update(["beverage_size" => 10]); // UPDATE `beverages` SET `beverage_size` = 10 $db->update("beverages", ["beverage_size" => 10]);
// UPDATE beverages SET beverage_size = 10
``` ```
```php ```php
true true
``` ```
In most cases you probably want to UPDATE against a constaint. Chain a [`where()`](#where) method before [`MySQL->update()`](#update) to set constraints ## WHERE
In most cases you probably want to UPDATE against a constaint. Passing an array to the 3:rd argument of `MySQL->update()` will let you define "equals AND" conditions.
# WHERE
Filter a [`MySQL->select()`](#select) or [`MySQL->update()`](#update) method by chaining the `MySQL->where()` method anywhere before it. The [`MySQL->delete()`](#delete) executor method also uses the same syntax for its arguments.
Each key, value pair will be `AND` constrained against each other.
```php ```php
MySQL->where( $filter = ["beverage_type" => "coffee"];
?array ...$conditions $update = ["beverage_size" => 10];
): self;
```
### Example $db->update("beverages", $update, $filter);
```php // UPDATE beverages SET beverage_size = 10 WHERE beverage_type = "coffee"
$coffee = MySQL->from("beverages")->where(["beverage_type" => "coffee"])->select(["beverage_name", "beverage_size"]); // SELECT `beverage_name`, `beverage_size` FROM `beverages` WHERE (`beverage_type` = "coffee");
``` ```
```php ```php
[ true
[
"beverage_name" => "cappuccino",
"beverage_size" => 10
],
[
"beverage_name" => "black",
"beverage_size" => 15
]
]
```
## Capture groups
### AND
Add additional key value pairs to an array passed to `where()` and they will all be compared as AND with each other.
```php
MySQL->where([
"beverage_type" => "coffee",
"beverage_size" => 15
]);
```
```sql
WHERE (`beverage_type` = 'coffee' AND `beverage_size` = 15)
```
### OR
Passing an additional array of key values as an argument will OR it with all other arrays passed.
```php
$filter1 = [
"beverage_type" => "coffee",
"beverage_size" => 15
];
$filter2 = [
"beverage_type" => "tea",
"beverage_name" => "black"
];
MySQL->where($filter1, $filter2, ...);
```
```sql
WHERE (`beverage_type` = 'coffee' AND `beverage_size` = 15) OR (`beverage_type` = 'tea' AND `beverage_name` = 'black')
```
## Define custom operators
By default, all values in an the assoc array passed to `where()` will be treated as an `EQUALS` (=) operator.
```php
MySQL->where(["column" => "euqals_this_value"]);
```
Setting the value of any key to another assoc array will allow for more "advanced" filtering by defining your own [`Operators`](https://github.com/VictorWesterlund/php-libmysqldriver/blob/master/src/Operators.php).
The key of this subarray can be any MySQL operator string, or the **->value** of any case in the [`Operators`](https://github.com/VictorWesterlund/php-libmysqldriver/blob/master/src/Operators.php) enum.
```php
MySQL->where([
"beverage_name" => [
Operators::LIKE->value => "%wildcard_contains%"
]
]);
```
# ORDER BY
Chain the `MySQL->order()` method before a [`MySQL->select()`](#select) statement to order by a specific column
```php
MySQL->order(
?array $order_by
): self;
```
```php
$coffee = MySQL->from("beverages")->order(["beverage_name" => "ASC"])->select(["beverage_name", "beverage_size"]); // SELECT `beverage_name`, `beverage_size` FROM `beverages` ORDER BY `beverage_name` ASC
```
```php
[
[
"beverage_name" => "tea",
"beverage_size" => 10
],
[
"beverage_name" => "tea",
"beverage_size" => 15
],
// ...etc for "`beverage_name` = coffee"
]
```
# LIMIT
Chain the `limit()` method before a [`MySQL->select()`](#select) statement to limit the amount of columns returned
```php
MySQL->limit(
?int $limit,
?int $offset = null
): self;
```
## Passing a single integer argument
This will simply `LIMIT` the results returned to the integer passed
```php
$coffee = MySQL->from("beverages")->limit(1)->select(["beverage_name", "beverage_size"]); // SELECT `beverage_name`, `beverage_size` FROM `beverages` WHERE `beverage_type` = "coffee" LIMIT 1
```
```php
[
[
"beverage_name" => "cappuccino",
"beverage_size" => 10
]
]
```
## Passing two integer arguments
This will `OFFSET` and `LIMIT` the results returned. The first argument will be the `LIMIT` and the second argument will be its `OFFSET`.
```php
$coffee = MySQL->from("beverages")->limit(3, 2)->select(["beverage_name", "beverage_size"]); // SELECT `beverage_name`, `beverage_size` FROM `beverages` LIMIT 3 OFFSET 2
```
```php
[
[
"beverage_name" => "tea",
"beverage_size" => 10
],
[
"beverage_name" => "tea",
"beverage_size" => 15
],
// ...etc
]
``` ```

10
composer.json
View file

@ -1,18 +1,18 @@
{ {
"name": "vlw/mysql", "name": "victorwesterlund/libmysqldriver",
"description": "Abstraction library for common MySQL/MariaDB DML operations with php-mysqli", "description": "Abstraction library for common mysqli features",
"type": "library", "type": "library",
"license": "GPL-3.0-or-later", "license": "GPL-3.0-only",
"authors": [ "authors": [
{ {
"name": "Victor Westerlund", "name": "Victor Westerlund",
"email": "victor@vlw.se" "email": "victor.vesterlund@gmail.com"
} }
], ],
"minimum-stability": "dev", "minimum-stability": "dev",
"autoload": { "autoload": {
"psr-4": { "psr-4": {
"vlw\\MySQL\\": "src/" "libmysqldriver\\": "src/"
} }
}, },
"require": {} "require": {}

18
composer.lock generated
View file

@ -1,18 +0,0 @@
{
"_readme": [
"This file locks the dependencies of your project to a known state",
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
"content-hash": "aa59b0c90afdd92fd11d1cbc9352676c",
"packages": [],
"packages-dev": [],
"aliases": [],
"minimum-stability": "dev",
"stability-flags": [],
"prefer-stable": false,
"prefer-lowest": false,
"platform": [],
"platform-dev": [],
"plugin-api-version": "2.0.0"
}

121
src/DatabaseDriver.php Normal file
View file

@ -0,0 +1,121 @@
<?php
namespace libmysqldriver\Driver;
use \mysqli;
use \mysqli_stmt;
use \mysqli_result;
// MySQL query builder and executer abstractions
class DatabaseDriver extends mysqli {
// Passing arguments to https://www.php.net/manual/en/mysqli.construct.php
function __construct() {
parent::__construct(...func_get_args());
}
// Create CSV from array
private static function csv(array $items): string {
return implode(",", $items);
}
/* ---- */
// Create CSV from columns
public static function columns(array|string $columns): string {
return is_array($columns)
? self::csv($columns)
: $columns;
}
// Return CSV of '?' for use with prepared statements
public static function values(array|string $values): string {
return is_array($values)
? self::csv(array_fill(0, count($values), "?"))
: "?";
}
/* ---- */
// Bind SQL statements
private function bind_params(mysqli_stmt &$stmt, mixed $params): bool {
// Convert single value parameter to array
$params = is_array($params) ? $params : [$params];
if (empty($params)) {
return true;
}
// Concatenated string with types for each parameter
$types = "";
// Convert PHP primitves to SQL primitives
foreach ($params as $param) {
switch (gettype($param)) {
case "integer":
case "double":
case "boolean":
$types .= "i";
break;
case "string":
case "array":
case "object":
$types .= "s";
break;
default:
$types .= "b";
break;
}
}
return $stmt->bind_param($types, ...$params);
}
// Execute an SQL query with a prepared statement
private function run_query(string $sql, mixed $params = null): mysqli_result|bool {
$stmt = $this->prepare($sql);
// Bind parameters if provided
if ($params !== null) {
$this->bind_params($stmt, $params);
}
// Execute statement and get retrieve changes
$query = $stmt->execute();
$res = $stmt->get_result();
// Return true if an INSERT, UPDATE or DELETE was sucessful (no rows returned)
if (!empty($query) && empty($res)) {
return true;
}
// Return mysqli_result object
return $res;
}
/* ---- */
// Execute SQL query with optional prepared statement and return array of affected rows
public function exec(string $sql, mixed $params = null): array {
$query = $this->run_query($sql, $params);
$res = [];
// Fetch rows into sequential array
while ($row = $query->fetch_assoc()) {
$res[] = $row;
}
return $res;
}
// Execute SQL query with optional prepared statement and return true if query was successful
public function exec_bool(string $sql, mixed $params = null): bool {
$query = $this->run_query($sql, $params);
return gettype($query) === "boolean"
// Type is already a bool, so return it as is
? $query
// Return true if rows were matched
: $query->num_rows > 0;
}
}

309
src/MySQL.php
View file

@ -1,286 +1,119 @@
<?php <?php
namespace vlw\MySQL; namespace libmysqldriver;
use Exception; use libmysqldriver\Driver\DatabaseDriver;
use mysqli; require_once "DatabaseDriver.php";
use mysqli_stmt;
use mysqli_result;
use vlw\MySQL\Order;
use vlw\MySQL\Operators;
require_once "Order.php";
require_once "Operators.php";
// Interface for MySQL_Driver with abstractions for data manipulation // Interface for MySQL_Driver with abstractions for data manipulation
class MySQL extends mysqli { class MySQL extends DatabaseDriver {
public ?array $columns = null;
protected string $table;
protected ?string $limit = null;
protected ?string $order_by = null;
protected array $filter_columns = [];
protected array $filter_values = [];
protected ?string $filter_sql = null;
// Pass constructor arguments to driver // Pass constructor arguments to driver
function __construct() { function __construct() {
parent::__construct(...func_get_args()); parent::__construct(...func_get_args());
} }
/* // Create WHERE AND clause from assoc array of "column" => "value"
# Helper methods private static function where(?array $filter = null): array {
*/ // Return array of an empty string and empty array if no filter is defined
if (!$filter) {
private function throw_if_no_table() { return ["", []];
if (!isset($this->table)) {
throw new Exception("No table name defined");
}
} }
// Coerce input to single dimensional array // Format each filter as $key = ? for prepared statement
private static function to_list_array(mixed $input): array { $stmt = array_map(fn($k): string => "`{$k}` = ?", array_keys($filter));
return array_values(is_array($input) ? $input : [$input]);
}
// Convert value to MySQL tinyint // Separate each filter with ANDs
private static function filter_boolean(mixed $value): int { $sql = " WHERE " . implode(" AND ", $stmt);
return (int) filter_var($value, FILTER_VALIDATE_BOOLEAN); // Return array of SQL prepared statement string and values
} return [$sql, array_values($filter)];
// Convert all boolean type values to tinyints in array
private static function filter_booleans(array $values): array {
return array_map(fn(mixed $v): mixed => gettype($v) === "boolean" ? self::filter_boolean($v) : $v, $values);
}
private static function array_wrap_accents(array $input): array {
return array_map(fn(mixed $v): string => "`{$v}`", $input);
}
/*
# Definers
These methods are used to build an SQL query by chaining methods together.
Defined parameters will then be executed by an Executer method.
*/
// Use the following table name
public function from(string $table): self {
// Reset all definers when a new query begins
$this->where();
$this->limit();
$this->order();
$this->table = $table;
return $this;
}
#[\Deprecated(
message: "use MySQL->from() instead",
since: "3.5.7",
)]
public function for(string $table): self {
return $this->from($table);
}
// Create a WHERE statement from filters
public function where(?array ...$conditions): self {
// Unset filters if null was passed
if ($conditions === null) {
$this->filter_sql = null;
$this->filter_columns = null;
$this->filter_values = null;
return $this;
}
$values = [];
$filters = [];
// Group each condition into an AND block
foreach ($conditions as $condition) {
$filter = [];
// Move along if the condition is empty
if (empty($condition)) {
continue;
}
// Create SQL string and append values to array for prepared statement
foreach ($condition as $col => $operation) {
$this->filter_columns[] = $col;
// Assume we want an equals comparison if value is not an array
if (!is_array($operation)) {
$operation = [Operators::EQUALS->value => $operation];
}
// Resolve all operator enum values in inner array
foreach ($operation as $operator => $value) {
// Null values have special syntax
if (is_null($value)) {
// Treat anything that isn't an equals operator as falsy
if ($operator !== Operators::EQUALS->value) {
$filter[] = "`{$col}` IS NOT NULL";
continue;
}
$filter[] = "`{$col}` IS NULL";
continue;
}
// Create SQL for prepared statement
$filter[] = "`{$col}` {$operator} ?";
// Append value to array with all other values
$values[] = $value;
}
}
// AND together all conditions into a group
$filters[] = "(" . implode(" AND ", $filter) . ")";
}
// Do nothing if no filters were set
if (empty($filters)) {
return $this;
}
// OR all filter groups
$this->filter_sql = implode(" OR ", $filters);
// Set values property
$this->filter_values = $values;
return $this;
}
// SQL LIMIT string
public function limit(?int $limit = null, ?int $offset = null): self {
// Unset row limit if null was passed
if ($limit === null) {
$this->limit = null;
return $this;
}
// Coerce offset to zero if no offset is defined
$offset = $offset ?? 0;
// Set limit and offset as SQL CSV
$this->limit = "{$offset},{$limit}";
return $this;
} }
// Return SQL SORT BY string from assoc array of columns and direction // Return SQL SORT BY string from assoc array of columns and direction
public function order(?array $order_by = null): self { private static function order_by(array $order_by): string {
// Unset row order by if null was passed $sql = " ORDER BY ";
if ($order_by === null) {
$this->order_by = null; // Create CSV from columns
return $this; $sql .= implode(",", array_keys($order_by));
// Create pipe DSV from values
$sql .= " " . implode("|", array_values($order_by));
return $sql;
} }
// Assign Order Enum entries from array of arrays<Order|string> // Return SQL LIMIT string from integer or array of [offset => limit]
$orders = array_map(fn(Order|string $order): Order => $order instanceof Order ? $order : Order::tryFrom($order), array_values($order_by)); private static function limit(int|array $limit): string {
// Create CSV string with Prepared Statement abbreviations from length of fields array. $sql = " LIMIT ";
$sql = array_map(fn(string $column, Order|string $order): string => "`{$column}` " . $order->value, array_keys($order_by), $orders);
$this->order_by = implode(",", $sql); // Return LIMIT without range directly as string
return $this; if (is_int($limit)) {
return $sql . $limit;
} }
/* // Use array key as LIMIT range start value
# Executors $offset = (int) array_keys($limit)[0];
These methods execute various statements that each return a mysqli_result // Use array value as LIMIT range end value
*/ $limit = (int) array_values($limit)[0];
// Return as SQL LIMIT CSV
return $sql . "{$offset},{$limit}";
}
/* ---- */
// Create Prepared Statament for SELECT with optional WHERE filters // Create Prepared Statament for SELECT with optional WHERE filters
public function select(array|string|null $columns = null): mysqli_result|bool { public function get(string $table, array|string $columns = null, ?array $filter = [], ?array $order_by = null, int|array|null $limit = null): array|bool {
$this->throw_if_no_table(); // Create CSV string of columns if argument defined, else return bool
$columns_sql = $columns ? self::columns($columns) : "NULL";
// Create array of columns from CSV
$this->columns = is_array($columns) || is_null($columns) ? $columns : explode(",", $columns);
// Create CSV from columns or default to SQL NULL as a string
$columns_sql = $this->columns ? implode(",", self::array_wrap_accents($this->columns)) : "NULL";
// Create LIMIT statement if argument is defined // Create LIMIT statement if argument is defined
$limit_sql = !is_null($this->limit) ? " LIMIT {$this->limit}" : ""; $limit_sql = $limit ? self::limit($limit) : "";
// Create ORDER BY statement if argument is defined // Create ORDER BY statement if argument is defined
$order_by_sql = !is_null($this->order_by) ? " ORDER BY {$this->order_by}" : ""; $order_by_sql = $order_by ? self::order_by($order_by) : "";
// Get array of SQL WHERE string and filter values // Get array of SQL WHERE string and filter values
$filter_sql = !is_null($this->filter_sql) ? " WHERE {$this->filter_sql}" : ""; [$filter_sql, $filter_values] = self::where($filter);
// Interpolate components into an SQL SELECT statmenet and execute // Interpolate components into an SQL SELECT statmenet and execute
$sql = "SELECT {$columns_sql} FROM `{$this->table}`{$filter_sql}{$order_by_sql}{$limit_sql}"; $sql = "SELECT {$columns_sql} FROM {$table}{$filter_sql}{$order_by_sql}{$limit_sql}";
// Return mysqli_response of matched rows
return $this->execute_query($sql, self::to_list_array($this->filter_values)); // No columns were specified, return true if query matched rows
if (!$columns) {
return $this->exec_bool($sql, $filter_values);
}
// Return array of matched rows
$exec = $this->exec($sql, $filter_values);
// Flatten array if $limit === 1
return empty($exec) || $limit !== 1 ? $exec : $exec[0];
} }
// Create Prepared Statement for UPDATE using PRIMARY KEY as anchor // Create Prepared Statement for UPDATE using PRIMARY KEY as anchor
public function update(array $entity): mysqli_result|bool { public function update(string $table, array $fields, ?array $filter = null): bool {
$this->throw_if_no_table();
// Create CSV string with Prepared Statement abbreviations from length of fields array. // Create CSV string with Prepared Statement abbreviations from length of fields array.
$changes = array_map(fn($column) => "`{$column}` = ?", array_keys($entity)); $changes = array_map(fn($column) => "{$column} = ?", array_keys($fields));
$changes = implode(",", $changes); $changes = implode(",", $changes);
// Get array of SQL WHERE string and filter values // Get array of SQL WHERE string and filter values
$filter_sql = !is_null($this->filter_sql) ? " WHERE {$this->filter_sql}" : ""; [$filter_sql, $filter_values] = self::where($filter);
// Get values from entity and convert booleans to tinyint $values = array_values($fields);
$values = self::filter_booleans(array_values($entity)); // Append filter values if defined
if ($filter_values) {
// Append values to filter property if where() was chained array_push($values, ...$filter_values);
if ($this->filter_values) {
array_push($values, ...$this->filter_values);
} }
// Interpolate components into an SQL UPDATE statement and execute // Interpolate components into an SQL UPDATE statement and execute
$sql = "UPDATE `{$this->table}` SET {$changes} {$filter_sql}"; $sql = "UPDATE {$table} SET {$changes} {$filter_sql}";
return $this->execute_query($sql, self::to_list_array($values)); return $this->exec_bool($sql, $values);
} }
// Create Prepared Statemt for INSERT // Create Prepared Statemt for INSERT
public function insert(array $values): mysqli_result|bool { public function insert(string $table, array $values): bool {
$this->throw_if_no_table(); // Return CSV string with Prepared Statement abbreviatons from length of fields array.
$values_stmt = self::csv(array_fill(0, count($values), "?"));
/*
Use array keys from $values as columns to insert if array is associative.
Treat statement as an all-columns INSERT if the $values array is sequential.
*/
$columns = !array_is_list($values) ? "(" . implode(",", array_keys($values)) . ")" : "";
// Convert booleans to tinyint
$values = self::filter_booleans($values);
// Create CSV string with Prepared Statement abbreviatons from length of fields array.
$values_stmt = implode(",", array_fill(0, count($values), "?"));
// Interpolate components into an SQL INSERT statement and execute // Interpolate components into an SQL INSERT statement and execute
$sql = "INSERT INTO `{$this->table}` {$columns} VALUES ({$values_stmt})"; $sql = "INSERT INTO {$table} VALUES ({$values_stmt})";
return $this->execute_query($sql, self::to_list_array($values)); return $this->exec_bool($sql, $values);
}
// Create Prepared Statemente for DELETE with WHERE condition(s)
public function delete(array ...$conditions): mysqli_result|bool {
$this->throw_if_no_table();
// Set DELETE WHERE conditions from arguments
if ($conditions) {
$this->where(...$conditions);
}
// Get array of SQL WHERE string and filter values
$filter_sql = !is_null($this->filter_sql) ? " WHERE {$this->filter_sql}" : "";
$sql = "DELETE FROM `{$this->table}`{$filter_sql}";
return $this->execute_query($sql, self::to_list_array($this->filter_values));
}
// Execute SQL query with optional prepared statement and return mysqli_result
public function exec(string $sql, mixed $params = null): mysqli_result {
return $this->execute_query($sql, self::to_list_array($params));
} }
} }

46
src/Operators.php
View file

@ -1,46 +0,0 @@
<?php
namespace vlw\MySQL;
enum Operators: string {
// Logical
case ALL = "ALL";
case AND = "AND";
case ANY = "ANY";
case BETWEEN = "BETWEEN";
case EXISTS = "EXISTS";
case IN = "IN";
case LIKE = "LIKE";
case NOT = "NOT";
case OR = "OR";
case SOME = "SOME";
// Comparison
case EQUALS = "=";
case GT = ">";
case LT = "<";
case GTE = ">=";
case LTE = "<=";
case NOTE = "<>";
// Arithmetic
case ADD = "+";
case SUBTRACT = "-";
case MULTIPLY = "*";
case DIVIDE = "/";
case MODULO = "%";
// Bitwise
case BS_AND = "&";
case BS_OR = "|";
case BS_XOR = "^";
// Compound
case ADDE = "+=";
case SUBE = "-=";
case DIVE = "/=";
case MODE = "%=";
case BS_ANDE = "&=";
case BS_ORE = "|*=";
case BS_XORE = "^-=";
}

8
src/Order.php
View file

@ -1,8 +0,0 @@
<?php
namespace vlw\MySQL;
enum Order: string {
case ASC = "ASC";
case DESC = "DESC";
}