PHPackages                             sectoroverload2k/php-mysql-database - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. sectoroverload2k/php-mysql-database

ActiveLibrary[Database & ORM](/categories/database)

sectoroverload2k/php-mysql-database
===================================

Lightweight PHP MySQL wrapper with prepared statements. Query returns MySQL object - call fetchAssoc() or fetchAll() to get data.

1.0.24(4w ago)0659↓86.7%MITPHPPHP >=8.0.0

Since Jul 11Pushed 4w ago1 watchersCompare

[ Source](https://github.com/sectoroverload2k/php-mysql-database)[ Packagist](https://packagist.org/packages/sectoroverload2k/php-mysql-database)[ Docs](https://github.com/sectoroverload2k/php-crud)[ RSS](/packages/sectoroverload2k-php-mysql-database/feed)WikiDiscussions main Synced yesterday

READMEChangelogDependencies (3)Versions (24)Used By (0)

php-mysql-database
==================

[](#php-mysql-database)

[![Latest Version](https://camo.githubusercontent.com/55a6aa934a3b077d6845009c2237a53264bf022c48383bf516f0232cb75fab55/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f736563746f726f7665726c6f6164326b2f7068702d6d7973716c2d64617461626173652e737667)](https://packagist.org/packages/sectoroverload2k/php-mysql-database)

A lightweight PHP MySQL database wrapper with prepared statement support and automatic parameter binding.

Installation
------------

[](#installation)

```
composer require sectoroverload2k/php-mysql-database
```

Quick Start
-----------

[](#quick-start)

```
use PhpMysqlDatabase\Database;

// Create connection
$db = new Database([
    'server' => 'localhost',
    'username' => 'username',
    'password' => 'password',
    'database' => 'database_name'
]);

// Simple query - returns MySQL object
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);

// YOU MUST CALL fetchAssoc() or fetchAll() to get the data
$user = $result->fetchAssoc();  // Returns single row as array
// OR
$users = $result->fetchAll();   // Returns all rows as array of arrays
```

⚠️ Important: Understanding Return Types
----------------------------------------

[](#️-important-understanding-return-types)

**KEY CONCEPT:** All query methods return a `MySQL` object, NOT an array. You must call fetch methods to retrieve data.

```
// ❌ WRONG - This will cause errors
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
$name = $result['name'];  // ERROR: Cannot use object as array

// ✅ CORRECT - Call fetch methods
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
$user = $result->fetchAssoc();
$name = $user['name'];  // Works!
```

Two Ways to Query
-----------------

[](#two-ways-to-query)

### Method 1: Simple Query (Recommended)

[](#method-1-simple-query-recommended)

Pass parameters directly to `query()` - most concise and preferred method:

```
// SELECT - single row
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
$user = $result->fetchAssoc();

// SELECT - multiple rows
$result = $db->query('SELECT * FROM users WHERE status = ?', ['active']);
$users = $result->fetchAll();

// INSERT
$db->query('INSERT INTO users (name, email) VALUES (?, ?)', ['John', 'john@example.com']);
$userId = $db->insert_id();

// UPDATE
$db->query('UPDATE users SET status = ? WHERE id = ?', ['inactive', 5]);

// DELETE
$db->query('DELETE FROM users WHERE id = ?', [5]);
```

### Method 2: Prepare/Bind/Execute (Advanced)

[](#method-2-preparebindexecute-advanced)

Use when you need more control or plan to execute the same query multiple times:

```
// Prepare
$stmt = $db->prepare('SELECT * FROM users WHERE username = ? AND status = ?');

// Bind parameters and execute
$stmt = $db->bind_param($stmt, ['john_doe', 'active']);
$result = $db->execute($stmt);

// Fetch data
$user = $result->fetchAssoc();
```

Complete Examples
-----------------

[](#complete-examples)

### Select Single Row

[](#select-single-row)

```
$result = $db->query('SELECT * FROM users WHERE email = ?', ['user@example.com']);
$user = $result->fetchAssoc();

if ($user) {
    echo "Found user: " . $user['name'];
} else {
    echo "User not found";
}
```

### Select Multiple Rows

[](#select-multiple-rows)

```
$result = $db->query('SELECT * FROM products WHERE category = ?', ['electronics']);
$products = $result->fetchAll();

foreach ($products as $product) {
    echo $product['name'] . ': $' . $product['price'] . "\n";
}
```

### Insert with Auto-Increment ID

[](#insert-with-auto-increment-id)

```
$db->query(
    'INSERT INTO users (name, email, created_at) VALUES (?, ?, NOW())',
    ['Jane Doe', 'jane@example.com']
);

$userId = $db->insert_id();
echo "Created user with ID: $userId";
```

### Update Records

[](#update-records)

```
$db->query(
    'UPDATE users SET last_login = NOW() WHERE id = ?',
    [123]
);

$rowsAffected = $db->affected_rows();
echo "Updated $rowsAffected rows";
```

### Delete Records

[](#delete-records)

```
$db->query('DELETE FROM sessions WHERE expires_at < NOW()', []);
```

### Complex Query with Multiple Parameters

[](#complex-query-with-multiple-parameters)

```
$result = $db->query(
    'SELECT * FROM orders WHERE user_id = ? AND status = ? AND created_at > ?',
    [42, 'pending', '2024-01-01']
);

$orders = $result->fetchAll();
```

### Join Query

[](#join-query)

```
$result = $db->query('
    SELECT u.name, u.email, p.title, p.created_at
    FROM users u
    INNER JOIN posts p ON u.id = p.user_id
    WHERE u.id = ?
    ORDER BY p.created_at DESC
    LIMIT 10
', [5]);

$posts = $result->fetchAll();
```

Fetch Methods
-------------

[](#fetch-methods)

After executing a SELECT query, use these methods to retrieve data:

```
$result = $db->query('SELECT * FROM users WHERE status = ?', ['active']);

// Fetch single row as associative array
$user = $result->fetchAssoc();
// Returns: ['id' => 1, 'name' => 'John', 'email' => 'john@example.com']
// Returns: null if no rows

// Fetch all rows as array of associative arrays
$users = $result->fetchAll();
// Returns: [
//   ['id' => 1, 'name' => 'John', ...],
//   ['id' => 2, 'name' => 'Jane', ...],
// ]
// Returns: [] if no rows

// Fetch single row as numeric array
$user = $result->fetchRow();
// Returns: [1, 'John', 'john@example.com']

// Get row count
$count = $result->numRows();

// Get column count
$cols = $result->numFields();
```

Parameter Type Detection
------------------------

[](#parameter-type-detection)

Parameters are **automatically typed** based on PHP variable type:

```
$id = 5;              // Auto-detected as integer (i)
$price = 99.99;       // Auto-detected as double (d)
$name = 'Product';    // Auto-detected as string (s)
$data = null;         // Auto-detected as string (s)

$db->query(
    'INSERT INTO products (id, name, price) VALUES (?, ?, ?)',
    [$id, $name, $price]
);
```

### Explicit Type Definition (Optional)

[](#explicit-type-definition-optional)

You can manually specify types if needed:

```
$stmt = $db->prepare('INSERT INTO products (name, price, in_stock) VALUES (?, ?, ?)');
$stmt = $db->bind_param($stmt, ['Laptop', 999.99, 10], 'sdi');
$db->execute($stmt);
```

**Type identifiers:**

- `i` - Integer
- `d` - Double (floating-point)
- `s` - String
- `b` - Blob (binary data)

Error Handling
--------------

[](#error-handling)

The library throws exceptions on database errors:

```
try {
    $result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
    $user = $result->fetchAssoc();
} catch (RestRouter\Exceptions\DBErrorException $e) {
    echo "Database error: " . $e->getMessage();
} catch (RestRouter\Exceptions\ForeignKeyException $e) {
    echo "Foreign key constraint: " . $e->getMessage();
}
```

Common Patterns
---------------

[](#common-patterns)

### Check if Record Exists

[](#check-if-record-exists)

```
$result = $db->query('SELECT id FROM users WHERE email = ?', ['test@example.com']);
$exists = ($result->fetchAssoc() !== null);

if ($exists) {
    echo "Email already registered";
}
```

### Count Records

[](#count-records)

```
$result = $db->query('SELECT COUNT(*) as count FROM users WHERE status = ?', ['active']);
$row = $result->fetchAssoc();
$count = $row['count'];
```

### Pagination

[](#pagination)

```
$page = 1;
$perPage = 20;
$offset = ($page - 1) * $perPage;

$result = $db->query(
    'SELECT * FROM posts ORDER BY created_at DESC LIMIT ? OFFSET ?',
    [$perPage, $offset]
);

$posts = $result->fetchAll();
```

### Conditional Queries

[](#conditional-queries)

```
$sql = 'SELECT * FROM products WHERE 1=1';
$params = [];

if (!empty($category)) {
    $sql .= ' AND category = ?';
    $params[] = $category;
}

if (!empty($minPrice)) {
    $sql .= ' AND price >= ?';
    $params[] = $minPrice;
}

$result = $db->query($sql, $params);
$products = $result->fetchAll();
```

Transaction Support
-------------------

[](#transaction-support)

Wrap multiple queries in a transaction to ensure atomicity - either all operations succeed or all fail.

### Basic Transaction

[](#basic-transaction)

```
try {
    $db->beginTransaction();

    $db->query('INSERT INTO orders (user_id, total) VALUES (?, ?)', [123, 99.99]);
    $orderId = $db->insert_id();

    $db->query('INSERT INTO order_items (order_id, product_id) VALUES (?, ?)',
               [$orderId, 456]);

    $db->commit();
} catch (RestRouter\Exceptions\DBErrorException $e) {
    $db->rollback();
    echo "Transaction failed: " . $e->getMessage();
}
```

### Money Transfer Example

[](#money-transfer-example)

```
try {
    $db->beginTransaction();

    // Deduct from sender
    $db->query('UPDATE wallets SET balance = balance - ? WHERE user_id = ? AND balance >= ?',
               [100.00, $fromUser, 100.00]);

    // Add to receiver
    $db->query('UPDATE wallets SET balance = balance + ? WHERE user_id = ?',
               [100.00, $toUser]);

    // Log transaction
    $db->query('INSERT INTO transactions (from_user, to_user, amount) VALUES (?, ?, ?)',
               [$fromUser, $toUser, 100.00]);

    $db->commit();
} catch (Exception $e) {
    $db->rollback();
    throw $e;
}
```

### Transaction Methods

[](#transaction-methods)

#### `beginTransaction(): bool`

[](#begintransaction-bool)

Start a new transaction.

**Returns:** True on success **Throws:** DBErrorException on failure

#### `commit(): bool`

[](#commit-bool)

Commit the current transaction.

**Returns:** True on success **Throws:** DBErrorException on failure or if no transaction is active

#### `rollback(): bool`

[](#rollback-bool)

Rollback the current transaction.

**Returns:** True on success **Throws:** DBErrorException on failure or if no transaction is active

#### `inTransaction(): bool`

[](#intransaction-bool)

Check if currently in a transaction.

**Returns:** True if in transaction, false otherwise

### Transaction Best Practices

[](#transaction-best-practices)

1. **Always use try-catch** - Catch exceptions and rollback on errors
2. **Commit explicitly** - Don't rely on auto-commit
3. **Keep transactions short** - Minimize lock time on tables
4. **Handle all errors** - Always rollback on any exception
5. **Check state when needed** - Use `inTransaction()` if transaction state is uncertain

API Reference
-------------

[](#api-reference)

### Database Class

[](#database-class)

#### `__construct(array $config)`

[](#__constructarray-config)

Creates database connection.

**Config array:**

- `server` - Database host
- `username` - Database user
- `password` - Database password
- `database` - Database name

#### `query(string $sql, array $params = []): MySQL|null`

[](#querystring-sql-array-params---mysqlnull)

Execute a query with optional parameters.

**Returns:** MySQL object on success, null on failure **Throws:** DBErrorException, ForeignKeyException

#### `prepare(string $sql): MySQL|null`

[](#preparestring-sql-mysqlnull)

Prepare a statement for execution.

**Returns:** MySQL object on success, null on failure

#### `bind_param(MySQL $stmt, mixed $params, string $types = null): MySQL`

[](#bind_parammysql-stmt-mixed-params-string-types--null-mysql)

Bind parameters to prepared statement.

**Returns:** MySQL object

#### `execute(MySQL $stmt): MySQL`

[](#executemysql-stmt-mysql)

Execute a prepared statement.

**Returns:** MySQL object with results

#### `insert_id(): int`

[](#insert_id-int)

Get the last inserted auto-increment ID.

**Returns:** Integer ID

#### `affected_rows(): int`

[](#affected_rows-int)

Get the number of affected rows from the last query.

**Returns:** Number of rows affected by the last INSERT, UPDATE, DELETE, or REPLACE query

#### `beginTransaction(): bool`

[](#begintransaction-bool-1)

Start a database transaction.

**Returns:** True on success **Throws:** DBErrorException

#### `commit(): bool`

[](#commit-bool-1)

Commit the current transaction.

**Returns:** True on success **Throws:** DBErrorException

#### `rollback(): bool`

[](#rollback-bool-1)

Rollback the current transaction.

**Returns:** True on success **Throws:** DBErrorException

#### `inTransaction(): bool`

[](#intransaction-bool-1)

Check if currently in a transaction.

**Returns:** Boolean transaction state

### MySQL Class (Result Object)

[](#mysql-class-result-object)

#### `fetchAssoc(): array|null`

[](#fetchassoc-arraynull)

Fetch single row as associative array.

**Returns:** Array on success, null if no more rows

#### `fetchAll(): array`

[](#fetchall-array)

Fetch all remaining rows as array of associative arrays.

**Returns:** Array of arrays (empty array if no rows)

#### `fetchRow(): array|null`

[](#fetchrow-arraynull)

Fetch single row as numeric array.

**Returns:** Array on success, null if no more rows

#### `numRows(): int`

[](#numrows-int)

Get number of rows in result set.

**Returns:** Integer count

#### `numFields(): int`

[](#numfields-int)

Get number of columns in result set.

**Returns:** Integer count

Best Practices
--------------

[](#best-practices)

1. **Always use parameterized queries** - Never concatenate user input into SQL
2. **Always fetch results** - Call `fetchAssoc()` or `fetchAll()` on SELECT queries
3. **Check for null** - `fetchAssoc()` returns null when no rows found
4. **Use try-catch** - Catch database exceptions in production
5. **Close connections** - Call `$db->disconnect()` when done (optional, happens automatically)

Common Mistakes to Avoid
------------------------

[](#common-mistakes-to-avoid)

❌ **Don't use result object as array:**

```
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
$name = $result['name'];  // ERROR!
```

✅ **Do fetch the data first:**

```
$result = $db->query('SELECT * FROM users WHERE id = ?', [5]);
$user = $result->fetchAssoc();
$name = $user['name'];  // Correct!
```

❌ **Don't forget parameters for INSERT/UPDATE/DELETE:**

```
$result = $db->query('DELETE FROM users WHERE id = ?', [5]);
$deleted = $result->fetchAssoc();  // Wrong - no results from DELETE
```

✅ **INSERT/UPDATE/DELETE don't return data:**

```
$db->query('DELETE FROM users WHERE id = ?', [5]);
// No fetch needed - deletion complete
```

License
-------

[](#license)

MIT License

Contributing
------------

[](#contributing)

Pull requests are welcome. For major changes, please open an issue first.

Support
-------

[](#support)

For issues and questions, please use the GitHub issue tracker.

###  Health Score

47

—

FairBetter than 93% of packages

Maintenance94

Actively maintained with recent releases

Popularity19

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity55

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~31 days

Recently: every ~51 days

Total

23

Last Release

28d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/6f0a0462b1e78fdbc05fbe6beb4a573476e72cfeb3112a5f1f90dcf37b94db95?d=identicon)[sectoroverload2k](/maintainers/sectoroverload2k)

---

Top Contributors

[![sectoroverload2k](https://avatars.githubusercontent.com/u/3073583?v=4)](https://github.com/sectoroverload2k "sectoroverload2k (28 commits)")

---

Tags

databasemysqlwrappercrudmysqliprepared-statements

### Embed Badge

![Health badge](/badges/sectoroverload2k-php-mysql-database/health.svg)

```
[![Health](https://phpackages.com/badges/sectoroverload2k-php-mysql-database/health.svg)](https://phpackages.com/packages/sectoroverload2k-php-mysql-database)
```

###  Alternatives

[ezsql/ezsql

Advance database access library. Make interacting with a database ridiculously easy. An universal interchangeable CRUD system.

86849.1k](/packages/ezsql-ezsql)[jv2222/ezsql

Advance database access library. Make interacting with a database ridiculously easy. An universal interchangeable CRUD system.

87211.6k2](/packages/jv2222-ezsql)[sergeytsalkov/meekrodb

The Simple PHP/MySQL Library

346410.5k13](/packages/sergeytsalkov-meekrodb)[stefangabos/zebra_database

An advanced, compact and lightweight MySQL database wrapper library, built around PHP's MySQLi extension.

11712.6k](/packages/stefangabos-zebra-database)[krugozor/database

PHP class library for simple, convenient, fast and safe work with MySql database, using PHP mysqli extension and imitation of prepared queries.

412.5k](/packages/krugozor-database)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)