csplit –f "out_" nazwa_pliku_backup.sql "/^COPY /" {*}
head –n 1 out_*

W wyniku pracy programu csplit uzyskałem kilkadziesiąt mniejszych plików – po jednym dla każdej tabeli w bazie.

Robiąc kopię bazy danych, należy pamiętać o pewnych zasadach bezpieczeństwa. Gdy kopia danych systemu ma być używana do celów deweloperskich – to należy zniszczyć wszystkie wrażliwe dane w bazie: imiona i nazwiska, hasła, adresy, numery telefonów. Taka kopia danych może być bowiem użyta na laptopach programistów, lub na słabiej zabezpieczonych systemach. Warto więc wypracować pewne procedury w tym zakresie.

Kilka lat temu zaproponowałem następującą procedurę: po wykonaniu kopii wszystkie imiona, hasła, adresy, nazwy i temu podobne dane zostaną zniszczone. Są trzy typy niszczenia.

Niszczenie tekstów i nazw własnych. Dla każdego znaku w ciągu znaków powinien zostać wylosowany inny znak. Czyli na przykład, gdy w bazie danych był ciąg znaków “Antoni Jakubiak” to mógł zostać zastąpiony “Xhkkia Uksbtlka”. Dzięki temu podczas testowania systemu widzimy ciągi znaków na ekranie, i zajmują one mniej więcej tyle samo miejsca co prawdziwe dane. Jest to rozwiązanie nieco lepsze, od kasowania danych lub losowania nowych danych w całości gdyż testuje się wygodniej.

Niszczenie adresów e-mail jest szczególnie ważne. Po pierwsze, adresy e-mail naszych użytkowników nie powinny się gdzieś zgubić. Po drugie, gdy nasz system wysyła e-mail automatycznie, to głupio by były żeby wyszły one z testowego systemy do prawdziwego użytkownika: “Kupiłeś sokowirówkę – obciążyliśmy twoją kartę kredytową”. Uważam, że najlepiej jest zastąpić wszystkie adresy e-mail występujące w bazie danych – własnym adresem e-mail. Podoba sprawa dotyczy numerów telefonów, szczególnie gdy nasz system dzwoni lub automatycznie wysyła SMSy. Gorzej, jeżeli adres e-mail jest polem unikalnym – na przykład loginem. Wtedy trzeba się napracować w stylu: update auth set email=concat(‘mój.adres.email+dev’||next_val(‘jakaś.tam.sekwencja’)||’@gmail.com’. Z całą pewnością jednak warto!

Niszczenie haseł. Hasła w bazie danych zwykle są jakoś zaszyfrowane, jednak ich kradzież, szczególnie połączona z kradzieżą loginu lub e-mail, będzie kompromitująca. Uważam, że hasła najlepiej jest po prostu skasować. W testowej kopii systemu można też ustawić wszystkim użytkownikom jednakowe hasła – jednak lepiej je po prosu skasować zupełnie. Testerzy systemu założą sobie po prostu nowe hasło w procedurze jego odzyskiwania. Oczywiście, jeżeli wcześniej zmieniliśmy adresy e-mail.

Napisanie takiej procedury dobremu programiście znającemu system zajmie na pewno mniej, niż dzień roboczy. Warto, żeby była to procedura półautomatyczna, lub żeby w jakiejś dokumentacji programistycznej systemu została ona zapisana. Warto pilnować, by taka procedura była przestrzegana. Ogólnie, warto pamiętać o tym by pilnować backupów systemu.

Jakie są zalety takiego rozwiązania? Prostota implementacji, błyskawiczne wyszukiwanie potomków, szybkie wyszukiwanie rodziców, miłe przeglądanie bazy w konsoli SQL, szybkie sortowanie. Oczywiście, gdy potrzebujemy sortowania to należy użyć dodatkowego identyfikatora kolejności, na przykład:

Zestawienie zalet i wad rozwiązanie z ścieżką:

• Wady
  • Więcej miejsca na dysku
• Zalety
  • Prosta implementacja
  • Prostota modelu
  • Błyskawiczne wyszukiwanie potomków
  • Szybkie wyszukiwanie rodziców
  • Szybkie sortowanie
  • Miłe przeglądanie bazy w trybie administratora

Czy są lepsze rozwiązania? Oczywiście. Wystarczy wprowadzić założenie, że w naszym drzewie może być tylko kilka poziomów zagłębienia i liczba ta jest określona przez programistę systemu. Wtedy, w bazie danych możemy zapisywać informację w następujący sposób:

W świecie prawdziwych problemów, często właśnie ta trywialna implementacja drzewa będzie najlepsza: jest najprostsza w implementacji i jest rewelacyjnie szybka. Przykłady kodu:

Moim zdaniem, najprostsze rozwiązanie jest zwykle najlepsze.

create table hotel(
  primary key int id,
  varchar nazwa,
  varchar opis
)

• W systemie tworzymy tabelę hotel zawierającą kolumnę opis dla każdego z dostępnych języków. Będzie to wyglądać mniej więcej tak:

  table hotel(
    primary key int id,
    varchar nazwa,
    varchar opis_en, 
    varchar opis_de, 
    varchar opis_pl
  )
  

  Przedstawione rozwiązanie powinno działać bardzo szybko, jednak ma wadę – dodanie kolejnego języka do wymaga modyfikacji bazy danych – a to jest brzydkie.
• Dla każdej wersji językowej tworzymy osobną tabelę zawierającą pola, które trzeba przetłumaczyć. Wygląda to mniej więcej tak:

  table hotel(
    primary key int id,
    varchar nazwa,
  )
  table hotel_en(
    primary key int id,
    varchar opis
  )
  table hotel_pl(
    primary key int id,
    varchar opis
  )
  

  To rozwiązanie będzie działać szybko. Dodanie nowego języka będzie wymagać modyfikacji bazy danych. Oczywiście, korzystając z tego lub z poprzedniego rozwiązania warto napisać program, który będzie tłumaczył zapytania SQL i pobierał dane z odpowiednich tabel językowych. Obydwa te rozwiązania będą działać szybko jednak moim zdaniem nie są one ładne.
• Znam jeszcze coś takiego:

  table hotel(
    primary key int id,
    varchar nazwa
  )
  table hotel_tłumaczenia(
    primary key int id,
    int identyfikator_języka,
    varchar opis
  )
  

  To rozwiązanie jest lepsze od poprzednich tym, że wprowadzenie do systemu nowego języka nie będzie wymagało zmiany w strukturze danych.
• Ja najbardziej lubiłem jednak tworzenie tablicy słownikowej. W uproszczeniu wygląda to tak:

  table słownik (
    primary key int identyfikator_tłumaczonego_tekstu,
    int identyfikator_języka,
    varchar tłumaczenie
  )
  table hotel(
    primary key int id,
    varchar nazwa,
    identyfikator_tłumaczonego_tekstu opis
  )
  

  To rozwiązanie jest o tyle fajne, że proste. Nie wymaga modyfikacji struktury bazy danych w momencie dodania nowego języka. Łatwo też pisać zapytania SQL, które pobierają teksty w wybranym języku. Niestety, to rozwiązanie jest wolniejsze, szczególnie wtedy gdy tabelka hotel ma wiele pól które chcemy przetłumaczyć.

@Entity
class Hotel{
  @Id
  private Long id;
 
  private String nazwa;

  @Tłumaczenie
  private String opis;
}

class JakubiakDbAdapterPdoPgsql extends Zend_Db_Adapter_Pdo_Pgsql{
  public function query($sql, $bind = array()){
    $sql = $sql . ""; // a sprobuj no bez tego
    $hash = $this->_calculateHash($sql,$bind);
    // czy uda nam sie pobrac z kesza
    if($this->_isCacheEnabled) {
      if($this->_allowCache($sql,$bind)) {
        if(isset($this->_cachedResults[$hash])) {
          return $this->_cachedResults[$hash];  
        } 
      }
    }
    $res = parent::query($sql, $bind);
    // dopisanie do kesza
    if($this->_isCacheEnabled) {
      $this->_cachedResults[$hash] = $res;
    }
    return $res;
  }
  // pozwalam na keszowanie tylko zapytan rozpoczynajacych sie od select
  private function _allowCache($sql,$bind) {
    return preg_match("/^select/i",$sql));
  }
  private function _calculateHash($sql,$bind) {
    return md5($sql.var_export($bind,true));
  }
  [...]
}

  public function __construct($config) {
    parent::__construct($config);
    $this->getConnection()->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('JakubiakDbStatement', array($this)));
  }

class JakubiakDbStatement extends PDOStatement {
  $_cache = null;
  public function fetchAll($how, $class_name=null, $ctor_args=null) {
    if(!empty($this->_cache)) {
      return $this->_cache;
    }
    $this->_cache = parent::fetchAll($how);
    return $this->_cache;
  }
}

from Movie m where m.media.user.name='Antek';

select m.* from movie v 
join media m on m.mediaid=v.mediaid 
join user u on u.userid=m.userid 
where user.name='Antek';

protected function _fetch($where = null, $order = null, 
$count = null, $offset = null) {
  $select = $this->_db->select();
  $select->from($this->_name, $this->_cols);
  $where = (array) $where;
  foreach ($where as $key => $val) {
    if (is_int($key)) {
      $select->where($val);
    } else {
      // drobna modyfikacja rodzica
      $key = $this->refJoin($select,$key);
      $select->where($key, $val);
    }
  }
  // dalej tak jak u rodzica[...]
}
public function refJoin($select, $where) {
  foreach($this->_referenceMap as $key => $ref) {
    $regExp = "#^$key\.#";
    if (preg_match($regExp,$where)) {
      $refDao = new $ref['refTableClass'];
      $on = "";
      foreach($ref['columns'] as $i => $colName){
        if($i>0) $on .= ' and ';
        $on .= ' ';
        $on .= $this->getTableName() . '.' . $colName . '=';
        $on .= $refDao->getTableName() . '.' .$ref['refColumns'][$i] . ' ';
      }
      $select->join($refDao->getTableName(), $on,array());
      $where = preg_replace($regExp,"",$where);
      return $refDao->refJoin($select,$where); 
    }
  }
  return $this->getTableName().'.'.$where;
}
public function getTableName() {
  return $this->_name;
}

$movieTable = new MovieTable();
$movies = $movieTable->fetchAll(array("media.user.name=?"=>$_REQUEST['username']));

class JakubiakDbAdapterPdoPgsql extends Zend_Db_Adapter_Pdo_Pgsql{
  public function query($sql, $bind = array()){
    // poprawienie błędu dla typu Boolean
    if(is_array($bind)){
      foreach($bind as $k => $v) {
        if(is_bool($v)) {
          $bind[$k] = $v ? 't' : 'f';
        }
      }
    }
    return parent::query($sql, $bind);
  }
  public function lastInsertId($tableName = null) {
    // Jeżeli sekwencja nazywasz inaczej niż domyślnie, to prawdopodobnie trzeba
    // będzie nadpisać też tą funkcję, u mnie wygląda ona tak 
    // sekwencje dla kluczy głównych nazywam {nazwa_tabelki}_seq
    if (!$tableName) {
      throw new Zend_Db_Adapter_Exception("Sequence name must be specified");
    }
    $this->_connect();
    $sequenceName = "{$tableName}_seq";
    $sequenceName = preg_replace('/_+/','_',$sequenceName);
    return $this->_connection->lastInsertId($sequenceName);
  }

class JakubiakDbTable extends Zend_Db_Table {
  // chcę, aby wszystkie wiersze w tabelkach były reprezentowane przez
  // obiekty tej klasy
  protected $_rowClass = 'JakubiakDbTableRow';
  // następnie poprawiam błąd - lastInsertedId
  public function insert(array $data)  {
    $this->_db->insert($this->_name, $data);
    return $this->_db->lastInsertId(empty($this->_seqName)
      ? $this->_name : $this->_seqName);
  }
  // przydatna funkcja do zliczania wierszy w tabeli
  public function count(array $where = array()) {
    $select = $this->_db->select();
    $select->from($this->_name, array('count'=>'count(*)'));
    $where = (array) $where;
    foreach ($where as $key => $val) {
      if (is_int($key)) {
        $select->where($val);
      } else {
        $select->where($key, $val);
      }
    }
    $select->limit(1, 0);
    $stmt = $this->_db->query($select);
    $data = $stmt->fetch();
    return empty($data['count']) ? 0 : intval($data['count']);
  }
  // pobieranie nowej encji
  public function fetchNew() {
    $newRow = parent::fetchNew();
    $newRow->loadDefaults();
    return $newRow;
  }
  // to się jeszcze przyda, aczkolwiek wydaje mi się, że ta funkcja trafi prędzej czy 
  // później do core
  public function getReferenceMap($key){
    if(empty($this->_referenceMap[$key])){
      return null;
    }
    return $this->_referenceMap[$key];     
  }
}

class JakubiakDbTableRow extends Zend_Db_Table_Row {
  // czy jesteśmy nową encją?
  private $_isNew = false;
  // wczytanie domyślnych wartości, na podstawie metadanych zapisanych w tabeli
  public function loadDefaults() {
    $db = $this->_getTable()->getAdapter();    
    $info = $this->_getTable()->info();
    foreach($info['metadata'] as $col => $meta){
      if(empty($meta['DEFAULT'])) continue;
      $default = $meta['DEFAULT'];
      $one = $db->query("select $default as def")->fetch();
      $this->_data[$col] = $one['def'];
    }
    $this->_isNew = true;
  }
  // zapisywanie rekordu do bazy, kod prawie taki sam jak w klasie nadrzędnej,
  // ale wykorzystuje prywatną zmienną isNew
  public function save() {
    $keys = $this->_getPrimaryKey();
    $values = array_filter($keys);
    if ($this->_isNew) {
      $this->_insert();
      $result = $this->_getTable()->insert($this->_data);
      if (is_numeric($result)) {
        $this->_data[key($keys)] = $result;
        $this->_refresh();
      }
    } else {
      $where = $this->_getWhereQuery(false);
      $this->_update();
      $depTables = $this->_getTable()->getDependentTables();
      if (!empty($depTables)) {
        $db = $this->_getTable()->getAdapter();
        $pkNew = $this->_getPrimaryKey(true);
        $pkOld = $this->_getPrimaryKey(false);
        $thisClass = get_class($this);
        foreach ($depTables as $tableClass) {
          Zend_Loader::loadClass($tableClass);
          $t = new $tableClass(array('db' => $db));
          $t->_cascadeUpdate($this->getTableClass(), $pkOld, $pkNew);
        }
      }
      $result = $this->_getTable()->update($this->_data, $where);
      if (is_int($result)) {
        // update worked, refresh with data from the table
        $this->_refresh();
      }
    }
    return $result;
  }
  // pobieranie many to one w bardziej intuicyjny sposób
  public function __get($key) {
    $r = $this->_getTable()->getReferenceMap($key);
    if (!empty($r)) {
      // tu można dopisać loader dla klasy 
      return $this->findParentRow($r['refTableClass'],$key);
    }
    return parent::__get($key);
  }
  // domyślnie setter zabrania zmieniać wartości klucza głównego, 
  // ale czasami chcę to robić, kod prawie taki sam jak rodzica
  public function __set($key, $value) {
    if (!$this->_isNew && in_array($key, $this->_primary)) {
      require_once 'Zend/Db/Table/Row/Exception.php';
      throw new Zend_Db_Table_Row_Exception("Changing the primary key value(s) is not allowed");
    }
    if (!array_key_exists($key, $this->_data)) {
      require_once 'Zend/Db/Table/Row/Exception.php';
      throw new Zend_Db_Table_Row_Exception("Specified column \"$key\" is not in the row");
    }
    $this->_data[$key] = $value;
  }

$fileTable = new FileTable();
$fileRow = $fileTable->fetchNew($_FILES[$filename]);
$fileRow->save();
$mediaTable = new MediaTable();
$mediaRow = $mediaTable->fetchNew();
$mediaRow->mediatitle = $request->getParam('mediatitle');
$mediaRow->mediadescription = $request->getParam('mediadescription');
$mediaRow->fileid = $fileRow->fileid;
$mediaRow->userid = UserTable::getFromAuth()->userid;
$mediaRow->save();
$photoTable = new PhotoTable();
$photoRow = $photoTable->fetchNew();    
$photoRow->mediaid = $mediaRow->mediaid;
$photoRow->photowidth = $width;
$photoRow->photoheight = $height;
$photoRow->save();
echo $photoRow->media->file->fileid;

    public function insert(array $data)
    {
        $this->_db->insert($this->_name, $data);
        return $this->_db->lastInsertId();
    }
    public function lastInsertId($tableName = null, $primaryKey = 'id')
    {
        if (!$tableName) {
            throw new Zend_Db_Adapter_Exception("Sequence name must be specified");
        }