AbstractReference::getForeignKey() - Code Metrics - Inspection of "more cs" - spiral/components - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature/pre-split (7b42f5)

by Anton

created 2016-12-07 11:39 UTC

AbstractReference::getForeignKey() A

↳ Parent: AbstractReference

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

namespace Spiral\Database\Schemas;

use Spiral\Database\Schemas\Prototypes\AbstractElement;
use Spiral\Database\Schemas\ReferenceInterface;
use Spiral\ODM\Exceptions\SchemaException;

/**
 * Abstract foreign schema with read (see ReferenceInterface) and write abilities. Must be
 * implemented by driver to support DBMS specific syntax and creation rules.
 */
abstract class AbstractReference extends AbstractElement implements ReferenceInterface
{
    /**
     * Local column name (key name).
     *
     * @var string
     */
    protected $column = '';

    /**
     * Referenced table name (including prefix).
     *
     * @var string
     */
    protected $foreignTable = '';

    /**
     * Linked foreign key name (foreign column).
     *
     * @var string
     */
    protected $foreignKey = '';

    /**
     * Action on foreign column value deletion.
     *
     * @var string
     */
    protected $deleteRule = self::NO_ACTION;

    /**
     * Action on foreign column value update.
     *
     * @var string
     */
    protected $updateRule = self::NO_ACTION;

    /**
     * Mark schema entity as declared, it will be kept in final diff.
     *
     * @param bool $declared
     *
     * @return $this
     */
    public function declared($declared = true)
    {
        if ($declared && $this->table->hasIndex([$this->column])) {
            //Some databases require index for each foreign key
            $this->table->index([$this->column])->declared(true);
        }

        return parent::declared($declared);
    }

    /**
     * {@inheritdoc}
     *
     * @param string $name
     *
     * @return $this
     */
    public function setName($name)
    {
        if (!empty($this->name)) {
            throw new SchemaException('Changing reference name is not allowed');
        }

        return parent::setName($name);
    }

    /**
     * {@inheritdoc}
     *
     * @param bool $quoted Quote name.
     */
    public function getName($quoted = false)
    {
        if (empty($this->name)) {
            $this->setName($this->generateName());
        }

        return parent::getName($quoted);
    }

    /**
     * {@inheritdoc}
     */
    public function getColumn()
    {
        return $this->column;
    }

    /**
     * {@inheritdoc}
     */
    public function getForeignTable()
    {
        return $this->foreignTable;
    }

    /**
     * {@inheritdoc}
     */
    public function getForeignKey()
    {
        return $this->foreignKey;
    }

    /**
     * {@inheritdoc}
     */
    public function getDeleteRule()
    {
        return $this->deleteRule;
    }

    /**
     * {@inheritdoc}
     */
    public function getUpdateRule()
    {
        return $this->updateRule;
    }

    /**
     * Set local column name foreign key relates to. Make sure column type is the same as foreign
     * column one.
     *
     * @param string $column
     *
     * @return $this
     */
    public function column($column)
    {
        $this->column = $column;

        return $this;
    }

    /**
     * Set foreign table name and key local column must reference to. Make sure local and foreign
     * column types are identical.
     *
     * @param string $table  Foreign table name without database prefix (will be added
     *                       automatically).
     * @param string $column Foreign key name (id by default).
     *
     * @return $this
     */
    public function references($table, $column = 'id')
    {
        $this->foreignTable = $this->table->getPrefix() . $table;
        $this->foreignKey = $column;

        return $this;
    }

    /**
     * Set foreign key delete behaviour.
     *
     * @param string $rule Possible values: NO ACTION, CASCADE, etc (driver specific).
     *
     * @return $this
     */
    public function onDelete($rule = self::NO_ACTION)
    {
        $this->deleteRule = strtoupper($rule);

        return $this;
    }

    /**
     * Set foreign key update behaviour.
     *
     * @param string $rule Possible values: NO ACTION, CASCADE, etc (driver specific).
     *
     * @return $this
     */
    public function onUpdate($rule = self::NO_ACTION)
    {
        $this->updateRule = strtoupper($rule);

        return $this;
    }

    /**
     * Foreign key creation syntax.
     *
     * @return string
     */
    public function sqlStatement()
    {
        $statement = [];

        $statement[] = 'CONSTRAINT';
        $statement[] = $this->getName(true);
        $statement[] = 'FOREIGN KEY';
        $statement[] = '(' . $this->table->driver()->identifier($this->column) . ')';

        $statement[] = 'REFERENCES ' . $this->table->driver()->identifier($this->foreignTable);
        $statement[] = '(' . $this->table->driver()->identifier($this->foreignKey) . ')';

        $statement[] = "ON DELETE {$this->deleteRule}";
        $statement[] = "ON UPDATE {$this->updateRule}";

        return implode(' ', $statement);
    }

    /**
     * Compare two elements together.
     *
     * @param self $initial
     *
     * @return bool
     */
    public function compare(self $initial)
    {
        $normalized = clone $initial;
        $normalized->declared = $this->declared;

        return $this == $normalized;
    }

    /**
     * Generate unique foreign key name.
     *
     * @return string
     */
    protected function generateName()
    {
        $name = $this->table->getName() . '_foreign_' . $this->column . '_' . uniqid();

        if (strlen($name) > 64) {
            //Many dbs has limitations on identifier length
            $name = md5($name);
        }

        return $name;
    }
}


1			<?php
2			/**
3			* Spiral Framework.
4			*
5			* @license MIT
6			* @author Anton Titov (Wolfy-J)
7			*/
8
9			namespace Spiral\Database\Schemas;
10
11			use Spiral\Database\Schemas\Prototypes\AbstractElement;
12			use Spiral\Database\Schemas\ReferenceInterface;
13			use Spiral\ODM\Exceptions\SchemaException;
14
15			/**
16			* Abstract foreign schema with read (see ReferenceInterface) and write abilities. Must be
17			* implemented by driver to support DBMS specific syntax and creation rules.
18			*/
19			abstract class AbstractReference extends AbstractElement implements ReferenceInterface
20			{
21			/**
22			* Local column name (key name).
23			*
24			* @var string
25			*/
26			protected $column = '';
27
28			/**
29			* Referenced table name (including prefix).
30			*
31			* @var string
32			*/
33			protected $foreignTable = '';
34
35			/**
36			* Linked foreign key name (foreign column).
37			*
38			* @var string
39			*/
40			protected $foreignKey = '';
41
42			/**
43			* Action on foreign column value deletion.
44			*
45			* @var string
46			*/
47			protected $deleteRule = self::NO_ACTION;
48
49			/**
50			* Action on foreign column value update.
51			*
52			* @var string
53			*/
54			protected $updateRule = self::NO_ACTION;
55
56			/**
57			* Mark schema entity as declared, it will be kept in final diff.
58			*
59			* @param bool $declared
60			*
61			* @return $this
62			*/
63			public function declared($declared = true)
64			{
65			if ($declared && $this->table->hasIndex([$this->column])) {
66			//Some databases require index for each foreign key
67			$this->table->index([$this->column])->declared(true);
68			}
69
70			return parent::declared($declared);
71			}
72
73			/**
74			* {@inheritdoc}
75			*
76			* @param string $name
77			*
78			* @return $this
79			*/
80			public function setName($name)
81			{
82			if (!empty($this->name)) {
83			throw new SchemaException('Changing reference name is not allowed');
84			}
85
86			return parent::setName($name);
87			}
88
89			/**
90			* {@inheritdoc}
91			*
92			* @param bool $quoted Quote name.
93			*/
94			public function getName($quoted = false)
95			{
96			if (empty($this->name)) {
97			$this->setName($this->generateName());
98			}
99
100			return parent::getName($quoted);
101			}
102
103			/**
104			* {@inheritdoc}
105			*/
106			public function getColumn()
107			{
108			return $this->column;
109			}
110
111			/**
112			* {@inheritdoc}
113			*/
114			public function getForeignTable()
115			{
116			return $this->foreignTable;
117			}
118
119			/**
120			* {@inheritdoc}
121			*/
122			public function getForeignKey()
123			{
124			return $this->foreignKey;
125			}
126
127			/**
128			* {@inheritdoc}
129			*/
130			public function getDeleteRule()
131			{
132			return $this->deleteRule;
133			}
134
135			/**
136			* {@inheritdoc}
137			*/
138			public function getUpdateRule()
139			{
140			return $this->updateRule;
141			}
142
143			/**
144			* Set local column name foreign key relates to. Make sure column type is the same as foreign
145			* column one.
146			*
147			* @param string $column
148			*
149			* @return $this
150			*/
151			public function column($column)
152			{
153			$this->column = $column;
154
155			return $this;
156			}
157
158			/**
159			* Set foreign table name and key local column must reference to. Make sure local and foreign
160			* column types are identical.
161			*
162			* @param string $table Foreign table name without database prefix (will be added
163			* automatically).
164			* @param string $column Foreign key name (id by default).
165			*
166			* @return $this
167			*/
168			public function references($table, $column = 'id')
169			{
170			$this->foreignTable = $this->table->getPrefix() . $table;
171			$this->foreignKey = $column;
172
173			return $this;
174			}
175
176			/**
177			* Set foreign key delete behaviour.
178			*
179			* @param string $rule Possible values: NO ACTION, CASCADE, etc (driver specific).
180			*
181			* @return $this
182			*/
183			public function onDelete($rule = self::NO_ACTION)
184			{
185			$this->deleteRule = strtoupper($rule);
186
187			return $this;
188			}
189
190			/**
191			* Set foreign key update behaviour.
192			*
193			* @param string $rule Possible values: NO ACTION, CASCADE, etc (driver specific).
194			*
195			* @return $this
196			*/
197			public function onUpdate($rule = self::NO_ACTION)
198			{
199			$this->updateRule = strtoupper($rule);
200
201			return $this;
202			}
203
204			/**
205			* Foreign key creation syntax.
206			*
207			* @return string
208			*/
209			public function sqlStatement()
210			{
211			$statement = [];
212
213			$statement[] = 'CONSTRAINT';
214			$statement[] = $this->getName(true);
215			$statement[] = 'FOREIGN KEY';
216			$statement[] = '(' . $this->table->driver()->identifier($this->column) . ')';
217
218			$statement[] = 'REFERENCES ' . $this->table->driver()->identifier($this->foreignTable);
219			$statement[] = '(' . $this->table->driver()->identifier($this->foreignKey) . ')';
220
221			$statement[] = "ON DELETE {$this->deleteRule}";
222			$statement[] = "ON UPDATE {$this->updateRule}";
223
224			return implode(' ', $statement);
225			}
226
227			/**
228			* Compare two elements together.
229			*
230			* @param self $initial
231			*
232			* @return bool
233			*/
234			public function compare(self $initial)
235			{
236			$normalized = clone $initial;
237			$normalized->declared = $this->declared;
238
239			return $this == $normalized;
240			}
241
242			/**
243			* Generate unique foreign key name.
244			*
245			* @return string
246			*/
247			protected function generateName()
248			{
249			$name = $this->table->getName() . '_foreign_' . $this->column . '_' . uniqid();
250
251			if (strlen($name) > 64) {
252			//Many dbs has limitations on identifier length
253			$name = md5($name);
254			}
255
256			return $name;
257			}
258			}
259

spiral / components

Branch — feature/pre-split (7b42f5)

AbstractReference::getForeignKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like