PHPackages                             zyxus/db - 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. zyxus/db

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

zyxus/db
========

PHP Wrapper for MySQL PDO

039[1 issues](https://github.com/zyxus/db/issues)PHP

Since May 15Pushed 6y ago1 watchersCompare

[ Source](https://github.com/zyxus/db)[ Packagist](https://packagist.org/packages/zyxus/db)[ RSS](/packages/zyxus-db/feed)WikiDiscussions master Synced 1w ago

READMEChangelogDependenciesVersions (1)Used By (0)

Небольшой класс оберкта для PDO. Был разработан для служебных нужд, с целью облегчения перехода на PDO. Конструктор запросов расширяет функционал использования PDO.

Установка
---------

[](#установка)

Установка через [Composer](https://getcomposer.org).

```
$ composer require zyxus/db
```

Оглавление
----------

[](#оглавление)

- [Использование](#%D0%98%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)

    - [::query()](#query)
    - [rowCount()](#rowCount)
    - [fetch()](#fetch)
    - [fetchAll()](#fetchAll)
    - [lastInsertId()](#lastInsertId)
- [Подготовленные выражения (prepared statements)](#prepared-statements)

    - [Безымянные placeholder’ы (?)](#placeholder)
    - [Именные placeholder’ы (:placeholder\_name)](#placeholder_name)
    - [Выбор варианта возвращаемых индексов FETCH\_STYLE](#fetch_style)
    - [Проверка результатов запроса](#%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D1%80%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%D0%BE%D0%B2-%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%B0)
    - [Вставка строки в таблицу INSERT](#insert)
    - [Синтаксис INSERT ON DUPLICATE KEY UPDATE](#on_duplicate_key)
- [Конструктор запросов](#%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D0%BE%D1%80-%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%BE%D0%B2)

    - [table](#table)
    - [fields](#fields)
    - [join](#join)
    - [innerJoin](#innerJoin)
    - [where](#where)
    - [whereRaw](#whereRaw)
    - [order](#order)
    - [limit](#limit)
    - [exec](#exec)

Использование
-------------

[](#использование)

### DB::query()

[](#dbquery)

Возвращает результат `true` - если запрос выполнен, `false` - если запрос ничего не вернул. В случае ошибки выбрасывается исключение и выводится скрипт и строка ошибки и описание ошибки.

```
bool DB::query($query);
```

### rowCount()

[](#rowcount)

Возвращает количество обработанных запросом строк

```
$count = DB::query($query)->rowCount();
```

### fetch()

[](#fetch)

Возвращает 1 строку с результатом запроса

```
$count = DB::query($query)->fetch();
```

### fetchAll()

[](#fetchall)

Возвращает все строки с результатами запроса

```
$count = DB::query($query)->fetch();
```

### lastInsertId()

[](#lastinsertid)

Возвращает последний вставленный запросом id

```
$count = DB::instance()->lastInsertId();
```

Подготовленные выражения (prepared statements)
-------------------------------------------------------------------------------------------

[](#подготовленные-выражения-prepared-statements)

> Использование prepared statements укрепляет защиту от SQL-инъекций.

Prepared statement — это заранее скомпилированное SQL-выражение, которое может быть многократно выполнено путем отправки серверу лишь различных наборов данных. Дополнительным преимуществом является невозможность провести SQL-инъекцию через данные, используемые в placeholder’ах.

### Безымянные placeholder’ы (?)

[](#безымянные-placeholderы-)

```
$query = "SELECT `field1`, `field2` FROM `table` WHERE `id` = ? AND `field3` = ?";
$params = [100, 'Y'];
$data = DB::query($query, params)->fetch();
```

### Именные placeholder’ы (:placeholder\_name)

[](#именные-placeholderы-placeholder_name)

```
$query = "SELECT `field1`, `field2` FROM `table` WHERE `id` = :id AND `field3` = :field3";
$params = [
    ':id' => 100,
    ':field3' => 'Y',
];
$data = DB::query($query, params)->fetch();
```

### Выборка результатов запроса SELECT

[](#выборка-результатов-запроса-select)

Выбор одной строки *fetch()*

```
$query = "SELECT `field` FROM `table` WHERE `id` = :id";
$articul = DB::query($query, [':id' => 2797])->fetch(); // если не указан PDO::FETCH_NUM то вернется ассоциативный массив
```

Возвращает

```
[
    [id] => 1234
    [name] => Название поля
]
// или если в fetch(PDO::FETCH_NUM) то вернется нумерованный массив
[
    [0] => 1234
    [1] => Название поля
]
```

Выбор всех результатов запроса *fetchAll()*

```
$data = DB::query($query)->fetchAll();
```

### Выбор варианта возвращаемых индексов FETCH\_STYLE

[](#выбор-варианта-возвращаемых-индексов-fetch_style)

Выборка ассоциативного массива данных

```
$data = DB::query($query)->fetchAll(PDO::FETCH_ASSOC);
```

Возвращает

```
[
    [0] => Array
        (
            [id] => 1234
            [name] => Название поля 1
        )
    [1] => Array
        (
            [id] => 1235
            [name] => Название поля 2
        )
    [2] => Array
        (
            [id] => 1236
            [name] => Название поля 3
        )
]
```

Выборка нумерованного массива данных

```
$data = DB::query($query)->fetchAll(PDO::FETCH_NUM);
```

Возвращает

```
[
    [0] => Array
        (
            [0] => 1234
            [1] => Название поля 1
        )
    [1] => Array
        (
            [0] => 1235
            [1] => Название поля 2
        )
    [2] => Array
        (
            [0] => 1236
            [1] => Название поля 3
        )
]
```

### Проверка результатов запроса

[](#проверка-результатов-запроса)

```
$query = "SELECT `id`, `name` FROM `table` WHERE `id` = ?";
if (!$array = DB::query($query, [$id])->fetchAll()) {
    echo "Нет записей";
}
```

```
$query = "SELECT `name` FROM `table` WHERE `id` = ?";
$result = DB::query($query, [$articul]);

if ($result->rowCount() > 0) {

    $row = $result->fetch();
    echo $row['name'];

} else {

    echo "Empty results";
}
```

### Вставка строки в таблицу INSERT

[](#вставка-строки-в-таблицу-insert)

```
$query = "
    INSERT INTO `table` (
        `id`,
        `title`
    ) VALUES (
        NULL,
        :title
    );
";
$params = array(
    ':title' => $title,
);
DB::query($query, $params);
```

### Синтаксис INSERT ON DUPLICATE KEY UPDATE

[](#синтаксис-insert-on-duplicate-key-update)

```
INSERT INTO
    `table`
SET
    `field1` = :field1,
    `field2` = :field2
ON DUPLICATE KEY UPDATE
    `field2` = VALUES(`field2`)
```

Конструктор запросов
--------------------

[](#конструктор-запросов)

#### Пример

[](#пример)

```
$menu = DB::table('table')
    ->fields('table.id, table.name, table_parent.name as parent')
    ->limit(2, 2)
    ->order('table.id');

$menu->join('table', 'table_parent.id', 'table.parent_id', null, 'table_parent');
$menu->where('table.articul', '', '');
$products = $menu->exec();
```

### table($table)

[](#tabletable)

Установка таблицы

```
$query = DB::table('table');
```

### fields($fields)

[](#fieldsfields)

Назначаем поля таблицы

```
$query->fields('table.field1, table.field2');
```

### join($table, $field1, $field2, $condition = ' = ', $alias = '')

[](#jointable-field1-field2-condition-----alias--)

```
$query->join('table', 'table.id', 'table.parent_id', null, 'table_alias');
```

### innerJoin($table, $field1, $field2, $condition = ' = ', $alias = '')

[](#innerjointable-field1-field2-condition-----alias--)

Аналогичен `join`.

### where($field, $value, $condition = ' = ', $combine\_condition = 'AND')

[](#wherefield-value-condition-----combine_condition--and)

```
$query->where('table.title', '', '');
```

### whereRaw($where)

[](#whererawwhere)

```
$query->whereRaw('id = :id');
```

### order($field, $direction = 'ASC')

[](#orderfield-direction--asc)

Сортировка по полю `$field` с направлением `$direction`

```
$query->order('id');
```

### limit($limit, $from = '0')

[](#limitlimit-from--0)

Выбор `$limit` записей начиная от `$from`

```
$query->limit(10);
```

### exec()

[](#exec)

Выполнение подготовленного запроса

```
$products = $query->exec();
```

###  Health Score

18

—

LowBetter than 8% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity7

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity33

Early-stage or recently created project

 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.

### Community

Maintainers

![](https://www.gravatar.com/avatar/8abb601bb344d1f539091373cf0366a6d8cc26d11d9a8dd11f786132dcc3a3c4?d=identicon)[Zyxus](/maintainers/Zyxus)

---

Top Contributors

[![zyxus](https://avatars.githubusercontent.com/u/4077104?v=4)](https://github.com/zyxus "zyxus (17 commits)")

### Embed Badge

![Health badge](/badges/zyxus-db/health.svg)

```
[![Health](https://phpackages.com/badges/zyxus-db/health.svg)](https://phpackages.com/packages/zyxus-db)
```

###  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.4k](/packages/illuminate-database)[mongodb/mongodb

MongoDB driver library

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

Use ramsey/uuid as a Doctrine field type.

90340.3M211](/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)