PHPackages                             callismart/dbprism - 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. callismart/dbprism

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

callismart/dbprism
==================

DBPrism: Intent-based database abstraction layer with unified adapters, schema inspection, and migrations. Supports MySQL, PostgreSQL, SQLite, PDO, and WordPress.

v0.1.29(1w ago)019↓62.5%MITPHPPHP ^8.1

Since May 20Pushed 4d agoCompare

[ Source](https://github.com/CallismartLtd/DBPrism)[ Packagist](https://packagist.org/packages/callismart/dbprism)[ Docs](https://github.com/callismart/dbprism)[ RSS](/packages/callismart-dbprism/feed)WikiDiscussions master Synced 1w ago

READMEChangelog (4)Dependencies (4)Versions (13)Used By (0)

DBPrism
=======

[](#dbprism)

> **Refract your queries across any database.**
>
> Intent-based database abstraction layer with unified adapters, schema inspection, and migrations. Write once. Query everywhere.

[![PHP Version](https://camo.githubusercontent.com/7663c9d53dc13cedaf0660a8745a7e77d2dd711257f36aa86ebce12a0600ef42/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d253345253344382e312d626c75652e737667)](https://www.php.net)[![License: MIT](https://camo.githubusercontent.com/fdf2982b9f5d7489dcf44570e714e3a15fce6253e0cc6b5aa61a075aac2ff71b/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c6963656e73652d4d49542d79656c6c6f772e737667)](https://opensource.org/licenses/MIT)

---

Table of Contents
-----------------

[](#table-of-contents)

- [What is DBPrism?](#what-is-dbprism)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Supported Databases](#supported-databases)
- [Query Building API](#query-building-api)
    - [SELECT Queries](#select-queries)
    - [INSERT Queries](#insert-queries)
    - [UPDATE Queries](#update-queries)
    - [DELETE Queries](#delete-queries)
- [Schema Operations](#schema-operations)
- [Schema Inspection](#schema-inspection)
- [Migrations](#migrations)
- [API Reference](#api-reference)

---

What is DBPrism?
----------------

[](#what-is-dbprism)

DBPrism is a sophisticated, framework-agnostic database abstraction layer that unifies database operations across **MySQL**, **PostgreSQL**, and **SQLite**.

Like a prism refracting light into its component colors, DBPrism takes your query intents and refracts them into engine-specific SQL—transparently, elegantly, and efficiently.

### Core Features

[](#core-features)

- **🔄 Unified Adapters** — Single API for 5+ database engines
- **🎯 Intent-Based Query Building** — Declarative query construction with automatic SQL rendering
- **🔍 Schema Inspection** — Deep schema introspection across all engines
- **🚀 Migrations** — Fluent migration API with helpers for schema transformations
- **⚡ Multi-Engine Rendering** — One query intent → Multiple engine-specific SQL outputs
- **💪 Type Normalization** — Consistent column types across databases
- **🧩 Framework-Agnostic** — Works standalone or integrated with any framework

---

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

[](#installation)

```
composer require callismart/dbprism
```

**Requirements:**

- PHP 8.1+
- One or more: MySQLi, PDO, PostgreSQL, SQLite extensions

---

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

[](#quick-start)

### 1. Initialize the Database

[](#1-initialize-the-database)

```
use Callismart\DBPrism\Database;
use Callismart\DBPrism\Adapters\MysqliAdapter;
use Callismart\DBPrism\DBConfigDTO;

$config = new DBConfigDTO([
    'host'     => 'localhost',
    'username' => 'root',
    'password' => 'secret',
    'dbname'   => 'myapp',
    'driver'   => 'mysql',
]);

$adapter = new MysqliAdapter($config);
$db = new Database($adapter);
```

### 2. Execute Simple Queries

[](#2-execute-simple-queries)

```
// Insert
$user_id = $db->insert('users', [
    'name'  => 'John Doe',
    'email' => 'john@example.com',
]);

// Fetch
$user = $db->get_row('SELECT * FROM users WHERE id = ?', [$user_id]);

// Update
$db->update('users',
    ['status' => 'active'],
    ['id' => $user_id]
);

// Delete
$db->delete('users', ['id' => $user_id]);
```

### 3. Build Complex Queries with Intents

[](#3-build-complex-queries-with-intents)

```
use Callismart\DBPrism\Query\SQLBuilder;

$builder = new SQLBuilder($db->get_driver());

// Build a SELECT query
$intent = $builder->select('id', 'name', 'email')
    ->from('users')
    ->where('status', '=', 'active')
    ->where('created_at', '>', '2024-01-01')
    ->order_by('created_at', 'DESC')
    ->limit(10);

$sql = $intent->build();
$bindings = $intent->get_bindings();

$users = $db->get_results($sql, $bindings);
```

---

Supported Databases
-------------------

[](#supported-databases)

### MySQL / MariaDB

[](#mysql--mariadb)

```
use Callismart\DBPrism\Adapters\MysqliAdapter;

$config = new DBConfigDTO([
    'host'     => 'localhost',
    'username' => 'root',
    'password' => 'secret',
    'dbname'   => 'myapp',
    'driver'   => 'mysql',
]);

$adapter = new MysqliAdapter($config);
$db = new Database($adapter);
```

### PostgreSQL

[](#postgresql)

```
use Callismart\DBPrism\Adapters\PostgresAdapter;

$config = new DBConfigDTO([
    'host'     => 'localhost',
    'username' => 'postgres',
    'password' => 'secret',
    'dbname'   => 'myapp',
    'driver'   => 'pgsql',
]);

$adapter = new PostgresAdapter($config);
$db = new Database($adapter);
```

### SQLite

[](#sqlite)

```
use Callismart\DBPrism\Adapters\SqliteAdapter;

$config = new DBConfigDTO([
    'dbname' => '/path/to/database.sqlite',
    'driver' => 'sqlite',
]);

$adapter = new SqliteAdapter($config);
$db = new Database($adapter);
```

### PDO (Universal)

[](#pdo-universal)

```
use Callismart\DBPrism\Adapters\PdoAdapter;

$config = new DBConfigDTO([
    'dsn'      => 'mysql:host=localhost;dbname=myapp',
    'username' => 'root',
    'password' => 'secret',
    'driver'   => 'pdo',
]);

$adapter = new PdoAdapter($config);
$db = new Database($adapter);
```

### WordPress

[](#wordpress)

```
use Callismart\DBPrism\Adapters\WPDBAdapter;

$adapter = new WPDBAdapter();
$db = new Database($adapter);
```

---

Query Building API
------------------

[](#query-building-api)

### SELECT Queries

[](#select-queries)

Select queries are built using the `SelectionIntent` class, accessed via `SQLBuilder::select()`.

#### Basic SELECT

[](#basic-select)

```
$builder = new SQLBuilder('mysql');

$intent = $builder->select('id', 'name', 'email')
    ->from('users');

$sql = $intent->build();
// SELECT `id`, `name`, `email` FROM `users`;
```

#### SELECT with WHERE Conditions

[](#select-with-where-conditions)

```
$intent = $builder->select('*')
    ->from('orders')
    ->where('status', '=', 'completed')
    ->where('total', '>', 100);

$sql = $intent->build();
$bindings = $intent->get_bindings();
```

#### WHERE Operators & Conditions

[](#where-operators--conditions)

```
// Basic comparison
->where('age', '>=', 18)
->where('name', '!=', 'Admin')
->where('email', 'LIKE', '%@example.com')

// IS NULL / IS NOT NULL
->where_null('deleted_at')
->where_not_null('verified_at')

// Direct SQL operators
->where('deleted_at', 'IS NULL')
->where('verified_at', 'IS NOT NULL')

// IN / NOT IN
->where_in('status', ['active', 'pending'])
->where_not_in('role', ['banned', 'suspended'])

// BETWEEN / NOT BETWEEN
->where_between('age', 18, 65)
->where_not_between('created_at', '2023-01-01', '2023-12-31')

// OR conditions
->where('status', '=', 'active')
->or_where('status', '=', 'pending')

// Grouped conditions
->where_group(function($q) {
    $q->where('status', '=', 'active')
      ->or_where('status', '=', 'pending');
})

// Raw SQL
->where_raw('YEAR(created_at) = 2024', [])
```

#### JOINs

[](#joins)

```
// INNER JOIN
->join('orders', 'users.id', '=', 'orders.user_id')

// LEFT JOIN
->left_join('profiles', 'users.id', '=', 'profiles.user_id')

// RIGHT JOIN
->right_join('departments', 'employees.dept_id', '=', 'departments.id')

// CROSS JOIN
->cross_join('statuses')
```

#### GROUP BY, ORDER BY, LIMIT/OFFSET

[](#group-by-order-by-limitoffset)

```
$intent = $builder->select('category', 'COUNT(*) as total')
    ->from('products')
    ->group_by('category')
    ->order_by('total', 'DESC')
    ->limit(10)
    ->offset(0);

$sql = $intent->build();
```

### INSERT Queries

[](#insert-queries)

Insert queries are built using the `PersistenceIntent` class, accessed via `SQLBuilder::insert()`.

#### Single Row Insert

[](#single-row-insert)

```
$intent = $builder->insert('users')
    ->values([
        'name'       => 'John Doe',
        'email'      => 'john@example.com',
        'password'   => hash('sha256', 'secret'),
    ]);

$sql = $intent->build();
$bindings = $intent->get_bindings();
```

#### Multi-Row Insert (Bulk)

[](#multi-row-insert-bulk)

```
$intent = $builder->insert('users')
    ->multi_values([
        ['name' => 'John Doe', 'email' => 'john@example.com'],
        ['name' => 'Jane Smith', 'email' => 'jane@example.com'],
        ['name' => 'Bob Wilson', 'email' => 'bob@example.com'],
    ]);

$sql = $intent->build();
```

#### Insert with SET Alias

[](#insert-with-set-alias)

```
$intent = $builder->insert('users')
    ->set(['name' => 'John Doe', 'email' => 'john@example.com']);
```

### UPDATE Queries

[](#update-queries)

Update queries are built using the `PersistenceIntent` class, accessed via `SQLBuilder::update()`.

#### Basic UPDATE

[](#basic-update)

```
$intent = $builder->update('users')
    ->set([
        'status'     => 'inactive',
        'updated_at' => date('Y-m-d H:i:s'),
    ])
    ->where('id', '=', 1);

$sql = $intent->build();
```

#### UPDATE with Multiple WHERE Conditions

[](#update-with-multiple-where-conditions)

```
$intent = $builder->update('users')
    ->set([
        'verified' => true,
        'verified_at' => date('Y-m-d H:i:s'),
    ])
    ->where('email_confirmed', '=', true)
    ->where_null('deleted_at')
    ->where_in('status', ['pending', 'new']);
```

### DELETE Queries

[](#delete-queries)

Delete queries are built using the `DeleteIntent` class, accessed via `SQLBuilder::delete()`.

#### Basic DELETE

[](#basic-delete)

```
$intent = $builder->delete('users')
    ->where('id', '=', 1);

$sql = $intent->build();
```

#### DELETE with Multiple Conditions

[](#delete-with-multiple-conditions)

```
$intent = $builder->delete('sessions')
    ->where('user_id', '=', 5)
    ->where('expires_at', '