PHPackages                             tarantool/client - 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. tarantool/client

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

tarantool/client
================

PHP client for Tarantool.

v0.10.1(1y ago)67430.7k↓11.2%23[1 issues](https://github.com/tarantool-php/client/issues)20MITPHPPHP ^7.2.5|^8

Since Mar 14Pushed 1y ago7 watchersCompare

[ Source](https://github.com/tarantool-php/client)[ Packagist](https://packagist.org/packages/tarantool/client)[ GitHub Sponsors](https://github.com/rybakit)[ RSS](/packages/tarantool-client/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (10)Dependencies (7)Versions (19)Used By (20)

PHP client for Tarantool
========================

[](#php-client-for-tarantool)

[![Quality Assurance](https://github.com/tarantool-php/client/workflows/QA/badge.svg)](https://github.com/tarantool-php/client/actions?query=workflow%3AQA)[![Scrutinizer Code Quality](https://camo.githubusercontent.com/e2c597b66c412e118968ff787649cb664d800b39685f75f897dbb8e99f18cb25/68747470733a2f2f7363727574696e697a65722d63692e636f6d2f672f746172616e746f6f6c2d7068702f636c69656e742f6261646765732f7175616c6974792d73636f72652e706e673f623d6d6173746572)](https://scrutinizer-ci.com/g/tarantool-php/client/?branch=master)[![Code Coverage](https://camo.githubusercontent.com/08f4d87d2c6f0de22291bcd33bc962e881b755c4423d1b57167018ade9cf583f/68747470733a2f2f7363727574696e697a65722d63692e636f6d2f672f746172616e746f6f6c2d7068702f636c69656e742f6261646765732f636f7665726167652e706e673f623d6d6173746572)](https://scrutinizer-ci.com/g/tarantool-php/client/?branch=master)[![Telegram](https://camo.githubusercontent.com/fcbb762172f6027f3e2f84b45d2f561a6c730200c819552f3cf384015c3c782f/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f54656c656772616d2d6a6f696e253230636861742d626c75652e737667)](https://t.me/tarantool_php)

A pure PHP client for [Tarantool](https://www.tarantool.io/en/developers/) 1.7.1 or above.

Features
--------

[](#features)

- Written in pure PHP, no extensions are required
- Supports Unix domain sockets
- Supports SQL protocol
- Supports user-defined types (decimals and UUIDs are included)
- Highly customizable
- [Thoroughly tested](https://github.com/tarantool-php/client/actions?query=workflow%3AQA)
- Being used in a number of projects, including [Queue](https://github.com/tarantool-php/queue), [Mapper](https://github.com/tarantool-php/mapper), [Web Admin](https://github.com/basis-company/tarantool-admin)and [others](https://github.com/tarantool-php).

Table of contents
-----------------

[](#table-of-contents)

- [Installation](#installation)
- [Creating a client](#creating-a-client)
- [Handlers](#handlers)
- [Middleware](#middleware)
- [Data manipulation](#data-manipulation)
    - [Binary protocol](#binary-protocol)
    - [SQL protocol](#sql-protocol)
    - [User-defined types](#user-defined-types)
- [Tests](#tests)
- [Benchmarks](#benchmarks)
- [License](#license)

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

[](#installation)

The recommended way to install the library is through [Composer](http://getcomposer.org):

```
composer require tarantool/client
```

In order to use the [Decimal](https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/#the-decimal-type)type that was added in Tarantool 2.3, you additionally need to install the [decimal](http://php-decimal.io/#installation)extension. Also, to improve performance when working with the [UUID](https://www.tarantool.io/en/doc/latest/dev_guide/internals/msgpack_extensions/#the-uuid-type)type, which is available since Tarantool 2.4, it is recommended to additionally install the [uuid](https://pecl.php.net/package/uuid) extension.

Creating a client
-----------------

[](#creating-a-client)

The easiest way to create a client is by using the default configuration:

```
use Tarantool\Client\Client;

$client = Client::fromDefaults();
```

The client will be configured to connect to `127.0.0.1` on port `3301` with the default stream connection options. Also, the best available msgpack package will be chosen automatically. A custom configuration can be accomplished by one of several methods listed.

#### DSN string

[](#dsn-string)

The client supports the following Data Source Name formats:

```
tcp://[[username[:password]@]host[:port][/?option1=value1&optionN=valueN]
unix://[[username[:password]@]path[/?option1=value1&optionN=valueN]

```

Some examples:

```
use Tarantool\Client\Client;

$client = Client::fromDsn('tcp://127.0.0.1');
$client = Client::fromDsn('tcp://[fe80::1]:3301');
$client = Client::fromDsn('tcp://user:pass@example.com:3301');
$client = Client::fromDsn('tcp://user@example.com/?connect_timeout=5.0&max_retries=3');
$client = Client::fromDsn('unix:///var/run/tarantool/my_instance.sock');
$client = Client::fromDsn('unix://user:pass@/var/run/tarantool/my_instance.sock?max_retries=3');
```

If the username, password, path or options include special characters such as `@`, `:`, `/` or `%`, they must be encoded according to [RFC 3986](https://tools.ietf.org/html/rfc3986#section-2.1)(for example, with the [rawurlencode()](https://www.php.net/manual/en/function.rawurlencode.php) function).

#### Array of options

[](#array-of-options)

It is also possible to create the client from an array of configuration options:

```
use Tarantool\Client\Client;

$client = Client::fromOptions([
    'uri' => 'tcp://127.0.0.1:3301',
    'username' => '',
    'password' => '',
    ...
);
```

The following options are available:

NameTypeDefaultDescription*uri*string'tcp://127.0.0.1:3301'The connection uri that is used to create a `StreamConnection` object.*connect\_timeout*float5.0The number of seconds that the client waits for a connect to a Tarantool server before throwing a `ConnectionFailed` exception.*socket\_timeout*float5.0The number of seconds that the client waits for a respond from a Tarantool server before throwing a `CommunicationFailed` exception.*tcp\_nodelay*booleantrueWhether the Nagle algorithm is disabled on a TCP connection.*persistent*booleanfalseWhether to use a persistent connection.*username*stringThe username for the user being authenticated.*password*string''The password for the user being authenticated. If the username is not set, this option will be ignored.*max\_retries*integer0The number of times the client retries unsuccessful request. If set to 0, the client does not try to resend the request after the initial unsuccessful attempt.#### Custom build

[](#custom-build)

For more deep customisation, you can build a client from the ground up:

```
use MessagePack\BufferUnpacker;
use MessagePack\Packer;
use Tarantool\Client\Client;
use Tarantool\Client\Connection\StreamConnection;
use Tarantool\Client\Handler\DefaultHandler;
use Tarantool\Client\Handler\MiddlewareHandler;
use Tarantool\Client\Middleware\AuthenticationMiddleware;
use Tarantool\Client\Middleware\RetryMiddleware;
use Tarantool\Client\Packer\PurePacker;

$connection = StreamConnection::createTcp('tcp://127.0.0.1:3301', [
    'socket_timeout' => 5.0,
    'connect_timeout' => 5.0,
    // ...
]);

$pureMsgpackPacker = new Packer();
$pureMsgpackUnpacker = new BufferUnpacker();
$packer = new PurePacker($pureMsgpackPacker, $pureMsgpackUnpacker);

$handler = new DefaultHandler($connection, $packer);
$handler = MiddlewareHandler::append($handler, [
    RetryMiddleware::exponential(3),
    new AuthenticationMiddleware('', ''),
    // ...
]);

$client = new Client($handler);
```

Handlers
--------

[](#handlers)

A handler is a function which transforms a request into a response. Once you have created a handler object, you can make requests to Tarantool, for example:

```
use Tarantool\Client\Keys;
use Tarantool\Client\Request\CallRequest;

...

$request = new CallRequest('box.stat');
$response = $handler->handle($request);
$data = $response->getBodyField(Keys::DATA);
```

The library ships with two handlers:

- `DefaultHandler` is used for handling low-level communication with a Tarantool server
- `MiddlewareHandler` is used as an extension point for an underlying handler via [middleware](#middleware)

Middleware
----------

[](#middleware)

Middleware is the suggested way to extend the client with custom functionality. There are several middleware classes implemented to address the common use cases, like authentification, logging and [more](src/Middleware). The usage is straightforward:

```
use Tarantool\Client\Client;
use Tarantool\Client\Middleware\AuthenticationMiddleware;

$client = Client::fromDefaults()->withMiddleware(
    new AuthenticationMiddleware('', '')
);
```

You may also assign multiple middleware to the client (they will be executed in [FIFO](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics)) order):

```
use Tarantool\Client\Client;
use Tarantool\Client\Middleware\FirewallMiddleware;
use Tarantool\Client\Middleware\LoggingMiddleware;
use Tarantool\Client\Middleware\RetryMiddleware;

...

$client = Client::fromDefaults()->withMiddleware(
    FirewallMiddleware::allowReadOnly(),
    RetryMiddleware::linear(),
    new LoggingMiddleware($logger)
);
```

Please be aware that the order in which you add the middleware does matter. The same middleware, placed in different order, can give very different or sometimes unexpected behavior. To illustrate, consider the following configurations:

```
$client1 = Client::fromDefaults()->withMiddleware(
    RetryMiddleware::linear(),
    new AuthenticationMiddleware('', '')
);

$client2 = Client::fromDefaults()->withMiddleware(
    new AuthenticationMiddleware('', ''),
    RetryMiddleware::linear()
);

$client3 = Client::fromOptions([
    'username' => '',
    'password' => '',
])->withMiddleware(RetryMiddleware::linear());
```

In this example, `$client1` will retry an unsuccessful operation and in case of connection problems may initiate reconnection with follow-up re-authentication. However, `$client2`and `$client3` will perform reconnection *without* doing any re-authentication.

> *You may wonder why `$client3` behaves like `$client2` in this case. This is because specifying some options (via array or DSN string) may implicitly register middleware. Thus, the `username/password` options will be turned into `AuthenticationMiddleware`under the hood, making the two configurations identical.*

To make sure your middleware runs first, use the `withPrependedMiddleware()` method:

```
$client = $client->withPrependedMiddleware($myMiddleware);
```

Data manipulation
-----------------

[](#data-manipulation)

### Binary protocol

[](#binary-protocol)

The following are examples of binary protocol requests. For more detailed information and examples please see the [official documentation](https://www.tarantool.io/en/doc/latest/book/box/data_model/#operations).

**Select**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
space:create_index('secondary', {type = 'tree', unique = false, parts = {2, 'str'}})
space:insert({1, 'foo'})
space:insert({2, 'bar'})
space:insert({3, 'bar'})
space:insert({4, 'bar'})
space:insert({5, 'baz'})
```

*Code*

```
$space = $client->getSpace('example');
$result1 = $space->select(Criteria::key([1]));
$result2 = $space->select(Criteria::index('secondary')
    ->andKey(['bar'])
    ->andLimit(2)
    ->andOffset(1)
);

printf("Result 1: %s\n", json_encode($result1));
printf("Result 2: %s\n", json_encode($result2));
```

*Output*

```
Result 1: [[1,"foo"]]
Result 2: [[3,"bar"],[4,"bar"]]

```

**Insert**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
```

*Code*

```
$space = $client->getSpace('example');
$result = $space->insert([1, 'foo', 'bar']);

printf("Result: %s\n", json_encode($result));
```

*Output*

```
Result: [[1,"foo","bar"]]

```

*Space data*

```
tarantool> box.space.example:select()
---
- - [1, 'foo', 'bar']
...
```

**Update**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
space:format({
    {name = 'id', type = 'unsigned'},
    {name = 'num', type = 'unsigned'},
    {name = 'name', type = 'string'}
})

space:insert({1, 10, 'foo'})
space:insert({2, 20, 'bar'})
space:insert({3, 30, 'baz'})
```

*Code*

```
$space = $client->getSpace('example');
$result = $space->update([2], Operations::add(1, 5)->andSet(2, 'BAR'));

// Since Tarantool 2.3 you can refer to tuple fields by name:
// $result = $space->update([2], Operations::add('num', 5)->andSet('name', 'BAR'));

printf("Result: %s\n", json_encode($result));
```

*Output*

```
Result: [[2,25,"BAR"]]

```

*Space data*

```
tarantool> box.space.example:select()
---
- - [1, 10, 'foo']
  - [2, 25, 'BAR']
  - [3, 30, 'baz']
...
```

**Upsert**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
space:format({
    {name = 'id', type = 'unsigned'},
    {name = 'name1', type = 'string'},
    {name = 'name2', type = 'string'}
})
```

*Code*

```
$space = $client->getSpace('example');
$space->upsert([1, 'foo', 'bar'], Operations::set(1, 'baz'));
$space->upsert([1, 'foo', 'bar'], Operations::set(2, 'qux'));

// Since Tarantool 2.3 you can refer to tuple fields by name:
// $space->upsert([1, 'foo', 'bar'], Operations::set('name1', 'baz'));
// $space->upsert([1, 'foo', 'bar'], Operations::set('name2'', 'qux'));
```

*Space data*

```
tarantool> box.space.example:select()
---
- - [1, 'foo', 'qux']
...
```

**Replace**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
space:insert({1, 'foo'})
space:insert({2, 'bar'})
```

*Code*

```
$space = $client->getSpace('example');
$result1 = $space->replace([2, 'BAR']);
$result2 = $space->replace([3, 'BAZ']);

printf("Result 1: %s\n", json_encode($result1));
printf("Result 2: %s\n", json_encode($result2));
```

*Output*

```
Result 1: [[2,"BAR"]]
Result 2: [[3,"BAZ"]]

```

*Space data*

```
tarantool> box.space.example:select()
---
- - [1, 'foo']
  - [2, 'BAR']
  - [3, 'BAZ']
...
```

**Delete**
*Fixtures*

```
local space = box.schema.space.create('example')
space:create_index('primary', {type = 'tree', parts = {1, 'unsigned'}})
space:create_index('secondary', {type = 'tree', parts = {2, 'str'}})
space:insert({1, 'foo'})
space:insert({2, 'bar'})
space:insert({3, 'baz'})
space:insert({4, 'qux'})
```

*Code*

```
$space = $client->getSpace('example');
$result1 = $space->delete([2]);
$result2 = $space->delete(['baz'], 'secondary');

printf("Result 1: %s\n", json_encode($result1));
printf("Result 2: %s\n", json_encode($result2));
```

*Output*

```
Result 1: [[2,"bar"]]
Result 2: [[3,"baz"]]

```

*Space data*

```
tarantool> box.space.example:select()
---
- - [1, 'foo']
  - [4, 'qux']
...
```

**Call**
*Fixtures*

```
function func_42()
    return 42
end
```

*Code*

```
$result1 = $client->call('func_42');
$result2 = $client->call('math.min', 5, 3, 8);

printf("Result 1: %s\n", json_encode($result1));
printf("Result 2: %s\n", json_encode($result2));
```

*Output*

```
Result 1: [42]
Result 2: [3]

```

**Evaluate**
*Code*

```
$result1 = $client->evaluate('function func_42() return 42 end');
$result2 = $client->evaluate('return func_42()');
$result3 = $client->evaluate('return math.min(...)', 5, 3, 8);

printf("Result 1: %s\n", json_encode($result1));
printf("Result 2: %s\n", json_encode($result2));
printf("Result 3: %s\n", json_encode($result3));
```

*Output*

```
Result 1: []
Result 2: [42]
Result 3: [3]

```

### SQL protocol

[](#sql-protocol)

The following are examples of SQL protocol requests. For more detailed information and examples please see the [official documentation](https://www.tarantool.io/en/doc/latest/reference/reference_sql/sql/). *Note that SQL is supported only as of Tarantool 2.0.*

**Execute**
*Code*

```
$client->execute('CREATE TABLE users ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "email" VARCHAR(255))');

$result1 = $client->executeUpdate('CREATE UNIQUE INDEX email ON users ("email")');

$result2 = $client->executeUpdate('
    INSERT INTO users VALUES (null, :email1), (null, :email2)
',
    [':email1' => 'foo@example.com'],
    [':email2' => 'bar@example.com']
);

$result3 = $client->executeQuery('SELECT * FROM users WHERE "email" = ?', 'foo@example.com');
$result4 = $client->executeQuery('SELECT * FROM users WHERE "id" IN (?, ?)', 1, 2);

printf("Result 1: %s\n", json_encode([$result1->count(), $result1->getAutoincrementIds()]));
printf("Result 2: %s\n", json_encode([$result2->count(), $result2->getAutoincrementIds()]));
printf("Result 3: %s\n", json_encode([$result3->count(), $result3[0]]));
printf("Result 4: %s\n", json_encode(iterator_to_array($result4)));
```

*Output*

```
Result 1: [1,[]]
Result 2: [2,[1,2]]
Result 3: [1,{"id":1,"email":"foo@example.com"}]
Result 4: [{"id":1,"email":"foo@example.com"},{"id":2,"email":"bar@example.com"}]

```

If you need to execute a dynamic SQL statement whose type you don't know, you can use the generic method `execute()`. This method returns a Response object with the body containing either an array of result set rows or an array with information about the changed rows:

```
$response = $client->execute('');
$resultSet = $response->tryGetBodyField(Keys::DATA);

if ($resultSet === null) {
    $sqlInfo = $response->getBodyField(Keys::SQL_INFO);
    $affectedCount = $sqlInfo[Keys::SQL_INFO_ROW_COUNT];
}
```

**Prepare**
*Note that the `prepare` request is supported only as of Tarantool 2.3.2.*

*Code*

```
$client->execute('CREATE TABLE users ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" VARCHAR(50))');

$stmt = $client->prepare('INSERT INTO users VALUES(null, ?)');
for ($i = 1; $i execute("name_$i");
    // You can also use executeSelect() and executeUpdate(), e.g.:
    // $lastInsertIds = $stmt->executeUpdate("name_$i")->getAutoincrementIds();
}
$stmt->close();

// Note the SEQSCAN keyword in the query. It is available as of Tarantool 2.11.
// If you are using an older version of Tarantool, omit this keyword.
$result = $client->executeQuery('SELECT COUNT("id") AS "cnt" FROM SEQSCAN users');

printf("Result: %s\n", json_encode($result[0]));
```

*Output*

```
Result: {"cnt":100}

```

### User-defined types

[](#user-defined-types)

To store complex structures inside a tuple you may want to use objects:

```
$space->insert([42, Money::EUR(500)]);
[[$id, $money]] = $space->select(Criteria::key([42]));
```

This can be achieved by extending the MessagePack type system with your own types. To do this, you need to write a MessagePack extension that converts your objects into MessagePack structures and back (for more details, read the msgpack.php's [README](https://github.com/rybakit/msgpack.php#custom-types)). Once you have implemented your extension, you should register it with the packer object:

```
$packer = PurePacker::fromExtensions(new MoneyExtension());
$client = new Client(new DefaultHandler($connection, $packer));
```

> *A working example of using the user-defined types can be found in the [examples](examples/user_defined_type) folder.*

Tests
-----

[](#tests)

To run unit tests:

```
vendor/bin/phpunit --testsuite unit
```

To run integration tests:

```
vendor/bin/phpunit --testsuite integration
```

> *Make sure to start [client.lua](tests/Integration/client.lua) first.*

To run all tests:

```
vendor/bin/phpunit
```

If you already have Docker installed, you can run the tests in a docker container. First, create a container:

```
./dockerfile.sh | docker build -t client -
```

The command above will create a container named `client` with PHP 8.3 runtime. You may change the default runtime by defining the `PHP_IMAGE` environment variable:

```
PHP_IMAGE='php:8.2-cli' ./dockerfile.sh | docker build -t client -
```

> *See a list of various images [here](https://hub.docker.com/_/php).*

Then run a Tarantool instance (needed for integration tests):

```
docker network create tarantool-php
docker run -d --net=tarantool-php -p 3301:3301 --name=tarantool \
    -v $(pwd)/tests/Integration/client.lua:/client.lua \
    tarantool/tarantool:3 tarantool /client.lua
```

And then run both unit and integration tests:

```
docker run --rm --net=tarantool-php -v $(pwd):/client -w /client client
```

Benchmarks
----------

[](#benchmarks)

The benchmarks can be found in the [dedicated repository](https://github.com/tarantool-php/benchmarks).

License
-------

[](#license)

The library is released under the MIT License. See the bundled [LICENSE](LICENSE) file for details.

###  Health Score

47

—

FairBetter than 94% of packages

Maintenance39

Infrequent updates — may be unmaintained

Popularity51

Moderate usage in the ecosystem

Community34

Small or concentrated contributor base

Maturity57

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 95.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 ~201 days

Recently: every ~366 days

Total

16

Last Release

697d ago

PHP version history (5 changes)v0.1.0PHP ^5.4|^7.0

v0.3.0PHP ^5.6|^7.0

v0.5.0PHP ^7.1

v0.9.0PHP ^7.1|^8

v0.10.0PHP ^7.2.5|^8

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/533861?v=4)[Eugene Leonovich](/maintainers/rybakit)[@rybakit](https://github.com/rybakit)

---

Top Contributors

[![rybakit](https://avatars.githubusercontent.com/u/533861?v=4)](https://github.com/rybakit "rybakit (410 commits)")[![ylobankov](https://avatars.githubusercontent.com/u/3645987?v=4)](https://github.com/ylobankov "ylobankov (3 commits)")[![nekufa](https://avatars.githubusercontent.com/u/405067?v=4)](https://github.com/nekufa "nekufa (3 commits)")[![DifferentialOrange](https://avatars.githubusercontent.com/u/20455996?v=4)](https://github.com/DifferentialOrange "DifferentialOrange (2 commits)")[![AlgebraicWolf](https://avatars.githubusercontent.com/u/36044777?v=4)](https://github.com/AlgebraicWolf "AlgebraicWolf (2 commits)")[![nshy](https://avatars.githubusercontent.com/u/1797510?v=4)](https://github.com/nshy "nshy (2 commits)")[![xBazilio](https://avatars.githubusercontent.com/u/4119114?v=4)](https://github.com/xBazilio "xBazilio (1 commits)")[![drewdzzz](https://avatars.githubusercontent.com/u/54822306?v=4)](https://github.com/drewdzzz "drewdzzz (1 commits)")[![Buristan](https://avatars.githubusercontent.com/u/37304959?v=4)](https://github.com/Buristan "Buristan (1 commits)")[![terehov-space](https://avatars.githubusercontent.com/u/71380522?v=4)](https://github.com/terehov-space "terehov-space (1 commits)")[![icamys](https://avatars.githubusercontent.com/u/6891299?v=4)](https://github.com/icamys "icamys (1 commits)")[![ja1cap](https://avatars.githubusercontent.com/u/2099802?v=4)](https://github.com/ja1cap "ja1cap (1 commits)")

---

Tags

luanosqlphpsqltarantooltarantool-clienttarantool-connectorclientnosqlpuretarantool

###  Code Quality

Static AnalysisPsalm

Code StylePHP CS Fixer

Type Coverage Yes

### Embed Badge

![Health badge](/badges/tarantool-client/health.svg)

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

###  Alternatives

[tarantool/mapper

PHP Object Mapper for Tarantool.

6862.4k4](/packages/tarantool-mapper)[clue/redis-react

Async Redis client implementation, built on top of ReactPHP.

28210.5M45](/packages/clue-redis-react)[basho/riak

Official Riak client for PHP

159246.7k7](/packages/basho-riak)[mroosz/php-cassandra

A pure-PHP client for Apache Cassandra and ScyllaDB with support for CQL binary protocol v3, v4 and v5 (Cassandra 2.1+ incl. 3.x-5.x; ScyllaDB 6.2 and 2025.x), synchronous and asynchronous APIs, prepared statements, batches, result iterators, object mapping, SSL/TLS, and LZ4 compression.

205.6k2](/packages/mroosz-php-cassandra)[chocofamilyme/laravel-tarantool

A Tarantool based Eloquent ORM and Query builder for Laravel

182.3k](/packages/chocofamilyme-laravel-tarantool)

PHPackages © 2026

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