{@inheritdoc}

@see \Doctrine\DBAL\Schema\AbstractSchemaManager::createTable()
433266
public function createTable(Table $table)
    {
        if (!$table->hasOption('charset') && !$table->hasOption('collate')) {
            $connParams = $this->_conn->getParams();
            if (isset($connParams['defaultTableOptions']['charset']) && isset($connParams['defaultTableOptions']['collate'])) {
                $table
                    ->addOption('charset', $connParams['defaultTableOptions']['charset'])
                    ->addOption('collate', $connParams['defaultTableOptions']['collate'])
                ;
            }
        }

        return parent::createTable($table);
    }
868533
public function createTable()
    {
        $sql = $this->getSql();

        $createTable = new CreateTable($this->getTableName());
        $tableStructure = $this->getTableStructure();

        foreach($tableStructure['columns'] as $column) {
            $createTable->addColumn($column);
        }

        foreach($tableStructure['constraints'] as $constraint) {
            $createTable->addConstraint($constraint);
        }

        $sql->getAdapter()->query(
            $sql->getSqlStringForSqlObject($createTable),
            Adapter::QUERY_MODE_EXECUTE
        );

        return $this;
    }
161961
public static function createTable($table, callable $callback) {
        $table = new Table($table);
        call_user_func($callback, $table);
        return $table->create();
    }
670760
public static function table($table)
    {
        static::verifyConnection();

        $table = static::$adapter->getTablePrefix().$table;

        return new QueryBuilder(
            $table,
            static::$adapter->getConnection()
        );
    }
182136
public function createTable($tableName, $tableConfig = null)
    {
        if ($this->hasTable($tableName)) {
            throw new RuntimeException("Table with name {$tableName} is exist. Use rewriteTable()");
        }

        return $this->create($tableName, $tableConfig);
    }
982427
public function createTableIfNotExists()
    {
        Schema::make(
            $this,
            function ($table) {
                $table->tableName = $this->getTable();

                /*
                | Check if table already exists
                | if not we will create an table to store session info
                 */
                if (!$table->hasTable()->run()) {
                    $table->create(
                        [
                            [
                                'column'    => 'id',
                                'type'      => 'int',
                                'length'    => 11,
                                'increment' => true,
                                'key'       => 'primary',
                            ],
                            ['column' => 'access', 'type' => 'int', 'length' => 11],
                            ['column' => 'data', 'type' => 'text'],
                            ['column' => 'session_id', 'type' => 'string', 'length' => 128],
                        ],
                        'InnoDB',
                        'latin1'
                    )->run();
                }
            }
        );
    }
371246
public function table($table)
    {
        if (!isset($this->tables[$table])) {
            $this->tables[$table] = new Table($table, $this->storage);
        }

        return new QueryBuilder($this->tables[$table], $this->filters);
    }
1332073
public function createTables(array $tableCreates, SchemaCheck $response)
    {
        foreach ($tableCreates as $tableName => $tableCreate) {
            $this->createTable($tableName, $tableCreate, $response);
        }
    }
868588
public function createTable($conn, $table, $schema, array $definition)
    {
        if (empty($definition['columns'])) {
            throw new Exception("The table must contain at least one column");
        }
        $conn->execute($this->getDialect($conn)->createTable($table, $schema, $definition));
    }
382669
public function createTable($tableName)
    {
        $table = new Table($tableName);
        $this->_addTable($table);

        foreach ($this->_schemaConfig->getDefaultTableOptions() as $name => $value) {
            $table->addOption($name, $value);
        }

        return $table;
    }
1171882
public function create($table, $schema)
    {
        return $this
            ->destroy($schema, $table)
            ->initialize($schema, $table)
            ;
    }
246158
public function createTable($tablename, $connection = NULL)
    {
        $connection = DatabaseQuery::connect();
        try
        {
            $sqlQuery = self::sanitizeQuery($tablename);
            $query = $connection->prepare($sqlQuery);
            if($query->execute())
            {
                return true;
            }
        }catch(PDOException $e){
            return $e->getMessage();
        }
    }
632525
private function createTable()
    {
        Schema::create($this->table, function ($tab) {
            $tab->inc('id');
            $tab->string('name');
            $tab->string('value');
            $tab->long('lifetime');
            $tab->unique('cacheunique', ['name']);
        });
    }
663574
public function createTable(ModelInterface $model)
    {
        $i = 0;

        $model->setConnection($this->connection);

        $schemaManager = $this->connection->getSchemaManager();
        $builder = $this->getQueryBuilder();
        $tableName = TableNameResolver::getTableName($model->tableName());

        $columns = [];
        $indexes = [];

        foreach ($model->getMeta()->getFields() as $name => $field) {
            $field->setModel($model);

            if ($field instanceof ManyToManyField) {
                $field->setConnection($this->connection);

                /* @var $field \Mindy\Orm\Fields\ManyToManyField */
                if (null === $field->through) {
                    $fieldTableName = TableNameResolver::getTableName($field->getTableName());
                    if (false === $this->hasTable($fieldTableName)) {
                        $fieldTable = new Table(
                            $fieldTableName,
                            $field->getColumns()
                        );
                        $schemaManager->createTable($fieldTable);
                        $i += 1;
                    }
                }
            } else {
                $column = $field->getColumn();
                if (empty($column)) {
                    continue;
                }

                $columns[] = $column;
                $indexes = array_merge($indexes, $field->getSqlIndexes());
            }
        }

        if (false === $this->hasTable($tableName)) {
            $table = new Table($tableName, $columns, []);
            $table->setPrimaryKey($model->getPrimaryKeyName(true), 'primary');
            $schemaManager->createTable($table);

            $i += 1;
        }

        return $i;
    }
25835
protected function createTable()
    {
        if ($this->db->getTableSchema($this->tableName) === null) {
            $this->db->createCommand()
                ->createTable($this->tableName, [
                    'id' => 'pk',
                    'created_at' => 'integer',
                    'updated_at' => 'integer',
                    'data' => 'binary',
                ])->execute();
            $this->db->getTableSchema($this->tableName, true);
        }
    }
1373904
public function createTable()
    {
        phpCAS::traceBegin();

        // initialize this PGTStorage object if it hasn't been initialized yet
        if ( !$this->isInitialized() ) {
            $this->init();
        }

        // initialize the PDO object for this method
        $pdo = $this->_getPdo();
        $this->_setErrorMode();

        try {
            $pdo->beginTransaction();

            $query = $pdo->query($this->createTableSQL());
            $query->closeCursor();

            $pdo->commit();
        }
        catch(PDOException $e) {
            // attempt rolling back the transaction before throwing a phpCAS error
            try {
                $pdo->rollBack();
            }
            catch(PDOException $e) {
            }
            phpCAS::error('error creating PGT storage table: ' . $e->getMessage());
        }

        // reset the PDO object
        $this->_resetErrorMode();

        phpCAS::traceEnd();
    }
1140138
public function create()
        {
            $sql = $this->generateCreateSql();
            $query = new RawQuery($sql);
            try {
                $this->drop();
                return Statement::getPreparedStatement($query)->execute();
            } catch (\Exception $e) {
                throw new Exception('Error creating table ' . $this->getB2DBName() . ': ' . $e->getMessage(), $sql);
            }
        }