class Schema in Drupal 9

SQLite implementation of \Drupal\Core\Database\Schema.

Hierarchy

• class \Drupal\Core\Database\Schema implements PlaceholderInterface
  • class \Drupal\Core\Database\Driver\sqlite\Schema

Related topics

Schema API

API to handle database schemas.

3 string references to 'Schema'

Connection::getDriverClass in core/lib/Drupal/Core/Database/Connection.php

Gets the driver-specific override class if any for the specified class.

Connection::schema in core/lib/Drupal/Core/Database/Connection.php

Returns a DatabaseSchema object for manipulating the schema.

ConnectionTest::providerGetDriverClass in core/tests/Drupal/Tests/Core/Database/ConnectionTest.php

Data provider for testGetDriverClass().

File

core/lib/Drupal/Core/Database/Driver/sqlite/Schema.php, line 17

Namespace

Drupal\Core\Database\Driver\sqlite

class Schema extends DatabaseSchema {

  /**
   * Override DatabaseSchema::$defaultSchema.
   *
   * @var string
   */
  protected $defaultSchema = 'main';

  /**
   * {@inheritdoc}
   */
  public function tableExists($table) {
    $info = $this
      ->getPrefixInfo($table);

    // Don't use {} around sqlite_master table.
    return (bool) $this->connection
      ->query('SELECT 1 FROM ' . $info['schema'] . '.sqlite_master WHERE type = :type AND name = :name', [
      ':type' => 'table',
      ':name' => $info['table'],
    ])
      ->fetchField();
  }

  /**
   * {@inheritdoc}
   */
  public function fieldExists($table, $column) {
    $schema = $this
      ->introspectSchema($table);
    return !empty($schema['fields'][$column]);
  }

  /**
   * Generate SQL to create a new table from a Drupal schema definition.
   *
   * @param $name
   *   The name of the table to create.
   * @param $table
   *   A Schema API table definition array.
   *
   * @return
   *   An array of SQL statements to create the table.
   */
  public function createTableSql($name, $table) {
    if (!empty($table['primary key']) && is_array($table['primary key'])) {
      $this
        ->ensureNotNullPrimaryKey($table['primary key'], $table['fields']);
    }
    $sql = [];
    $sql[] = "CREATE TABLE {" . $name . "} (\n" . $this
      ->createColumnsSql($name, $table) . "\n)\n";
    return array_merge($sql, $this
      ->createIndexSql($name, $table));
  }

  /**
   * Build the SQL expression for indexes.
   */
  protected function createIndexSql($tablename, $schema) {
    $sql = [];
    $info = $this
      ->getPrefixInfo($tablename);
    if (!empty($schema['unique keys'])) {
      foreach ($schema['unique keys'] as $key => $fields) {
        $sql[] = 'CREATE UNIQUE INDEX ' . $info['schema'] . '.' . $info['table'] . '_' . $key . ' ON ' . $info['table'] . ' (' . $this
          ->createKeySql($fields) . ")\n";
      }
    }
    if (!empty($schema['indexes'])) {
      foreach ($schema['indexes'] as $key => $fields) {
        $sql[] = 'CREATE INDEX ' . $info['schema'] . '.' . $info['table'] . '_' . $key . ' ON ' . $info['table'] . ' (' . $this
          ->createKeySql($fields) . ")\n";
      }
    }
    return $sql;
  }

  /**
   * Build the SQL expression for creating columns.
   */
  protected function createColumnsSql($tablename, $schema) {
    $sql_array = [];

    // Add the SQL statement for each field.
    foreach ($schema['fields'] as $name => $field) {
      if (isset($field['type']) && $field['type'] == 'serial') {
        if (isset($schema['primary key']) && ($key = array_search($name, $schema['primary key'])) !== FALSE) {
          unset($schema['primary key'][$key]);
        }
      }
      $sql_array[] = $this
        ->createFieldSql($name, $this
        ->processField($field));
    }

    // Process keys.
    if (!empty($schema['primary key'])) {
      $sql_array[] = " PRIMARY KEY (" . $this
        ->createKeySql($schema['primary key']) . ")";
    }
    return implode(", \n", $sql_array);
  }

  /**
   * Build the SQL expression for keys.
   */
  protected function createKeySql($fields) {
    $return = [];
    foreach ($fields as $field) {
      if (is_array($field)) {
        $return[] = $field[0];
      }
      else {
        $return[] = $field;
      }
    }
    return implode(', ', $return);
  }

  /**
   * Set database-engine specific properties for a field.
   *
   * @param $field
   *   A field description array, as specified in the schema documentation.
   */
  protected function processField($field) {
    if (!isset($field['size'])) {
      $field['size'] = 'normal';
    }

    // Set the correct database-engine specific datatype.
    // In case one is already provided, force it to uppercase.
    if (isset($field['sqlite_type'])) {
      $field['sqlite_type'] = mb_strtoupper($field['sqlite_type']);
    }
    else {
      $map = $this
        ->getFieldTypeMap();
      $field['sqlite_type'] = $map[$field['type'] . ':' . $field['size']];

      // Numeric fields with a specified scale have to be stored as floats.
      if ($field['sqlite_type'] === 'NUMERIC' && isset($field['scale'])) {
        $field['sqlite_type'] = 'FLOAT';
      }
    }
    if (isset($field['type']) && $field['type'] == 'serial') {
      $field['auto_increment'] = TRUE;
    }
    return $field;
  }

  /**
   * Create an SQL string for a field to be used in table creation or alteration.
   *
   * Before passing a field out of a schema definition into this function it has
   * to be processed by self::processField().
   *
   * @param $name
   *   Name of the field.
   * @param $spec
   *   The field specification, as per the schema data structure format.
   */
  protected function createFieldSql($name, $spec) {
    $name = $this->connection
      ->escapeField($name);
    if (!empty($spec['auto_increment'])) {
      $sql = $name . " INTEGER PRIMARY KEY AUTOINCREMENT";
      if (!empty($spec['unsigned'])) {
        $sql .= ' CHECK (' . $name . '>= 0)';
      }
    }
    else {
      $sql = $name . ' ' . $spec['sqlite_type'];
      if (in_array($spec['sqlite_type'], [
        'VARCHAR',
        'TEXT',
      ])) {
        if (isset($spec['length'])) {
          $sql .= '(' . $spec['length'] . ')';
        }
        if (isset($spec['binary']) && $spec['binary'] === FALSE) {
          $sql .= ' COLLATE NOCASE_UTF8';
        }
      }
      if (isset($spec['not null'])) {
        if ($spec['not null']) {
          $sql .= ' NOT NULL';
        }
        else {
          $sql .= ' NULL';
        }
      }
      if (!empty($spec['unsigned'])) {
        $sql .= ' CHECK (' . $name . '>= 0)';
      }
      if (isset($spec['default'])) {
        if (is_string($spec['default'])) {
          $spec['default'] = $this->connection
            ->quote($spec['default']);
        }
        $sql .= ' DEFAULT ' . $spec['default'];
      }
      if (empty($spec['not null']) && !isset($spec['default'])) {
        $sql .= ' DEFAULT NULL';
      }
    }
    return $sql;
  }

  /**
   * {@inheritdoc}
   */
  public function getFieldTypeMap() {

    // Put :normal last so it gets preserved by array_flip. This makes
    // it much easier for modules (such as schema.module) to map
    // database types back into schema types.
    // $map does not use drupal_static as its value never changes.
    static $map = [
      'varchar_ascii:normal' => 'VARCHAR',
      'varchar:normal' => 'VARCHAR',
      'char:normal' => 'CHAR',
      'text:tiny' => 'TEXT',
      'text:small' => 'TEXT',
      'text:medium' => 'TEXT',
      'text:big' => 'TEXT',
      'text:normal' => 'TEXT',
      'serial:tiny' => 'INTEGER',
      'serial:small' => 'INTEGER',
      'serial:medium' => 'INTEGER',
      'serial:big' => 'INTEGER',
      'serial:normal' => 'INTEGER',
      'int:tiny' => 'INTEGER',
      'int:small' => 'INTEGER',
      'int:medium' => 'INTEGER',
      'int:big' => 'INTEGER',
      'int:normal' => 'INTEGER',
      'float:tiny' => 'FLOAT',
      'float:small' => 'FLOAT',
      'float:medium' => 'FLOAT',
      'float:big' => 'FLOAT',
      'float:normal' => 'FLOAT',
      'numeric:normal' => 'NUMERIC',
      'blob:big' => 'BLOB',
      'blob:normal' => 'BLOB',
    ];
    return $map;
  }

  /**
   * {@inheritdoc}
   */
  public function renameTable($table, $new_name) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("Cannot rename '{$table}' to '{$new_name}': table '{$table}' doesn't exist.");
    }
    if ($this
      ->tableExists($new_name)) {
      throw new SchemaObjectExistsException("Cannot rename '{$table}' to '{$new_name}': table '{$new_name}' already exists.");
    }
    $schema = $this
      ->introspectSchema($table);

    // SQLite doesn't allow you to rename tables outside of the current
    // database. So the syntax '... RENAME TO database.table' would fail.
    // So we must determine the full table name here rather than surrounding
    // the table with curly braces in case the db_prefix contains a reference
    // to a database outside of our existing database.
    $info = $this
      ->getPrefixInfo($new_name);
    $this->connection
      ->query('ALTER TABLE {' . $table . '} RENAME TO ' . $info['table']);

    // Drop the indexes, there is no RENAME INDEX command in SQLite.
    if (!empty($schema['unique keys'])) {
      foreach ($schema['unique keys'] as $key => $fields) {
        $this
          ->dropIndex($table, $key);
      }
    }
    if (!empty($schema['indexes'])) {
      foreach ($schema['indexes'] as $index => $fields) {
        $this
          ->dropIndex($table, $index);
      }
    }

    // Recreate the indexes.
    $statements = $this
      ->createIndexSql($new_name, $schema);
    foreach ($statements as $statement) {
      $this->connection
        ->query($statement);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function dropTable($table) {
    if (!$this
      ->tableExists($table)) {
      return FALSE;
    }
    $this->connection->tableDropped = TRUE;
    $this->connection
      ->query('DROP TABLE {' . $table . '}');
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function addField($table, $field, $specification, $keys_new = []) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("Cannot add field '{$table}.{$field}': table doesn't exist.");
    }
    if ($this
      ->fieldExists($table, $field)) {
      throw new SchemaObjectExistsException("Cannot add field '{$table}.{$field}': field already exists.");
    }
    if (isset($keys_new['primary key']) && in_array($field, $keys_new['primary key'], TRUE)) {
      $this
        ->ensureNotNullPrimaryKey($keys_new['primary key'], [
        $field => $specification,
      ]);
    }

    // SQLite doesn't have a full-featured ALTER TABLE statement. It only
    // supports adding new fields to a table, in some simple cases. In most
    // cases, we have to create a new table and copy the data over.
    if (empty($keys_new) && (empty($specification['not null']) || isset($specification['default']))) {

      // When we don't have to create new keys and we are not creating a
      // NOT NULL column without a default value, we can use the quicker version.
      $query = 'ALTER TABLE {' . $table . '} ADD ' . $this
        ->createFieldSql($field, $this
        ->processField($specification));
      $this->connection
        ->query($query);

      // Apply the initial value if set.
      if (isset($specification['initial_from_field'])) {
        if (isset($specification['initial'])) {
          $expression = 'COALESCE(' . $specification['initial_from_field'] . ', :default_initial_value)';
          $arguments = [
            ':default_initial_value' => $specification['initial'],
          ];
        }
        else {
          $expression = $specification['initial_from_field'];
          $arguments = [];
        }
        $this->connection
          ->update($table)
          ->expression($field, $expression, $arguments)
          ->execute();
      }
      elseif (isset($specification['initial'])) {
        $this->connection
          ->update($table)
          ->fields([
          $field => $specification['initial'],
        ])
          ->execute();
      }
    }
    else {

      // We cannot add the field directly. Use the slower table alteration
      // method, starting from the old schema.
      $old_schema = $this
        ->introspectSchema($table);
      $new_schema = $old_schema;

      // Add the new field.
      $new_schema['fields'][$field] = $specification;

      // Build the mapping between the old fields and the new fields.
      $mapping = [];
      if (isset($specification['initial_from_field'])) {

        // If we have an initial value, copy it over.
        if (isset($specification['initial'])) {
          $expression = 'COALESCE(' . $specification['initial_from_field'] . ', :default_initial_value)';
          $arguments = [
            ':default_initial_value' => $specification['initial'],
          ];
        }
        else {
          $expression = $specification['initial_from_field'];
          $arguments = [];
        }
        $mapping[$field] = [
          'expression' => $expression,
          'arguments' => $arguments,
        ];
      }
      elseif (isset($specification['initial'])) {

        // If we have an initial value, copy it over.
        $mapping[$field] = [
          'expression' => ':newfieldinitial',
          'arguments' => [
            ':newfieldinitial' => $specification['initial'],
          ],
        ];
      }
      else {

        // Else use the default of the field.
        $mapping[$field] = NULL;
      }

      // Add the new indexes.
      $new_schema = array_merge($new_schema, $keys_new);
      $this
        ->alterTable($table, $old_schema, $new_schema, $mapping);
    }
  }

  /**
   * Create a table with a new schema containing the old content.
   *
   * As SQLite does not support ALTER TABLE (with a few exceptions) it is
   * necessary to create a new table and copy over the old content.
   *
   * @param $table
   *   Name of the table to be altered.
   * @param $old_schema
   *   The old schema array for the table.
   * @param $new_schema
   *   The new schema array for the table.
   * @param $mapping
   *   An optional mapping between the fields of the old specification and the
   *   fields of the new specification. An associative array, whose keys are
   *   the fields of the new table, and values can take two possible forms:
   *     - a simple string, which is interpreted as the name of a field of the
   *       old table,
   *     - an associative array with two keys 'expression' and 'arguments',
   *       that will be used as an expression field.
   */
  protected function alterTable($table, $old_schema, $new_schema, array $mapping = []) {
    $i = 0;
    do {
      $new_table = $table . '_' . $i++;
    } while ($this
      ->tableExists($new_table));
    $this
      ->createTable($new_table, $new_schema);

    // Build a SQL query to migrate the data from the old table to the new.
    $select = $this->connection
      ->select($table);

    // Complete the mapping.
    $possible_keys = array_keys($new_schema['fields']);
    $mapping += array_combine($possible_keys, $possible_keys);

    // Now add the fields.
    foreach ($mapping as $field_alias => $field_source) {

      // Just ignore this field (ie. use its default value).
      if (!isset($field_source)) {
        continue;
      }
      if (is_array($field_source)) {
        $select
          ->addExpression($field_source['expression'], $field_alias, $field_source['arguments']);
      }
      else {
        $select
          ->addField($table, $field_source, $field_alias);
      }
    }

    // Execute the data migration query.
    $this->connection
      ->insert($new_table)
      ->from($select)
      ->execute();
    $old_count = $this->connection
      ->query('SELECT COUNT(*) FROM {' . $table . '}')
      ->fetchField();
    $new_count = $this->connection
      ->query('SELECT COUNT(*) FROM {' . $new_table . '}')
      ->fetchField();
    if ($old_count == $new_count) {
      $this
        ->dropTable($table);
      $this
        ->renameTable($new_table, $table);
    }
  }

  /**
   * Find out the schema of a table.
   *
   * This function uses introspection methods provided by the database to
   * create a schema array. This is useful, for example, during update when
   * the old schema is not available.
   *
   * @param $table
   *   Name of the table.
   *
   * @return
   *   An array representing the schema.
   *
   * @throws \Exception
   *   If a column of the table could not be parsed.
   */
  protected function introspectSchema($table) {
    $mapped_fields = array_flip($this
      ->getFieldTypeMap());
    $schema = [
      'fields' => [],
      'primary key' => [],
      'unique keys' => [],
      'indexes' => [],
    ];
    $info = $this
      ->getPrefixInfo($table);
    $result = $this->connection
      ->query('PRAGMA ' . $info['schema'] . '.table_info(' . $info['table'] . ')');
    foreach ($result as $row) {
      if (preg_match('/^([^(]+)\\((.*)\\)$/', $row->type, $matches)) {
        $type = $matches[1];
        $length = $matches[2];
      }
      else {
        $type = $row->type;
        $length = NULL;
      }
      if (isset($mapped_fields[$type])) {
        list($type, $size) = explode(':', $mapped_fields[$type]);
        $schema['fields'][$row->name] = [
          'type' => $type,
          'size' => $size,
          'not null' => !empty($row->notnull) || $row->pk !== "0",
          'default' => trim($row->dflt_value, "'"),
        ];
        if ($length) {
          $schema['fields'][$row->name]['length'] = $length;
        }

        // $row->pk contains a number that reflects the primary key order. We
        // use that as the key and sort (by key) below to return the primary key
        // in the same order that it is stored in.
        if ($row->pk) {
          $schema['primary key'][$row->pk] = $row->name;
        }
      }
      else {
        throw new \Exception("Unable to parse the column type " . $row->type);
      }
    }
    ksort($schema['primary key']);

    // Re-key the array because $row->pk starts counting at 1.
    $schema['primary key'] = array_values($schema['primary key']);
    $indexes = [];
    $result = $this->connection
      ->query('PRAGMA ' . $info['schema'] . '.index_list(' . $info['table'] . ')');
    foreach ($result as $row) {
      if (strpos($row->name, 'sqlite_autoindex_') !== 0) {
        $indexes[] = [
          'schema_key' => $row->unique ? 'unique keys' : 'indexes',
          'name' => $row->name,
        ];
      }
    }
    foreach ($indexes as $index) {
      $name = $index['name'];

      // Get index name without prefix.
      $index_name = substr($name, strlen($info['table']) + 1);
      $result = $this->connection
        ->query('PRAGMA ' . $info['schema'] . '.index_info(' . $name . ')');
      foreach ($result as $row) {
        $schema[$index['schema_key']][$index_name][] = $row->name;
      }
    }
    return $schema;
  }

  /**
   * {@inheritdoc}
   */
  public function dropField($table, $field) {
    if (!$this
      ->fieldExists($table, $field)) {
      return FALSE;
    }
    $old_schema = $this
      ->introspectSchema($table);
    $new_schema = $old_schema;
    unset($new_schema['fields'][$field]);

    // Drop the primary key if the field to drop is part of it. This is
    // consistent with the behavior on PostgreSQL.
    // @see \Drupal\Core\Database\Driver\mysql\Schema::dropField()
    if (isset($new_schema['primary key']) && in_array($field, $new_schema['primary key'], TRUE)) {
      unset($new_schema['primary key']);
    }

    // Handle possible index changes.
    foreach ($new_schema['indexes'] as $index => $fields) {
      foreach ($fields as $key => $field_name) {
        if ($field_name == $field) {
          unset($new_schema['indexes'][$index][$key]);
        }
      }

      // If this index has no more fields then remove it.
      if (empty($new_schema['indexes'][$index])) {
        unset($new_schema['indexes'][$index]);
      }
    }
    $this
      ->alterTable($table, $old_schema, $new_schema);
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function changeField($table, $field, $field_new, $spec, $keys_new = []) {
    if (!$this
      ->fieldExists($table, $field)) {
      throw new SchemaObjectDoesNotExistException("Cannot change the definition of field '{$table}.{$field}': field doesn't exist.");
    }
    if ($field != $field_new && $this
      ->fieldExists($table, $field_new)) {
      throw new SchemaObjectExistsException("Cannot rename field '{$table}.{$field}' to '{$field_new}': target field already exists.");
    }
    if (isset($keys_new['primary key']) && in_array($field_new, $keys_new['primary key'], TRUE)) {
      $this
        ->ensureNotNullPrimaryKey($keys_new['primary key'], [
        $field_new => $spec,
      ]);
    }
    $old_schema = $this
      ->introspectSchema($table);
    $new_schema = $old_schema;

    // Map the old field to the new field.
    if ($field != $field_new) {
      $mapping[$field_new] = $field;
    }
    else {
      $mapping = [];
    }

    // Remove the previous definition and swap in the new one.
    unset($new_schema['fields'][$field]);
    $new_schema['fields'][$field_new] = $spec;

    // Map the former indexes to the new column name.
    $new_schema['primary key'] = $this
      ->mapKeyDefinition($new_schema['primary key'], $mapping);
    foreach ([
      'unique keys',
      'indexes',
    ] as $k) {
      foreach ($new_schema[$k] as &$key_definition) {
        $key_definition = $this
          ->mapKeyDefinition($key_definition, $mapping);
      }
    }

    // Add in the keys from $keys_new.
    if (isset($keys_new['primary key'])) {
      $new_schema['primary key'] = $keys_new['primary key'];
    }
    foreach ([
      'unique keys',
      'indexes',
    ] as $k) {
      if (!empty($keys_new[$k])) {
        $new_schema[$k] = $keys_new[$k] + $new_schema[$k];
      }
    }
    $this
      ->alterTable($table, $old_schema, $new_schema, $mapping);
  }

  /**
   * Utility method: rename columns in an index definition according to a new mapping.
   *
   * @param $key_definition
   *   The key definition.
   * @param $mapping
   *   The new mapping.
   */
  protected function mapKeyDefinition(array $key_definition, array $mapping) {
    foreach ($key_definition as &$field) {

      // The key definition can be an array($field, $length).
      if (is_array($field)) {
        $field =& $field[0];
      }
      $mapped_field = array_search($field, $mapping, TRUE);
      if ($mapped_field !== FALSE) {
        $field = $mapped_field;
      }
    }
    return $key_definition;
  }

  /**
   * {@inheritdoc}
   */
  public function addIndex($table, $name, $fields, array $spec) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("Cannot add index '{$name}' to table '{$table}': table doesn't exist.");
    }
    if ($this
      ->indexExists($table, $name)) {
      throw new SchemaObjectExistsException("Cannot add index '{$name}' to table '{$table}': index already exists.");
    }
    $schema['indexes'][$name] = $fields;
    $statements = $this
      ->createIndexSql($table, $schema);
    foreach ($statements as $statement) {
      $this->connection
        ->query($statement);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function indexExists($table, $name) {
    $info = $this
      ->getPrefixInfo($table);
    return $this->connection
      ->query('PRAGMA ' . $info['schema'] . '.index_info(' . $info['table'] . '_' . $name . ')')
      ->fetchField() != '';
  }

  /**
   * {@inheritdoc}
   */
  public function dropIndex($table, $name) {
    if (!$this
      ->indexExists($table, $name)) {
      return FALSE;
    }
    $info = $this
      ->getPrefixInfo($table);
    $this->connection
      ->query('DROP INDEX ' . $info['schema'] . '.' . $info['table'] . '_' . $name);
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function addUniqueKey($table, $name, $fields) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("Cannot add unique key '{$name}' to table '{$table}': table doesn't exist.");
    }
    if ($this
      ->indexExists($table, $name)) {
      throw new SchemaObjectExistsException("Cannot add unique key '{$name}' to table '{$table}': unique key already exists.");
    }
    $schema['unique keys'][$name] = $fields;
    $statements = $this
      ->createIndexSql($table, $schema);
    foreach ($statements as $statement) {
      $this->connection
        ->query($statement);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function dropUniqueKey($table, $name) {
    if (!$this
      ->indexExists($table, $name)) {
      return FALSE;
    }
    $info = $this
      ->getPrefixInfo($table);
    $this->connection
      ->query('DROP INDEX ' . $info['schema'] . '.' . $info['table'] . '_' . $name);
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function addPrimaryKey($table, $fields) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("Cannot add primary key to table '{$table}': table doesn't exist.");
    }
    $old_schema = $this
      ->introspectSchema($table);
    $new_schema = $old_schema;
    if (!empty($new_schema['primary key'])) {
      throw new SchemaObjectExistsException("Cannot add primary key to table '{$table}': primary key already exists.");
    }
    $new_schema['primary key'] = $fields;
    $this
      ->ensureNotNullPrimaryKey($new_schema['primary key'], $new_schema['fields']);
    $this
      ->alterTable($table, $old_schema, $new_schema);
  }

  /**
   * {@inheritdoc}
   */
  public function dropPrimaryKey($table) {
    $old_schema = $this
      ->introspectSchema($table);
    $new_schema = $old_schema;
    if (empty($new_schema['primary key'])) {
      return FALSE;
    }
    unset($new_schema['primary key']);
    $this
      ->alterTable($table, $old_schema, $new_schema);
    return TRUE;
  }

  /**
   * {@inheritdoc}
   */
  protected function findPrimaryKeyColumns($table) {
    if (!$this
      ->tableExists($table)) {
      return FALSE;
    }
    $schema = $this
      ->introspectSchema($table);
    return $schema['primary key'];
  }

  /**
   * {@inheritdoc}
   */
  protected function introspectIndexSchema($table) {
    if (!$this
      ->tableExists($table)) {
      throw new SchemaObjectDoesNotExistException("The table {$table} doesn't exist.");
    }
    $schema = $this
      ->introspectSchema($table);
    unset($schema['fields']);
    return $schema;
  }

  /**
   * {@inheritdoc}
   */
  public function findTables($table_expression) {
    $tables = [];

    // The SQLite implementation doesn't need to use the same filtering strategy
    // as the parent one because individually prefixed tables live in their own
    // schema (database), which means that neither the main database nor any
    // attached one will contain a prefixed table name, so we just need to loop
    // over all known schemas and filter by the user-supplied table expression.
    $attached_dbs = $this->connection
      ->getAttachedDatabases();
    foreach ($attached_dbs as $schema) {

      // Can't use query placeholders for the schema because the query would
      // have to be :prefixsqlite_master, which does not work. We also need to
      // ignore the internal SQLite tables.
      $result = $this->connection
        ->query("SELECT name FROM " . $schema . ".sqlite_master WHERE type = :type AND name LIKE :table_name AND name NOT LIKE :pattern", [
        ':type' => 'table',
        ':table_name' => $table_expression,
        ':pattern' => 'sqlite_%',
      ]);
      $tables += $result
        ->fetchAllKeyed(0, 0);
    }
    return $tables;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Schema::$connection	protected	property	The database connection.
Schema::$defaultSchema	protected	property	Override DatabaseSchema::$defaultSchema. Overrides Schema::$defaultSchema
Schema::$placeholder	protected	property	The placeholder counter.
Schema::$uniqueIdentifier	protected	property	A unique identifier for this query object.
Schema::addField	public	function	Add a new field to a table. Overrides Schema::addField
Schema::addIndex	public	function	Add an index. Overrides Schema::addIndex
Schema::addPrimaryKey	public	function	Add a primary key. Overrides Schema::addPrimaryKey
Schema::addUniqueKey	public	function	Add a unique key. Overrides Schema::addUniqueKey
Schema::alterTable	protected	function	Create a table with a new schema containing the old content.
Schema::buildTableNameCondition	protected	function	Build a condition to match a table name against a standard information_schema.	1
Schema::changeField	public	function	Change a field definition. Overrides Schema::changeField
Schema::createColumnsSql	protected	function	Build the SQL expression for creating columns.
Schema::createFieldSql	protected	function	Create an SQL string for a field to be used in table creation or alteration.
Schema::createIndexSql	protected	function	Build the SQL expression for indexes.
Schema::createKeySql	protected	function	Build the SQL expression for keys.
Schema::createTable	public	function	Create a new table from a Drupal table definition.
Schema::createTableSql	public	function	Generate SQL to create a new table from a Drupal schema definition.
Schema::dropField	public	function	Drop a field. Overrides Schema::dropField
Schema::dropIndex	public	function	Drop an index. Overrides Schema::dropIndex
Schema::dropPrimaryKey	public	function	Drop the primary key. Overrides Schema::dropPrimaryKey
Schema::dropTable	public	function	Drop a table. Overrides Schema::dropTable
Schema::dropUniqueKey	public	function	Drop a unique key. Overrides Schema::dropUniqueKey
Schema::ensureNotNullPrimaryKey	protected	function	Ensures that all the primary key fields are correctly defined.
Schema::escapeDefaultValue	protected	function	Return an escaped version of its parameter to be used as a default value on a column.
Schema::fieldExists	public	function	Check if a column exists in the given table. Overrides Schema::fieldExists
Schema::fieldNames	public	function	Return an array of field names from an array of key/index column specifiers.
Schema::findPrimaryKeyColumns	protected	function	Finds the primary key columns of a table, from the database. Overrides Schema::findPrimaryKeyColumns
Schema::findTables	public	function	Finds all tables that are like the specified base table name. Overrides Schema::findTables
Schema::getFieldTypeMap	public	function	Returns a mapping of Drupal schema field names to DB-native field types. Overrides Schema::getFieldTypeMap
Schema::getPrefixInfo	protected	function	Get information about the table name and schema from the prefix.	1
Schema::indexExists	public	function	Checks if an index exists in the given table. Overrides Schema::indexExists
Schema::introspectIndexSchema	protected	function	Finds the columns for the primary key, unique keys and indexes of a table. Overrides Schema::introspectIndexSchema
Schema::introspectSchema	protected	function	Find out the schema of a table.
Schema::mapKeyDefinition	protected	function	Utility method: rename columns in an index definition according to a new mapping.
Schema::nextPlaceholder	public	function	Returns the next placeholder ID for the query. Overrides PlaceholderInterface::nextPlaceholder
Schema::prefixNonTable	public	function	Create names for indexes, primary keys and constraints.
Schema::prepareComment	public	function	Prepare a table or column comment for database query.	1
Schema::processField	protected	function	Set database-engine specific properties for a field.
Schema::renameTable	public	function	Rename a table. Overrides Schema::renameTable
Schema::tableExists	public	function	Check if a table exists. Overrides Schema::tableExists
Schema::uniqueIdentifier	public	function	Returns a unique identifier for this object. Overrides PlaceholderInterface::uniqueIdentifier
Schema::__clone	public	function	Implements the magic __clone function.
Schema::__construct	public	function