2014-09-18 17:22:54 +02:00
|
|
|
<?php
|
|
|
|
|
|
|
|
abstract class PhabricatorConfigSchemaSpec extends Phobject {
|
|
|
|
|
2014-09-18 17:25:34 +02:00
|
|
|
private $server;
|
|
|
|
private $utf8Charset;
|
2014-10-01 17:18:53 +02:00
|
|
|
private $utf8BinaryCollation;
|
|
|
|
private $utf8SortingCollation;
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-11-04 13:42:05 +01:00
|
|
|
const DATATYPE_UNKNOWN = '<unknown>';
|
|
|
|
|
2014-10-01 17:18:53 +02:00
|
|
|
public function setUTF8SortingCollation($utf8_sorting_collation) {
|
|
|
|
$this->utf8SortingCollation = $utf8_sorting_collation;
|
2014-09-18 17:25:34 +02:00
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
2014-10-01 17:18:53 +02:00
|
|
|
public function getUTF8SortingCollation() {
|
|
|
|
return $this->utf8SortingCollation;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setUTF8BinaryCollation($utf8_binary_collation) {
|
|
|
|
$this->utf8BinaryCollation = $utf8_binary_collation;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getUTF8BinaryCollation() {
|
|
|
|
return $this->utf8BinaryCollation;
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public function setUTF8Charset($utf8_charset) {
|
|
|
|
$this->utf8Charset = $utf8_charset;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getUTF8Charset() {
|
|
|
|
return $this->utf8Charset;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function setServer(PhabricatorConfigServerSchema $server) {
|
|
|
|
$this->server = $server;
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getServer() {
|
|
|
|
return $this->server;
|
|
|
|
}
|
|
|
|
|
|
|
|
abstract public function buildSchemata();
|
|
|
|
|
2014-10-02 18:51:20 +02:00
|
|
|
protected function buildLiskObjectSchema(PhabricatorLiskDAO $object) {
|
2014-09-18 17:36:22 +02:00
|
|
|
$this->buildRawSchema(
|
|
|
|
$object->getApplicationName(),
|
|
|
|
$object->getTableName(),
|
|
|
|
$object->getSchemaColumns(),
|
|
|
|
$object->getSchemaKeys());
|
|
|
|
}
|
|
|
|
|
|
|
|
protected function buildRawSchema(
|
|
|
|
$database_name,
|
|
|
|
$table_name,
|
|
|
|
array $columns,
|
|
|
|
array $keys) {
|
|
|
|
$database = $this->getDatabase($database_name);
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-09-18 17:36:22 +02:00
|
|
|
$table = $this->newTable($table_name);
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-09-18 17:36:22 +02:00
|
|
|
foreach ($columns as $name => $type) {
|
2014-09-18 20:15:49 +02:00
|
|
|
if ($type === null) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
$details = $this->getDetailsForDataType($type);
|
2014-10-01 17:24:51 +02:00
|
|
|
list($column_type, $charset, $collation, $nullable, $auto) = $details;
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
$column = $this->newColumn($name)
|
|
|
|
->setDataType($type)
|
|
|
|
->setColumnType($column_type)
|
|
|
|
->setCharacterSet($charset)
|
|
|
|
->setCollation($collation)
|
2014-10-01 17:24:51 +02:00
|
|
|
->setNullable($nullable)
|
|
|
|
->setAutoIncrement($auto);
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
$table->addColumn($column);
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
2014-09-18 17:32:44 +02:00
|
|
|
|
|
|
|
foreach ($keys as $key_name => $key_spec) {
|
2014-09-18 20:15:38 +02:00
|
|
|
if ($key_spec === null) {
|
|
|
|
// This is a subclass removing a key which Lisk expects.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
$key = $this->newKey($key_name)
|
|
|
|
->setColumnNames(idx($key_spec, 'columns', array()));
|
|
|
|
|
2014-09-19 20:46:30 +02:00
|
|
|
$key->setUnique((bool)idx($key_spec, 'unique'));
|
Fix almost all remaining schemata issues
Summary:
Ref T1191. This fixes nearly every remaining blocker for utf8mb4 -- primarily, overlong keys.
Remaining issue is https://secure.phabricator.com/T1191#77467
Test Plan: I'll annotate inline.
Reviewers: btrahan
Reviewed By: btrahan
Subscribers: epriestley, hach-que
Maniphest Tasks: T6099, T6129, T6133, T6134, T6150, T6148, T6147, T6146, T6105, T1191
Differential Revision: https://secure.phabricator.com/D10601
2014-10-01 17:18:36 +02:00
|
|
|
$key->setIndexType(idx($key_spec, 'type', 'BTREE'));
|
2014-09-19 20:46:30 +02:00
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
$table->addKey($key);
|
|
|
|
}
|
|
|
|
|
|
|
|
$database->addTable($table);
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
|
|
|
|
2014-09-18 20:15:38 +02:00
|
|
|
protected function buildEdgeSchemata(PhabricatorLiskDAO $object) {
|
|
|
|
$this->buildRawSchema(
|
|
|
|
$object->getApplicationName(),
|
|
|
|
PhabricatorEdgeConfig::TABLE_NAME_EDGE,
|
|
|
|
array(
|
|
|
|
'src' => 'phid',
|
|
|
|
'type' => 'uint32',
|
|
|
|
'dst' => 'phid',
|
|
|
|
'dateCreated' => 'epoch',
|
|
|
|
'seq' => 'uint32',
|
|
|
|
'dataID' => 'id?',
|
|
|
|
),
|
|
|
|
array(
|
|
|
|
'PRIMARY' => array(
|
|
|
|
'columns' => array('src', 'type', 'dst'),
|
2014-09-19 20:46:44 +02:00
|
|
|
'unique' => true,
|
|
|
|
),
|
|
|
|
'src' => array(
|
|
|
|
'columns' => array('src', 'type', 'dateCreated', 'seq'),
|
2014-09-18 20:15:38 +02:00
|
|
|
),
|
2014-09-29 00:12:58 +02:00
|
|
|
'key_dst' => array(
|
|
|
|
'columns' => array('dst', 'type', 'src'),
|
|
|
|
'unique' => true,
|
|
|
|
),
|
2014-09-18 20:15:38 +02:00
|
|
|
));
|
|
|
|
|
|
|
|
$this->buildRawSchema(
|
|
|
|
$object->getApplicationName(),
|
|
|
|
PhabricatorEdgeConfig::TABLE_NAME_EDGEDATA,
|
|
|
|
array(
|
2014-10-01 17:24:51 +02:00
|
|
|
'id' => 'auto',
|
2014-09-18 20:15:38 +02:00
|
|
|
'data' => 'text',
|
|
|
|
),
|
|
|
|
array(
|
|
|
|
'PRIMARY' => array(
|
|
|
|
'columns' => array('id'),
|
2014-09-19 20:46:44 +02:00
|
|
|
'unique' => true,
|
2014-09-18 20:15:38 +02:00
|
|
|
),
|
|
|
|
));
|
|
|
|
}
|
2014-09-18 17:25:34 +02:00
|
|
|
|
|
|
|
protected function getDatabase($name) {
|
|
|
|
$server = $this->getServer();
|
|
|
|
|
|
|
|
$database = $server->getDatabase($this->getNamespacedDatabase($name));
|
|
|
|
if (!$database) {
|
|
|
|
$database = $this->newDatabase($name);
|
|
|
|
$server->addDatabase($database);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $database;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected function newDatabase($name) {
|
|
|
|
return id(new PhabricatorConfigDatabaseSchema())
|
|
|
|
->setName($this->getNamespacedDatabase($name))
|
|
|
|
->setCharacterSet($this->getUTF8Charset())
|
2014-10-01 17:18:53 +02:00
|
|
|
->setCollation($this->getUTF8BinaryCollation());
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
protected function getNamespacedDatabase($name) {
|
|
|
|
$namespace = PhabricatorLiskDAO::getStorageNamespace();
|
|
|
|
return $namespace.'_'.$name;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected function newTable($name) {
|
|
|
|
return id(new PhabricatorConfigTableSchema())
|
|
|
|
->setName($name)
|
2014-10-01 17:18:53 +02:00
|
|
|
->setCollation($this->getUTF8BinaryCollation());
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
protected function newColumn($name) {
|
|
|
|
return id(new PhabricatorConfigColumnSchema())
|
|
|
|
->setName($name);
|
|
|
|
}
|
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
protected function newKey($name) {
|
|
|
|
return id(new PhabricatorConfigKeySchema())
|
|
|
|
->setName($name);
|
|
|
|
}
|
|
|
|
|
2014-09-18 17:25:34 +02:00
|
|
|
private function getDetailsForDataType($data_type) {
|
|
|
|
$column_type = null;
|
|
|
|
$charset = null;
|
|
|
|
$collation = null;
|
2014-10-01 17:24:51 +02:00
|
|
|
$auto = false;
|
2014-09-18 17:25:34 +02:00
|
|
|
|
2014-09-18 17:32:44 +02:00
|
|
|
// If the type ends with "?", make the column nullable.
|
|
|
|
$nullable = false;
|
|
|
|
if (preg_match('/\?$/', $data_type)) {
|
|
|
|
$nullable = true;
|
|
|
|
$data_type = substr($data_type, 0, -1);
|
|
|
|
}
|
|
|
|
|
2014-10-01 17:17:45 +02:00
|
|
|
// NOTE: MySQL allows fragments like "VARCHAR(32) CHARACTER SET binary",
|
|
|
|
// but just interprets that to mean "VARBINARY(32)". The fragment is
|
|
|
|
// totally disallowed in a MODIFY statement vs a CREATE TABLE statement.
|
|
|
|
|
2014-10-02 23:44:22 +02:00
|
|
|
$is_binary = ($this->getUTF8Charset() == 'binary');
|
|
|
|
$matches = null;
|
|
|
|
if (preg_match('/^(fulltext|sort|text)(\d+)?\z/', $data_type, $matches)) {
|
|
|
|
|
|
|
|
// Limit the permitted column lengths under the theory that it would
|
|
|
|
// be nice to eventually reduce this to a small set of standard lengths.
|
|
|
|
|
|
|
|
static $valid_types = array(
|
|
|
|
'text255' => true,
|
|
|
|
'text160' => true,
|
|
|
|
'text128' => true,
|
|
|
|
'text80' => true,
|
|
|
|
'text64' => true,
|
|
|
|
'text40' => true,
|
|
|
|
'text32' => true,
|
|
|
|
'text20' => true,
|
|
|
|
'text16' => true,
|
|
|
|
'text12' => true,
|
|
|
|
'text8' => true,
|
|
|
|
'text4' => true,
|
|
|
|
'text' => true,
|
|
|
|
'sort255' => true,
|
|
|
|
'sort128' => true,
|
|
|
|
'sort64' => true,
|
|
|
|
'sort32' => true,
|
|
|
|
'sort' => true,
|
|
|
|
'fulltext' => true,
|
|
|
|
);
|
|
|
|
|
|
|
|
if (empty($valid_types[$data_type])) {
|
|
|
|
throw new Exception(pht('Unknown column type "%s"!', $data_type));
|
|
|
|
}
|
|
|
|
|
|
|
|
$type = $matches[1];
|
|
|
|
$size = idx($matches, 2);
|
|
|
|
|
|
|
|
if ($is_binary) {
|
|
|
|
if ($size) {
|
|
|
|
$column_type = 'varbinary('.$size.')';
|
|
|
|
} else {
|
|
|
|
$column_type = 'longblob';
|
|
|
|
}
|
|
|
|
|
|
|
|
// MySQL (at least, under MyISAM) refuses to create a FULLTEXT index
|
|
|
|
// on a LONGBLOB column. We'd also lose case insensitivity in search.
|
|
|
|
// Force this column to utf8 collation. This will truncate results with
|
|
|
|
// 4-byte UTF characters in their text, but work reasonably in the
|
|
|
|
// majority of cases.
|
|
|
|
|
|
|
|
if ($type == 'fulltext') {
|
|
|
|
$column_type = 'longtext';
|
|
|
|
$charset = 'utf8';
|
|
|
|
$collation = 'utf8_general_ci';
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ($size) {
|
|
|
|
$column_type = 'varchar('.$size.')';
|
|
|
|
} else {
|
|
|
|
$column_type = 'longtext';
|
|
|
|
}
|
2014-09-18 17:25:34 +02:00
|
|
|
$charset = $this->getUTF8Charset();
|
2014-10-02 23:44:22 +02:00
|
|
|
if ($type == 'sort' || $type == 'fulltext') {
|
|
|
|
$collation = $this->getUTF8SortingCollation();
|
|
|
|
} else {
|
|
|
|
$collation = $this->getUTF8BinaryCollation();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch ($data_type) {
|
|
|
|
case 'auto':
|
|
|
|
$column_type = 'int(10) unsigned';
|
|
|
|
$auto = true;
|
|
|
|
break;
|
|
|
|
case 'auto64':
|
|
|
|
$column_type = 'bigint(20) unsigned';
|
|
|
|
$auto = true;
|
|
|
|
break;
|
|
|
|
case 'id':
|
|
|
|
case 'epoch':
|
|
|
|
case 'uint32':
|
|
|
|
$column_type = 'int(10) unsigned';
|
|
|
|
break;
|
|
|
|
case 'sint32':
|
|
|
|
$column_type = 'int(10)';
|
|
|
|
break;
|
|
|
|
case 'id64':
|
|
|
|
case 'uint64':
|
|
|
|
$column_type = 'bigint(20) unsigned';
|
|
|
|
break;
|
|
|
|
case 'sint64':
|
|
|
|
$column_type = 'bigint(20)';
|
|
|
|
break;
|
|
|
|
case 'phid':
|
|
|
|
case 'policy';
|
|
|
|
$column_type = 'varbinary(64)';
|
|
|
|
break;
|
|
|
|
case 'bytes64':
|
|
|
|
$column_type = 'binary(64)';
|
|
|
|
break;
|
|
|
|
case 'bytes40':
|
|
|
|
$column_type = 'binary(40)';
|
|
|
|
break;
|
|
|
|
case 'bytes32':
|
|
|
|
$column_type = 'binary(32)';
|
|
|
|
break;
|
|
|
|
case 'bytes20':
|
|
|
|
$column_type = 'binary(20)';
|
|
|
|
break;
|
|
|
|
case 'bytes12':
|
|
|
|
$column_type = 'binary(12)';
|
|
|
|
break;
|
|
|
|
case 'bytes4':
|
|
|
|
$column_type = 'binary(4)';
|
|
|
|
break;
|
|
|
|
case 'bytes':
|
|
|
|
$column_type = 'longblob';
|
|
|
|
break;
|
|
|
|
case 'bool':
|
|
|
|
$column_type = 'tinyint(1)';
|
|
|
|
break;
|
|
|
|
case 'double':
|
|
|
|
$column_type = 'double';
|
|
|
|
break;
|
|
|
|
case 'date':
|
|
|
|
$column_type = 'date';
|
|
|
|
break;
|
|
|
|
default:
|
2014-11-04 13:42:05 +01:00
|
|
|
$column_type = self::DATATYPE_UNKNOWN;
|
|
|
|
$charset = self::DATATYPE_UNKNOWN;
|
|
|
|
$collation = self::DATATYPE_UNKNOWN;
|
2014-10-02 23:44:22 +02:00
|
|
|
break;
|
|
|
|
}
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
|
|
|
|
2014-10-01 17:24:51 +02:00
|
|
|
return array($column_type, $charset, $collation, $nullable, $auto);
|
2014-09-18 17:25:34 +02:00
|
|
|
}
|
2014-09-18 17:22:54 +02:00
|
|
|
|
|
|
|
}
|