Database

Elentra Platform Technical Documentation
Search…
Database
Database Migrations
The process for recording changes to the Elentra Platform database schema, is relatively simple thanks to the Elentra CLI utility.
Creating New Migrations
In this example, we will be adding a new uuid column to the elentra_auth.user_data table.
Using Terminal change to your Elentra project directory in the docker container, and run the base CLI utility
1
cd /var/www/vhosts/elentra-1x-me
2
php elentra
Copied!
You should see something like:
1
php elentra
2
​
3
The following commands are available in Elentra CLI 1.0:
4
​
5
migrate        Allows you to manage database migrations.
6
model          Create blank models based on database information.
7
help           The Elentra CLI help menu.
Copied!
Now lets see which actions are available to the migrate command:
1
php elentra migrate
2
​
3
The following actions are available in the migrate command:
4
​
5
--create         Create a new database migration file.
6
--pending        See a list of the pending database migrations in your installation.
7
--up-s           Run all pending migrations against your database. Provide optional filename to output SQL instead of run it.
8
--down-s         Rollback the last successful up migration. Provide optional filename to output SQL instead of run it.
9
--audit          Verifies that all present migrations have been run successfully.
10
--help           The migrate help menu.
Copied!
To create a new migration use the --create action:
1
php elentra migrate --create
2
​
3
Provide the Elentra ME Jira Issue number for this change: ME1234
4
​
5
Successfully created new migration file:
6
/Users/simpson/Sites/elentra-1x-me/www-root/core/library/Migrate/2020_04_17_233339_ME1234.php
Copied!
Open up the newly generated www-root/core/library/Migrate/2020_04_17_233339_ME1234.php file and record your changes for upgrading to the up() method, and your changes for reverting to the down() method. Elentra also provides an extremely useful audit() method that allows you to programmatically check to see if this change exists in your Elentra database or not.
1
<?php
2
class Migrate_2020_04_17_225348_ME1234 extends Entrada_Cli_Migrate {
3
​
4
    /**
5
     * Required: SQL / PHP that performs the upgrade migration.
6
     */
7
    public function up() {
8
        $this->record();
9
        ?>
10
        ALTER TABLE `<?php echo AUTH_DATABASE; ?>`.`user_data` ADD COLUMN `uuid` varchar(36) DEFAULT NULL;
11
        <?php
12
        $this->stop();
13
​
14
        return $this->run();
15
    }
16
​
17
    /**
18
     * Required: SQL / PHP that performs the downgrade migration.
19
     */
20
    public function down() {
21
        $this->record();
22
        ?>
23
        ALTER TABLE `<?php echo AUTH_DATABASE; ?>`.`user_data` DROP `uuid`;
24
        <?php
25
        $this->stop();
26
​
27
        return $this->run();
28
    }
29
​
30
    /**
31
     * Optional: PHP that verifies whether or not the changes outlined
32
     * in "up" are present in the active database.
33
     *
34
     * Return Values: -1 (not run) | 0 (changes not present or complete) | 1 (present)
35
     *
36
     * @return int
37
     */
38
    public function audit() {
39
        $migration = new Models_Migration();
40
        if ($migration->columnExists(AUTH_DATABASE, "user_data", "uuid")) {
41
            return 1;
42
        }
43
​
44
        return 0;
45
    }
46
}
Copied!
You can now commit this file to version control, and everyone can apply your changes.
Applying Pending Migrations
If you would simply like to see if there are pending migrations you can use --pending:
1
php elentra migrate --pending
2
​
3
The following 2 up migrations need to be run:
4
    > 2015_04_17_225348_ME1234
5
    > 2015_04_17_233339_ME1235
Copied!
To apply the changes to your database simply use --up:
1
php elentra migrate --up
2
​
3
The following 2 up migrations need to be run:
4
    > 2020_04_17_225348_ME1234
5
    > 2020_04_17_233339_ME1235
6
​
7
These SQL changes will be automatically applied to the database.
8
​
9
Would you like to proceed? [Y/n]: 
Copied!
Database Models
A model is a PHP class that represents a table in the database. It provides getter and setter methods for attributes that correspond to the columns in the table. A model class also provides the create, read, update and delete (CRUD) methods required to interact with the database. Elentra ME read methods follow the naming convention fetchRowBy<attributes> or fetchAllBy<attributes> to fetch a single row or a collection of results, respectively. <attributes> is replaced by the names of the columns that are used in the query.
Elentra ME has a base model that all other models can inherit from. This base model provides private fetchRow and fetchAll methods that child classes can call from their public fetch* methods. This helps to abstract the basic mechanics of performing a fetch and provides a simplified interface for creating queries.
Below is an example of how to use the model base class. The base class itself is commented with a detailed explanation of how to use the fetch methods it contains.
1
class Models_Example extends Models_Base {
2
    /**
3
     * N.B.: Put the exact names of the columns as these are accessed literally
4
     * in the base class's fetching code (e.g. fromArray()).
5
     */
6
    protected $example_id;
7
    protected $title;
8
    protected $active;
9
​
10
    protected $database_name = DATABASE_NAME;
11
​
12
    protected $table_name = "example";
13
    protected $primary_key = "example_id";      // Name of primary key column in the database. The "closest thing to a standard" is to name primary key columns table_name_singular_id, e.g. "events.event_id".
14
    protected $default_sort_column = "title";
15
​
16
    public function __construct($arr = NULL) {
17
        parent::__construct($arr);
18
    }
19
​
20
    /**
21
     * Get the primary key.
22
     *
23
     * @return The primary key of the record represented by this model.
24
     */
25
    public function getID() {
26
        return $this->example_id;
27
    }
28
​
29
    /**
30
     * @param int $active
31
     */
32
    public function setActive($active) {
33
        $this->active = $active;
34
    }
35
​
36
    /**
37
     * @return int
38
     */
39
    public function getActive() {
40
        return $this->active;
41
    }
42
​
43
    /**
44
     * @param string $title
45
     */
46
    public function setTitle($title) {
47
        $this->title = $title;
48
    }
49
​
50
    /**
51
     * @return string
52
     */
53
    public function getTitle() {
54
        return $this->title;
55
    }
56
​
57
    public static function fetchRowByID($example_id, $active = 1) {
58
        $self = new self();
59
​
60
        $constraints = array(
61
            array(
62
                "key" => "example_id",
63
                "method" => "=",
64
                "value" => $example_id,
65
                "mode" => "AND"
66
            ),
67
            array(
68
                "key" => "active",
69
                "method" => "=",
70
                "value" => $active,
71
                "mode" => "AND"
72
            )
73
        );
74
​
75
        return $self->fetchRow($constraints);
76
    }
77
​
78
    public static function fetchAllByActive($active = 1) {
79
        $self = new self();
80
​
81
        $constraints = array(
82
            array(
83
                "key"       => "active",
84
                "method"    => "="
85
                "value"     => $active,
86
                "mode"      => "AND",
87
            )
88
        );
89
​
90
        return $self->fetchAll($constraints);
91
    }
92
}
Copied!
The table name is stored in the $table_name attribute and can be used in the insert and update methods. The $default_sort_column is used when a sort column is not found in a fetch method call. The constructor calls the base class constructor and the getID() method is our naming convention of getting the primary key of the record that is represented by an instance of the model class.
An $active attribute is typically included as part of a database table in order to deactivate data instead of actually deleting it.
Database Tables
ID fields that effectively contain foreign keys should use NULL as an "empty" value instead of 0, even if using MyISAM, as using "0" as an empty value can cause problems when implementing foreign keys in InnoDB.
There has been a recommendation to use utf8_unicode_ci as the collation in new work going forward.
Column naming
The closest thing to a standard is naming PRIMARY KEY columns as the singular of the table name, then _id. The first n - 1 words are abbreviated by their first letters. For example, if the table is events, it would be event_id. If it were event_contacts it would be econtact_id. If it were event_contact_positions it would be ecposition_id.
Code Review
Next - Developers
Global Namespace
Last modified 5mo ago
Copy link
Contents
Database Migrations
Creating New Migrations
Applying Pending Migrations
Database Models
Database Tables
Column naming