[dev] Initial commit from HarryGulliford/laravel-firebird.

Added support for L12, handling search without a case-sensitive search at the database query level.

Changed namespaces to xgrz.

8 files changed, 1049 insertions, 0 deletions

diff --git a/src/FirebirdConnection.php b/src/FirebirdConnection.php
new file mode 100755
index 0000000..8128b18
--- /dev/null
+++ b/src/FirebirdConnection.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace Xgrz\Firebird;
+
+use Illuminate\Database\Connection as DatabaseConnection;
+use Xgrz\Firebird\Query\Builder as FirebirdQueryBuilder;
+use Xgrz\Firebird\Query\Grammars\FirebirdGrammar as FirebirdQueryGrammar;
+use Xgrz\Firebird\Query\Processors\FirebirdProcessor as FirebirdQueryProcessor;
+use Xgrz\Firebird\Schema\Builder as FirebirdSchemaBuilder;
+use Xgrz\Firebird\Schema\Grammars\FirebirdGrammar as FirebirdSchemaGrammar;
+
+class FirebirdConnection extends DatabaseConnection
+{
+    /**
+     * Get the default query grammar instance.
+     *
+     * @return \Illuminate\Database\Query\Grammars\Grammar
+     */
+    protected function getDefaultQueryGrammar()
+    {
+        return new FirebirdQueryGrammar($this);
+    }
+
+    /**
+     * Get the default post processor instance.
+     *
+     * @return \Illuminate\Database\Query\Processors\Processor
+     */
+    protected function getDefaultPostProcessor()
+    {
+        return new FirebirdQueryProcessor;
+    }
+
+    /**
+     * Get a schema builder instance for this connection.
+     *
+     * @return \Firebird\Schema\Builder
+     */
+    public function getSchemaBuilder()
+    {
+        if (is_null($this->schemaGrammar)) {
+            $this->useDefaultSchemaGrammar();
+        }
+
+        return new FirebirdSchemaBuilder($this);
+    }
+
+    /**
+     * Get the default schema grammar instance.
+     *
+     * @return \Firebird\Schema\Grammars\FirebirdGrammar
+     */
+    protected function getDefaultSchemaGrammar()
+    {
+        return $this->withTablePrefix(new FirebirdSchemaGrammar);
+    }
+
+    /**
+     * Get a new query builder instance.
+     *
+     * @return \Firebird\Query\Builder
+     */
+    public function query()
+    {
+        return new FirebirdQueryBuilder(
+            $this, $this->getQueryGrammar(), $this->getPostProcessor()
+        );
+    }
+
+    /**
+     * Execute a stored procedure.
+     *
+     * @param  string  $procedure
+     * @param  array  $values
+     * @return \Illuminate\Support\Collection
+     */
+    public function executeProcedure($procedure, array $values = [])
+    {
+        return $this->query()->fromProcedure($procedure, $values)->get();
+    }
+}
diff --git a/src/FirebirdConnector.php b/src/FirebirdConnector.php
new file mode 100755
index 0000000..99ed3ba
--- /dev/null
+++ b/src/FirebirdConnector.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace Xgrz\Firebird;
+
+use Illuminate\Database\Connectors\Connector;
+use Illuminate\Database\Connectors\ConnectorInterface;
+
+class FirebirdConnector extends Connector implements ConnectorInterface
+{
+    /**
+     * Establish a database connection.
+     *
+     * @param  array  $config
+     * @return \PDO
+     */
+    public function connect(array $config)
+    {
+        return $this->createConnection(
+            $this->getDsn($config),
+            $config,
+            $this->getOptions($config)
+        );
+    }
+
+    /**
+     * Create a DSN string from the configuration.
+     *
+     * @param  array  $config
+     * @return string
+     */
+    protected function getDsn(array $config)
+    {
+        extract($config);
+
+        if (! isset($host) || ! isset($database)) {
+            trigger_error('Cannot connect to Firebird Database, no host or database supplied');
+        }
+
+        $dsn = "firebird:dbname={$host}";
+
+        if (isset($port)) {
+            $dsn .= "/{$port}";
+        }
+
+        $dsn .= ":{$database};";
+
+        if (isset($role)) {
+            $dsn .= "role={$role};";
+        }
+
+        if (isset($charset)) {
+            $dsn .= "charset={$charset};";
+        }
+
+        return $dsn;
+    }
+}
diff --git a/src/FirebirdServiceProvider.php b/src/FirebirdServiceProvider.php
new file mode 100755
index 0000000..b75ab54
--- /dev/null
+++ b/src/FirebirdServiceProvider.php
@@ -0,0 +1,23 @@
+<?php
+
+use Illuminate\Database\Connection;
+use Illuminate\Support\ServiceProvider;
+use Xgrz\Firebird\FirebirdConnection;
+use Xgrz\Firebird\FirebirdConnector;
+
+class FirebirdServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        Connection::resolverFor('firebird', function($connection, $database, $tablePrefix, $config) {
+            return new FirebirdConnection($connection, $database, $tablePrefix, $config);
+        });
+
+        $this->app->bind('db.connector.firebird', FirebirdConnector::class);
+    }
+}
diff --git a/src/Query/Builder.php b/src/Query/Builder.php
new file mode 100755
index 0000000..c91c6bd
--- /dev/null
+++ b/src/Query/Builder.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace Xgrz\Firebird\Query;
+
+use Illuminate\Database\Query\Builder as QueryBuilder;
+
+class Builder extends QueryBuilder
+{
+    /**
+     * Determine if any rows exist for the current query.
+     *
+     * @return bool
+     */
+    public function exists()
+    {
+        return parent::count() > 0;
+    }
+
+    /**
+     * Add a from stored procedure clause to the query builder.
+     *
+     * @param string $procedure
+     * @param array  $values
+     * @return \Illuminate\Database\Query\Builder|static
+     */
+    public function fromProcedure(string $procedure, array $values = [])
+    {
+        $compiledProcedure = $this->grammar->compileProcedure($this, $procedure, $values);
+
+        // Remove any expressions from the values array, as they will have
+        // already been evaluated by the grammar's parameterize() function.
+        $values = array_filter($values, function($value) {
+            return ! $this->grammar->isExpression($value);
+        });
+
+        $this->fromRaw($compiledProcedure, array_values($values));
+
+        return $this;
+    }
+
+    public function where($column, $operator = NULL, $value = NULL, $boolean = 'and')
+    {
+        // detect is not search
+        if (! str($operator)->contains('like', true)) {
+            return parent::where($column, $operator, $value, $boolean); // TODO: Change the autogenerated stub
+        }
+
+        // when is search covert to upper case column and value at database level
+        $wrapped = $this->grammar->wrap($column);
+        return $boolean === 'and'
+            ? parent::whereRaw("UPPER($wrapped) LIKE UPPER(?)", [$value])
+            : parent::orWhereRaw("UPPER($wrapped) LIKE UPPER(?)", [$value]);
+    }
+}
diff --git a/src/Query/Grammars/FirebirdGrammar.php b/src/Query/Grammars/FirebirdGrammar.php
new file mode 100755
index 0000000..c8b5535
--- /dev/null
+++ b/src/Query/Grammars/FirebirdGrammar.php
@@ -0,0 +1,172 @@
+<?php
+
+namespace Xgrz\Firebird\Query\Grammars;
+
+use Illuminate\Database\Query\Builder;
+use Illuminate\Database\Query\Grammars\Grammar;
+use Illuminate\Support\Str;
+
+class FirebirdGrammar extends Grammar
+{
+    /**
+     * The components that make up a select clause.
+     *
+     * @var string[]
+     */
+    protected $selectComponents = [
+        'aggregate',
+        'columns',
+        'from',
+        'joins',
+        'wheres',
+        'groups',
+        'havings',
+        'orders',
+        // 'limit', - Handled in the compileColumns() method.
+        // 'offset', - Handled in the compileColumns() method.
+        'lock',
+    ];
+
+    /**
+     * All of the available clause operators.
+     *
+     * @var array
+     *
+     * @link https://ib-aid.com/download/docs/firebird-language-reference-2.5/fblangref25-commons-predicates.html
+     */
+    protected $operators = [
+        '=', '<', '>', '<=', '>=', '<>', '!=',
+        'like', 'not like', 'between', 'not between',
+        'containing', 'not containing', 'starting with', 'not starting with',
+        'similar to', 'not similar to', 'is distinct from', 'is not distinct from',
+    ];
+
+    /**
+     * @param  Builder  $query
+     * @param  array  $columns
+     * @return string|null
+     */
+    protected function compileColumns(Builder $query, $columns)
+    {
+        // See superclass.
+        if (! is_null($query->aggregate)) {
+            return;
+        }
+
+        // In Firebird, the correct syntax for limiting and offsetting rows is
+        // "select first [num_rows] skip [start_row] * from table". Laravel does
+        // not support adding components between the "select" keyword and the
+        // column names, so compile the limit and offset components here. Note
+        // that they are commented out in the $selectComponents class variable.
+        // Reference: http://mc-computing.com/Databases/Firebird/SQL.html
+
+        $select = 'select ';
+
+        if ($query->limit) {
+            $select .= $this->compileLimit($query, $query->limit).' ';
+        }
+
+        if ($query->offset) {
+            $select .= $this->compileOffset($query, $query->offset).' ';
+        }
+
+        if ($query->distinct) {
+            $select .= 'distinct ';
+        }
+
+        return $select.$this->columnize($columns);
+    }
+
+    /**
+     * Compile the "limit" portions of the query.
+     *
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  int  $limit
+     * @return string
+     */
+    protected function compileLimit(Builder $query, $limit)
+    {
+        return 'first '.(int) $limit;
+    }
+
+    /**
+     * Compile the "offset" portions of the query.
+     *
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  int  $offset
+     * @return string
+     */
+    protected function compileOffset(Builder $query, $offset)
+    {
+        return 'skip '.(int) $offset;
+    }
+
+    /**
+     * Compile the random statement into SQL.
+     *
+     * @param  string  $seed
+     * @return string
+     */
+    public function compileRandom($seed)
+    {
+        return 'RAND()';
+    }
+
+    /**
+     * Wrap a union subquery in parentheses.
+     *
+     * @param  string  $sql
+     * @return string
+     */
+    protected function wrapUnion($sql)
+    {
+        return $sql;
+    }
+
+    /**
+     * Compile a date based where clause.
+     *
+     * @param  string  $type
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  array  $where
+     * @return string
+     */
+    protected function dateBasedWhere($type, Builder $query, $where)
+    {
+        $value = $this->parameter($where['value']);
+
+        return 'EXTRACT('.$type.' FROM '.$this->wrap($where['column']).') '.$where['operator'].' '.$value;
+    }
+
+    /**
+     * Compile SQL statement for a stored procedure.
+     *
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  string  $procedure
+     * @param  array  $values
+     * @return string
+     */
+    public function compileProcedure(Builder $query, $procedure, array $values = null)
+    {
+        $procedure = $this->wrap($procedure);
+
+        return $procedure.' ('.$this->parameterize($values).')';
+    }
+
+    /**
+     * Compile an aggregated select clause.
+     *
+     * @param  \Illuminate\Database\Query\Builder  $query
+     * @param  array  $aggregate
+     * @return string
+     */
+    protected function compileAggregate(Builder $query, $aggregate)
+    {
+        // Wrap `aggregate` in double quotes to ensure the resultset returns the
+        // column name as a lowercase string. This resolves compatibility with
+        // the framework's paginator.
+        return Str::replaceLast(
+            'as aggregate', 'as "aggregate"', parent::compileAggregate($query, $aggregate)
+        );
+    }
+}
diff --git a/src/Query/Processors/FirebirdProcessor.php b/src/Query/Processors/FirebirdProcessor.php
new file mode 100644
index 0000000..0d10706
--- /dev/null
+++ b/src/Query/Processors/FirebirdProcessor.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Xgrz\Firebird\Query\Processors;
+
+use Illuminate\Database\Query\Processors\Processor;
+
+class FirebirdProcessor extends Processor
+{
+    /**
+     * Process the results of a column listing query.
+     *
+     * @param  array  $results
+     * @return array
+     */
+    public function processColumnListing($results)
+    {
+        return array_map(function ($result) {
+            return ((object) $result)->column_name;
+        }, $results);
+    }
+}
diff --git a/src/Schema/Builder.php b/src/Schema/Builder.php
new file mode 100755
index 0000000..2069b67
--- /dev/null
+++ b/src/Schema/Builder.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Xgrz\Firebird\Schema;
+
+use Illuminate\Database\Schema\Builder as SchemaBuilder;
+
+class Builder extends SchemaBuilder
+{
+    //
+}
diff --git a/src/Schema/Grammars/FirebirdGrammar.php b/src/Schema/Grammars/FirebirdGrammar.php
new file mode 100755
index 0000000..6c11385
--- /dev/null
+++ b/src/Schema/Grammars/FirebirdGrammar.php
@@ -0,0 +1,631 @@
+<?php
+
+namespace Xgrz\Firebird\Schema\Grammars;
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Schema\Grammars\Grammar;
+use Illuminate\Support\Fluent;
+
+class FirebirdGrammar extends Grammar
+{
+    /**
+     * The possible column modifiers.
+     *
+     * @var array
+     */
+    protected $modifiers = ['Charset', 'Collate', 'Increment', 'Nullable', 'Default'];
+
+    /**
+     * The columns available as serials.
+     *
+     * @var array
+     */
+    protected $serials = ['bigInteger', 'integer', 'mediumInteger', 'smallInteger', 'tinyInteger'];
+
+    /**
+     * Compile the query to determine the tables.
+     *
+     * @return string
+     */
+    public function compileTables()
+    {
+        return 'select trim(trailing from rdb$relation_name) as "name" '
+            .'from rdb$relations '
+            .'where rdb$relation_type = 0 '
+            .'and (rdb$system_flag is null or rdb$system_flag = 0) '
+            .'order by rdb$relation_name';
+    }
+
+    /**
+     * Compile the query to determine if a table exists.
+     *
+     * @return string
+     */
+    public function compileTableExists()
+    {
+        return 'select rdb$relation_name from rdb$relations where rdb$relation_name = ?';
+    }
+
+    /**
+     * Compile the query to determine the views.
+     *
+     * @return string
+     */
+    public function compileViews()
+    {
+        return 'select trim(trailing from rdb$relation_name) as "name", '
+        .'rdb$view_source as "definition" '
+        .'from rdb$relations '
+        .'where rdb$view_blr is not null '
+        .'and (rdb$system_flag is null or rdb$system_flag = 0)';
+    }
+
+    /**
+     * Compile the query to determine the columns.
+     *
+     * @param  string  $table
+     * @return string
+     */
+    public function compileColumns($table)
+    {
+        return 'select trim(trailing from rdb$field_name) as "name" '
+            .'from rdb$relation_fields '
+            .'where rdb$relation_name = '.$this->quoteString($table).' '
+            .'order by rdb$relation_name';
+    }
+
+    /**
+     * Compile the query to determine the list of columns.
+     *
+     * @param  string  $table
+     * @return string
+     */
+    public function compileColumnListing($table)
+    {
+        return "select trim(rdb\$field_name) as \"column_name\" from rdb\$relation_fields where rdb\$relation_name = '$table'";
+    }
+
+    /**
+     * Compile a create table command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileCreate(Blueprint $blueprint, Fluent $command)
+    {
+        if ($blueprint->temporary) {
+            throw new \LogicException('This database driver does not support temporary tables.');
+        }
+
+        $columns = implode(', ', $this->getColumns($blueprint));
+
+        $sql = 'create table '.$this->wrapTable($blueprint)." ($columns)";
+
+        return $sql;
+    }
+
+    /**
+     * Compile a drop table command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileDrop(Blueprint $blueprint, Fluent $command)
+    {
+        return 'drop table '.$this->wrapTable($blueprint);
+    }
+
+    /**
+     * Compile a drop table (if exists) command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileDropIfExists(Blueprint $blueprint, Fluent $command)
+    {
+        // Replace the double quotes with single quotes.
+        $table = str_replace('"', "'", $this->wrapTable($blueprint));
+
+        return sprintf(
+            "execute block as begin if (exists(%s)) then execute statement '%s'; end",
+            str_replace('?', $table, $this->compileTableExists()), // Replace the ? character with the table name.
+            $this->compileDrop($blueprint, $command)
+        );
+    }
+
+    /**
+     * Compile a column addition command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileAdd(Blueprint $blueprint, Fluent $command)
+    {
+        $table = $this->wrapTable($blueprint);
+
+        $columns = $this->prefixArray('ADD', $this->getColumns($blueprint));
+
+        return 'ALTER TABLE '.$table.' '.implode(', ', $columns);
+    }
+
+    /**
+     * Compile a primary key command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compilePrimary(Blueprint $blueprint, Fluent $command)
+    {
+        $columns = $this->columnize($command->columns);
+
+        return 'ALTER TABLE '.$this->wrapTable($blueprint)." ADD PRIMARY KEY ({$columns})";
+    }
+
+    /**
+     * Compile a unique key command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileUnique(Blueprint $blueprint, Fluent $command)
+    {
+        $table = $this->wrapTable($blueprint);
+
+        $index = $this->wrap(substr($command->index, 0, 31));
+
+        $columns = $this->columnize($command->columns);
+
+        return "ALTER TABLE {$table} ADD CONSTRAINT {$index} UNIQUE ({$columns})";
+    }
+
+    /**
+     * Compile a plain index key command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileIndex(Blueprint $blueprint, Fluent $command)
+    {
+        $columns = $this->columnize($command->columns);
+
+        $index = $this->wrap(substr($command->index, 0, 31));
+
+        $table = $this->wrapTable($blueprint);
+
+        return "CREATE INDEX {$index} ON {$table} ($columns)";
+    }
+
+    /**
+     * Compile a foreign key command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileForeign(Blueprint $blueprint, Fluent $command)
+    {
+        $table = $this->wrapTable($blueprint);
+
+        $on = $this->wrapTable($command->on);
+
+        // We need to prepare several of the elements of the foreign key definition
+        // before we can create the SQL, such as wrapping the tables and convert
+        // an array of columns to comma-delimited strings for the SQL queries.
+        $columns = $this->columnize($command->columns);
+
+        $onColumns = $this->columnize((array) $command->references);
+
+        $fkName = substr($command->index, 0, 31);
+
+        $sql = "ALTER TABLE {$table} ADD CONSTRAINT {$fkName} ";
+
+        $sql .= "FOREIGN KEY ({$columns}) REFERENCES {$on} ({$onColumns})";
+
+        // Once we have the basic foreign key creation statement constructed we can
+        // build out the syntax for what should happen on an update or delete of
+        // the affected columns, which will get something like "cascade", etc.
+        if (! is_null($command->onDelete)) {
+            $sql .= " ON DELETE {$command->onDelete}";
+        }
+
+        if (! is_null($command->onUpdate)) {
+            $sql .= " ON UPDATE {$command->onUpdate}";
+        }
+
+        return $sql;
+    }
+
+    /**
+     * Compile a drop foreign key command.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $command
+     * @return string
+     */
+    public function compileDropForeign(Blueprint $blueprint, Fluent $command)
+    {
+        $table = $this->wrapTable($blueprint);
+
+        return "ALTER TABLE {$table} DROP CONSTRAINT {$command->index}";
+    }
+
+    /**
+     * Get the SQL for a character set column modifier.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string|null
+     */
+    protected function modifyCharset(Blueprint $blueprint, Fluent $column)
+    {
+        if (! is_null($column->charset)) {
+            return ' CHARACTER SET '.$column->charset;
+        }
+    }
+
+    /**
+     * Get the SQL for a collation column modifier.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string|null
+     */
+    protected function modifyCollate(Blueprint $blueprint, Fluent $column)
+    {
+        if (! is_null($column->collation)) {
+            return ' COLLATE '.$column->collation;
+        }
+    }
+
+    /**
+     * Get the SQL for a nullable column modifier.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string|null
+     */
+    protected function modifyNullable(Blueprint $blueprint, Fluent $column)
+    {
+        return $column->nullable ? '' : ' NOT NULL';
+    }
+
+    /**
+     * Get the SQL for a default column modifier.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string|null
+     */
+    protected function modifyDefault(Blueprint $blueprint, Fluent $column)
+    {
+        if (! is_null($column->default)) {
+            return ' DEFAULT '.$this->getDefaultValue($column->default);
+        }
+    }
+
+    /**
+     * Create the column definition for a char type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeChar(Fluent $column)
+    {
+        return "CHAR({$column->length})";
+    }
+
+    /**
+     * Create the column definition for a string type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeString(Fluent $column)
+    {
+        return "VARCHAR({$column->length})";
+    }
+
+    /**
+     * Create the column definition for a text type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeText(Fluent $column)
+    {
+        return 'BLOB SUB_TYPE TEXT';
+    }
+
+    /**
+     * Create the column definition for a medium text type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeMediumText(Fluent $column)
+    {
+        return 'BLOB SUB_TYPE TEXT';
+    }
+
+    /**
+     * Create the column definition for a long text type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeLongText(Fluent $column)
+    {
+        return 'BLOB SUB_TYPE TEXT';
+    }
+
+    /**
+     * Create the column definition for a integer type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeInteger(Fluent $column)
+    {
+        return 'INTEGER';
+    }
+
+    /**
+     * Create the column definition for a big integer type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeBigInteger(Fluent $column)
+    {
+        return 'BIGINT';
+    }
+
+    /**
+     * Create the column definition for a medium integer type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeMediumInteger(Fluent $column)
+    {
+        return 'INTEGER';
+    }
+
+    /**
+     * Create the column definition for a tiny integer type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeTinyInteger(Fluent $column)
+    {
+        return 'SMALLINT';
+    }
+
+    /**
+     * Create the column definition for a small integer type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeSmallInteger(Fluent $column)
+    {
+        return 'SMALLINT';
+    }
+
+    /**
+     * Create the column definition for a float type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeFloat(Fluent $column)
+    {
+        return 'FLOAT';
+    }
+
+    /**
+     * Create the column definition for a double type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeDouble(Fluent $column)
+    {
+        return 'DOUBLE PRECISION';
+    }
+
+    /**
+     * Create the column definition for a decimal type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeDecimal(Fluent $column)
+    {
+        return "DECIMAL({$column->total}, {$column->places})";
+    }
+
+    /**
+     * Create the column definition for a boolean type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeBoolean(Fluent $column)
+    {
+        return 'CHAR(1)';
+    }
+
+    /**
+     * Create the column definition for an enum type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeEnum(Fluent $column)
+    {
+        $allowed = array_map(function ($a) {
+            return "'".$a."'";
+        }, $column->allowed);
+
+        return "VARCHAR(255) CHECK (\"{$column->name}\" IN (".implode(', ', $allowed).'))';
+    }
+
+    /**
+     * Create the column definition for a json type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeJson(Fluent $column)
+    {
+        return 'VARCHAR(8191)';
+    }
+
+    /**
+     * Create the column definition for a jsonb type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeJsonb(Fluent $column)
+    {
+        return 'VARCHAR(8191) CHARACTER SET OCTETS';
+    }
+
+    /**
+     * Create the column definition for a date type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeDate(Fluent $column)
+    {
+        return 'DATE';
+    }
+
+    /**
+     * Create the column definition for a date-time type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeDateTime(Fluent $column)
+    {
+        return 'TIMESTAMP';
+    }
+
+    /**
+     * Create the column definition for a date-time type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeDateTimeTz(Fluent $column)
+    {
+        // No timezone support, default to plain date time
+        return $this->typeDateTime($column);
+    }
+
+    /**
+     * Create the column definition for a time type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeTime(Fluent $column)
+    {
+        return 'TIME';
+    }
+
+    /**
+     * Create the column definition for a time type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeTimeTz(Fluent $column)
+    {
+        // No timezone support, default to plain time
+        return $this->typeTime($column);
+    }
+
+    /**
+     * Create the column definition for a timestamp type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeTimestamp(Fluent $column)
+    {
+        if ($column->useCurrent) {
+            return 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP';
+        }
+
+        return 'TIMESTAMP';
+    }
+
+    /**
+     * Create the column definition for a timestamp type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeTimestampTz(Fluent $column)
+    {
+        // No timezone support, default to plain timestamp
+        return $this->typeTimestamp($column);
+    }
+
+    /**
+     * Create the column definition for a binary type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeBinary(Fluent $column)
+    {
+        return 'BLOB SUB_TYPE BINARY';
+    }
+
+    /**
+     * Create the column definition for a uuid type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeUuid(Fluent $column)
+    {
+        return 'CHAR(36)';
+    }
+
+    /**
+     * Create the column definition for an IP address type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeIpAddress(Fluent $column)
+    {
+        return 'VARCHAR(45)';
+    }
+
+    /**
+     * Create the column definition for a MAC address type.
+     *
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string
+     */
+    protected function typeMacAddress(Fluent $column)
+    {
+        return 'VARCHAR(17)';
+    }
+}