OracleGrammar::wrapValue() - Code Metrics - Inspection of "Implement reserved words qouting on schema grammar..." - yajra/laravel-oci8 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 4.0 ( eb4219...df36c7 )

by Arjay

created 2015-12-04 02:56 UTC

OracleGrammar::wrapValue() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	4
rs	10
cc	2
eloc	2
nc	2
nop	1

<?php

namespace Yajra\Oci8\Schema\Grammars;

use Illuminate\Database\Connection;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Schema\Grammars\Grammar;
use Illuminate\Support\Fluent;
use Yajra\Oci8\OracleReservedWords;

class OracleGrammar extends Grammar
{
    use OracleReservedWords;

    /**
     * The keyword identifier wrapper format.
     *
     * @var string
     */
    protected $wrapper = '%s';

    /**
     * The possible column modifiers.
     *
     * @var array
     */
    protected $modifiers = ['Increment', 'Nullable', 'Default'];

    /**
     * The possible column serials
     *
     * @var array
     */
    protected $serials = ['bigInteger', 'integer', 'mediumInteger', 'smallInteger', 'tinyInteger'];

    /**
     * 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)
    {
        $columns = implode(', ', $this->getColumns($blueprint));

        $sql = 'create table ' . $this->wrapTable($blueprint) . " ( $columns";

        /**
         * To be able to name the primary/foreign keys when the table is
         * initially created we will need to check for a primary/foreign
         * key commands and add the columns to the table's declaration
         * here so they can be created on the tables.
         */
        $sql .= (string) $this->addForeignKeys($blueprint);

        $sql .= (string) $this->addPrimaryKeys($blueprint);

        $sql .= ' )';

        return $sql;
    }

    /**
     * Get the foreign key syntax for a table creation statement.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @return string
     */
    protected function addForeignKeys(Blueprint $blueprint)
    {
        $sql = '';

        $foreigns = $this->getCommandsByName($blueprint, 'foreign');

        // Once we have all the foreign key commands for the table creation statement
        // we'll loop through each of them and add them to the create table SQL we
        // are building
        foreach ($foreigns as $foreign) {
            $on = $this->wrapTable($foreign->on);

            $columns = $this->columnize($foreign->columns);

            $onColumns = $this->columnize((array) $foreign->references);

            $sql .= ", constraint {$foreign->index} 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($foreign->onDelete)) {
                $sql .= " on delete {$foreign->onDelete}";
            }
        }

        return $sql;
    }

    /**
     * Get the primary key syntax for a table creation statement.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @return string|null
     */
    protected function addPrimaryKeys(Blueprint $blueprint)
    {
        $primary = $this->getCommandByName($blueprint, 'primary');

        if (! is_null($primary)) {
            $columns = $this->columnize($primary->columns);

            return ", constraint {$primary->index} primary key ( {$columns} )";
        }

        return "";
    }

    /**
     * Compile the query to determine if a table exists.
     *
     * @return string
     */
    public function compileTableExists()
    {
        return "select * from user_tables where upper(table_name) = upper(?)";
    }

    /**
     * Compile the query to determine the list of columns.
     *
     * @return string
     */
    public function compileColumnExists()
    {
        return "select column_name from user_tab_columns where table_name = upper(?) and column_name = upper(?)";
    }

    /**
     * Compile an add column command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileAdd(Blueprint $blueprint, Fluent $command)
    {
        $columns = implode(', ', $this->getColumns($blueprint));

        $sql = 'alter table ' . $this->wrapTable($blueprint) . " add ( $columns";

        $sql .= (string) $this->addPrimaryKeys($blueprint);

        return $sql .= ' )';
    }

    /**
     * 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)
    {
        $create = $this->getCommandByName($blueprint, 'create');

        if (is_null($create)) {
            $columns = $this->columnize($command->columns);

            $table = $this->wrapTable($blueprint);

            return "alter table {$table} add constraint {$command->index} primary key ({$columns})";
        }
    }

    /**
     * Compile a foreign key command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string|void
     */
    public function compileForeign(Blueprint $blueprint, Fluent $command)
    {
        $create = $this->getCommandByName($blueprint, 'create');

        if (is_null($create)) {
            $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);

            $sql = "alter table {$table} add constraint {$command->index} ";

            $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}";
            }

            return $sql;
        }
    }

    /**
     * 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)
    {
        return "alter table " . $this->wrapTable($blueprint) . " add constraint {$command->index} unique ( " . $this->columnize($command->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)
    {
        return "create index {$command->index} on " . $this->wrapTable($blueprint) . " ( " . $this->columnize($command->columns) . " )";
    }

    /**
     * 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)
    {
        $table = $this->wrapTable($blueprint);

        return "declare c int;
            begin
               select count(*) into c from user_tables where table_name = upper('$table');
               if c = 1 then
                  execute immediate 'drop table $table';
               end if;
            end;";
    }

    /**
     * Compile a drop column command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileDropColumn(Blueprint $blueprint, Fluent $command)
    {
        $columns = $this->wrapArray($command->columns);

        $table = $this->wrapTable($blueprint);

        return 'alter table ' . $table . ' drop ( ' . implode(', ', $columns) . ' )';
    }

    /**
     * Compile a drop primary key command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileDropPrimary(Blueprint $blueprint, Fluent $command)
    {
        return $this->dropConstraint($blueprint, $command, 'primary');
    }

    /**
     * @param Blueprint $blueprint
     * @param Fluent $command
     * @param string $type
     * @return string
     */
    private function dropConstraint(Blueprint $blueprint, Fluent $command, $type)
    {
        $table = $this->wrapTable($blueprint);
        $index = substr($command->index, 0, 30);

        if ($type === 'index') {
            return "drop index {$index}";
        }

        return "alter table {$table} drop constraint {$index}";
    }

    /**
     * Compile a drop unique key command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileDropUnique(Blueprint $blueprint, Fluent $command)
    {
        return $this->dropConstraint($blueprint, $command, 'unique');
    }

    /**
     * Compile a drop index command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileDropIndex(Blueprint $blueprint, Fluent $command)
    {
        return $this->dropConstraint($blueprint, $command, 'index');
    }

    /**
     * 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)
    {
        return $this->dropConstraint($blueprint, $command, 'foreign');
    }

    /**
     * Compile a rename table command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @return string
     */
    public function compileRename(Blueprint $blueprint, Fluent $command)
    {
        $from = $this->wrapTable($blueprint);

        return "alter table {$from} rename to " . $this->wrapTable($command->to);
    }

    /**
     * Compile a rename column command.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $command
     * @param  \Illuminate\Database\Connection $connection
     * @return array
     */
    public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
    {
        $table = $this->wrapTable($blueprint);

        $rs    = [];
        $rs[0] = 'alter table ' . $table . ' rename column ' . $command->from . ' to ' . $command->to;

        return (array) $rs;
    }

    /**
     * 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 "varchar2({$column->length})";
    }

    /**
     * Create the column definition for a text type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeText(Fluent $column)
    {
        return "clob";
    }

    /**
     * Create the column definition for a medium text type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeMediumText(Fluent $column)
    {
        return 'clob';
    }

    /**
     * Create the column definition for a long text type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeLongText(Fluent $column)
    {
        return 'clob';
    }

    /**
     * Create the column definition for a integer type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeInteger(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 10;

        return "number({$length},0)";
    }

    /**
     * Create the column definition for a integer type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeBigInteger(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 19;

        return "number({$length},0)";
    }

    /**
     * Create the column definition for a medium integer type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeMediumInteger(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 7;

        return "number({$length},0)";
    }

    /**
     * Create the column definition for a small integer type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeSmallInteger(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 5;

        return "number({$length},0)";
    }

    /**
     * Create the column definition for a tiny integer type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeTinyInteger(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 3;

        return "number({$length},0)";
    }

    /**
     * Create the column definition for a float type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeFloat(Fluent $column)
    {
        return "number({$column->total}, {$column->places})";
    }

    /**
     * Create the column definition for a double type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeDouble(Fluent $column)
    {
        return "number({$column->total}, {$column->places})";
    }

    /**
     * Create the column definition for a decimal type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeDecimal(Fluent $column)
    {
        return "number({$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 a enum type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeEnum(Fluent $column)
    {
        $length = ($column->length) ? $column->length : 255;

        return "varchar2({$length})";
    }

    /**
     * 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 'date';
    }

    /**
     * Create the column definition for a time type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeTime(Fluent $column)
    {
        return 'date';
    }

    /**
     * Create the column definition for a timestamp type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeTimestamp(Fluent $column)
    {
        return 'timestamp';
    }

    /**
     * Create the column definition for a timestamp type with timezone.
     *
     * @param Fluent $column
     * @return string
     */
    protected function typeTimestampTz(Fluent $column)
    {
        return 'timestamp with time zone';
    }

    /**
     * Create the column definition for a binary type.
     *
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function typeBinary(Fluent $column)
    {
        return 'blob';
    }

    /**
     * Get the SQL for a nullable column modifier.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function modifyNullable(Blueprint $blueprint, Fluent $column)
    {
        // check if field is declared as enum
        $enum = "";
        if (count((array) $column->allowed)) {
            $enum = " check ({$column->name} in ('" . implode("', '", $column->allowed) . "'))";
        }

        $null = $column->nullable ? ' null' : ' not null';
        $null .= $enum;

        if (! is_null($column->default)) {
            return " default " . $this->getDefaultValue($column->default) . $null;
        }

        return $null;
    }

    /**
     * Get the SQL for a default column modifier.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $column
     * @return string
     */
    protected function modifyDefault(Blueprint $blueprint, Fluent $column)
    {
        // implemented @modifyNullable
        return "";
    }

    /**
     * Get the SQL for an auto-increment column modifier.
     *
     * @param  \Illuminate\Database\Schema\Blueprint $blueprint
     * @param  \Illuminate\Support\Fluent $column
     * @return string|null
     */
    protected function modifyIncrement(Blueprint $blueprint, Fluent $column)
    {
        if (in_array($column->type, $this->serials) && $column->autoIncrement) {
            $blueprint->primary($column->name);
        }
    }
}


1			<?php
2
3			namespace Yajra\Oci8\Schema\Grammars;
4
5			use Illuminate\Database\Connection;
6			use Illuminate\Database\Schema\Blueprint;
7			use Illuminate\Database\Schema\Grammars\Grammar;
8			use Illuminate\Support\Fluent;
9			use Yajra\Oci8\OracleReservedWords;
10
11			class OracleGrammar extends Grammar
12			{
13			use OracleReservedWords;
14
15			/**
16			* The keyword identifier wrapper format.
17			*
18			* @var string
19			*/
20			protected $wrapper = '%s';
21
22			/**
23			* The possible column modifiers.
24			*
25			* @var array
26			*/
27			protected $modifiers = ['Increment', 'Nullable', 'Default'];
28
29			/**
30			* The possible column serials
31			*
32			* @var array
33			*/
34			protected $serials = ['bigInteger', 'integer', 'mediumInteger', 'smallInteger', 'tinyInteger'];
35
36			/**
37			* Compile a create table command.
38			*
39			* @param \Illuminate\Database\Schema\Blueprint $blueprint
40			* @param \Illuminate\Support\Fluent $command
41			* @return string
42			*/
43			public function compileCreate(Blueprint $blueprint, Fluent $command)
44			{
45			$columns = implode(', ', $this->getColumns($blueprint));
46
47			$sql = 'create table ' . $this->wrapTable($blueprint) . " ( $columns";
48
49			/**
50			* To be able to name the primary/foreign keys when the table is
51			* initially created we will need to check for a primary/foreign
52			* key commands and add the columns to the table's declaration
53			* here so they can be created on the tables.
54			*/
55			$sql .= (string) $this->addForeignKeys($blueprint);
56
57			$sql .= (string) $this->addPrimaryKeys($blueprint);
58
59			$sql .= ' )';
60
61			return $sql;
62			}
63
64			/**
65			* Get the foreign key syntax for a table creation statement.
66			*
67			* @param \Illuminate\Database\Schema\Blueprint $blueprint
68			* @return string
69			*/
70			protected function addForeignKeys(Blueprint $blueprint)
71			{
72			$sql = '';
73
74			$foreigns = $this->getCommandsByName($blueprint, 'foreign');
75
76			// Once we have all the foreign key commands for the table creation statement
77			// we'll loop through each of them and add them to the create table SQL we
78			// are building
79			foreach ($foreigns as $foreign) {
80			$on = $this->wrapTable($foreign->on);
81
82			$columns = $this->columnize($foreign->columns);
83
84			$onColumns = $this->columnize((array) $foreign->references);
85
86			$sql .= ", constraint {$foreign->index} foreign key ( {$columns} ) references {$on} ( {$onColumns} )";
87
88			// Once we have the basic foreign key creation statement constructed we can
89			// build out the syntax for what should happen on an update or delete of
90			// the affected columns, which will get something like "cascade", etc.
91			if (! is_null($foreign->onDelete)) {
92			$sql .= " on delete {$foreign->onDelete}";
93			}
94			}
95
96			return $sql;
97			}
98
99			/**
100			* Get the primary key syntax for a table creation statement.
101			*
102			* @param \Illuminate\Database\Schema\Blueprint $blueprint
103			* @return string\|null
104			*/
105			protected function addPrimaryKeys(Blueprint $blueprint)
106			{
107			$primary = $this->getCommandByName($blueprint, 'primary');
108
109			if (! is_null($primary)) {
110			$columns = $this->columnize($primary->columns);
111
112			return ", constraint {$primary->index} primary key ( {$columns} )";
113			}
114
115			return "";
116			}
117
118			/**
119			* Compile the query to determine if a table exists.
120			*
121			* @return string
122			*/
123			public function compileTableExists()
124			{
125			return "select * from user_tables where upper(table_name) = upper(?)";
126			}
127
128			/**
129			* Compile the query to determine the list of columns.
130			*
131			* @return string
132			*/
133			public function compileColumnExists()
134			{
135			return "select column_name from user_tab_columns where table_name = upper(?) and column_name = upper(?)";
136			}
137
138			/**
139			* Compile an add column command.
140			*
141			* @param \Illuminate\Database\Schema\Blueprint $blueprint
142			* @param \Illuminate\Support\Fluent $command
143			* @return string
144			*/
145			public function compileAdd(Blueprint $blueprint, Fluent $command)
146			{
147			$columns = implode(', ', $this->getColumns($blueprint));
148
149			$sql = 'alter table ' . $this->wrapTable($blueprint) . " add ( $columns";
150
151			$sql .= (string) $this->addPrimaryKeys($blueprint);
152
153			return $sql .= ' )';
154			}
155
156			/**
157			* Compile a primary key command.
158			*
159			* @param \Illuminate\Database\Schema\Blueprint $blueprint
160			* @param \Illuminate\Support\Fluent $command
161			* @return string
162			*/
163			public function compilePrimary(Blueprint $blueprint, Fluent $command)
164			{
165			$create = $this->getCommandByName($blueprint, 'create');
166
167			if (is_null($create)) {
168			$columns = $this->columnize($command->columns);
169
170			$table = $this->wrapTable($blueprint);
171
172			return "alter table {$table} add constraint {$command->index} primary key ({$columns})";
173			}
174			}
175
176			/**
177			* Compile a foreign key command.
178			*
179			* @param \Illuminate\Database\Schema\Blueprint $blueprint
180			* @param \Illuminate\Support\Fluent $command
181			* @return string\|void
182			*/
183			public function compileForeign(Blueprint $blueprint, Fluent $command)
184			{
185			$create = $this->getCommandByName($blueprint, 'create');
186
187			if (is_null($create)) {
188			$table = $this->wrapTable($blueprint);
189
190			$on = $this->wrapTable($command->on);
191
192			// We need to prepare several of the elements of the foreign key definition
193			// before we can create the SQL, such as wrapping the tables and convert
194			// an array of columns to comma-delimited strings for the SQL queries.
195			$columns = $this->columnize($command->columns);
196
197			$onColumns = $this->columnize((array) $command->references);
198
199			$sql = "alter table {$table} add constraint {$command->index} ";
200
201			$sql .= "foreign key ( {$columns} ) references {$on} ( {$onColumns} )";
202
203			// Once we have the basic foreign key creation statement constructed we can
204			// build out the syntax for what should happen on an update or delete of
205			// the affected columns, which will get something like "cascade", etc.
206			if (! is_null($command->onDelete)) {
207			$sql .= " on delete {$command->onDelete}";
208			}
209
210			return $sql;
211			}
212			}
213
214			/**
215			* Compile a unique key command.
216			*
217			* @param \Illuminate\Database\Schema\Blueprint $blueprint
218			* @param \Illuminate\Support\Fluent $command
219			* @return string
220			*/
221			public function compileUnique(Blueprint $blueprint, Fluent $command)
222			{
223			return "alter table " . $this->wrapTable($blueprint) . " add constraint {$command->index} unique ( " . $this->columnize($command->columns) . " )";
224			}
225
226			/**
227			* Compile a plain index key command.
228			*
229			* @param \Illuminate\Database\Schema\Blueprint $blueprint
230			* @param \Illuminate\Support\Fluent $command
231			* @return string
232			*/
233			public function compileIndex(Blueprint $blueprint, Fluent $command)
234			{
235			return "create index {$command->index} on " . $this->wrapTable($blueprint) . " ( " . $this->columnize($command->columns) . " )";
236			}
237
238			/**
239			* Compile a drop table command.
240			*
241			* @param \Illuminate\Database\Schema\Blueprint $blueprint
242			* @param \Illuminate\Support\Fluent $command
243			* @return string
244			*/
245			public function compileDrop(Blueprint $blueprint, Fluent $command)
246			{
247			return 'drop table ' . $this->wrapTable($blueprint);
248			}
249
250			/**
251			* Compile a drop table (if exists) command.
252			*
253			* @param \Illuminate\Database\Schema\Blueprint $blueprint
254			* @param \Illuminate\Support\Fluent $command
255			* @return string
256			*/
257			public function compileDropIfExists(Blueprint $blueprint, Fluent $command)
258			{
259			$table = $this->wrapTable($blueprint);
260
261			return "declare c int;
262			begin
263			select count(*) into c from user_tables where table_name = upper('$table');
264			if c = 1 then
265			execute immediate 'drop table $table';
266			end if;
267			end;";
268			}
269
270			/**
271			* Compile a drop column command.
272			*
273			* @param \Illuminate\Database\Schema\Blueprint $blueprint
274			* @param \Illuminate\Support\Fluent $command
275			* @return string
276			*/
277			public function compileDropColumn(Blueprint $blueprint, Fluent $command)
278			{
279			$columns = $this->wrapArray($command->columns);
280
281			$table = $this->wrapTable($blueprint);
282
283			return 'alter table ' . $table . ' drop ( ' . implode(', ', $columns) . ' )';
284			}
285
286			/**
287			* Compile a drop primary key command.
288			*
289			* @param \Illuminate\Database\Schema\Blueprint $blueprint
290			* @param \Illuminate\Support\Fluent $command
291			* @return string
292			*/
293			public function compileDropPrimary(Blueprint $blueprint, Fluent $command)
294			{
295			return $this->dropConstraint($blueprint, $command, 'primary');
296			}
297
298			/**
299			* @param Blueprint $blueprint
300			* @param Fluent $command
301			* @param string $type
302			* @return string
303			*/
304			private function dropConstraint(Blueprint $blueprint, Fluent $command, $type)
305			{
306			$table = $this->wrapTable($blueprint);
307			$index = substr($command->index, 0, 30);
308
309			if ($type === 'index') {
310			return "drop index {$index}";
311			}
312
313			return "alter table {$table} drop constraint {$index}";
314			}
315
316			/**
317			* Compile a drop unique key command.
318			*
319			* @param \Illuminate\Database\Schema\Blueprint $blueprint
320			* @param \Illuminate\Support\Fluent $command
321			* @return string
322			*/
323			public function compileDropUnique(Blueprint $blueprint, Fluent $command)
324			{
325			return $this->dropConstraint($blueprint, $command, 'unique');
326			}
327
328			/**
329			* Compile a drop index command.
330			*
331			* @param \Illuminate\Database\Schema\Blueprint $blueprint
332			* @param \Illuminate\Support\Fluent $command
333			* @return string
334			*/
335			public function compileDropIndex(Blueprint $blueprint, Fluent $command)
336			{
337			return $this->dropConstraint($blueprint, $command, 'index');
338			}
339
340			/**
341			* Compile a drop foreign key command.
342			*
343			* @param \Illuminate\Database\Schema\Blueprint $blueprint
344			* @param \Illuminate\Support\Fluent $command
345			* @return string
346			*/
347			public function compileDropForeign(Blueprint $blueprint, Fluent $command)
348			{
349			return $this->dropConstraint($blueprint, $command, 'foreign');
350			}
351
352			/**
353			* Compile a rename table command.
354			*
355			* @param \Illuminate\Database\Schema\Blueprint $blueprint
356			* @param \Illuminate\Support\Fluent $command
357			* @return string
358			*/
359			public function compileRename(Blueprint $blueprint, Fluent $command)
360			{
361			$from = $this->wrapTable($blueprint);
362
363			return "alter table {$from} rename to " . $this->wrapTable($command->to);
364			}
365
366			/**
367			* Compile a rename column command.
368			*
369			* @param \Illuminate\Database\Schema\Blueprint $blueprint
370			* @param \Illuminate\Support\Fluent $command
371			* @param \Illuminate\Database\Connection $connection
372			* @return array
373			*/
374			public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
375			{
376			$table = $this->wrapTable($blueprint);
377
378			$rs = [];
379			$rs[0] = 'alter table ' . $table . ' rename column ' . $command->from . ' to ' . $command->to;
380
381			return (array) $rs;
382			}
383
384			/**
385			* Create the column definition for a char type.
386			*
387			* @param \Illuminate\Support\Fluent $column
388			* @return string
389			*/
390			protected function typeChar(Fluent $column)
391			{
392			return "char({$column->length})";
393			}
394
395			/**
396			* Create the column definition for a string type.
397			*
398			* @param \Illuminate\Support\Fluent $column
399			* @return string
400			*/
401			protected function typeString(Fluent $column)
402			{
403			return "varchar2({$column->length})";
404			}
405
406			/**
407			* Create the column definition for a text type.
408			*
409			* @param \Illuminate\Support\Fluent $column
410			* @return string
411			*/
412			protected function typeText(Fluent $column)
413			{
414			return "clob";
415			}
416
417			/**
418			* Create the column definition for a medium text type.
419			*
420			* @param \Illuminate\Support\Fluent $column
421			* @return string
422			*/
423			protected function typeMediumText(Fluent $column)
424			{
425			return 'clob';
426			}
427
428			/**
429			* Create the column definition for a long text type.
430			*
431			* @param \Illuminate\Support\Fluent $column
432			* @return string
433			*/
434			protected function typeLongText(Fluent $column)
435			{
436			return 'clob';
437			}
438
439			/**
440			* Create the column definition for a integer type.
441			*
442			* @param \Illuminate\Support\Fluent $column
443			* @return string
444			*/
445			protected function typeInteger(Fluent $column)
446			{
447			$length = ($column->length) ? $column->length : 10;
448
449			return "number({$length},0)";
450			}
451
452			/**
453			* Create the column definition for a integer type.
454			*
455			* @param \Illuminate\Support\Fluent $column
456			* @return string
457			*/
458			protected function typeBigInteger(Fluent $column)
459			{
460			$length = ($column->length) ? $column->length : 19;
461
462			return "number({$length},0)";
463			}
464
465			/**
466			* Create the column definition for a medium integer type.
467			*
468			* @param \Illuminate\Support\Fluent $column
469			* @return string
470			*/
471			protected function typeMediumInteger(Fluent $column)
472			{
473			$length = ($column->length) ? $column->length : 7;
474
475			return "number({$length},0)";
476			}
477
478			/**
479			* Create the column definition for a small integer type.
480			*
481			* @param \Illuminate\Support\Fluent $column
482			* @return string
483			*/
484			protected function typeSmallInteger(Fluent $column)
485			{
486			$length = ($column->length) ? $column->length : 5;
487
488			return "number({$length},0)";
489			}
490
491			/**
492			* Create the column definition for a tiny integer type.
493			*
494			* @param \Illuminate\Support\Fluent $column
495			* @return string
496			*/
497			protected function typeTinyInteger(Fluent $column)
498			{
499			$length = ($column->length) ? $column->length : 3;
500
501			return "number({$length},0)";
502			}
503
504			/**
505			* Create the column definition for a float type.
506			*
507			* @param \Illuminate\Support\Fluent $column
508			* @return string
509			*/
510			protected function typeFloat(Fluent $column)
511			{
512			return "number({$column->total}, {$column->places})";
513			}
514
515			/**
516			* Create the column definition for a double type.
517			*
518			* @param \Illuminate\Support\Fluent $column
519			* @return string
520			*/
521			protected function typeDouble(Fluent $column)
522			{
523			return "number({$column->total}, {$column->places})";
524			}
525
526			/**
527			* Create the column definition for a decimal type.
528			*
529			* @param \Illuminate\Support\Fluent $column
530			* @return string
531			*/
532			protected function typeDecimal(Fluent $column)
533			{
534			return "number({$column->total}, {$column->places})";
535			}
536
537			/**
538			* Create the column definition for a boolean type.
539			*
540			* @param \Illuminate\Support\Fluent $column
541			* @return string
542			*/
543			protected function typeBoolean(Fluent $column)
544			{
545			return "char(1)";
546			}
547
548			/**
549			* Create the column definition for a enum type.
550			*
551			* @param \Illuminate\Support\Fluent $column
552			* @return string
553			*/
554			protected function typeEnum(Fluent $column)
555			{
556			$length = ($column->length) ? $column->length : 255;
557
558			return "varchar2({$length})";
559			}
560
561			/**
562			* Create the column definition for a date type.
563			*
564			* @param \Illuminate\Support\Fluent $column
565			* @return string
566			*/
567			protected function typeDate(Fluent $column)
568			{
569			return 'date';
570			}
571
572			/**
573			* Create the column definition for a date-time type.
574			*
575			* @param \Illuminate\Support\Fluent $column
576			* @return string
577			*/
578			protected function typeDateTime(Fluent $column)
579			{
580			return 'date';
581			}
582
583			/**
584			* Create the column definition for a time type.
585			*
586			* @param \Illuminate\Support\Fluent $column
587			* @return string
588			*/
589			protected function typeTime(Fluent $column)
590			{
591			return 'date';
592			}
593
594			/**
595			* Create the column definition for a timestamp type.
596			*
597			* @param \Illuminate\Support\Fluent $column
598			* @return string
599			*/
600			protected function typeTimestamp(Fluent $column)
601			{
602			return 'timestamp';
603			}
604
605			/**
606			* Create the column definition for a timestamp type with timezone.
607			*
608			* @param Fluent $column
609			* @return string
610			*/
611			protected function typeTimestampTz(Fluent $column)
612			{
613			return 'timestamp with time zone';
614			}
615
616			/**
617			* Create the column definition for a binary type.
618			*
619			* @param \Illuminate\Support\Fluent $column
620			* @return string
621			*/
622			protected function typeBinary(Fluent $column)
623			{
624			return 'blob';
625			}
626
627			/**
628			* Get the SQL for a nullable column modifier.
629			*
630			* @param \Illuminate\Database\Schema\Blueprint $blueprint
631			* @param \Illuminate\Support\Fluent $column
632			* @return string
633			*/
634			protected function modifyNullable(Blueprint $blueprint, Fluent $column)
635			{
636			// check if field is declared as enum
637			$enum = "";
638			if (count((array) $column->allowed)) {
639			$enum = " check ({$column->name} in ('" . implode("', '", $column->allowed) . "'))";
640			}
641
642			$null = $column->nullable ? ' null' : ' not null';
643			$null .= $enum;
644
645			if (! is_null($column->default)) {
646			return " default " . $this->getDefaultValue($column->default) . $null;
647			}
648
649			return $null;
650			}
651
652			/**
653			* Get the SQL for a default column modifier.
654			*
655			* @param \Illuminate\Database\Schema\Blueprint $blueprint
656			* @param \Illuminate\Support\Fluent $column
657			* @return string
658			*/
659			protected function modifyDefault(Blueprint $blueprint, Fluent $column)
660			{
661			// implemented @modifyNullable
662			return "";
663			}
664
665			/**
666			* Get the SQL for an auto-increment column modifier.
667			*
668			* @param \Illuminate\Database\Schema\Blueprint $blueprint
669			* @param \Illuminate\Support\Fluent $column
670			* @return string\|null
671			*/
672			protected function modifyIncrement(Blueprint $blueprint, Fluent $column)
673			{
674			if (in_array($column->type, $this->serials) && $column->autoIncrement) {
675			$blueprint->primary($column->name);
676			}
677			}
678			}
679

yajra / laravel-oci8

Push — 4.0 ( eb4219...df36c7 )

OracleGrammar::wrapValue() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like