public function getTablePage($tableId)
{
if (is_numeric($tableId)) {
$tableId = array_keys($this->columnsMap)[$tableId];
}
$entity = new DatabaseSchemaPage();
$entity->setName($tableId);
$entity->setCollation("latin1_bin");
$entity->setEngine(Engine::INFORMATION_SCHEMA());
$entity->setType(Type::TABLE());
return $entity;
}
public function setType(Type $type)
{
switch ($type) {
case Type::VIEW():
$this->setEngine(Engine::VIEW());
break;
case Type::TABLE():
if ($this->getEngine() === Engine::VIEW()) {
$this->setEngine(Engine::INNODB());
}
break;
}
}
public function executeJob(StatementJob $statement, array $parameters = array())
{
/* @var $statement CreateTableStatement */
$context = new ExecutionContext($this->schemaManager, $statement, $parameters);
/* @var $databaseSchema Schema */
$databaseSchema = $this->schemaManager->getSchema();
$schemaId = $this->schemaManager->getCurrentlyUsedDatabaseId();
$tableName = $this->valueResolver->resolveValue($statement->getName(), $context);
$schemaPage = new DatabaseSchemaPage();
$schemaPage->setName($tableName);
$schemaPage->setType(Type::TABLE());
$schemaPage->setEngine(Engine::factory($statement->getEngine()->getName()));
$schemaPage->setCollation(strtoupper($statement->getCollate()));
$schemaPage->setUseChecksum($statement->getUseChecksum());
$schemaPage->setMaxRows($statement->getMaximumRows());
$schemaPage->setMinRows($statement->getMinimumRows());
$schemaPage->setPackKeys($statement->getPackKeys());
$schemaPage->setDelayKeyWrite($statement->getDelayKeyWrite());
$schemaPage->setRowFormat(RowFormat::factory($statement->getRowFormat()));
$schemaPage->setInsertMethod(InsertMethod::factory($statement->getInsertMethod()));
$databaseSchema->registerTableSchema($schemaPage);
/* @var $tableSchema TableSchema */
$tableSchema = $this->schemaManager->getTableSchema($tableName);
assert($tableSchema instanceof TableSchema);
### WRITE COLUMNS
switch (true) {
case is_array($statement->getColumnDefinition()):
foreach ($statement->getColumnDefinition() as $name => $column) {
/* @var $column ColumnDefinition */
$columnPage = new ColumnSchema();
$columnPage->setName($name);
$columnPage->setDataType(DataType::factory($column->getDataType()->getName()));
/* @var $dataType DataType */
$dataType = $columnPage->getDataType();
$flags = 0;
if ($column->getIsPrimaryKey()) {
$flags = $flags ^ ColumnSchema::EXTRA_PRIMARY_KEY;
}
if ($column->getIsUnique()) {
$flags = $flags ^ ColumnSchema::EXTRA_UNIQUE_KEY;
}
if (!$column->getIsNullable()) {
$flags = $flags ^ ColumnSchema::EXTRA_NOT_NULL;
}
if ($column->getIsAutoIncrement()) {
$flags = $flags ^ ColumnSchema::EXTRA_AUTO_INCREMENT;
}
$columnPage->setExtraFlags($flags);
/* @var $dataType DataType */
$dataType = $column->getDataType();
$columnPage->setLength($dataType->getByteLength());
$columnPage->setSecondLength($dataType->getSecondByteLength());
if (!is_null($column->getDataTypeLength())) {
$columnPage->setLength($column->getDataTypeLength());
}
if (!is_null($column->getDataTypeSecondLength())) {
$columnPage->setSecondLength($column->getDataTypeSecondLength());
}
if (!is_null($column->getDefaultValue()) && !$columnPage->isDefaultValueInFile()) {
$columnPage->setDefaultValue($column->getDefaultValue());
}
$columnIndex = $tableSchema->addColumnSchema($columnPage);
if (!is_null($column->getDefaultValue()) && $columnPage->isDefaultValueInFile()) {
$defaultValueFilepath = sprintf(FilePathes::FILEPATH_DEFAULT_VALUE, $schemaId, $tableName, $columnIndex);
$this->tableManager->getFilesystem()->putFileContents($defaultValueFilepath, $column->getDefaultValue());
}
}
break;
case $statement->getColumnDefinition() instanceof Select:
break;
case $statement->getColumnDefinition() instanceof TableInterface:
break;
}
foreach ($statement->getIndexes() as $indexName => $index) {
/* @var $index Index */
$indexSchemaPage = new IndexSchema();
$indexSchemaPage->setName($indexName);
$indexSchemaPage->setEngine(IndexEngine::BTREE());
switch (true) {
case $index->getIsPrimary():
$indexSchemaPage->setType(IndexType::PRIMARY());
break;
case $index->getIsUnique():
$indexSchemaPage->setType(IndexType::UNIQUE());
break;
default:
$indexSchemaPage->setType(IndexType::INDEX());
break;
}
$method = ForeignKeyMethod::factory($index->getForeignKeyOnDeleteReferenceOption()->getName());
$indexSchemaPage->setForeignKeyOnDeleteMethod($method);
$method = ForeignKeyMethod::factory($index->getForeignKeyOnUpdateReferenceOption()->getName());
$indexSchemaPage->setForeignKeyOnUpdateMethod($method);
$keyLength = 0;
$columns = array();
foreach ($index->getColumns() as $indexColumnName) {
$indexColumnId = $tableSchema->getColumnIndex((string) $indexColumnName);
if (strlen($indexColumnId) <= 0) {
throw new ErrorException("Could not find index column '{$indexColumnName}' in table-schema!");
}
$columns[] = $indexColumnId;
$keyLength += $statement->getColumnDefinition()[(string) $indexColumnName]->getDataSize();
}
$indexSchemaPage->setColumns($columns);
$indexSchemaPage->setKeyLength($keyLength);
$tableSchema->addIndexSchema($indexSchemaPage);
}
foreach ($this->tableManager->getTableFactories() as $tableFactory) {
/* @var $tableFactory TableFactoryInterface */
if ($tableFactory instanceof InformationSchemaTableFactory) {
$tableFactory->clearCache();
}
}
### RESULT
$result = new TemporaryResult();
$result->setIsSuccess(true);
return $result;
}
public function registerTableSchema(DatabaseSchemaPage $schemaPage, $index = null)
{
switch ($schemaPage->getType()) {
case Type::TABLE():
if ($this->tableExists($schemaPage->getName())) {
throw new InvalidArgumentException("Table '{$schemaPage->getName()}' already exist!");
}
break;
case Type::VIEW():
if ($this->viewExists($schemaPage->getName())) {
throw new InvalidArgumentException("View '{$schemaPage->getName()}' already exist!");
}
break;
default:
throw new ErrorException("Unknown schema-page-type!");
}
$indexFile = $this->getSchemaIndexFile();
if (is_null($index)) {
$indexFile->addData($schemaPage->getData());
} else {
$indexFile->seek($index * DatabaseSchemaPage::PAGE_SIZE);
$indexFile->write($schemaPage->getData());
}
}