AbstractDatabaseTable.php

Go to the documentation of this file.

<?php
 
namespace Drupal\dkan_common\Storage;
 
use Contracts\RemoverInterface;
use Contracts\RetrieverInterface;
use Contracts\StorerInterface;
use Dkan\Datastore\Storage\StorageInterface;
use Dkan\Datastore\Storage\Database\SqlStorageTrait;
use Drupal\Core\Database\Connection;
use Drupal\dkan_datastore\Storage\Query;
 
abstract class AbstractDatabaseTable implements StorageInterface, StorerInterface, RetrieverInterface, RemoverInterface {
  use SqlStorageTrait;
  use QueryToQueryHelperTrait;
 
  protected $connection;
 
  abstract protected function getTableName();
 
  abstract protected function prepareData(string $data, string $id = NULL): array;
 
  abstract protected function primaryKey();
 
  public function __construct(Connection $connection) {
    $this->connection = $connection;
 
    if ($this->tableExist($this->getTableName())) {
      $this->setSchemaFromTable();
    }
  }
 
  public function retrieve(string $id) {
    $this->setTable();
 
    /* @var $statement StatementInterface */
    $statement = $this->connection->select($this->getTableName(), 't')
      ->fields('t', array_keys($this->getSchema()['fields']))
      ->condition($this->primaryKey(), $id)
      ->execute();
 
    // The docs do not mention it, but fetch can return false.
    $return = (isset($statement)) ? $statement->fetch() : NULL;
 
    return ($return === FALSE) ? NULL : $return;
  }
 
  public function retrieveAll(): array {
    $this->setTable();
    $tableName = $this->getTableName();
 
    $result = $this->connection->select($tableName, 't')
      ->fields('t', [$this->primaryKey()])
      ->execute()
      ->fetchAll();
 
    if ($result === FALSE) {
      return [];
    }
 
    $result = array_map(function ($item) {
      return $item->{$this->primaryKey()};
    }, $result);
 
    return $result;
  }
 
  public function store($data, string $id = NULL): string {
    $this->setTable();
 
    $existing = (isset($id)) ? $this->retrieve($id) : NULL;
 
    $data = $this->prepareData($data, $id);
 
    $returned_id = NULL;
 
    if ($existing === NULL) {
      $fields = $this->getNonSerialFields();
 
      if (count($fields) != count($data)) {
        throw new \Exception("The number of fields and data given do not match: fields - " .
        json_encode($fields) . " data - " . json_encode($data));
      }
 
      $q = $this->connection->insert($this->getTableName());
      $q->fields($fields);
      $q->values($data);
      $returned_id = $q->execute();
    }
    else {
      $q = $this->connection->update($this->getTableName());
      $q->fields($data)
        ->condition($this->primaryKey(), $id)
        ->execute();
    }
 
    return ($returned_id) ? "$returned_id" : "{$id}";
  }
 
  public function storeMultiple(array $data) : string {
    $this->setTable();
 
    $fields = $this->getNonSerialFields();
 
    $q = $this->connection->insert($this->getTableName());
    $q->fields($fields);
    foreach ($data as $datum) {
      $datum = $this->prepareData($datum);
      if (count($fields) != count($datum)) {
        throw new \Exception("The number of fields and data given do not match: fields - " .
          json_encode($fields) . " data - " . json_encode($datum));
      }
      $q->values($datum);
    }
    return $q->execute();
  }
 
  protected function getNonSerialFields() {
    $fields = [];
    foreach ($this->schema['fields'] as $field => $info) {
      if ($info['type'] != 'serial') {
        $fields[] = $field;
      }
    }
    return $fields;
  }
 
  public function remove(string $id) {
    $tableName = $this->getTableName();
    $this->connection->delete($tableName)
      ->condition($this->primaryKey(), $id)
      ->execute();
  }
 
  public function count(): int {
    $this->setTable();
    $query = $this->connection->select($this->getTableName());
    return $query->countQuery()->execute()->fetchField();
  }
 
  public function query(Query $query): array {
    $this->setTable();
    $db_query = $this->connection->select($this->getTableName(), 't')
      ->fields('t', $query->properties);
 
    $this->setQueryConditions($db_query, $query);
    $this->setQueryOrderBy($db_query, $query);
    $this->setQueryLimitAndOffset($db_query, $query);
 
    if ($query->count) {
      $db_query = $db_query->countQuery();
    }
 
    $result = $db_query->execute()->fetchAll();
 
    return $result;
  }
 
  private function setTable() {
    if (!$this->tableExist($this->getTableName())) {
      if ($this->schema) {
        $this->tableCreate($this->getTableName(), $this->schema);
      }
      else {
        throw new \Exception("Could not instantiate the table due to a lack of schema.");
      }
    }
  }
 
  public function destroy() {
    if ($this->tableExist($this->getTableName())) {
      $this->connection->schema()->dropTable($this->getTableName());
    }
  }
 
  private function tableExist($table_name) {
    $exists = $this->connection->schema()->tableExists($table_name);
    return $exists;
  }
 
  private function tableCreate($table_name, $schema) {
    $this->connection->schema()->createTable($table_name, $schema);
  }
 
  private function setSchemaFromTable() {
    $fields_info = $this->connection->query("DESCRIBE `{$this->getTableName()}`")->fetchAll();
    if (!empty($fields_info)) {
      $fields = $this->getFieldsFromFieldsInfo($fields_info);
      $this->setSchema($this->getTableSchema($fields));
    }
  }
 
  private function getFieldsFromFieldsInfo(array $fieldsInfo) {
    $fields = [];
    foreach ($fieldsInfo as $info) {
      $fields[] = $info->Field;
    }
    return $fields;
  }
 
  private function getTableSchema($fields) {
    $schema = [];
    $header = $fields;
    foreach ($header as $field) {
      $schema['fields'][$field] = [
        'type' => "text",
      ];
    }
    return $schema;
  }
 
}