PHPackages                             rmc0863/mysqli-database-class - 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. rmc0863/mysqli-database-class

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

rmc0863/mysqli-database-class
=============================

PHP MySQL Wrapper and object mapper which utilizes MySQLi and prepared statements

1.2(2y ago)0258GPL-3.0-or-laterPHPPHP >=5.3.0

Since Sep 13Pushed 2y agoCompare

[ Source](https://github.com/Cherry-toto/PHP-MySQLi-Database-Class)[ Packagist](https://packagist.org/packages/rmc0863/mysqli-database-class)[ RSS](/packages/rmc0863-mysqli-database-class/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (3)DependenciesVersions (4)Used By (0)

MysqliDb -- Simple MySQLi wrapper and object mapper with prepared statements

---

### Table of Contents

[](#table-of-contents)

**[Initialization](#initialization)**
**[Objects mapping](#objects-mapping)**
**[Insert Query](#insert-query)**
**[Update Query](#update-query)**
**[Select Query](#select-query)**
**[Delete Query](#delete-query)**
**[Insert Data](#insert-data)**
**[Insert XML](#insert-xml)**
**[Pagination](#pagination)**
**[Running raw SQL queries](#running-raw-sql-queries)**
**[Query Keywords](#query-keywords)**
**[Where Conditions](#where--having-methods)**
**[Order Conditions](#ordering-method)**
**[Group Conditions](#grouping-method)**
**[Properties Sharing](#properties-sharing)**
**[Joining Tables](#join-method)**
**[Subqueries](#subqueries)**
**[EXISTS / NOT EXISTS condition](#exists--not-exists-condition)**
**[Has method](#has-method)**
**[Helper Methods](#helper-methods)**
**[Transaction Helpers](#transaction-helpers)**
**[Error Helpers](#error-helpers)**
**[Table Locking](#table-locking)**

Support Me
----------

[](#support-me)

This software is developed during my free time and I will be glad if somebody will support me.

Everyone's time should be valuable, so please consider donating.

[Donate with paypal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=a%2ebutenka%40gmail%2ecom&lc=DO&item_name=mysqlidb&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)

### Installation

[](#installation)

To utilize this class, first import MysqliDb.php into your project, and require it.

```
require_once ('MysqliDb.php');
```

### Installation with composer

[](#installation-with-composer)

It is also possible to install library via composer

```
composer require thingengineer/mysqli-database-class:dev-master

```

### Initialization

[](#initialization)

Simple initialization with utf8 charset set by default:

```
$db = new MysqliDb ('host', 'username', 'password', 'databaseName');
```

Advanced initialization:

```
$db = new MysqliDb (Array (
                'host' => 'host',
                'username' => 'username',
                'password' => 'password',
                'db'=> 'databaseName',
                'port' => 3306,
                'prefix' => 'my_',
                'charset' => 'utf8'));
```

table prefix, port and database charset params are optional. If no charset should be set charset, set it to null

Also it is possible to reuse already connected mysqli object:

```
$mysqli = new mysqli ('host', 'username', 'password', 'databaseName');
$db = new MysqliDb ($mysqli);
```

If no table prefix were set during object creation its possible to set it later with a separate call:

```
$db->setPrefix ('my_');
```

If connection to mysql will be dropped Mysqlidb will try to automatically reconnect to the database once. To disable this behavoir use

```
$db->autoReconnect = false;
```

If you need to get already created mysqliDb object from another class or function use

```
    function init () {
        // db staying private here
        $db = new MysqliDb ('host', 'username', 'password', 'databaseName');
    }
    ...
    function myfunc () {
        // obtain db object created in init  ()
        $db = MysqliDb::getInstance();
        ...
    }
```

### Multiple database connection

[](#multiple-database-connection)

If you need to connect to multiple databases use following method:

```
$db->addConnection('slave', Array (
                'host' => 'host',
                'username' => 'username',
                'password' => 'password',
                'db'=> 'databaseName',
                'port' => 3306,
                'prefix' => 'my_',
                'charset' => 'utf8')
);
```

To select database use connection() method

```
$users = $db->connection('slave')->get('users');
```

### Objects mapping

[](#objects-mapping)

dbObject.php is an object mapping library built on top of mysqliDb to provide model representation functionality. See [dbObject manual for more information](dbObject.md)

### Insert Query

[](#insert-query)

Simple example

```
$data = Array ("login" => "admin",
               "firstName" => "John",
               "lastName" => 'Doe'
);
$id = $db->insert ('users', $data);
if($id)
    echo 'user was created. Id=' . $id;
```

Insert with functions use

```
$data = Array (
	'login' => 'admin',
    'active' => true,
	'firstName' => 'John',
	'lastName' => 'Doe',
	'password' => $db->func('SHA1(?)',Array ("secretpassword+salt")),
	// password = SHA1('secretpassword+salt')
	'createdAt' => $db->now(),
	// createdAt = NOW()
	'expires' => $db->now('+1Y')
	// expires = NOW() + interval 1 year
	// Supported intervals [s]econd, [m]inute, [h]hour, [d]day, [M]onth, [Y]ear
);

$id = $db->insert ('users', $data);
if ($id)
    echo 'user was created. Id=' . $id;
else
    echo 'insert failed: ' . $db->getLastError();
```

Insert with on duplicate key update

```
$data = Array ("login" => "admin",
               "firstName" => "John",
               "lastName" => 'Doe',
               "createdAt" => $db->now(),
               "updatedAt" => $db->now(),
);
$updateColumns = Array ("updatedAt");
$lastInsertId = "id";
$db->onDuplicate($updateColumns, $lastInsertId);
$id = $db->insert ('users', $data);
```

Insert multiple datasets at once

```
$data = Array(
    Array ("login" => "admin",
        "firstName" => "John",
        "lastName" => 'Doe'
    ),
    Array ("login" => "other",
        "firstName" => "Another",
        "lastName" => 'User',
        "password" => "very_cool_hash"
    )
);
$ids = $db->insertMulti('users', $data);
if(!$ids) {
    echo 'insert failed: ' . $db->getLastError();
} else {
    echo 'new users inserted with following id\'s: ' . implode(', ', $ids);
}
```

If all datasets only have the same keys, it can be simplified

```
$data = Array(
    Array ("admin", "John", "Doe"),
    Array ("other", "Another", "User")
);
$keys = Array("login", "firstName", "lastName");

$ids = $db->insertMulti('users', $data, $keys);
if(!$ids) {
    echo 'insert failed: ' . $db->getLastError();
} else {
    echo 'new users inserted with following id\'s: ' . implode(', ', $ids);
}
```

### Replace Query

[](#replace-query)

[Replace()](https://dev.mysql.com/doc/refman/5.0/en/replace.html) method implements same API as insert();

### Update Query

[](#update-query)

```
$data = Array (
	'firstName' => 'Bobby',
	'lastName' => 'Tables',
	'editCount' => $db->inc(2),
	// editCount = editCount + 2;
	'active' => $db->not()
	// active = !active;
);
$db->where ('id', 1);
if ($db->update ('users', $data))
    echo $db->count . ' records were updated';
else
    echo 'update failed: ' . $db->getLastError();
```

`update()` also support limit parameter:

```
$db->update ('users', $data, 10);
// Gives: UPDATE users SET ... LIMIT 10
```

### Select Query

[](#select-query)

After any select/get function calls amount or returned rows is stored in $count variable

```
$users = $db->get('users'); //contains an Array of all users
$users = $db->get('users', 10); //contains an Array 10 users
```

or select with custom columns set. Functions also could be used

```
$cols = Array ("id", "name", "email");
$users = $db->get ("users", null, $cols);
if ($db->count > 0)
    foreach ($users as $user) {
        print_r ($user);
    }
```

or select just one row

```
$db->where ("id", 1);
$user = $db->getOne ("users");
echo $user['id'];

$stats = $db->getOne ("users", "sum(id), count(*) as cnt");
echo "total ".$stats['cnt']. "users found";
```

or select one column value or function result

```
$count = $db->getValue ("users", "count(*)");
echo "{$count} users found";
```

select one column value or function result from multiple rows:

```
$logins = $db->getValue ("users", "login", null);
// select login from users
$logins = $db->getValue ("users", "login", 5);
// select login from users limit 5
foreach ($logins as $login)
    echo $login;
```

### Insert Data

[](#insert-data)

You can also load .CSV or .XML data into a specific table. To insert .csv data, use the following syntax:

```
$path_to_file = "/home/john/file.csv";
$db->loadData("users", $path_to_file);
```

This will load a .csv file called **file.csv** in the folder **/home/john/** (john's home directory.) You can also attach an optional array of options. Valid options are:

```
Array(
	"fieldChar" => ';', 	// Char which separates the data
	"lineChar" => '\r\n', 	// Char which separates the lines
	"linesToIgnore" => 1	// Amount of lines to ignore at the beginning of the import
);
```

Attach them using

```
$options = Array("fieldChar" => ';', "lineChar" => '\r\n', "linesToIgnore" => 1);
$db->loadData("users", "/home/john/file.csv", $options);
// LOAD DATA ...
```

You can specify to **use LOCAL DATA** instead of **DATA**:

```
$options = Array("fieldChar" => ';', "lineChar" => '\r\n', "linesToIgnore" => 1, "loadDataLocal" => true);
$db->loadData("users", "/home/john/file.csv", $options);
// LOAD DATA LOCAL ...
```

### Insert XML

[](#insert-xml)

To load XML data into a table, you can use the method **loadXML**. The syntax is smillar to the loadData syntax.

```
$path_to_file = "/home/john/file.xml";
$db->loadXML("users", $path_to_file);
```

You can also add optional parameters. Valid parameters:

```
Array(
	"linesToIgnore" => 0,		// Amount of lines / rows to ignore at the beginning of the import
	"rowTag"	=> ""	// The tag which marks the beginning of an entry
)
```

Usage:

```
$options = Array("linesToIgnore" => 0, "rowTag"	=> ""):
$path_to_file = "/home/john/file.xml";
$db->loadXML("users", $path_to_file, $options);
```

### Pagination

[](#pagination)

Use paginate() instead of get() to fetch paginated result

```
$page = 1;
// set page limit to 2 results per page. 20 by default
$db->pageLimit = 2;
$products = $db->arraybuilder()->paginate("products", $page);
echo "showing $page out of " . $db->totalPages;
```

### Result transformation / map

[](#result-transformation--map)

Instead of getting an pure array of results its possible to get result in an associative array with a needed key. If only 2 fields to fetch will be set in get(), method will return result in array($k => $v) and array ($k => array ($v, $v)) in rest of the cases.

```
$user = $db->map ('login')->ObjectBuilder()->getOne ('users', 'login, id');
Array
(
    [user1] => 1
)

$user = $db->map ('login')->ObjectBuilder()->getOne ('users', 'id,login,createdAt');
Array
(
    [user1] => stdClass Object
        (
            [id] => 1
            [login] => user1
            [createdAt] => 2015-10-22 22:27:53
        )

)
```

### Defining a return type

[](#defining-a-return-type)

MysqliDb can return result in 3 different formats: Array of Array, Array of Objects and a Json string. To select a return type use ArrayBuilder(), ObjectBuilder() and JsonBuilder() methods. Note that ArrayBuilder() is a default return type

```
// Array return type
$u= $db->getOne("users");
echo $u['login'];
// Object return type
$u = $db->ObjectBuilder()->getOne("users");
echo $u->login;
// Json return type
$json = $db->JsonBuilder()->getOne("users");
```

### Running raw SQL queries

[](#running-raw-sql-queries)

```
$users = $db->rawQuery('SELECT * from users where id >= ?', Array (10));
foreach ($users as $user) {
    print_r ($user);
}
```

To avoid long if checks there are couple helper functions to work with raw query select results:

Get 1 row of results:

```
$user = $db->rawQueryOne('SELECT * from users where id=?', Array(10));
echo $user['login'];
// Object return type
$user = $db->ObjectBuilder()->rawQueryOne('SELECT * from users where id=?', Array(10));
echo $user->login;
```

Get 1 column value as a string:

```
$password = $db->rawQueryValue('SELECT password from users where id=? limit 1', Array(10));
echo "Password is {$password}";
NOTE: for a rawQueryValue() to return string instead of an array 'limit 1' should be added to the end of the query.
```

Get 1 column value from multiple rows:

```
$logins = $db->rawQueryValue('SELECT login from users limit 10');
foreach ($logins as $login)
    echo $login;
```

More advanced examples:

```
$params = Array(1, 'admin');
$users = $db->rawQuery("SELECT id, firstName, lastName FROM users WHERE id = ? AND login = ?", $params);
print_r($users); // contains Array of returned rows

// will handle any SQL query
$params = Array(10, 1, 10, 11, 2, 10);
$q = "(
    SELECT a FROM t1
        WHERE a = ? AND B = ?
        ORDER BY a LIMIT ?
) UNION (
    SELECT a FROM t2
        WHERE a = ? AND B = ?
        ORDER BY a LIMIT ?
)";
$results = $db->rawQuery ($q, $params);
print_r ($results); // contains Array of returned rows
```

### Where / Having Methods

[](#where--having-methods)

`where()`, `orWhere()`, `having()` and `orHaving()` methods allows you to specify where and having conditions of the query. All conditions supported by where() are supported by having() as well.

WARNING: In order to use column to column comparisons only raw where conditions should be used as column name or functions cannot be passed as a bind variable.

Regular == operator with variables:

```
$db->where ('id', 1);
$db->where ('login', 'admin');
$results = $db->get ('users');
// Gives: SELECT * FROM users WHERE id=1 AND login='admin';
```

```
$db->where ('id', 1);
$db->having ('login', 'admin');
$results = $db->get ('users');
// Gives: SELECT * FROM users WHERE id=1 HAVING login='admin';
```

Regular == operator with column to column comparison:

```
// WRONG
$db->where ('lastLogin', 'createdAt');
// CORRECT
$db->where ('lastLogin = createdAt');
$results = $db->get ('users');
// Gives: SELECT * FROM users WHERE lastLogin = createdAt;
```

```
$db->where ('id', 50, ">=");
// or $db->where ('id', Array ('>=' => 50));
$results = $db->get ('users');
// Gives: SELECT * FROM users WHERE id >= 50;
```

BETWEEN / NOT BETWEEN:

```
$db->where('id', Array (4, 20), 'BETWEEN');
// or $db->where ('id', Array ('BETWEEN' => Array(4, 20)));

$results = $db->get('users');
// Gives: SELECT * FROM users WHERE id BETWEEN 4 AND 20
```

IN / NOT IN:

```
$db->where('id', Array(1, 5, 27, -1, 'd'), 'IN');
// or $db->where('id', Array( 'IN' => Array(1, 5, 27, -1, 'd') ) );

$results = $db->get('users');
// Gives: SELECT * FROM users WHERE id IN (1, 5, 27, -1, 'd');
```

OR CASE:

```
$db->where ('firstName', 'John');
$db->orWhere ('firstName', 'Peter');
$results = $db->get ('users');
// Gives: SELECT * FROM users WHERE firstName='John' OR firstName='peter'
```

NULL comparison:

```
$db->where ("lastName", NULL, 'IS NOT');
$results = $db->get("users");
// Gives: SELECT * FROM users where lastName IS NOT NULL
```

LIKE comparison:

```
$db->where ("fullName", 'John%', 'like');
$results = $db->get("users");
// Gives: SELECT * FROM users where fullName like 'John%'
```

Also you can use raw where conditions:

```
$db->where ("id != companyId");
$db->where ("DATE(createdAt) = DATE(lastLogin)");
$results = $db->get("users");
```

Or raw condition with variables:

```
$db->where ("(id = ? or id = ?)", Array(6,2));
$db->where ("login","mike");
$res = $db->get ("users");
// Gives: SELECT * FROM users WHERE (id = 6 or id = 2) and login='mike';
```

Find the total number of rows matched. Simple pagination example:

```
$offset = 10;
$count = 15;
$users = $db->withTotalCount()->get('users', Array ($offset, $count));
echo "Showing {$count} from {$db->totalCount}";
```

### Query Keywords

[](#query-keywords)

To add LOW PRIORITY | DELAYED | HIGH PRIORITY | IGNORE and the rest of the mysql keywords to INSERT (), REPLACE (), GET (), UPDATE (), DELETE() method or FOR UPDATE | LOCK IN SHARE MODE into SELECT ():

```
$db->setQueryOption ('LOW_PRIORITY')->insert ($table, $param);
// GIVES: INSERT LOW_PRIORITY INTO table ...
```

```
$db->setQueryOption ('FOR UPDATE')->get ('users');
// GIVES: SELECT * FROM USERS FOR UPDATE;
```

Also you can use an array of keywords:

```
$db->setQueryOption (Array('LOW_PRIORITY', 'IGNORE'))->insert ($table,$param);
// GIVES: INSERT LOW_PRIORITY IGNORE INTO table ...
```

Same way keywords could be used in SELECT queries as well:

```
$db->setQueryOption ('SQL_NO_CACHE');
$db->get("users");
// GIVES: SELECT SQL_NO_CACHE * FROM USERS;
```

Optionally you can use method chaining to call where multiple times without referencing your object over and over:

```
$results = $db
	->where('id', 1)
	->where('login', 'admin')
	->get('users');
```

### Delete Query

[](#delete-query)

```
$db->where('id', 1);
if($db->delete('users')) echo 'successfully deleted';
```

### Ordering method

[](#ordering-method)

```
$db->orderBy("id","asc");
$db->orderBy("login","Desc");
$db->orderBy("RAND ()");
$results = $db->get('users');
// Gives: SELECT * FROM users ORDER BY id ASC,login DESC, RAND ();
```

Order by values example:

```
$db->orderBy('userGroup', 'ASC', array('superuser', 'admin', 'users'));
$db->get('users');
// Gives: SELECT * FROM users ORDER BY FIELD (userGroup, 'superuser', 'admin', 'users') ASC;
```

If you are using setPrefix () functionality and need to use table names in orderBy() method make sure that table names are escaped with ``.

```
$db->setPrefix ("t_");
$db->orderBy ("users.id","asc");
$results = $db->get ('users');
// WRONG: That will give: SELECT * FROM t_users ORDER BY users.id ASC;

$db->setPrefix ("t_");
$db->orderBy ("`users`.id", "asc");
$results = $db->get ('users');
// CORRECT: That will give: SELECT * FROM t_users ORDER BY t_users.id ASC;
```

### Grouping method

[](#grouping-method)

```
$db->groupBy ("name");
$results = $db->get ('users');
// Gives: SELECT * FROM users GROUP BY name;
```

### JOIN method

[](#join-method)

Join table products with table users with LEFT JOIN by tenantID

```
$db->join("users u", "p.tenantID=u.tenantID", "LEFT");
$db->where("u.id", 6);
$products = $db->get ("products p", null, "u.name, p.productName");
print_r ($products);
// Gives: SELECT u.name, p.productName FROM products p LEFT JOIN users u ON p.tenantID=u.tenantID WHERE u.id = 6
```

### Join Conditions

[](#join-conditions)

Add AND condition to join statement

```
$db->join("users u", "p.tenantID=u.tenantID", "LEFT");
$db->joinWhere("users u", "u.tenantID", 5);
$products = $db->get ("products p", null, "u.name, p.productName");
print_r ($products);
// Gives: SELECT  u.name, p.productName FROM products p LEFT JOIN users u ON (p.tenantID=u.tenantID AND u.tenantID = 5)
```

Add OR condition to join statement

```
$db->join("users u", "p.tenantID=u.tenantID", "LEFT");
$db->joinOrWhere("users u", "u.tenantID", 5);
$products = $db->get ("products p", null, "u.name, p.productName");
print_r ($products);
// Gives: SELECT  u.login, p.productName FROM products p LEFT JOIN users u ON (p.tenantID=u.tenantID OR u.tenantID = 5)
```

### Properties sharing

[](#properties-sharing)

It is also possible to copy properties

```
$db->where ("agentId", 10);
$db->where ("active", true);

$customers = $db->copy ();
$res = $customers->get ("customers", Array (10, 10));
// SELECT * FROM customers WHERE agentId = 10 AND active = 1 LIMIT 10, 10

$cnt = $db->getValue ("customers", "count(id)");
echo "total records found: " . $cnt;
// SELECT count(id) FROM customers WHERE agentId = 10 AND active = 1
```

### Subqueries

[](#subqueries)

Subquery init

Subquery init without an alias to use in inserts/updates/where Eg. (select \* from users)

```
$sq = $db->subQuery();
$sq->get ("users");
```

A subquery with an alias specified to use in JOINs . Eg. (select \* from users) sq

```
$sq = $db->subQuery("sq");
$sq->get ("users");
```

Subquery in selects:

```
$ids = $db->subQuery ();
$ids->where ("qty", 2, ">");
$ids->get ("products", null, "userId");

$db->where ("id", $ids, 'in');
$res = $db->get ("users");
// Gives SELECT * FROM users WHERE id IN (SELECT userId FROM products WHERE qty > 2)
```

Subquery in inserts:

```
$userIdQ = $db->subQuery ();
$userIdQ->where ("id", 6);
$userIdQ->getOne ("users", "name"),

$data = Array (
    "productName" => "test product",
    "userId" => $userIdQ,
    "lastUpdated" => $db->now()
);
$id = $db->insert ("products", $data);
// Gives INSERT INTO PRODUCTS (productName, userId, lastUpdated) values ("test product", (SELECT name FROM users WHERE id = 6), NOW());
```

Subquery in joins:

```
$usersQ = $db->subQuery ("u");
$usersQ->where ("active", 1);
$usersQ->get ("users");

$db->join($usersQ, "p.userId=u.id", "LEFT");
$products = $db->get ("products p", null, "u.login, p.productName");
print_r ($products);
// SELECT u.login, p.productName FROM products p LEFT JOIN (SELECT * FROM t_users WHERE active = 1) u on p.userId=u.id;
```

### EXISTS / NOT EXISTS condition

[](#exists--not-exists-condition)

```
$sub = $db->subQuery();
$sub->where("company", 'testCompany');
$sub->get ("users", null, 'userId');
$db->where (null, $sub, 'exists');
$products = $db->get ("products");
// Gives SELECT * FROM products WHERE EXISTS (SELECT userId FROM users WHERE company='testCompany')
```

### Has method

[](#has-method)

A convenient function that returns TRUE if exists at least an element that satisfy the where condition specified calling the "where" method before this one.

```
$db->where("user", $user);
$db->where("password", md5($password));
if($db->has("users")) {
    return "You are logged";
} else {
    return "Wrong user/password";
}
```

### Helper methods

[](#helper-methods)

Disconnect from the database:

```
    $db->disconnect();
```

Reconnect in case mysql connection died:

```
if (!$db->ping())
    $db->connect()
```

Get last executed SQL query: Please note that this method returns the SQL query only for debugging purposes as its execution most likely will fail due to missing quotes around char variables.

```
    $db->get('users');
    echo "Last executed query was ". $db->getLastQuery();
```

Check if table exists:

```
    if ($db->tableExists ('users'))
        echo "hooray";
```

mysqli\_real\_escape\_string() wrapper:

```
    $escaped = $db->escape ("' and 1=1");
```

### Transaction helpers

[](#transaction-helpers)

Please keep in mind that transactions are working on innoDB tables. Rollback transaction if insert fails:

```
$db->startTransaction();
...
if (!$db->insert ('myTable', $insertData)) {
    //Error while saving, cancel new record
    $db->rollback();
} else {
    //OK
    $db->commit();
}
```

### Error helpers

[](#error-helpers)

After you executed a query you have options to check if there was an error. You can get the MySQL error string or the error code for the last executed query.

```
$db->where('login', 'admin')->update('users', ['firstName' => 'Jack']);

if ($db->getLastErrno() === 0)
    echo 'Update succesfull';
else
    echo 'Update failed. Error: '. $db->getLastError();
```

### Query execution time benchmarking

[](#query-execution-time-benchmarking)

To track query execution time setTrace() function should be called.

```
$db->setTrace (true);
// As a second parameter it is possible to define prefix of the path which should be striped from filename
// $db->setTrace (true, $_SERVER['SERVER_ROOT']);
$db->get("users");
$db->get("test");
print_r ($db->trace);
```

```
    [0] => Array
        (
            [0] => SELECT  * FROM t_users ORDER BY `id` ASC
            [1] => 0.0010669231414795
            [2] => MysqliDb->get() >>  file "/avb/work/PHP-MySQLi-Database-Class/tests.php" line #151
        )

    [1] => Array
        (
            [0] => SELECT  * FROM t_test
            [1] => 0.00069189071655273
            [2] => MysqliDb->get() >>  file "/avb/work/PHP-MySQLi-Database-Class/tests.php" line #152
        )

```

### Table Locking

[](#table-locking)

To lock tables, you can use the **lock** method together with **setLockMethod**. The following example will lock the table **users** for **write** access.

```
$db->setLockMethod("WRITE")->lock("users");
```

Calling another **->lock()** will remove the first lock. You can also use

```
$db->unlock();
```

to unlock the previous locked tables. To lock multiple tables, you can use an array. Example:

```
$db->setLockMethod("READ")->lock(array("users", "log"));
```

This will lock the tables **users** and **log** for **READ** access only. Make sure you use \**unlock()* afterwards or your tables will remain locked!

###  Health Score

27

—

LowBetter than 49% of packages

Maintenance31

Infrequent updates — may be unmaintained

Popularity11

Limited adoption so far

Community19

Small or concentrated contributor base

Maturity44

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 75.8% 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 ~294 days

Total

3

Last Release

746d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/b090a515519c61a1abc0c24534d89187320db42c2e6c14fc8300de62683c197c?d=identicon)[rmc](/maintainers/rmc)

---

Top Contributors

[![avbdr](https://avatars.githubusercontent.com/u/3286514?v=4)](https://github.com/avbdr "avbdr (380 commits)")[![ThingEngineer](https://avatars.githubusercontent.com/u/418426?v=4)](https://github.com/ThingEngineer "ThingEngineer (38 commits)")[![JeffreyWay](https://avatars.githubusercontent.com/u/183223?v=4)](https://github.com/JeffreyWay "JeffreyWay (17 commits)")[![Noneatme](https://avatars.githubusercontent.com/u/6305695?v=4)](https://github.com/Noneatme "Noneatme (14 commits)")[![Skazza94](https://avatars.githubusercontent.com/u/10586339?v=4)](https://github.com/Skazza94 "Skazza94 (4 commits)")[![KTP95](https://avatars.githubusercontent.com/u/9784455?v=4)](https://github.com/KTP95 "KTP95 (4 commits)")[![ilyagory](https://avatars.githubusercontent.com/u/20206138?v=4)](https://github.com/ilyagory "ilyagory (4 commits)")[![ricwein](https://avatars.githubusercontent.com/u/870354?v=4)](https://github.com/ricwein "ricwein (3 commits)")[![Cherry-toto](https://avatars.githubusercontent.com/u/16120893?v=4)](https://github.com/Cherry-toto "Cherry-toto (3 commits)")[![rongzhj1990](https://avatars.githubusercontent.com/u/4045227?v=4)](https://github.com/rongzhj1990 "rongzhj1990 (3 commits)")[![vstaikov](https://avatars.githubusercontent.com/u/11332307?v=4)](https://github.com/vstaikov "vstaikov (2 commits)")[![dave-swift](https://avatars.githubusercontent.com/u/1645985?v=4)](https://github.com/dave-swift "dave-swift (2 commits)")[![duhow](https://avatars.githubusercontent.com/u/1145001?v=4)](https://github.com/duhow "duhow (2 commits)")[![dzpt](https://avatars.githubusercontent.com/u/5781080?v=4)](https://github.com/dzpt "dzpt (2 commits)")[![Gemorroj](https://avatars.githubusercontent.com/u/885731?v=4)](https://github.com/Gemorroj "Gemorroj (2 commits)")[![jefvhal](https://avatars.githubusercontent.com/u/5992075?v=4)](https://github.com/jefvhal "jefvhal (2 commits)")[![JustinEldracher](https://avatars.githubusercontent.com/u/11478912?v=4)](https://github.com/JustinEldracher "JustinEldracher (2 commits)")[![kevinkaske](https://avatars.githubusercontent.com/u/172011?v=4)](https://github.com/kevinkaske "kevinkaske (2 commits)")[![leigh-ols](https://avatars.githubusercontent.com/u/6872441?v=4)](https://github.com/leigh-ols "leigh-ols (2 commits)")[![luke-j](https://avatars.githubusercontent.com/u/6657011?v=4)](https://github.com/luke-j "luke-j (2 commits)")

### Embed Badge

![Health badge](/badges/rmc0863-mysqli-database-class/health.svg)

```
[![Health](https://phpackages.com/badges/rmc0863-mysqli-database-class/health.svg)](https://phpackages.com/packages/rmc0863-mysqli-database-class)
```

###  Alternatives

[doctrine/orm

Object-Relational-Mapper for PHP

10.2k285.3M6.2k](/packages/doctrine-orm)[jdorn/sql-formatter

a PHP SQL highlighting library

3.9k115.1M102](/packages/jdorn-sql-formatter)[illuminate/database

The Illuminate Database package.

2.8k52.4M9.3k](/packages/illuminate-database)[mongodb/mongodb

MongoDB driver library

1.6k64.0M542](/packages/mongodb-mongodb)[ramsey/uuid-doctrine

Use ramsey/uuid as a Doctrine field type.

90340.3M209](/packages/ramsey-uuid-doctrine)[reliese/laravel

Reliese Components for Laravel Framework code generation.

1.7k3.4M16](/packages/reliese-laravel)

PHPackages © 2026

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