forked from doctrine/dbal
/
Schema.php
374 lines (308 loc) · 9.97 KB
/
Schema.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
<?php
declare(strict_types=1);
namespace Doctrine\DBAL\Schema;
use Doctrine\DBAL\Exception;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\Exception\NamespaceAlreadyExists;
use Doctrine\DBAL\Schema\Exception\SequenceAlreadyExists;
use Doctrine\DBAL\Schema\Exception\SequenceDoesNotExist;
use Doctrine\DBAL\Schema\Exception\TableAlreadyExists;
use Doctrine\DBAL\Schema\Exception\TableDoesNotExist;
use Doctrine\DBAL\SQL\Builder\CreateSchemaObjectsSQLBuilder;
use Doctrine\DBAL\SQL\Builder\DropSchemaObjectsSQLBuilder;
use function array_values;
use function str_contains;
use function strtolower;
/**
* Object representation of a database schema.
*
* Different vendors have very inconsistent naming with regard to the concept
* of a "schema". Doctrine understands a schema as the entity that conceptually
* wraps a set of database objects such as tables, sequences, indexes and
* foreign keys that belong to each other into a namespace. A Doctrine Schema
* has nothing to do with the "SCHEMA" defined as in PostgreSQL, it is more
* related to the concept of "DATABASE" that exists in MySQL and PostgreSQL.
*
* Every asset in the doctrine schema has a name. A name consists of either a
* namespace.local name pair or just a local unqualified name.
*
* The abstraction layer that covers a PostgreSQL schema is the namespace of an
* database object (asset). A schema can have a name, which will be used as
* default namespace for the unqualified database objects that are created in
* the schema.
*
* In the case of MySQL where cross-database queries are allowed this leads to
* databases being "misinterpreted" as namespaces. This is intentional, however
* the CREATE/DROP SQL visitors will just filter this queries and do not
* execute them. Only the queries for the currently connected database are
* executed.
*/
class Schema extends AbstractAsset
{
/**
* The namespaces in this schema.
*
* @var array<string, string>
*/
private array $namespaces = [];
/** @var array<string, Table> */
protected array $_tables = [];
/** @var array<string, Sequence> */
protected array $_sequences = [];
protected SchemaConfig $_schemaConfig;
/**
* @param array<Table> $tables
* @param array<Sequence> $sequences
* @param array<string> $namespaces
*/
public function __construct(
array $tables = [],
array $sequences = [],
?SchemaConfig $schemaConfig = null,
array $namespaces = [],
) {
$schemaConfig ??= new SchemaConfig();
$this->_schemaConfig = $schemaConfig;
$name = $schemaConfig->getName();
if ($name !== null) {
$this->_setName($name);
}
foreach ($namespaces as $namespace) {
$this->createNamespace($namespace);
}
foreach ($tables as $table) {
$this->_addTable($table);
}
foreach ($sequences as $sequence) {
$this->_addSequence($sequence);
}
}
protected function _addTable(Table $table): void
{
$namespaceName = $table->getNamespaceName();
$tableName = $this->normalizeName($table);
if (isset($this->_tables[$tableName])) {
throw TableAlreadyExists::new($tableName);
}
if (
$namespaceName !== null
&& ! $table->isInDefaultNamespace($this->getName())
&& ! $this->hasNamespace($namespaceName)
) {
$this->createNamespace($namespaceName);
}
$this->_tables[$tableName] = $table;
$table->setSchemaConfig($this->_schemaConfig);
}
protected function _addSequence(Sequence $sequence): void
{
$namespaceName = $sequence->getNamespaceName();
$seqName = $this->normalizeName($sequence);
if (isset($this->_sequences[$seqName])) {
throw SequenceAlreadyExists::new($seqName);
}
if (
$namespaceName !== null
&& ! $sequence->isInDefaultNamespace($this->getName())
&& ! $this->hasNamespace($namespaceName)
) {
$this->createNamespace($namespaceName);
}
$this->_sequences[$seqName] = $sequence;
}
/**
* Returns the namespaces of this schema.
*
* @return list<string> A list of namespace names.
*/
public function getNamespaces(): array
{
return array_values($this->namespaces);
}
/**
* Gets all tables of this schema.
*
* @return list<Table>
*/
public function getTables(): array
{
return array_values($this->_tables);
}
public function getTable(string $name): Table
{
$name = $this->getFullQualifiedAssetName($name);
if (! isset($this->_tables[$name])) {
throw TableDoesNotExist::new($name);
}
return $this->_tables[$name];
}
private function getFullQualifiedAssetName(string $name): string
{
$name = $this->getUnquotedAssetName($name);
if (! str_contains($name, '.')) {
$name = $this->getName() . '.' . $name;
}
return strtolower($name);
}
/**
* The normalized name is qualified and lower-cased. Lower-casing is
* actually wrong, but we have to do it to keep our sanity. If you are
* using database objects that only differentiate in the casing (FOO vs
* Foo) then you will NOT be able to use Doctrine Schema abstraction.
*
* Every non-namespaced element is prefixed with this schema name.
*/
private function normalizeName(AbstractAsset $asset): string
{
$name = $asset->getName();
if ($asset->getNamespaceName() === null) {
$name = $this->getName() . '.' . $name;
}
return strtolower($name);
}
/**
* Returns the unquoted representation of a given asset name.
*/
private function getUnquotedAssetName(string $assetName): string
{
if ($this->isIdentifierQuoted($assetName)) {
return $this->trimQuotes($assetName);
}
return $assetName;
}
/**
* Does this schema have a namespace with the given name?
*/
public function hasNamespace(string $name): bool
{
$name = strtolower($this->getUnquotedAssetName($name));
return isset($this->namespaces[$name]);
}
/**
* Does this schema have a table with the given name?
*/
public function hasTable(string $name): bool
{
$name = $this->getFullQualifiedAssetName($name);
return isset($this->_tables[$name]);
}
public function hasSequence(string $name): bool
{
$name = $this->getFullQualifiedAssetName($name);
return isset($this->_sequences[$name]);
}
public function getSequence(string $name): Sequence
{
$name = $this->getFullQualifiedAssetName($name);
if (! $this->hasSequence($name)) {
throw SequenceDoesNotExist::new($name);
}
return $this->_sequences[$name];
}
/** @return list<Sequence> */
public function getSequences(): array
{
return array_values($this->_sequences);
}
/**
* Creates a new namespace.
*
* @return $this
*/
public function createNamespace(string $name): self
{
$unquotedName = strtolower($this->getUnquotedAssetName($name));
if (isset($this->namespaces[$unquotedName])) {
throw NamespaceAlreadyExists::new($unquotedName);
}
$this->namespaces[$unquotedName] = $name;
return $this;
}
/**
* Creates a new table.
*/
public function createTable(string $name): Table
{
$table = new Table($name);
$this->_addTable($table);
foreach ($this->_schemaConfig->getDefaultTableOptions() as $option => $value) {
$table->addOption($option, $value);
}
return $table;
}
/**
* Renames a table.
*
* @return $this
*/
public function renameTable(string $oldName, string $newName): self
{
$table = $this->getTable($oldName);
$table->_setName($newName);
$this->dropTable($oldName);
$this->_addTable($table);
return $this;
}
/**
* Drops a table from the schema.
*
* @return $this
*/
public function dropTable(string $name): self
{
$name = $this->getFullQualifiedAssetName($name);
$this->getTable($name);
unset($this->_tables[$name]);
return $this;
}
/**
* Creates a new sequence.
*/
public function createSequence(string $name, int $allocationSize = 1, int $initialValue = 1): Sequence
{
$seq = new Sequence($name, $allocationSize, $initialValue);
$this->_addSequence($seq);
return $seq;
}
/** @return $this */
public function dropSequence(string $name): self
{
$name = $this->getFullQualifiedAssetName($name);
unset($this->_sequences[$name]);
return $this;
}
/**
* Returns an array of necessary SQL queries to create the schema on the given platform.
*
* @return list<string>
*
* @throws Exception
*/
public function toSql(AbstractPlatform $platform): array
{
$builder = new CreateSchemaObjectsSQLBuilder($platform);
return $builder->buildSQL($this);
}
/**
* Return an array of necessary SQL queries to drop the schema on the given platform.
*
* @return list<string>
*/
public function toDropSql(AbstractPlatform $platform): array
{
$builder = new DropSchemaObjectsSQLBuilder($platform);
return $builder->buildSQL($this);
}
/**
* Cloning a Schema triggers a deep clone of all related assets.
*/
public function __clone()
{
foreach ($this->_tables as $k => $table) {
$this->_tables[$k] = clone $table;
}
foreach ($this->_sequences as $k => $sequence) {
$this->_sequences[$k] = clone $sequence;
}
}
}