Postgres Stored Procedure Call in PHP

Introduction

PostgreSQL allows for expansion of database functionality by creating specialized user-defined functions. These functions are often referred to as stored procedures that permit for more effective creation of various customized procedural roles. Once created, stored procedures can then be executed as needed to increase the ease and speed of database workflow applications. This tutorial will explain how to set up, execute and provide examples for using the Postgres stored procedure call in PHP.

Prerequisites

  • A basic working knowledge of PostgreSQL is required to execute the Postgres stored procedure call in PHP.

  • PostgreSQL must be properly installed and configured on the local system.

  • PHP must be properly installed on the local system, in either the standalone version or as part of a package installer like XAMPP.

  • Composer must also be properly installed on the local system.

What is Postgres Stored Procedure

Ultimately, stored procedures allows for faster, easier and more effective creation of customized functions. The Postgres stored procedures function is used for defining customized aggregate functions or creating specific triggers. Stored procedures add various procedural functions, such as advance calculations and control structure.

Following is the basic structure of a stored procedure in Postgres:

1
2
3
4
5
CREATE [OR REPLACE] PROCEDURE <name_of_the_procdure>(list_of_parameter)
AS $$
    body_of_the_procedure;
$$;
LANGUAGE language_name

Following is a breakdown of the above command:

1) The name of the procedure is specified immediately after the CREATE PROCEDURE clause. 2) The list of parameters is then defined. 3) The actual procedure is placed inside the body_of_the_procedure block, right after the AS keyword. 4) To end the procedure, the stored procedure is enclosed using the $$ double dollar sign.

Note that the programming language can also be specified using the stored procedure in either SQL or PLpgSQL.

Creating Sample Dataset

The section will explain how to create some sample datasets that will be used to execute the examples in this tutorial.

First, log into the Postgres shell and then:

  • Create database with the following command:
1
create database product
  • Next, create tables for the database as follows:
1
2
3
4
5
6
7
8
CREATE TABLE IF NOT EXISTS stock (
    id SERIAL PRIMARY KEY,
    product_name CHARACTER VARYING(100),
    sku CHARACTER VARYING(100),
    description CHARACTER VARYING(100),
    quantity INT

);

Now, insert sample records in the “stock” table as shown here:

1
2
3
4
5
6
7
INSERT INTO stock (id, product_name, sku, description, quantity)
VALUES
   (1,'fire extinguisher','PR0300', 'Fire repellant chemical', 300),
   (2,'Facial Visor','PR0310', 'Facial protective gear', 300),
   (3,'Medical Gown','PR0311', 'Protective gear', 240),
   (4,'Rubber Boots','PR0321', 'Electricity protective gear', 500),
   (5,'Back Pack','PR0321', 'Ordinary Back pack', 500);

The table should now resemble this:

1
2
3
4
5
6
7
8
 id |   product_name    |  sku   |         description         | quantity
----+-------------------+--------+-----------------------------+----------
  1 | fire extinguisher | PR0300 | Fire repellant chemical     |      300
  2 | Facial Visor      | PR0310 | Facial protective gear      |      300
  3 | Medical Gown      | PR0311 | Protective gear             |      240
  4 | Rubber Boots      | PR0321 | Electricity protective gear |      500
  5 | Back Pack         | PR0321 | Ordinary Back pack          |      500
(5 rows)

Project Structure

This section will explain the overall structure of our project. The following screenshot provides an overview:

Stored Procedure in PostgreSQL Example

This section will cover creating the Postgres stored procedure. In the following example the goal is to add two (2) integers and return the value to the user:

1
2
3
4
5
6
7
8
CREATE OR REPLACE FUNCTION sum_it_up(
    x INTEGER,
    y INTEGER)
  RETURNS INTEGER AS $$
BEGIN
RETURN x + y;
END; $$
  LANGUAGE 'plpgsql';

Execute the following steps to execute the Postgres stored procedure call in PHP:

1) Connect to the target database. 2) Create a statement that will call the stored procedure via the prepare() method of the PDO object. 3) Use the bindValue() method as an option to pass the values into the statement. 4) Execute the procedure using the execute() method.

5) The value will be returned via the fethColumn() method and will return one column of the succeeding row within the result set.

Now the phpStock.php file can be modified using the following script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
namespace phpprocedurecall;

class phpStock {

    private $pdo;
 
    /**
     * Initialize the object with a specified PDO object
     * @param \PDO $pdo
     */

    public function __construct($pdo) {
        $this->pdo = $pdo;
    }


 /**
     * We call the simple stored procedure that we created named sum_it_up
     * @param int $x
     * @param int $y
     * @return int
     */

    public function sum_it_up($x, $y) {
        $stmt = $this->pdo->prepare('SELECT * FROM sum_it_up(:x,:y)');
        $stmt->setFetchMode(\PDO::FETCH_ASSOC);
        $stmt->execute([
            ':x' => $x,
            ':y' => $y
        ]);
        return $stmt->fetchColumn(0);
    }
}

Note that in order to execute the above script it is necessary to modify the index.php file as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
 
require 'vendor/autoload.php';
 
use phpprocedurecall\Connection as Connection;
use phpprocedurecall\phpStock as phpStock;
 
try {
    // connect to the PostgreSQL database
    $pdo = Connection::get()->connect();

    $phpStock = new phpStock($pdo);
 
    $result = $phpStock->sum_it_up(24, 35);
    echo $result;
   
} catch (\PDOException $e) {
    echo $e->getMessage();
}

Now test the example in a browser using the following URL: http://localhost/phpprocedurecall/index.php

If everything was done correctly, the output should be 59.

Stored Procedure Returning a Result Set

This section will explain how to use the stored procedure to retrieve data from a database.

The query for the stored procedure is as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CREATE OR REPLACE FUNCTION get_all_stock()
  RETURNS TABLE(id INTEGER,
                product_name CHARACTER VARYING,
                sku CHARACTER VARYING,
                description CHARACTER VARYING,
                quantity INTEGER) AS
$$
BEGIN
 RETURN QUERY
 
 SELECT *
 FROM stock;
END; $$
 
LANGUAGE plpgsql;

Here is the script for the ‘index.php’ file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<?php
require 'vendor/autoload.php';
 
use phpprocedurecall\Connection as Connection;
use phpprocedurecall\phpStock as phpStock;
 
try {
    // connect to the PostgreSQL database
    $pdo = Connection::get()->connect();
    //
    $stockItems = new phpStock($pdo);
   
    $stocks = $stockItems->get_all_stock();
   
} catch (\PDOException $e) {
    echo $e->getMessage();
}
?>
<!DOCTYPE html>
<html>
    <head>
        <title>PostgreSQL Stored Procedure</title>
        <link rel="stylesheet" href="https://cdn.rawgit.com/twbs/bootstrap/v4-dev/dist/css/bootstrap.css">
    </head>
    <body>
        <div class="container">
            <h1>Stock Listing</h1>
            <table class="table table-bordered">
            <thead>
                    <tr>
                        <th>ID</th>
                        <th>Product Name</th>
                        <th>SKU</th>
                        <th>Description</th>
                        <th>Quantity</th>
                    </tr>
                </thead>
                <tbody>
                    <?php foreach ($stocks as $stock) : ?>
                        <tr>
                            <td><?php echo htmlspecialchars($stock['id']) ?></td>
                            <td><?php echo htmlspecialchars($stock['product_name']); ?></td>
                            <td><?php echo htmlspecialchars($stock['sku']); ?></td>
                            <td><?php echo htmlspecialchars($stock['description']); ?></td>
                            <td><?php echo htmlspecialchars($stock['quantity']); ?></td>
                        </tr>
                    <?php endforeach; ?>
                </tbody>
            </table>
        </div>
    </body>
</html>

Now test the PHP application using the following URL: ‘http://localhost/phpprocedurecall/index.php’

The output should resemble the following image:

Conclusion

This tutorial explained how to use the Postgres stored procedure call in PHP to quickly and easily create customized functions. The tutorial provided an overview of the Postgres stored procedure, explained the basic structure of a stored procedure in Postgres and provided a breakdown of the basic command structure. The article then explained how to create a sample dataset, table and how to add records to the new table. The tutorial then gave an example for creating the project structure, storing the procedure and how to test the application. Remember that the programming language can be specified in either SQL or PLpgSQL when creating the basic structure for a stored procedure in Postgres.

The Code

Below are the code for other files that we used in this tutorial

Connection.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
<?php
 
namespace phpquery;
 
/**
 * Represent the Connection
 */

class Connection {
 
    /**
     * Connection
     * @var type
     */

    private static $conn;
 
    /**
     * Connect to the database and return an instance of \PDO object
     * @return \PDO
     * @throws \Exception
     */

    public function connect() {
 
        // This code will read the parameters on the Db.ini file using the parse_ini_file() function
       
        $paramDb = parse_ini_file('param.ini');
        if ($paramDb === false) {
            throw new \Exception("Error reading database config file, please check param.ini file");
        }
        // The following code will connect us to the database using the parsed parameters
        $connString = sprintf("pgsql:host=%s;port=%d;dbname=%s;user=%s;password=%s",
                $paramDb['host'],
                $paramDb['port'],
                $paramDb['database'],
                $paramDb['user'],
                $paramDb['password']);
 
        $pdo = new \PDO($connString);
        $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 
        return $pdo;
    }
 
    /**
     * this code will return an instance of the Connection object
     * @return type
     */

    public static function get() {
        if (null === static::$conn) {
            static::$conn = new static();
        }
 
        return static::$conn;
    }
 
    protected function __co/**
                           ID: 1475
                           Title: Postgres Stored Procedure Call in PHP 1475
                           Meta Description: A tutorial that explains and provides examples for executing the Postgres stored procedure call in PHP.
                           Meta Keywords: Postgres stored procedure call PHP
                           Author: Data Pilot
                           Template: Unstructured Tutorial
                           Categories: PostgreSQL
                           Tags: Postgres, stored procedure call, PHP
                           Status: Published
                           **/

                           
                           
                           ## Introduction
                         
                           PostgreSQL allows for expansion of database functionality by creating specialized user-defined functions. These functions are often referred to as stored procedures that permit for more effective creation of various customized procedural roles. Once created, stored procedures can then be executed as needed to increase the ease and speed of database workflow applications. This tutorial will explain how to set up, execute and provide examples for using the Postgres stored procedure call in PHP.
                           
                           
                           
                           ## Prerequisites
                         
                           * A basic working knowledge of PostgreSQL is required to execute the Postgres stored procedure call in PHP.
                           
                           * PostgreSQL must be properly installed and configured on the local system.
                           
                           * PHP must be properly installed on the local system, in either the standalone version or as part of a package installer like XAMPP.
                           
                           * Composer must also be properly installed on the local system.
                           
                           
                           ## What is Postgres Stored Procedure
                         
                           Ultimately, stored procedures allows for faster, easier and more effective creation of customized functions. The Postgres stored procedures function is used for defining customized aggregate functions or creating specific triggers. Stored procedures add various procedural functions, such as advance calculations and control structure.
                           
                           Following is the basic structure of a stored procedure in Postgres:
                           
                           ```sql
                           CREATE [OR REPLACE] PROCEDURE <name_of_the_procdure>(list_of_parameter)
                           AS $$
                               body_of_the_procedure;
                           $$;
                           LANGUAGE language_name
                           ```
                           
                           Following is a breakdown of the above command:
                           
                           1) The name of the procedure is specified immediately after the `CREATE PROCEDURE` clause.
                           2) The list of parameters is then defined.
                           3) The actual procedure is placed inside the `body_of_the_procedure` block, right after the `AS` keyword.
                           4) To end the procedure, the stored procedure is enclosed using the `$$` double dollar sign.
                           
                           Note that the programming language can also be specified using the stored procedure in either SQL or PLpgSQL.
                           
                           
                           ## Creating Sample Dataset
                         
                           The section will explain how to create some sample datasets that will be used to execute the examples in this tutorial.
                           
                           First, log into the Postgres shell and then:
                           
                           - Create database with the following command:
                           
                           ```bash
                           create database product
                           ```
                           
                           - Next, create tables for the database as follows:
                           
                           ```sql
                           CREATE TABLE IF NOT EXISTS stock (
                               id SERIAL PRIMARY KEY,
                               product_name CHARACTER VARYING(100),
                               sku CHARACTER VARYING(100),
                               description CHARACTER VARYING(100),
                               quantity INT
                           
                           );
                           ```
                           
                           Now, insert sample records in the “stock” table as shown here:
                           
                           ```sql
                           INSERT INTO stock (id, product_name, sku, description, quantity)
                           VALUES
                              (1,'fire extinguisher','PR0300', 'Fire repellant chemical', 300),
                              (2,'Facial Visor','PR0310', 'Facial protective gear', 300),
                              (3,'Medical Gown','PR0311', 'Protective gear', 240),
                              (4,'Rubber Boots','PR0321', 'Electricity protective gear', 500),
                              (5,'Back Pack','PR0321', 'Ordinary Back pack', 500);
                           ```
                           
                           The table should now resemble this:
                           
                           ```bash
                            id |   product_name    |  sku   |         description         | quantity
                           ----+-------------------+--------+-----------------------------+----------
                             1 | fire extinguisher | PR0300 | Fire repellant chemical     |      300
                             2 | Facial Visor      | PR0310 | Facial protective gear      |      300
                             3 | Medical Gown      | PR0311 | Protective gear             |      240
                             4 | Rubber Boots      | PR0321 | Electricity protective gear |      500
                             5 | Back Pack         | PR0321 | Ordinary Back pack          |      500
                           (5 rows)
                           ```
                           
                           ### Project Structure
                         
                           This section will explain the overall structure of our project. The following screenshot provides an overview:
                           
                           <img src="https://t.gyazo.com/teams/500rockets/e3a0feda066b1b32aa21b6f2c1e327ce.png" width="632" height="456">
                           
                           
                           ## Stored Procedure in PostgreSQL Example
                         
                           This section will cover creating the Postgres stored procedure. In the following example the goal is to add two (2) integers and return the value to the user:
                           
                           ```sql
                           CREATE OR REPLACE FUNCTION sum_it_up(
                               x INTEGER,
                               y INTEGER)
                             RETURNS integer AS $$
                           BEGIN
                           return x + y;
                           END; $$
                             LANGUAGE 'plpgsql';
                           ```
                           
                           Execute the following steps to execute the Postgres stored procedure call in PHP:
                           
                           1) Connect to the target database.
                           2) Create a statement that will call the stored procedure via the `prepare()` method of the PDO object.
                           3) Use the `bindValue()` method as an option to pass the values into the statement.
                           4) Execute the procedure using the `execute()` method.
                           
                           5) The value will be returned via the `fethColumn()` method and will return one column of the succeeding row within the result set.
                           
                           Now the _phpStock.php_ file can be modified using the following script:
                           
                           
                           ```php
                           <?php
                           namespace phpprocedurecall;
                           
                           class phpStock {
                           
                               private $pdo;
                           
                               /**
                                * Initialize the object with a specified PDO object
                                * @param \PDO $pdo
                                */

                               public function __construct($pdo) {
                                   $this->pdo = $pdo;
                               }
                           
                           
                            /**
                                * We call the simple stored procedure that we created named sum_it_up
                                * @param int $x
                                * @param int $y
                                * @return int
                                */

                               public function sum_it_up($x, $y) {
                                   $stmt = $this->pdo->prepare('SELECT * FROM sum_it_up(:x,:y)');
                                   $stmt->setFetchMode(\PDO::FETCH_ASSOC);
                                   $stmt->execute([
                                       ':x' => $x,
                                       ':y' => $y
                                   ]);
                                   return $stmt->fetchColumn(0);
                               }
                           }
                           
                           ```
                           
                           
                           Note that in order to execute the above script it is necessary to modify the _index.php_ file as follows:
                           
                           
                           ```php
                           <?php
                           
                           require 'vendor/autoload.php';
                           
                           use phpprocedurecall\Connection as Connection;
                           use phpprocedurecall\phpStock as phpStock;
                           
                           try {
                               // connect to the PostgreSQL database
                               $pdo = Connection::get()->connect();
                           
                               $phpStock = new phpStock($pdo);
                           
                               $result = $phpStock->sum_it_up(24, 35);
                               echo $result;
                               
                           } catch (\PDOException $e) {
                               echo $e->getMessage();
                           }
                           ```
                           
                           Now test the example in a browser using the following URL: `http://localhost/phpprocedurecall/index.php`
                           
                           If everything was done correctly, the output should be `59`.
                           
                           ## Stored Procedure Returning a Result Set
                         
                           This section will explain how to use the stored procedure to retrieve data from a database.
                           
                           The query for the stored procedure is as follows:
                           
                           ```sql
                           CREATE OR REPLACE FUNCTION get_all_stock()
                             RETURNS TABLE(id integer,
                                           product_name character varying,
                                           sku character varying,
                                           description character varying,
                                           quantity integer) AS
                           $$
                           BEGIN
                            RETURN QUERY
                           
                            SELECT *
                            FROM stock;
                           END; $$
                           
                           LANGUAGE plpgsql;
                           
                           ```
                           
                           Here is the script for the 'index.php' file:
                           
                           ```php
                           <?php
                           require 'vendor/autoload.php';
                           
                           use phpprocedurecall\Connection as Connection;
                           use phpprocedurecall\phpStock as phpStock;
                           
                           try {
                               // connect to the PostgreSQL database
                               $pdo = Connection::get()->connect();
                               //
                               $stockItems = new phpStock($pdo);
                             
                               $stocks = $stockItems->get_all_stock();
                               
                           } catch (\PDOException $e) {
                               echo $e->getMessage();
                           }
                           ?>
                           <!DOCTYPE html>
                           <html>
                               <head>
                                   <title>PostgreSQL Stored Procedure</title>
                                   <link rel="stylesheet" href="https://cdn.rawgit.com/twbs/bootstrap/v4-dev/dist/css/bootstrap.css">
                               </head>
                               <body>
                                   <div class="container">
                                       <h1>Stock Listing</h1>
                                       <table class="table table-bordered">
                                       <thead>
                                               <tr>
                                                   <th>ID</th>
                                                   <th>Product Name</th>
                                                   <th>SKU</th>
                                                   <th>Description</th>
                                                   <th>Quantity</th>
                                               </tr>
                                           </thead>
                                           <tbody>
                                               <?php foreach ($stocks as $stock) : ?>
                                                   <tr>
                                                       <td><?php echo htmlspecialchars($stock['id']) ?></td>
                                                       <td><?php echo htmlspecialchars($stock['product_name']); ?></td>
                                                       <td><?php echo htmlspecialchars($stock['sku']); ?></td>
                                                       <td><?php echo htmlspecialchars($stock['description']); ?></td>
                                                       <td><?php echo htmlspecialchars($stock['quantity']); ?></td>
                                                   </tr>
                                               <?php endforeach; ?>
                                           </tbody>
                                       </table>
                                   </div>
                               </body>
                           </html>
                           ```
                           
                           Now test the PHP application using the following URL: 'http://localhost/phpprocedurecall/index.php'
                           
                           The output should resemble the following image:
                           
                           <img src="https://t.gyazo.com/teams/500rockets/e00404270346eb5efab77e626b270875.png" width="632" height="456">
                           
                           
                           ## Conclusion
                         
                           This tutorial explained how to use the Postgres stored procedure call in PHP to quickly and easily create customized functions. The tutorial provided an overview of the Postgres stored procedure, explained the basic structure of a stored procedure in Postgres and provided a breakdown of the basic command structure. The article then explained how to create a sample dataset, table and how to add records to the new table. The tutorial then gave an example for creating the project structure, storing the procedure and how to test the application. Remember that the programming language can be specified in either SQL or PLpgSQL when creating the basic structure for a stored procedure in Postgres.
                           
                           
                           
                           ## The Code
                         
                           Below are the code for other files that we used in this tutorial
                           
                           ### Connection.php
                         
                           ```php
                           <?php
                           
                           namespace phpquery;
                           
                           /**
                            * Represent the Connection
                            */

                           class Connection {
                           
                               /**
                                * Connection
                                * @var type
                                */

                               private static $conn;
                           
                               /**
                                * Connect to the database and return an instance of \PDO object
                                * @return \PDO
                                * @throws \Exception
                                */

                               public function connect() {
                           
                                   // This code will read the parameters on the Db.ini file using the parse_ini_file() function
                                   
                                   $paramDb = parse_ini_file('param.ini');
                                   if ($paramDb === false) {
                                       throw new \Exception("Error reading database config file, please check param.ini file");
                                   }
                                   // The following code will connect us to the database using the parsed parameters
                                   $connString = sprintf("pgsql:host=%s;port=%d;dbname=%s;user=%s;password=%s",
                                           $paramDb['host'],
                                           $paramDb['port'],
                                           $paramDb['database'],
                                           $paramDb['user'],
                                           $paramDb['password']);
                           
                                   $pdo = new \PDO($connString);
                                   $pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
                           
                                   return $pdo;
                               }
                           
                               /**
                                * this code will return an instance of the Connection object
                                * @return type
                                */

                               public static function get() {
                                   if (null === static::$conn) {
                                       static::$conn = new static();
                                   }
                           
                                   return static::$conn;
                               }
                           
                               protected function __construct() {
                                   
                               }
                           
                           }
                           ```
                           
                           ### param.ini
                         
                           ```bash
                           host=localhost  
                           port=5432
                           database=product
                           user=postgres
                           password=1234
                           ```
                           
                           ### composer.json
                         
                           ```js
                           {
                               "autoload": {
                                   "psr-4": {
                                       "phpquery\": "app/"
                                   }
                               }
                           }
                           ```nstruct() {
       
    }
 
}

param.ini

1
2
3
4
5
host=localhost  
port=5432
database=product
user=postgres
password=1234

composer.json

1
2
3
4
5
6
7
{
    "autoload": {
        "psr-4": {
            "phpquery\": "app/"
        }
    }
}

Pilot the ObjectRocket Platform Free!

Try Fully-Managed CockroachDB, Elasticsearch, MongoDB, PostgreSQL (Beta) or Redis.

Get Started

Keep in the know!

Subscribe to our emails and we’ll let you know what’s going on at ObjectRocket. We hate spam and make it easy to unsubscribe.