<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 21819 -->
<!-- Reviewed: yes -->
<sect1 id="learning.quickstart.create-model">
    <title>Utworzenie modelu oraz tabeli w bazie danych</title>

    <para>
        Przed rozpoczęciem należy zastanowić się nad następującym zagadnieniem: gdzie tworzone
        klasy będą przechowywane i w jaki sposób będzie można je odnaleźć? Utworzony właśnie
        domyślny projekt, używa automatycznego dołączania plików (autoloader). Możliwe jest
        dołączenie do niego kolejnych autoloaderów tak by umożliwić odnajdywanie tworzonych
        klas. Typowym rozwiązaniem jest umieszczenie różnych klas w głównym katalogu - w tym
        wypadku nazwanego <filename>application/</filename> - i nazywanie ich z zachowaniem
        wspólnego prefiksu.
    </para>

    <para>
        Klasa <classname>Zend_Controller_Front</classname> umożliwia tworzenie modułów (modules)
        - odrębnych części, które same w sobie są mini-aplikacjami. W ramach każdego 
        modułu odwzorowywana jest taka sama struktura katalogów jaka jest tworzona przez
        narzędzie <command>zf</command> w katalogu głównym aplikacji. Nazwy wszystkich
        klas w jednym module muszą rozpoczynać się od wspólnego prefiksu - nazwy modułu.
        Katalog główny - <filename>application/</filename> również jest modułem (domyślnym)
        dlatego też jego zasoby zostaną uwzględnione w procesie automatycznego dołączania plików.
    </para>

    <para>
        <classname>Zend_Application_Module_Autoloader</classname> oferuje funkcjonalność
        niezbędną do odwzorowania zasobów modułów na odpowiednie ścieżki katalogów oraz
        ułatwia zachowanie spójnego standardu nazewnictwa. Instancja tej klasy jest tworzona
        domyślnie podczas uruchamiania klasy bootstrap. Domyślnym prefiksem używanym przez
        bootstrap jest "Application" więc modele, formularze oraz klasy tabel będą rozpoczynały
        się prefiksem "Application_".
    </para>

    <para>
        Teraz należy się zastanowić co składa się na księgę gości. Typowo będzie w niej
        lista wpisów z <emphasis>komentarzem</emphasis>, <emphasis>czasem zapisu</emphasis>
        oraz <emphasis>adresem email</emphasis>. Zakładając użycie bazy danych, pole
        <emphasis>unikalny identyfikator</emphasis> może również być przydatne. Aplikacja
        powinna umożliwiać zapis danych, pobieranie wpisów pojedynczo oraz wszystkich na raz.
        Prosty model oferujący opisaną funkcjonalność może przedstawiać się następująco:
    </para>

    <programlisting language="php"><![CDATA[
// application/models/Guestbook.php

class Application_Model_Guestbook
{
    protected $_comment;
    protected $_created;
    protected $_email;
    protected $_id;

    public function __set($name, $value);
    public function __get($name);

    public function setComment($text);
    public function getComment();

    public function setEmail($email);
    public function getEmail();

    public function setCreated($ts);
    public function getCreated();

    public function setId($id);
    public function getId();
}

class Application_Model_GuestbookMapper
{
    public function save(Application_Model_Guestbook $guestbook);
    public function find($id);
    public function fetchAll();
}
]]></programlisting>

    <para>
        Metody <methodname>__get()</methodname> oraz <methodname>__set()</methodname> 
        stanowią mechanizmy ułatwiające dostęp do poszczególnych właściwości oraz 
        pośredniczą w dostępie do innych getterów i setterów. Dzięki nim, można 
        również upewnić się, że jedynie pożądane właściwości będą dostępne.
    </para>

    <para>
        Metody <methodname>find()</methodname> oraz <methodname>fetchAll()</methodname> umożliwiają
        zwrócenie pojedynczego lub wszystkich rekordów natomiast <methodname>save()</methodname>
        zapisuje dane.
    </para>

    <para>
        W tym momencie można zacząć myśleć o skonfigurowaniu bazy danych.
    </para>

    <para>
        Na początku należy zainicjować zasób <classname>Db</classname>. Jego konfiguracja
        jest możliwa na podobnych zasadach jak w przypadku zasobów
        <classname>Layout</classname> oraz <classname>View</classname>.
        Można to osiągnąć za pomocą polecenia <command>zf configure db-adapter</command>:
    </para>

    <programlisting language="shell"><![CDATA[
% zf configure db-adapter \
> 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook.db"' \
> production
A db configuration for the production has been written to the application config file.

% zf configure db-adapter \
> 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-testing.db"' \
> testing
A db configuration for the production has been written to the application config file.

% zf configure db-adapter \
> 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-dev.db"' \
> development
A db configuration for the production has been written to the application config file.
]]></programlisting>

    <para>
        Teraz, po otworzeniu pliku <filename>application/configs/application.ini</filename>
        można zobaczyć instrukcje, jakie zostały do niego dodane w odpowiednich sekcjach.
    </para>

    <programlisting language="ini"><![CDATA[
; application/configs/application.ini

[production]
; ...
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

[testing : production]
; ...
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"

[development : production]
; ...
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"
]]></programlisting>

    <para>
        Ostatecznie plik konfiguracyjny powinien wyglądać następująco:
    </para>

    <programlisting language="ini"><![CDATA[
; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0
resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
resources.view[] =
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.db.adapter = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook-dev.db"
]]></programlisting>

    <para>
        Należy zauważyć, iż baza (bazy) danych będzie przechowywana w katalogu
        <filename>data/db/</filename>.
        Te katalogi powinny zostać utworzone i udostępnione wszystkim. W systemach 
        unix można tego dokonać następująco:
    </para>

    <programlisting language="shell"><![CDATA[
% mkdir -p data/db; chmod -R a+rwX data
]]></programlisting>

    <para>
        W systemach Windows należy utworzyć odpowiednie katalogi w eksploratorze 
        oraz ustawić uprawnienia w taki sposób aby każdy użytkownik miał prawo zapisu.
    </para>

    <para>
        Połączenie z bazą danych zostało utworzone - w tym przypadku bazą jest Sqlite
        znajdująca się w katalogu <filename>application/data/</filename>. Następnym krokiem jest
        utworzenie tabeli przechowującej rekordy księgi gości.
    </para>

    <programlisting language="sql"><![CDATA[
-- scripts/schema.sqlite.sql
--
-- Poniższy kod SQL należy uruchomić w bazie danych

CREATE TABLE guestbook (
    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    email VARCHAR(32) NOT NULL DEFAULT 'noemail@test.com',
    comment TEXT NULL,
    created DATETIME NOT NULL
);

CREATE INDEX "id" ON "guestbook" ("id");
]]></programlisting>

    <para>
        Aby mieć zestaw danych do testowania można utworzyć w tabeli kilka rekordów.
    </para>

    <programlisting language="sql"><![CDATA[
-- scripts/data.sqlite.sql
--
-- Poniższy kod SQL może posłużyć do zapełnienia tabeli testowymi danymi

INSERT INTO guestbook (email, comment, created) VALUES
    ('ralph.schindler@zend.com',
    'Hello! Hope you enjoy this sample zf application!',
    DATETIME('NOW'));
INSERT INTO guestbook (email, comment, created) VALUES
    ('foo@bar.com',
    'Baz baz baz, baz baz Baz baz baz - baz baz baz.',
    DATETIME('NOW'));
]]></programlisting>

    <para>
        Mamy zdefiniowany schemat bazy danych oraz niewielką ilość danych do zaimportowania.
        Teraz można napisać skrypt tworzący bazę danych. Ten krok nie jest potrzebny w środowisku
        produkcyjnym. Dzięki niemu można lokalnie wypracować odpowiednią strukturę bazy danych
        aby tworzona aplikacja działała zgodnie z założeniami. Skrypt
        <filename>scripts/load.sqlite.php</filename> można wypełnić w poniższy sposób:
    </para>

    <programlisting language="php"><![CDATA[
// scripts/load.sqlite.php

/**
 * Skrypt tworzący bazę danych i wypełniający ją danymi
 */

// Inicjalizacja ścieżek oraz autoloadera
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));
set_include_path(implode(PATH_SEPARATOR, array(
    APPLICATION_PATH . '/../library',
    get_include_path(),
)));
require_once 'Zend/Loader/Autoloader.php';
Zend_Loader_Autoloader::getInstance();

// Zdefiniowanie opcji CLI
$getopt = new Zend_Console_Getopt(array(
    'withdata|w' => 'Load database with sample data',
    'env|e-s'    => 'Application environment for which to create database (defaults to development)',
    'help|h'     => 'Help -- usage message',
));
try {
    $getopt->parse();
} catch (Zend_Console_Getopt_Exception $e) {
    // Bad options passed: report usage
    echo $e->getUsageMessage();
    return false;
}

// W przypadku zażądania pomocy, wyświetlenie informacji o użyciu
if ($getopt->getOption('h')) {
    echo $getopt->getUsageMessage();
    return true;
}

// Inicjalizacja wartości na podstawie opcji CLI
$withData = $getopt->getOption('w');
$env      = $getopt->getOption('e');
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (null === $env) ? 'development' : $env);

// Inicjalizacja Zend_Application
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);

// Inicjalizacja oraz zwrócenie zasobu bazy danych
$bootstrap = $application->getBootstrap();
$bootstrap->bootstrap('db');
$dbAdapter = $bootstrap->getResource('db');

// Powiadomienie użytkownika o postępie (w tym miejscu jest tworzona baza danych)
if ('testing' != APPLICATION_ENV) {
    echo 'Writing Database Guestbook in (control-c to cancel): ' . PHP_EOL;
    for ($x = 5; $x > 0; $x--) {
        echo $x . "\r"; sleep(1);
    }
}

// Sprawdzenie czy plik bazy danych istnieje
$options = $bootstrap->getOption('resources');
$dbFile  = $options['db']['params']['dbname'];
if (file_exists($dbFile)) {
    unlink($dbFile);
}

// Wywołanie poleceń zawartych w pliku tworzącym schemat
try {
    $schemaSql = file_get_contents(dirname(__FILE__) . '/schema.sqlite.sql');
    // bezpośrednie użycie obiektu połączenia w celu wywołania poleceń SQL
    $dbAdapter->getConnection()->exec($schemaSql);
    chmod($dbFile, 0666);

    if ('testing' != APPLICATION_ENV) {
        echo PHP_EOL;
        echo 'Database Created';
        echo PHP_EOL;
    }

    if ($withData) {
        $dataSql = file_get_contents(dirname(__FILE__) . '/data.sqlite.sql');
        // bezpośrednie użycie obiektu połączenia w celu wywołania poleceń SQL
        $dbAdapter->getConnection()->exec($dataSql);
        if ('testing' != APPLICATION_ENV) {
            echo 'Data Loaded.';
            echo PHP_EOL;
        }
    }

} catch (Exception $e) {
    echo 'AN ERROR HAS OCCURED:' . PHP_EOL;
    echo $e->getMessage() . PHP_EOL;
    return false;
}

// Ten skrypt powinien zostać uruchomiony z wiersza poleceń
return true;
]]></programlisting>

    <para>
        Teraz należy wywołać powyższy skrypt. Można to zrobić z poziomu terminala lub
        wiersza poleceń poprzez wpisanie następującej komendy:
    </para>

    <programlisting language="shell"><![CDATA[
% php scripts/load.sqlite.php --withdata
]]></programlisting>

    <para>
        Powinien pojawić się następujący komunikat:
    </para>

    <programlisting language="text"><![CDATA[
path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata
Writing Database Guestbook in (control-c to cancel):
1
Database Created
Data Loaded.
]]></programlisting>

    <para>
        Po zdefiniowaniu bazy danych aplikacji księgi gości można przystąpić do budowy kodu
        samej aplikacji. W następnych krokach zostanie zbudowana klasa dostępu do danych
        (poprzez <classname>Zend_Db_Table</classname>), oraz klasa mapująca - służąca do
        połączenia z wcześniej opisanym modelem.
        Na koniec utworzony zostanie kontroler zarządzający modelem, którego zadaniem będzie
        wyświetlanie istniejących rekordów oraz obróbka nowych danych.
    </para>

    <para>
        Aby łączyć się ze źródłem danych użyty zostanie wzorzec
        <ulink url="http://martinfowler.com/eaaCatalog/tableDataGateway.html">Table Data
        Gateway</ulink> udostępniany poprzez klasę <classname>Zend_Db_Table</classname>.
        Na początek należy utworzyć klasę opartą o  <classname>Zend_Db_Table</classname>.
        Podobnie jak przy layoucie oraz adapterze bazy danych - można skorzystać z narzędzia
        <command>zf</command> i jego komendy <command>create db-table</command>. Należy przy tym
        podać minimalnie dwa argumenty: nazwę tworzonej klasy oraz nazwę tabeli bazy danych,
        do której prowadzi.
    </para>

    <programlisting language="shell"><![CDATA[
% zf create db-table Guestbook guestbook
Creating a DbTable at application/models/DbTable/Guestbook.php
Updating project profile 'zfproject.xml'
]]></programlisting>

    <para>
        Spoglądając na strukturę katalogów należy zwrócić uwagę na nowy katalog
        <filename>application/models/DbTable/</filename> zawierający plik
        <filename>Guestbook.php</filename>. Ten plik powinien zawierać następującą
        treść:
    </para>

    <programlisting language="php"><![CDATA[
// application/models/DbTable/Guestbook.php

/**
 * This is the DbTable class for the guestbook table.
 */
class Application_Model_DbTable_Guestbook extends Zend_Db_Table_Abstract
{
    /** Table name */
    protected $_name    = 'guestbook';
}
]]></programlisting>

    <para>
        Należy zwrócić uwagę na prefiks: <classname>Application_Model_DbTable</classname>.
        Prefiks klas aplikacji "Application" znajduje się na pierwszym miejscu. Po nim
        występuje komponent "Model_DbTable", który jest mapowany do katalogu
        <filename>models/DbTable/</filename> znajdującego się w module.
    </para>

    <para>
        Jedyne dane niezbędne przy tworzeniu klasy pochodnej w stosunku do
        <classname>Zend_Db_Table</classname> to nazwa tabeli i opcjonalnie klucz pierwotny
        (jeśli jest inny niż "id").
    </para>

    <para>
        Teraz należy utworzyć klasę mapującą obiekt w aplikacji na obiekt w bazie danych czyli
        <ulink url="http://martinfowler.com/eaaCatalog/dataMapper.html">Data Mapper</ulink>.
        Obiektem w bazie danych jest <classname>Application_Model_Guestbook</classname> natomiast
        za obiekt bazy danych odpowiada <classname>Application_Model_DbTable_Guestbook</classname>.
        Typowe <acronym>API</acronym> takiej klasy wygląda następująco:
    </para>

    <programlisting language="php"><![CDATA[
// application/models/GuestbookMapper.php

class Application_Model_GuestbookMapper
{
    public function save($model);
    public function find($id, $model);
    public function fetchAll();
}
]]></programlisting>

    <para>
        Dodatkowo można zdefiniować metody ustawiające i zwracające Table Data Gateway.
        Do utworzenia klasy można użyć narzędzia <command>zf</command>:
    </para>

    <programlisting language="shell"><![CDATA[
% zf create model GuestbookMapper
Creating a model at application/models/GuestbookMapper.php
Updating project profile '.zfproject.xml'
]]></programlisting>

    <para>
        Po otwarciu klasy <classname>Application_Model_GuestbookMapper</classname> z lokalizacji
        <filename>application/models/GuestbookMapper.php</filename> widać następujący kod:
    </para>

    <programlisting language="php"><![CDATA[
// application/models/GuestbookMapper.php

class Application_Model_GuestbookMapper
{
    protected $_dbTable;

    public function setDbTable($dbTable)
    {
        if (is_string($dbTable)) {
            $dbTable = new $dbTable();
        }
        if (!$dbTable instanceof Zend_Db_Table_Abstract) {
            throw new Exception('Invalid table data gateway provided');
        }
        $this->_dbTable = $dbTable;
        return $this;
    }

    public function getDbTable()
    {
        if (null === $this->_dbTable) {
            $this->setDbTable('Application_Model_DbTable_Guestbook');
        }
        return $this->_dbTable;
    }

    public function save(Application_Model_Guestbook $guestbook)
    {
        $data = array(
            'email'   => $guestbook->getEmail(),
            'comment' => $guestbook->getComment(),
            'created' => date('Y-m-d H:i:s'),
        );

        if (null === ($id = $guestbook->getId())) {
            unset($data['id']);
            $this->getDbTable()->insert($data);
        } else {
            $this->getDbTable()->update($data, array('id = ?' => $id));
        }
    }

    public function find($id, Application_Model_Guestbook $guestbook)
    {
        $result = $this->getDbTable()->find($id);
        if (0 == count($result)) {
            return;
        }
        $row = $result->current();
        $guestbook->setId($row->id)
                  ->setEmail($row->email)
                  ->setComment($row->comment)
                  ->setCreated($row->created);
    }

    public function fetchAll()
    {
        $resultSet = $this->getDbTable()->fetchAll();
        $entries   = array();
        foreach ($resultSet as $row) {
            $entry = new Application_Model_Guestbook();
            $entry->setId($row->id)
                  ->setEmail($row->email)
                  ->setComment($row->comment)
                  ->setCreated($row->created);
            $entries[] = $entry;
        }
        return $entries;
    }
}
]]></programlisting>

    <para>
        W obecnym momencie można przystąpić do utworzenia klasy modelu używając 
        polecenia <command>zf create model</command>:
    </para>

    <programlisting language="shell"><![CDATA[
% zf create model Guestbook
Creating a model at application/models/Guestbook.php
Updating project profile '.zfproject.xml'
]]></programlisting>

    <para>
        Nowo utworzoną klasę <acronym>PHP</acronym> można zmodyfikować tak aby
        ułatwić umieszczanie danych 
        w modelu poprzez przekazanie tablicy do konstruktora lub do metody
        <methodname>setOptions()</methodname>. Ostatecznie model znajdujący się w
        <filename>application/models/Guestbook.php</filename> powinien wyglądać następująco:
    </para>

    <programlisting language="php"><![CDATA[
// application/models/Guestbook.php

class Application_Model_Guestbook
{
    protected $_comment;
    protected $_created;
    protected $_email;
    protected $_id;

    public function __construct(array $options = null)
    {
        if (is_array($options)) {
            $this->setOptions($options);
        }
    }

    public function __set($name, $value)
    {
        $method = 'set' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid guestbook property');
        }
        $this->$method($value);
    }

    public function __get($name)
    {
        $method = 'get' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid guestbook property');
        }
        return $this->$method();
    }

    public function setOptions(array $options)
    {
        $methods = get_class_methods($this);
        foreach ($options as $key => $value) {
            $method = 'set' . ucfirst($key);
            if (in_array($method, $methods)) {
                $this->$method($value);
            }
        }
        return $this;
    }

    public function setComment($text)
    {
        $this->_comment = (string) $text;
        return $this;
    }

    public function getComment()
    {
        return $this->_comment;
    }

    public function setEmail($email)
    {
        $this->_email = (string) $email;
        return $this;
    }

    public function getEmail()
    {
        return $this->_email;
    }

    public function setCreated($ts)
    {
        $this->_created = $ts;
        return $this;
    }

    public function getCreated()
    {
        return $this->_created;
    }

    public function setId($id)
    {
        $this->_id = (int) $id;
        return $this;
    }

    public function getId()
    {
        return $this->_id;
    }
}
]]></programlisting>

    <para>
        W ostatnim kroku, aby połączyć wszystkie elementy, należy utworzyć kontroler,
        którego zadaniem będzie zaprezentowanie listy zapisanych rekordów oraz obsługa
        dodawania nowych danych.
    </para>

    <para>
        Aby to osiągnąć należy użyć polecenia <command>zf create controller</command>:
    </para>

    <programlisting language="shell"><![CDATA[
% zf create controller Guestbook
Creating a controller at
    application/controllers/GuestbookController.php
Creating an index action method in controller Guestbook
Creating a view script for the index action method at
    application/views/scripts/guestbook/index.phtml
Creating a controller test file at
    tests/application/controllers/GuestbookControllerTest.php
Updating project profile '.zfproject.xml'
]]></programlisting>

    <para>
        Powyższe polecenie tworzy nowy kontroler - <classname>GuestbookController</classname>
        w pliku <filename>application/controllers/GuestbookController.php</filename> zawierający
        jedną akcję - <methodname>indexAction()</methodname>.
        Na użytek tego kontrolera utworzony zostaje również katalog widoków:
        <filename>application/views/scripts/guestbook/</filename> zawierający skrypt 
        widoku dla akcji index.
    </para>

    <para>
        Akcja "index" będzie stanowić domyślny punkt kontrolera pokazujący zapisane rekordy.
    </para>

    <para>
        Teraz należy zaprogramować logikę aplikacji. Aby pokazać zapisane rekordy użytkownikowi
        wchodzącemu do <methodname>indexAction()</methodname> można użyć poniższego kodu:
    </para>

    <programlisting language="php"><![CDATA[
// application/controllers/GuestbookController.php

class GuestbookController extends Zend_Controller_Action
{
    public function indexAction()
    {
        $guestbook = new Application_Model_GuestbookMapper();
        $this->view->entries = $guestbook->fetchAll();
    }
}
]]></programlisting>

    <para>
        Dodatkowo potrzebny jest jeszcze widok wyświetlający dane. W pliku
        <filename>application/views/scripts/guestbook/index.phtml</filename> można umieścić
        następujący zapis:
    </para>

    <programlisting language="php"><![CDATA[
<!-- application/views/scripts/guestbook/index.phtml -->

<p><a href="<?php echo $this->url(
    array(
        'controller' => 'guestbook',
        'action'     => 'sign'
    ),
    'default',
    true) ?>">Sign Our Guestbook</a></p>

Guestbook Entries: <br />
<dl>
    <?php foreach ($this->entries as $entry): ?>
    <dt><?php echo $this->escape($entry->email) ?></dt>
    <dd><?php echo $this->escape($entry->comment) ?></dd>
    <?php endforeach ?>
</dl>
]]></programlisting>

    <note>
        <title>Punkt kontrolny</title>

        <para>
            Teraz, po przejściu do "http://localhost/guestbook" powinna się pojawić lista
            zapisanych rekordów:
        </para>

        <para>
            <inlinegraphic width="525" scale="100" align="center" valign="middle"
                fileref="figures/learning.quickstart.create-model.png" format="PNG" />
        </para>
    </note>

    <note>
        <title>Użycie skryptu ładującego dane</title>

        <para>
            Skrypt ładujący dane pokazany we wcześniejszej części tego rozdziału
            (<filename>scripts/load.sqlite.php</filename>) może zostać użyty do utworzenia
            bazy danych jak i do zaimportowania przykładowych danych dla każdego środowiska.
            Wewnętrznie korzysta z klasy <classname>Zend_Console_Getopt</classname>, dzięki
            czemu możliwe jest podanie parametrów sterujących skryptem. Podając parametr
            "-h" lub "--help" można zapoznać się z dostępnymi opcjami:
        </para>

        <programlisting language="php"><![CDATA[
Usage: load.sqlite.php [ options ]
--withdata|-w         Load database with sample data
--env|-e [  ]         Application environment for which to create database
                      (defaults to development)
--help|-h             Help -- usage message)]]
]]></programlisting>

        <para>
            Parametr "-e" pozwala na nadanie wartości stałej <constant>APPLICATION_ENV</constant>
            określającej środowisko, co z kolei umożliwia utworzenie bazy danych SQLite dla
            każdego środowiska oddzielnie. Należy się upewnić, że skrypt jest uruchamiany z
            odpowiednią wartością tego parametru dla każdego ze środowisk.
        </para>
    </note>
</sect1>
