crate /
crate-dbal
Complex classes like CratePlatform often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use CratePlatform, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 38 | class CratePlatform extends AbstractPlatform |
||
| 39 | { |
||
| 40 | |||
| 41 | const TIMESTAMP_FORMAT = 'Y-m-d\TH:i:s'; |
||
| 42 | const TIMESTAMP_FORMAT_TZ = 'Y-m-d\TH:i:sO'; |
||
| 43 | |||
| 44 | /** |
||
| 45 | * {@inheritDoc} |
||
| 46 | */ |
||
| 47 | 105 | public function __construct() |
|
| 48 | { |
||
| 49 | 105 | parent::__construct(); |
|
| 50 | 105 | $this->initializeDoctrineTypeMappings(); |
|
| 51 | 105 | if (!Type::hasType(MapType::NAME)) { |
|
| 52 | Type::addType(MapType::NAME, 'Crate\DBAL\Types\MapType'); |
||
| 53 | } |
||
| 54 | 105 | if (!Type::hasType(TimestampType::NAME)) { |
|
| 55 | Type::addType(TimestampType::NAME, 'Crate\DBAL\Types\TimestampType'); |
||
| 56 | } |
||
| 57 | 105 | Type::overrideType('array', 'Crate\DBAL\Types\ArrayType'); |
|
| 58 | 105 | } |
|
| 59 | |||
| 60 | /** |
||
| 61 | * {@inheritDoc} |
||
| 62 | */ |
||
| 63 | 1 | public function getSubstringExpression($value, $from = 0, $length = null) |
|
| 71 | |||
| 72 | /** |
||
| 73 | * {@inheritDoc} |
||
| 74 | */ |
||
| 75 | 1 | public function getNowExpression() |
|
| 79 | |||
| 80 | /** |
||
| 81 | * {@inheritDoc} |
||
| 82 | */ |
||
| 83 | 1 | public function getRegexpExpression() |
|
| 87 | |||
| 88 | /** |
||
| 89 | * {@inheritDoc} |
||
| 90 | */ |
||
| 91 | 1 | public function getDateDiffExpression($date1, $date2) |
|
| 95 | |||
| 96 | /** |
||
| 97 | * {@inheritDoc} |
||
| 98 | */ |
||
| 99 | 2 | public function supportsSequences() |
|
| 103 | |||
| 104 | /** |
||
| 105 | * If we want to support Schemas, we need to implement |
||
| 106 | * getListNamespacesSQL and getCreateSchemaSQL methods |
||
| 107 | * |
||
| 108 | * {@inheritDoc} |
||
| 109 | */ |
||
| 110 | 2 | public function supportsSchemas() |
|
| 114 | |||
| 115 | /** |
||
| 116 | * {@inheritDoc} |
||
| 117 | */ |
||
| 118 | 1 | public function supportsIdentityColumns() |
|
| 122 | |||
| 123 | /** |
||
| 124 | * {@inheritDoc} |
||
| 125 | */ |
||
| 126 | 1 | public function supportsIndexes() |
|
| 130 | |||
| 131 | /** |
||
| 132 | * {@inheritDoc} |
||
| 133 | */ |
||
| 134 | 55 | public function supportsCommentOnStatement() |
|
| 138 | |||
| 139 | /** |
||
| 140 | * {@inheritDoc} |
||
| 141 | */ |
||
| 142 | 7 | public function supportsForeignKeyConstraints() |
|
| 146 | |||
| 147 | /** |
||
| 148 | * {@inheritDoc} |
||
| 149 | */ |
||
| 150 | 1 | public function supportsForeignKeyOnUpdate() |
|
| 154 | |||
| 155 | /** |
||
| 156 | * {@inheritDoc} |
||
| 157 | */ |
||
| 158 | 1 | public function supportsViews() |
|
| 162 | |||
| 163 | /** |
||
| 164 | * {@inheritDoc} |
||
| 165 | */ |
||
| 166 | 1 | public function prefersSequences() |
|
| 170 | |||
| 171 | /** |
||
| 172 | * {@inheritDoc} |
||
| 173 | */ |
||
| 174 | 1 | public function getListDatabasesSQL() |
|
| 178 | |||
| 179 | /** |
||
| 180 | * {@inheritDoc} |
||
| 181 | */ |
||
| 182 | public function getListTablesSQL() |
||
| 183 | { |
||
| 184 | return "SELECT table_name, schema_name FROM information_schema.tables " . |
||
| 185 | "WHERE schema_name = 'doc' OR schema_name = 'blob'"; |
||
| 186 | } |
||
| 187 | |||
| 188 | /** |
||
| 189 | * {@inheritDoc} |
||
| 190 | */ |
||
| 191 | public function getListTableColumnsSQL($table, $database = null) |
||
| 192 | { |
||
| 193 | $t = explode('.', $table); |
||
| 194 | if (count($t) == 1) { |
||
| 195 | array_unshift($t, 'doc'); |
||
| 196 | } |
||
| 197 | // todo: make safe |
||
| 198 | return "SELECT * from information_schema.columns " . |
||
| 199 | "WHERE table_name = '$t[1]' AND schema_name = '$t[0]'"; |
||
| 200 | } |
||
| 201 | |||
| 202 | /** |
||
| 203 | * {@inheritDoc} |
||
| 204 | */ |
||
| 205 | public function getListTableConstraintsSQL($table, $database = null) |
||
|
|
|||
| 206 | { |
||
| 207 | $t = explode('.', $table); |
||
| 208 | if (count($t) == 1) { |
||
| 209 | array_unshift($t, 'doc'); |
||
| 210 | } |
||
| 211 | // todo: make safe |
||
| 212 | return "SELECT constraint_name, constraint_type from information_schema.table_constraints " . |
||
| 213 | "WHERE table_name = '$t[1]' AND schema_name = '$t[0]' AND constraint_type = 'PRIMARY_KEY'"; |
||
| 214 | } |
||
| 215 | |||
| 216 | /** |
||
| 217 | * {@inheritDoc} |
||
| 218 | */ |
||
| 219 | 5 | public function getAlterTableSQL(TableDiff $diff) |
|
| 220 | { |
||
| 221 | 5 | $sql = array(); |
|
| 222 | 5 | $commentsSQL = array(); |
|
| 223 | 5 | $columnSql = array(); |
|
| 224 | |||
| 225 | 5 | foreach ($diff->addedColumns as $column) { |
|
| 226 | 2 | if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) { |
|
| 227 | continue; |
||
| 228 | } |
||
| 229 | |||
| 230 | 2 | $query = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $column->toArray()); |
|
| 231 | 2 | $sql[] = 'ALTER TABLE ' . $diff->name . ' ' . $query; |
|
| 232 | 2 | if ($comment = $this->getColumnComment($column)) { |
|
| 233 | 2 | $commentsSQL[] = $this->getCommentOnColumnSQL($diff->name, $column->getName(), $comment); |
|
| 234 | } |
||
| 235 | } |
||
| 236 | |||
| 237 | 5 | if (count($diff->removedColumns) > 0) { |
|
| 238 | throw DBALException::notSupported("Alter Table: drop columns"); |
||
| 239 | } |
||
| 240 | 5 | if (count($diff->changedColumns) > 0) { |
|
| 241 | throw DBALException::notSupported("Alter Table: change column options"); |
||
| 242 | } |
||
| 243 | 5 | if (count($diff->renamedColumns) > 0) { |
|
| 244 | throw DBALException::notSupported("Alter Table: rename columns"); |
||
| 245 | } |
||
| 246 | |||
| 247 | 5 | $tableSql = array(); |
|
| 248 | |||
| 249 | 5 | if (!$this->onSchemaAlterTable($diff, $tableSql)) { |
|
| 250 | 5 | if ($diff->newName !== false) { |
|
| 251 | throw DBALException::notSupported("Alter Table: rename table"); |
||
| 252 | } |
||
| 253 | |||
| 254 | 5 | $sql = array_merge($sql, $this->_getAlterTableIndexForeignKeySQL($diff), $commentsSQL); |
|
| 255 | } |
||
| 256 | |||
| 257 | 5 | return array_merge($sql, $tableSql, $columnSql); |
|
| 258 | } |
||
| 259 | |||
| 260 | /** |
||
| 261 | * {@inheritDoc} |
||
| 262 | */ |
||
| 263 | 58 | public function getColumnDeclarationSQL($name, array $field) |
|
| 264 | { |
||
| 265 | 58 | if (isset($field['columnDefinition'])) { |
|
| 266 | 34 | $columnDef = $this->getCustomTypeDeclarationSQL($field); |
|
| 267 | } else { |
||
| 268 | 57 | $typeDecl = $field['type']->getSqlDeclaration($field, $this); |
|
| 269 | 57 | $columnDef = $typeDecl; |
|
| 270 | } |
||
| 271 | |||
| 272 | 58 | return $name . ' ' . $columnDef; |
|
| 273 | } |
||
| 274 | |||
| 275 | /** |
||
| 276 | * Generate table index column declaration |
||
| 277 | * @codeCoverageIgnore |
||
| 278 | */ |
||
| 279 | public function getIndexDeclarationSQL($name, Index $index) |
||
| 290 | |||
| 291 | /** |
||
| 292 | * {@inheritDoc} |
||
| 293 | * |
||
| 294 | * Crate wants boolean values converted to the strings 'true'/'false'. |
||
| 295 | */ |
||
| 296 | 2 | public function convertBooleans($item) |
|
| 297 | { |
||
| 298 | 2 | if (is_array($item)) { |
|
| 299 | 1 | foreach ($item as $key => $value) { |
|
| 300 | 1 | if (is_bool($value)) { |
|
| 301 | 1 | $item[$key] = ($value) ? 'true' : 'false'; |
|
| 302 | 1 | } elseif (is_numeric($value)) { |
|
| 303 | 1 | $item[$key] = ($value > 0) ? 'true' : 'false'; |
|
| 304 | } |
||
| 305 | } |
||
| 306 | } else { |
||
| 307 | 2 | if (is_bool($item)) { |
|
| 308 | 2 | $item = ($item) ? 'true' : 'false'; |
|
| 309 | 1 | } elseif (is_numeric($item)) { |
|
| 310 | 1 | $item = ($item > 0) ? 'true' : 'false'; |
|
| 311 | } |
||
| 312 | } |
||
| 313 | |||
| 314 | 2 | return $item; |
|
| 315 | } |
||
| 316 | |||
| 317 | /** |
||
| 318 | * {@inheritDoc} |
||
| 319 | */ |
||
| 320 | 1 | public function getBooleanTypeDeclarationSQL(array $field) |
|
| 324 | |||
| 325 | /** |
||
| 326 | * {@inheritDoc} |
||
| 327 | */ |
||
| 328 | 53 | public function getIntegerTypeDeclarationSQL(array $field) |
|
| 332 | |||
| 333 | /** |
||
| 334 | * {@inheritDoc} |
||
| 335 | */ |
||
| 336 | 1 | public function getBigIntTypeDeclarationSQL(array $field) |
|
| 340 | |||
| 341 | /** |
||
| 342 | * {@inheritDoc} |
||
| 343 | */ |
||
| 344 | 1 | public function getSmallIntTypeDeclarationSQL(array $field) |
|
| 348 | |||
| 349 | /** |
||
| 350 | * {@inheritDoc} |
||
| 351 | */ |
||
| 352 | 34 | public function getFloatDeclarationSQL(array $field) |
|
| 356 | |||
| 357 | /** |
||
| 358 | * {@inheritDoc} |
||
| 359 | */ |
||
| 360 | public function getDecimalTypeDeclarationSQL(array $columnDef) |
||
| 364 | |||
| 365 | /** |
||
| 366 | * {@inheritDoc} |
||
| 367 | */ |
||
| 368 | 24 | public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration) |
|
| 372 | |||
| 373 | /** |
||
| 374 | * {@inheritDoc} |
||
| 375 | */ |
||
| 376 | 1 | public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration) |
|
| 380 | |||
| 381 | /** |
||
| 382 | * {@inheritDoc} |
||
| 383 | */ |
||
| 384 | 1 | public function getDateTypeDeclarationSQL(array $fieldDeclaration) |
|
| 388 | |||
| 389 | /** |
||
| 390 | * {@inheritDoc} |
||
| 391 | */ |
||
| 392 | 1 | public function getTimeTypeDeclarationSQL(array $fieldDeclaration) |
|
| 396 | |||
| 397 | /** |
||
| 398 | * {@inheritDoc} |
||
| 399 | */ |
||
| 400 | protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef) |
||
| 404 | |||
| 405 | /** |
||
| 406 | * {@inheritDoc} |
||
| 407 | */ |
||
| 408 | 52 | protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed) |
|
| 412 | |||
| 413 | /** |
||
| 414 | * {@inheritDoc} |
||
| 415 | */ |
||
| 416 | 1 | public function getClobTypeDeclarationSQL(array $field) |
|
| 417 | { |
||
| 418 | 1 | return 'STRING'; |
|
| 419 | } |
||
| 420 | |||
| 421 | /** |
||
| 422 | * Gets the SQL snippet used to declare an OBJECT column type. |
||
| 423 | * |
||
| 424 | * @param array $field |
||
| 425 | * |
||
| 426 | * @return string |
||
| 427 | */ |
||
| 428 | 36 | public function getMapTypeDeclarationSQL(array $field, array $options) |
|
| 429 | { |
||
| 430 | 36 | $type = array_key_exists('type', $options) ? $options['type'] : MapType::DYNAMIC; |
|
| 431 | |||
| 432 | 36 | $fields = array_key_exists('fields', $options) ? $options['fields'] : array(); |
|
| 433 | 36 | $columns = array(); |
|
| 434 | 36 | foreach ($fields as $field) { |
|
| 435 | 35 | $columns[$field->getQuotedName($this)] = $this->prepareColumnData($field); |
|
| 436 | } |
||
| 437 | 36 | $objectFields = $this->getColumnDeclarationListSQL($columns); |
|
| 438 | |||
| 439 | 36 | $declaration = count($columns) > 0 ? ' AS ( ' . $objectFields . ' )' : ''; |
|
| 440 | 36 | return 'OBJECT ( ' . $type . ' )' . $declaration ; |
|
| 441 | } |
||
| 442 | |||
| 443 | /** |
||
| 444 | * Gets the SQL snippet used to declare an ARRAY column type. |
||
| 445 | * |
||
| 446 | * @param array $field |
||
| 447 | * |
||
| 448 | * @return string |
||
| 449 | */ |
||
| 450 | 4 | public function getArrayTypeDeclarationSQL(array $field, array $options) |
|
| 455 | |||
| 456 | /** |
||
| 457 | * {@inheritDoc} |
||
| 458 | */ |
||
| 459 | 2 | public function getName() |
|
| 463 | |||
| 464 | /** |
||
| 465 | * {@inheritDoc} |
||
| 466 | * |
||
| 467 | * PostgreSQL returns all column names in SQL result sets in lowercase. |
||
| 468 | */ |
||
| 469 | 1 | public function getSQLResultCasing($column) |
|
| 473 | |||
| 474 | /** |
||
| 475 | * {@inheritDoc} |
||
| 476 | */ |
||
| 477 | 2 | public function getDateTimeTzFormatString() |
|
| 481 | |||
| 482 | /** |
||
| 483 | * {@inheritDoc} |
||
| 484 | */ |
||
| 485 | 5 | public function getDateTimeFormatString() |
|
| 489 | |||
| 490 | /** |
||
| 491 | * {@inheritDoc} |
||
| 492 | */ |
||
| 493 | 1 | public function getDateFormatString() |
|
| 497 | |||
| 498 | /** |
||
| 499 | * {@inheritDoc} |
||
| 500 | */ |
||
| 501 | 1 | public function getTimeFormatString() |
|
| 505 | |||
| 506 | /** |
||
| 507 | * {@inheritDoc} |
||
| 508 | */ |
||
| 509 | 1 | public function getTruncateTableSQL($tableName, $cascade = false) |
|
| 513 | |||
| 514 | /** |
||
| 515 | * {@inheritDoc} |
||
| 516 | */ |
||
| 517 | 1 | public function getReadLockSQL() |
|
| 521 | |||
| 522 | /** |
||
| 523 | * {@inheritDoc} |
||
| 524 | */ |
||
| 525 | 105 | protected function initializeDoctrineTypeMappings() |
|
| 526 | { |
||
| 527 | 105 | $this->doctrineTypeMapping = array( |
|
| 528 | 'short' => 'smallint', |
||
| 529 | 'integer' => 'integer', |
||
| 530 | 'long' => 'bigint', |
||
| 531 | 'int' => 'integer', |
||
| 532 | 'bool' => 'boolean', |
||
| 533 | 'boolean' => 'boolean', |
||
| 534 | 'string' => 'string', |
||
| 535 | 'float' => 'float', |
||
| 536 | 'double' => 'float', |
||
| 537 | 'timestamp' => 'timestamp', |
||
| 538 | 'object' => 'map', |
||
| 539 | 'string_array' => 'array', |
||
| 540 | 'float_array' => 'array', |
||
| 541 | 'double_array' => 'array', |
||
| 542 | 'integer_array' => 'array', |
||
| 543 | 'object_array' => 'array', |
||
| 544 | 'array' => 'array', |
||
| 545 | ); |
||
| 546 | 105 | } |
|
| 547 | |||
| 548 | /** |
||
| 549 | * {@inheritDoc} |
||
| 550 | */ |
||
| 551 | 52 | public function getVarcharMaxLength() |
|
| 555 | |||
| 556 | /** |
||
| 557 | * {@inheritDoc} |
||
| 558 | */ |
||
| 559 | 25 | protected function getReservedKeywordsClass() |
|
| 563 | |||
| 564 | /** |
||
| 565 | * {@inheritDoc} |
||
| 566 | */ |
||
| 567 | 1 | public function getBlobTypeDeclarationSQL(array $field) |
|
| 571 | |||
| 572 | /** |
||
| 573 | * {@inheritDoc} |
||
| 574 | * Gets the SQL statement(s) to create a table with the specified name, columns and constraints |
||
| 575 | * on this platform. |
||
| 576 | * |
||
| 577 | * @param Table $table The name of the table. |
||
| 578 | * @param integer $createFlags |
||
| 579 | * |
||
| 580 | * @return array The sequence of SQL statements. |
||
| 581 | */ |
||
| 582 | 57 | public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES) |
|
| 583 | { |
||
| 584 | 57 | if (!is_int($createFlags)) { |
|
| 585 | $msg = "Second argument of CratePlatform::getCreateTableSQL() has to be integer."; |
||
| 586 | throw new \InvalidArgumentException($msg); |
||
| 587 | } |
||
| 588 | |||
| 589 | 57 | if (count($table->getColumns()) === 0) { |
|
| 590 | 2 | throw DBALException::noColumnsSpecifiedForTable($table->getName()); |
|
| 591 | } |
||
| 592 | |||
| 593 | 55 | $tableName = $table->getQuotedName($this); |
|
| 594 | 55 | $options = $table->getOptions(); |
|
| 595 | 55 | $options['uniqueConstraints'] = array(); |
|
| 596 | 55 | $options['indexes'] = array(); |
|
| 597 | 55 | $options['primary'] = array(); |
|
| 598 | |||
| 599 | 55 | if (($createFlags&self::CREATE_INDEXES) > 0) { |
|
| 600 | 55 | foreach ($table->getIndexes() as $index) { |
|
| 601 | /* @var $index Index */ |
||
| 602 | 40 | if ($index->isPrimary()) { |
|
| 603 | 37 | $platform = $this; |
|
| 604 | 37 | $options['primary'] = array_map(function ($columnName) use ($table, $platform) { |
|
| 605 | 37 | return $table->getColumn($columnName)->getQuotedName($platform); |
|
| 606 | 37 | }, $index->getColumns()); |
|
| 607 | 37 | $options['primary_index'] = $index; |
|
| 608 | 3 | } else if ($index->isUnique()) { |
|
| 609 | 1 | throw DBALException::notSupported("Unique constraints are not supported. Use `primary key` instead"); |
|
| 610 | } else { |
||
| 611 | 39 | $options['indexes'][$index->getName()] = $index; |
|
| 612 | } |
||
| 613 | } |
||
| 614 | } |
||
| 615 | |||
| 616 | 54 | $columnSql = array(); |
|
| 617 | 54 | $columns = array(); |
|
| 618 | |||
| 619 | 54 | foreach ($table->getColumns() as $column) { |
|
| 620 | 54 | if (null !== $this->_eventManager && |
|
| 621 | 54 | $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)) { |
|
| 622 | |||
| 623 | 1 | $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this); |
|
| 624 | 1 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs); |
|
| 625 | |||
| 626 | 1 | $columnSql = array_merge($columnSql, $eventArgs->getSql()); |
|
| 627 | |||
| 628 | 1 | if ($eventArgs->isDefaultPrevented()) { |
|
| 629 | continue; |
||
| 630 | } |
||
| 631 | } |
||
| 632 | 54 | $columns[$column->getQuotedName($this)] = $this->prepareColumnData($column, $options['primary']); |
|
| 633 | } |
||
| 634 | |||
| 635 | 53 | if (null !== $this->_eventManager && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) { |
|
| 636 | 1 | $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this); |
|
| 637 | 1 | $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs); |
|
| 638 | |||
| 639 | 1 | if ($eventArgs->isDefaultPrevented()) { |
|
| 640 | return array_merge($eventArgs->getSql(), $columnSql); |
||
| 641 | } |
||
| 642 | } |
||
| 643 | |||
| 644 | 53 | $sql = $this->_getCreateTableSQL($tableName, $columns, $options); |
|
| 645 | 53 | if ($this->supportsCommentOnStatement()) { |
|
| 646 | foreach ($table->getColumns() as $column) { |
||
| 647 | if ($this->getColumnComment($column)) { |
||
| 648 | $sql[] = $this->getCommentOnColumnSQL( |
||
| 649 | $tableName, |
||
| 650 | $column->getName(), |
||
| 651 | $this->getColumnComment($column) |
||
| 652 | ); |
||
| 653 | } |
||
| 654 | } |
||
| 655 | } |
||
| 656 | |||
| 657 | 53 | return array_merge($sql, $columnSql); |
|
| 658 | } |
||
| 659 | |||
| 660 | /** |
||
| 661 | * {@inheritDoc} |
||
| 662 | */ |
||
| 663 | 53 | protected function _getCreateTableSQL($tableName, array $columns, array $options = array()) |
|
| 664 | { |
||
| 665 | 53 | $columnListSql = $this->getColumnDeclarationListSQL($columns); |
|
| 666 | |||
| 667 | 53 | if (isset($options['primary']) && ! empty($options['primary'])) { |
|
| 668 | 37 | $keyColumns = array_unique(array_values($options['primary'])); |
|
| 669 | 37 | $columnListSql .= ', PRIMARY KEY(' . implode(', ', $keyColumns) . ')'; |
|
| 670 | } |
||
| 671 | |||
| 672 | 53 | if (isset($options['indexes']) && ! empty($options['indexes'])) { |
|
| 673 | 2 | foreach ($options['indexes'] as $index => $definition) { |
|
| 674 | 2 | $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition); |
|
| 675 | } |
||
| 676 | } |
||
| 677 | |||
| 678 | 53 | if (isset($options['foreignKeys'])) { |
|
| 679 | throw DBALException::notSupported("Create Table: foreign keys"); |
||
| 680 | } |
||
| 681 | |||
| 682 | 53 | $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql . ')'; |
|
| 683 | 53 | return array($query); |
|
| 684 | } |
||
| 685 | |||
| 686 | /** |
||
| 687 | * @param \Doctrine\DBAL\Schema\Column $column The name of the table. |
||
| 688 | * @param array List of primary key column names |
||
| 689 | * |
||
| 690 | * @return array The column data as associative array. |
||
| 691 | */ |
||
| 692 | 56 | public function prepareColumnData($column, $primaries = array()) |
|
| 693 | { |
||
| 694 | 56 | if ($column->hasCustomSchemaOption("unique") ? $column->getCustomSchemaOption("unique") : false) { |
|
| 695 | 1 | throw DBALException::notSupported("Unique constraints are not supported. Use `primary key` instead"); |
|
| 696 | } |
||
| 697 | |||
| 698 | 55 | $columnData = array(); |
|
| 699 | 55 | $columnData['name'] = $column->getQuotedName($this); |
|
| 700 | 55 | $columnData['type'] = $column->getType(); |
|
| 701 | 55 | $columnData['length'] = $column->getLength(); |
|
| 702 | 55 | $columnData['notnull'] = $column->getNotNull(); |
|
| 703 | 55 | $columnData['fixed'] = $column->getFixed(); |
|
| 704 | 55 | $columnData['unique'] = false; |
|
| 705 | 55 | $columnData['version'] = $column->hasPlatformOption("version") ? $column->getPlatformOption("version") : false; |
|
| 706 | |||
| 707 | 55 | if (strtolower($columnData['type']) == "string" && $columnData['length'] === null) { |
|
| 708 | 46 | $columnData['length'] = 255; |
|
| 709 | } |
||
| 710 | |||
| 711 | 55 | $columnData['unsigned'] = $column->getUnsigned(); |
|
| 712 | 55 | $columnData['precision'] = $column->getPrecision(); |
|
| 713 | 55 | $columnData['scale'] = $column->getScale(); |
|
| 714 | 55 | $columnData['default'] = $column->getDefault(); |
|
| 715 | 55 | $columnData['columnDefinition'] = $column->getColumnDefinition(); |
|
| 716 | 55 | $columnData['autoincrement'] = $column->getAutoincrement(); |
|
| 717 | 55 | $columnData['comment'] = $this->getColumnComment($column); |
|
| 718 | 55 | $columnData['platformOptions'] = $column->getPlatformOptions(); |
|
| 719 | |||
| 720 | 55 | if (in_array($column->getName(), $primaries)) { |
|
| 721 | 36 | $columnData['primary'] = true; |
|
| 722 | } |
||
| 723 | 55 | return $columnData; |
|
| 724 | } |
||
| 725 | |||
| 726 | /** |
||
| 727 | * {@inheritDoc} |
||
| 728 | */ |
||
| 729 | 1 | public function getCreateDatabaseSQL($database) |
|
| 733 | |||
| 734 | /** |
||
| 735 | * {@inheritDoc} |
||
| 736 | */ |
||
| 737 | 1 | public function getDropDatabaseSQL($database) |
|
| 741 | |||
| 742 | /** |
||
| 743 | * {@inheritDoc} |
||
| 744 | */ |
||
| 745 | 1 | public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table) |
|
| 749 | |||
| 750 | /** |
||
| 751 | * {@inheritDoc} |
||
| 752 | */ |
||
| 753 | 1 | public function getGuidTypeDeclarationSQL(array $field) |
|
| 757 | } |
||
| 758 |
Loading history...
This check looks from parameters that have been defined for a function or method, but which are not used in the method body.