Note: as of the current release, only mysql database is supported. But support for other databases has been planned.
A simple database migration and versioning tool. Basically, it works by maintaining change logs in the database, and incrementally updating the database using user supplied change scripts. You can craft the change scripts manually or use some tools (e.g., mysql workbench, etc. ) to generate them for you. Then, you can add the database schema (tables, views, indexes, constraints, etc. ) exported by baseline and these change scripts into your version control system such as git.
Typically, when you use a database-first development approach, your team want to keep local development databases and want to keep track and sync of the changes collaboratively w/ each other, then baseline could help. However, baseline also supports other scenarios such as you team (probably a dedicated database team) is maintaining a shared database for development, you want to apply the changes to the database in production, etc.
baseline is a CLI tool that could be installed via npm as below:
npm install -g node-baselineNote: this tool requires nodejs version 4.0.0 or above.
Then, type baseline --help to see how to use it as below:
Usage: baseline <command> [options]
Commands:
init init the baselines of configured databases
up migrate the configured databases up from the baselines
backup backup the configured databases
restore restore the specified configured database
Options:
--config, -c the database configurations to use with baseline
--database, -d the target database to use with the command
--force, -f used with init command, force init if baseline exists
--production, -p use production config (`.baselinerc.production`)
--log-level logging level: verbose (default), debug, info, warn, error
--output, -o the output path of the database backup
--output-file the output file name of the database backup
--input, -i input backup file used for database restore
--drop-database drop database before restore [boolean]
--help show help information
--version Show version number
Copyright 2015, MIT licensed.
You have to create a configuration file for the databases that you want to add baseline support to.
Basically, you can use --config option or .baselinerc in the working directory to specify the required configurations. The config file supports YAML, JSON and node module formats whichever way you choose for that. See the sample configuration files below.
First, use the init command to integrate your database with baseline, e.g.,
baseline init --config /path/to/the/config/fileor without the --config option if there is a .baselinerc configuration file in the directory you're calling baseline:
baseline initWhen the init command executed successfully, baseline will create the _change_log table in the database and then export all the necessary schema of the database, including tables, indexes, constraints, views, etc., and an empty changes directory where your change scripts reside. All these files will go to the corresponding sub directories scoped by the database name under the configured rootPath. For example:
temp/db/test
├── changes
├── tables
│ ├── sales.sql
│ ├── attrs.sql
│ └── costs.sql
└── views
├── costs_view.sql
└── sales_view.sql
where, temp/db/ is the configured rootPath, and test is the name of the database integrated w/ baseline.
You can add some change scripts to the changes directory (as mentioned above). The file names of the change scripts should follow the convention major(\d{2}).minor(\d{2}).patch(\d{4}).sql, and be increased sequentially, e.g, 01.00.0001.sql, 01.00.0002.sql, ... 01.01.0001.sql, etc.
Then, issue the up command below to apply the changes to the configured databases:
baseline up --config /path/to/the/config/fileor without the --config option if there is a .baselinerc configuration file in the directory you're calling baseline:
baseline upEach time a database is updated by up command, it will be backed up firstly so that the database can be restored in case any error occurs while updating. When error indeed occurs, just fix it and re-execute the up command.
Note: change scripts are typically not intended to be changed after being applied to database and even after being committed to version control system. If something is changed unexpectedly by some change scripts, don't worry, but just append and apply another new change scripts.
By rebasing, baseline will treat the current database as a fresh new one and re-integrate w/ it from a new start point. You can rebase the database at any time you want by using the init command with --force option:
baseline init --config /path/to/the/config/file --forceor without the --config option if there is a .baselinerc configuration file in the directory you're calling baseline:
baseline init --forcebaseline is designed and implemented with team collaboration in mind. The typical workflow is:
- A integrates the database w/ baseline by
init - A commits all the necessary stuff generated by baseline to the git repository
- B pulls the stuffs committed by A
- B issues
baseline initto create the database w/ baseline integrated - A migrates up the database using change scripts by
up - A commits the change scripts to the git repository
- B pulls the change scripts committed by A
- B issues
baseline upto apply the changes from A - ...
However, there's a caveat here that when before one developer adds the change scripts to the changes directory, he/she must first pull the change scripts from others first, and then adds and tests the changes scripts before commit.
rootPath: ./temp/db
host: 127.0.0.1
port: 3306
user: root
password: secret
dialect: mysql
databases:
- name: test1
- name: test2
dialect: oracle
user: user
password: password
backup: true
backupDir: /backup/dir{
"rootPath": "./temp/db",
"host": "127.0.0.1",
"port": 3306,
"user": "root",
"password": "secret",
"dialect": "mysql",
"databases": [
{
"name": "test1"
},
{
"name": "test2",
"dialect": "oracle",
"user": "user",
"password": "...",
"backup": true,
"backupDir": "/backupDir"
}
]
}var path = require('path');
module.exports = {
rootPath: path.join(__dirname, 'temp/db'),
host: '127.0.0.1',
port: 3306,
user: 'root',
password: 'secret',
dialect: 'mysql',
databases: [
{ name: 'test1' },
{
name: 'test2',
dialect: 'oracle',
user: 'user',
password: '...',
backup: true,
backupDir: '/backup/dir'
}
]
};