PHP code example of popphp / pop-db

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

popphp / pop-db example snippets

use Pop\Db\Db;

$db = Db::connect('mysql', [
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS',
    'host'     => 'localhost'
]);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS',
    'host'     => 'localhost'
]);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$users = $db->select('SELECT * FROM `users`');
print_r($users);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db->insert(
    'INSERT INTO `users` (`username`, `password`, `email`) VALUES (?, ?, ?)',
    ['testuser1', 'password1', '[email protected]']
);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db->query('SELECT * FROM `users`');
$users = $db->fetchAll();
print_r($users);

use Pop\Db\Db;
use Pop\Db\Record;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

class Users extends Record {}

Record::setDb($db);

$users = Users::findAll();
print_r($users->toArray());

$user = Users::findById(1);
print_r($user->toArray());

$user = Users::findById(1);
$user->username = 'testuser2';
$user->email    = '[email protected]'; 
$user->save();
print_r($user->toArray());

$user = new Users([
    'username' => 'newuser',
    'password' => 'somepassword',
    'email'    => '[email protected]'
]);
$user->save();
print_r($user->toArray());

$user = Users::findById(1);
$user->delete();

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db = Db::pgsqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db = Db::sqliteConnect([
    'database' => '/path/to/my_database.sqlite',
]);

$db = Db::sqlsrvConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db = Db::pdoConnect([
    'type'     => 'mysql',
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

use Pop\Db\Db;
use Pop\Db\Record;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

class Users extends Record {}

Record::setDb($db);

use Pop\Db\Db;
use Pop\Db\Record;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$dbUsers = Db::mysqlConnect([
    'database' => 'DATABASE_FOR_USERS',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

class Users extends Record {};

Users::setDb($dbUsers); // Only the users table class uses the $dbUsers connection
Record::setDb($db);     // All other table classes will use the $db connection

class Users extends Record
{
    protected ?string $table       = 'users_table';
    protected ?string $prefix      = 'my_app_';
    protected array   $primaryKeys = ['user_id'];
}

class Users extends Record
{
    protected ?string $table   = 'users';

    // Allowlist: only these columns can be mass-assigned
    protected array   $fillable = ['username', 'email'];
}

class Users extends Record
{
    protected ?string $table  = 'users';

    // Denylist: everything except these columns can be mass-assigned
    protected array   $guarded = ['is_admin', 'role'];
}

$user = new Users($request->all()); // filtered through $fillable/$guarded
$user->save();

$user = Users::findById(1);
$user->fill($request->all()); // filtered through $fillable/$guarded
$user->save();                // updates the existing row

$user->isFillable('role'); // false, if 'role' is guarded or not in $fillable

// Fetch a single user record by ID
$user = Users::findById(1);

// Search for a single user record
$user = Users::findOne(['username' => 'testuser']);

// Search for a single user record, or create one if it doesn't exist
$user = Users::findOneOrCreate(['username' => 'testuser']);

// Search for the latest single user record
$user = Users::findLatest();

$criteria = Users::predicate()->equalTo('username', 'testuser')->equalTo('email', '[email protected]');

$user = Users::findOneOrCreate($criteria); // creates ['username' => 'testuser', 'email' => '[email protected]'] if not found

// Search for the latest single user record by 'last_login'
$user = Users::findLatest('last_login');

$user->username = 'newusername';
$user->save();

$user->delete();

$user->increment('attempts'); // Increment column by one and save
$user->decrement('capacity', 5); // Decrement column by 5 and save
$user->reset('attempts'); // Reset column to null and save
$user->reset('attempts', 0); // Reset column to a given value (e.g. 0 or '') and save

// Make a new copy of the user record in the database
// The $replace parameter can be an array of new, overriding column values
$newUser = $user->copy($replace);

class Users extends Pop\Db\Record
{
    protected function beforeSave(): void
    {
        $this->updated_at = date('Y-m-d H:i:s');
    }

    protected function afterDelete(): void
    {
        Logger::info('User deleted', ['id' => $this->id]);
    }
}

$user->username = 'newusername';
$user->email    = '[email protected]';

if ($user->isDirty()) {
    print_r($user->getDirty());
}

use Pop\Db\Record\Encoded;

class Users extends Encoded
{
    protected array $jsonFields   = ['metadata'];
    protected array $phpFields    = ['user_info'];
    protected array $base64Fields = ['user_image'];
} 

use Pop\Db\Record\Encoded;

class Users extends Encoded
{

    protected array  $hashFields    = ['password'];
    protected string $hashAlgorithm = PASSWORD_BCRYPT;
    protected array  $hashOptions   = ['cost' => 12];
}

$user = Users::findOne(['username' => 'testuser']);
if ($user->verify('password', $attemptedPassword)) {
    // The user submitted the correct password.
}

if ($user->verify('password', $attemptedPassword)) {
    if ($user->needsRehash()) {
        $user->rehash('password', $attemptedPassword); // re-hashes with current $hashOptions and saves
    }
    // proceed as authenticated
}

use Pop\Db\Record\Encoded;

class Users extends Encoded
{
    protected array   $encryptedFields = ['sensitive_data_field'];
    protected ?string $cipherMethod    = 'aes-256-cbc';
    protected ?string $key             = 'BASE64_ENCODED_KEY';
    protected array   $previousKeys    = ['BASE64_OLD_ENCODED_KEY1', 'BASE64_OLD_ENCODED_KEY2'];
}

use Pop\Db\Record\Auth;

class Users extends Auth
{
    // No $hashFields needed - Auth::__construct() always adds $passwordField to it for you
}

$user = new Users();

// $mfa = false: authenticate outright, no MFA step
if ($user->authenticate($username, $attemptedPassword, false)) {
    // Logged in
} else {
    echo $user->getAuthFailureMessage();
}

// $mfa = true (the default): on success, a fresh MFA code + expiration are generated,
// saved to the user record, and the record itself is returned so the app can send the
// code however it likes (email, SMS, etc.)
$result = $user->authenticate($username, $attemptedPassword);

if ($result !== false) {
    // $result is the user record - send $result->mfa_code to the user
} else {
    echo $user->getAuthFailureMessage();
}

$user = Users::findOne(['username' => $username]);

if ($user->authenticateMfa($attemptedCode)) {
    // MFA passed - the stored code is cleared, so it cannot be reused
} else {
    echo $user->getAuthFailureMessage(); // INVALID_MFA_CODE, MFA_CODE_EXPIRED, etc.
}

class Users extends Auth
{
    protected string $usernameField = 'username';
    protected string $passwordField = 'password';
    protected string $attemptsField = 'attempts';
    protected int    $attemptsLimit = 3;

    protected array $mfaConfig = [
        'length'              => 6,               // Code length
        'expires'             => 300,              // Seconds
        'alphanumeric'        => false,            // Numeric by default, can be alphanumeric
        'mfa_code_field'      => 'mfa_code',       // varchar database column, nullable
        'mfa_timestamp_field' => 'mfa_timestamp',  // integer database column, nullable
    ];
}

// Find all users who have never logged in.
$users = Users::findBy(['logins' => 0]);

// Find a group of users
$users = Users::findIn('username', ['testuser', 'someotheruser', 'anotheruser']);

// Find all users
$users = Users::findAll();

// Returns an array
$users = Users::findBy(['logins' => 0])->toArray();

// 3rd parameter $asArray set to true; Returns an array
$users = Users::findBy(['logins' => 0], null, true);

// Get count of all users
$count = Users::getTotal();

// Get count of all users who have never logged in.
$count = Users::getTotal(['logins' => 0]);

namespace MyApp\Table;

use Pop\Db\Record;

class Users extends Record
{

}

namespace MyApp\Model;

use Pop\Db\Model\AbstractDataModel;

class User extends AbstractDataModel
{

}

use MyApp\Model\User;

$user = User::createNew($userData);

use MyApp\Model\User;

$userModel = new User();
$user = $userModel->update(1, $userData);

use MyApp\Model\User;

$userModel = new User();
$userModel->delete(1);
$userModel->remove([2, 3, 4]);

use MyApp\Model\User;

$users = User::fetchAll();
$user  = User::fetch(1);

use MyApp\Model\User;

$users = User::filterBy('username LIKE myuser%')->getAll('-id', '10', 2);

$users = Users::findBy(['logins' => 0], [
    'select' => ['id', 'username'],
    'order'  => ['id DESC'],
    'offset' => 10,
    'limit'  => 25
]);

$users = Users::findBy(['logins' => 0], [
    'select' => [
        Users::table() . '.*',
        Roles::table() . '.role',
    ],
    'join' => [
        'table'   => Roles::table(),
        'columns' => [
            Roles::table() . '.id' => Users::table() . '.role_id',
        ],
    ],
]);

$users = Users::findBy(['id' => 1]);   // WHERE id = 1
$users = Users::findBy(['id!=' => 1]); // WHERE id != 1
$users = Users::findBy(['id>' => 1]);  // WHERE id > 1
$users = Users::findBy(['id>=' => 1]); // WHERE id >= 1
$users = Users::findBy(['id<' => 1]);  // WHERE id < 1
$users = Users::findBy(['id<=' => 1]); // WHERE id <= 1

$users = Users::findBy(['%username%'   => 'test']); // WHERE username LIKE '%test%'
$users = Users::findBy(['username%'    => 'test']); // WHERE username LIKE 'test%'
$users = Users::findBy(['%username'    => 'test']); // WHERE username LIKE '%test'
$users = Users::findBy(['-%username'   => 'test']); // WHERE username NOT LIKE '%test'
$users = Users::findBy(['username%-'   => 'test']); // WHERE username NOT LIKE 'test%'
$users = Users::findBy(['-%username%-' => 'test']); // WHERE username NOT LIKE '%test%'

$users = Users::findBy(['username' => null]);  // WHERE username IS NULL
$users = Users::findBy(['username-' => null]); // WHERE username IS NOT NULL

$users = Users::findBy(['id' => [2, 3]]);  // WHERE id IN (2, 3)
$users = Users::findBy(['id-' => [2, 3]]); // WHERE id NOT IN (2, 3)

$users = Users::findBy(['id' => '(1, 5)']);  // WHERE id BETWEEN (1, 5)
$users = Users::findBy(['id-' => '(1, 5)']); // WHERE id NOT BETWEEN (1, 5)

$users = Users::findBy([
    'id>'       => 1,
    '%username' => 'user1'
]);

$users = Users::findBy([
    'id>'       => 1,
    '%username' => 'user1 OR'
]);

$users = Users::findBy([
    'age'        => ['>=', 18],
    'status'     => ['!=', 'inactive'],
    'name'       => ['LIKE', '%smith%'],
    'created_at' => ['BETWEEN', '2024-01-01', '2024-12-31'],
    'role'       => ['IN', ['admin', 'editor']],
    'deleted_at' => ['IS NULL'],
]);

$users = Users::findBy([
    'status' => 'active',
    'OR' => [
        ['role' => 'admin'],
        ['age'  => ['>=', 65]],
    ],
]);
// WHERE status = 'active' AND (role = 'admin' OR age >= 65)

$users = Users::query('SELECT * FROM ' . Users::table());

$sql   = 'SELECT * FROM ' . Users::table() . ' WHERE last_login >= :last_login';
$users = Users::execute($sql, ['last_login' => '2023-11-01 08:00:00']);

$user = new Users([
    'username' => 'testuser',
    'password' => 'password',
    'email'    => '[email protected]'
]);
$user->startTransaction();
$user->save();

$user = Users::start([
    'username' => 'testuser',
    'password' => 'password',
    'email'    => '[email protected]'
]);
$user->save();

try {
    Record::start();

    $user = new Users([
        'username' => 'testuser',
        'password' => 'password',
        'email'    => '[email protected]'
    ]);
    $user->save();

    $role = new Roles([
        'role' => 'Admin'
    ]);
    $role->save();

    Record::commit();
} catch (\Exception $e) {
    Record::rollback();
    echo $e->getMessage();
}

try {
    Record::transaction(function() {
        $user = new Users([
            'username' => 'testuser',
            'password' => 'password',
            'email'    => '[email protected]'
        ]);
        $user->save();
    
        $role = new Roles([
            'role' => 'Admin'
        ]);
        $role->save();
    });
} catch (\Exception $e) {
    echo $e->getMessage();
}

try {
    Record::transaction(function() {
        $user = new Users([
            'username' => 'testuser',
            'password' => 'password',
            'email'    => '[email protected]'
        ]);
        $user->save();
        
        Record::transaction(function(){
            $role = new Roles([
                'role' => 'Admin'
            ]);
            $role->save();
        });
    });
} catch (\Exception $e) {
    echo $e->getMessage();
}

class Users extends Pop\Db\Record
{

    /**
     * Mock Schema
     *    - id
     *    - role_id (FK to roles.id)
     *    - username
     *    - password
     *    - email
     */

    // Define the 1:1 relationship of the user's role
    public function role(?array $options = null, bool $eager = false)
    {
        return $this->hasOneOf('Roles', 'role_id', $options, $eager);
    }

    // Define the 1:1 relationship of the info record this user owns
    public function info(?array $options = null, bool $eager = false)
    {
        return $this->hasOne('Info', 'user_id', $options, $eager);
    }

    // Define the 1:many relationship to all the orders this user owns
    public function orders(?array $options = null, bool $eager = false)
    {
        return $this->hasMany('Orders', 'user_id', $options, $eager);
    }

}

class Roles extends Pop\Db\Record
{
    /**
     * Mock Schema
     *    - id (FK to users.role_id)
     *    - role
     */
}

class Info extends Pop\Db\Record
{
    /**
     * Mock Schema
     *    - user_id (FK to users.id)
     *    - address
     *    - phone
     */
    // Define the parent relationship up to the user that owns this info record
    public function user(?array $options = null, bool $eager = false)
    {
        return $this->belongsTo('Users', 'user_id', $options, $eager);
    }

}

class Orders extends Pop\Db\Record
{
    /**
     * Mock Schema
     *    - id
     *    - user_id (FK to users.id)
     *    - order_date
     *    - order_total
     *    - products
     */

    // Define the parent relationship up to the user that owns this order record
    public function user(?array $options = null, bool $eager = false)
    {
        return $this->belongsTo('Users', 'user_id', $options, $eager);
    }

}

// The two 1:1 relationships
$user = Users::findById(1);
print_r($user->role()->toArray());
print_r($user->info()->toArray());

// The 1:many relationship
$user   = Users::findById(1);
$orders = $user->orders();

foreach ($orders as $order) {
    echo 'Order Total: $' . $order->order_total . PHP_EOL;
}

$user = Users::findById(1);

$newestOrder = $user->latest()->orders();       // single Orders record, ordered by id DESC
$oldestOrder = $user->oldest('order_date')->orders(); // single Orders record, ordered by order_date ASC

echo 'Most recent order total: $' . $newestOrder->order_total;

// The inverse 1:1 relationship
$userInfo = UserInfo::findOne(['user_id' => 1]);
print_r($userInfo->user()->toArray());

$user = Users::with('orders')->getById(1);
foreach ($user->orders as $order) {
    echo 'Order Total: $' . $order->order_total . PHP_EOL;
}

$user = Users::with(['role', 'info', 'orders'])->getById(1);

$user = Users::with('posts.comments')->getById(1);

$user = Users::with(['posts.comments', 'posts.tags'])->getById(1);

$user = Users::with(['info', 'orders'])->getOne(['id' => 1]);

var_dump($user->info);          // NULL -- a 1:1 relationship with no match
echo count($user->orders);      // 0    -- a 1:many relationship is an empty collection

class Orders extends Pop\Db\Record
{
    /**
     * Mock Schema
     *    - id
     *    - user_id (FK to users.id)
     *    - org_id  (FK to users.org_id)
     *    - order_date
     *    - order_total
     *    - products
     */

    // Define the parent relationship up to the user that owns this order record,
    // matched on both `user_id` and `org_id`
    public function user(?array $options = null, bool $eager = false)
    {
        return $this->belongsTo('Users', ['user_id', 'org_id'], $options, $eager);
    }

}

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$users = $db->select('SELECT * FROM `users`');
print_r($users);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$users = $db->select('SELECT * FROM `users` WHERE `id` < ?', [10]);
print_r($users);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db->query('SELECT * FROM `users`');
$users = $db->fetchAll();
print_r($users);

use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$db->prepare('SELECT * FROM `users` WHERE `id` = ?');
$db->bindParams(['id' => 1]);
$db->execute();

$users = $db->fetchAll();
print_r($users);

try {
    $db->beginTransaction();
    $db->query("INSERT INTO `users` (`username`, `email`) VALUES ('testuser', '[email protected]')");
    $db->commit();
} catch (\Exception $e) {
    $db->rollback();
}

try {
    $db->beginTransaction();
    $db->prepare("INSERT INTO `users` (`username`, `email`) VALUES (?, ?)")
        ->bindParam([
            'username' => 'testuser',
            'email'    => '[email protected]'
        ]);
    $db->execute();
    $db->commit();
} catch (\Exception $e) {
    $db->rollback();
}

try {
    $db->transaction(function() use ($db) {
        $db->query(
            "INSERT INTO `users` (`username`, `email`) VALUES ('testuser', '[email protected]')"
        );
    });
} catch (\Exception $e) {
    echo $e->getMessage();
}

try {
    $db->transaction(function() use ($db) {
        $db->query(
            "INSERT INTO `users` (`username`, `email`) VALUES ('testuser1', '[email protected]')"
        );
        $db->transaction(function() use ($db) {
            $db->query(
                "INSERT INTO `users` (`username`, `email`) VALUES ('testuser2', '[email protected]')"
            );
        });
    });
} catch (\Exception $e) {
    echo $e->getMessage();
}

php
use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$sql = $db->createSql();
$sql->select(['id', 'username'])
    ->from('users')
    ->where('id = :id');

echo $sql;

php
use Pop\Db\Db;

$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

$sql = $db->createSql();
$sql->select(['id', 'username'])
    ->from('users')
    ->where('id = :id');

$db->prepare($sql);
$db->bindParams(['id' => 1]);
$db->execute();

$users = $db->fetchAll();
print_r($users);

php
$sql->insert('users')->values([
    'username' => ':username',
    'password' => ':password'
]);

echo $sql;

php
$sql->update('users')->values([
    'username' => ':username',
    'password' => ':password'
])->where('id = :id');

echo $sql;

php
$sql->delete('users')
    ->where('id = :id');

echo $sql;

php
$sql->select(['id', 'username', 'email'])->from('users')
    ->leftJoin('user_info', ['users.id' => 'user_info.user_id'])
    ->where('id < :id')
    ->orderBy('id', 'DESC');

echo $sql;

php
$sql->select()
    ->from('users')
    ->where('id > :id')->andWhere('email LIKE :email');

echo $sql;

sql
-- MySQL
SELECT * FROM `users` WHERE ((`id` > ?) AND (`email` LIKE ?))

php
$sql->select()
    ->from('users')
    ->where('id > :id')->orWhere('email LIKE :email');

echo $sql;

sql
-- MySQL
SELECT * FROM `users` WHERE ((`id` > ?) OR (`email` LIKE ?))

php
$sql->select()
    ->from('users')
    ->where->greaterThan('id', ':id')->and()->equalTo('email', ':email');

echo $sql;

sql
-- MySQL
SELECT * FROM `users` WHERE ((`id` > ?) AND (`email` = ?))

php
$sql->select()
    ->from('users')
    ->where->greaterThan('id', ':id')
        ->nest()->greaterThan('logins', ':logins')
            ->or()->lessThanOrEqualTo('failed', ':failed');

echo $sql;

sql
-- MySQL
SELECT * FROM `users` WHERE ((`id` > ?) AND ((`logins` > ?) OR (`failed` <= ?)))

php
$subquery = $db->createSql()->select('user_id')->from('orders');
$subquery->where->greaterThanOrEqualTo('total', 100);

$sql->select()
    ->from('users')
    ->where->in('id', $subquery);

echo $sql;

php
$subquery = $db->createSql()->select('MAX(total)')->from('orders');

$sql->select()
    ->from('users')
    ->where->equalTo('total', $subquery);

php
$subquery = $db->createSql()->select('id')->from('orders');
$subquery->where->equalTo('user_id', 5);

$sql->select()->from('users')->where->exists($subquery);

php
Users::findBy(['id' => ['IN', $subquery]]);
Users::findBy(['EXISTS' => $subquery]);

php
$sql->select(['id', 'extracted_name' => $sql->jsonExtract('data', '$.name')])
    ->from('users');

echo $sql;

php
$sql->select()
    ->from('users')
    ->where->jsonEqualTo('data', '$.role', 'admin');

echo $sql;

php
$sql->select()
    ->from('users')
    ->where->jsonContains('data', '$.roles', 'admin');

echo $sql;

php
$schema->alter('users')
    ->varchar('email', 255)
    ->after('password');

echo $schema;

php
$schema->alter('users')
    ->addColumn('email', 'VARCHAR', 255)
    ->after('password');

echo $schema;

php
$schema->drop('users');

echo $schema;

php
$schema->execute();

php
$createTable   = $schema->create('users');
$alterTable    = $schema->alter('users');
$truncateTable = $schema->truncate('users');
$renameTable   = $schema->rename('users');
$dropTable     = $schema->drop('users');

php
use Pop\Db\Sql\Migrator;

Migrator::create('MyNewMigration', __DIR__ . 'migrations');

php


use Pop\Db\Sql\Migration\AbstractMigration;

class MyNewMigration extends AbstractMigration
{

    public function up()
    {

    }

    public function down()
    {

    }

}

php


use Pop\Db\Sql\Migration\AbstractMigration;

class MyNewMigration extends AbstractMigration
{

    public function up()
    {
        $schema = $this->db->createSchema();
        $schema->create('users')
            ->int('id', 16)->increment()
            ->varchar('username', 255)
            ->varchar('password', 255)
            ->primary('id');

        $schema->execute();
    }

    public function down()
    {
        $schema = $this->db->createSchema();
        $schema->drop('users');
        $schema->execute();
    }

}

php


use Pop\Db\Adapter\AbstractAdapter;
use Pop\Db\Sql\Seeder\AbstractSeeder;

class MyFirstSeeder extends AbstractSeeder
{

    public function run(AbstractAdapter $db): void
    {

    }

}

php


use Pop\Db\Adapter\AbstractAdapter;
use Pop\Db\Sql\Seeder\AbstractSeeder;

class MyFirstSeeder extends AbstractSeeder
{

    public function run(AbstractAdapter $db): void
    {
        $schema = $db->createSchema();
        $schema->create('users')
            ->int('id', 16)->notNullable()->increment()
            ->varchar('username', 255)->notNullable()
            ->varchar('password', 255)->notNullable()
            ->varchar('email', 255)->nullable()
            ->primary('id');

        $db->query($schema);

        $sql = $db->createSql();
        $sql->insert('users')->values([
            'username' => 'testuser1',
            'password' => '12345678',
            'email'    => '[email protected]'
        ]);
        $db->query($sql);

        $sql->insert('users')->values([
            'username' => 'testuser2',
            'password' => '87654321',
            'email'    => '[email protected]'
        ]);
        $db->query($sql);

        $sql->insert('users')->values([
            'username' => 'testuser3',
            'password' => '74185296',
            'email'    => '[email protected]'
        ]);
        $db->query($sql);
    }

}

php
$db = Db::mysqlConnect([
    'database' => 'DATABASE',
    'username' => 'DB_USER',
    'password' => 'DB_PASS'
]);

Seeder::run($db, __DIR__ . '/seeds');

text
Start:			1699246221.25475
Finish:			0.00000
Elapsed:		0.00997 seconds

Queries:
--------
INSERT INTO `users` (`username`, `password`, `email`) VALUES (?, ?, ?) [0.00674]
Start:			1699246221.25796
Finish:			1699246221.26470
Params:
	username => admin
	password => password
	email => [email protected]