repo_zf1/documentation/manual/de/tutorials/quickstart-create-model.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 20482 -->
<!-- Reviewed: no -->
<sect1 id="learning.quickstart.create-model">
    <title>Ein Modell und eine Datenbank Tabelle erstellen</title>

    <para>
        Bevor wir anfangen nehmen wie etwas an: Wo werden diese Klassen leben, und wie werden wir
        Sie finden? Das Standardprojekt welches wir erstellt haben instanziert einen Autoloader. Wir
        können Ihm andere Autoloader anhängen damit er weiss wo andere Klassen zu finden sind.
        Typischerweise wollen wir das unsere verschiedenen MVC Klassen im selben Baum gruppiert sind
        -- in diesem Fall <filename>application/</filename> -- und meistens einen gemeinsamen Präfix
        verwenden.
    </para>

    <para>
        <classname>Zend_Controller_Front</classname> hat den Begriff von "Modulen", welche
        individuelle Mini-Anwendungen sind. Module mimen die Verzeichnisstruktur welche das
        <command>zf</command> Tool unter <filename>application/</filename> einrichtet, und von allen
        Klassen in Ihm wird angenommen das Sie mit einen gemeinsamen Präfix beginnen, dem Namen des
        Moduls. <filename>application/</filename> selbst ist ein Modul -- das "default" oder
        "application" Modul. Als solches richten wir das Autoloading für Ressourcen in diesem
        Verzeichnis ein.
    </para>

    <para>
        <classname>Zend_Application_Module_Autoloader</classname> bietet die Funktionalität welche
        benötigt wird um die verschiedenen Ressourcen unter einem Modul mit den richtigen
        Verzeichnissen zu verbinden, und auch einen standardmäßigen Namensmechanismus. Standardmäßig
        wird eine Instanz der Klasse wärend der Initialisierung des Bootstrap Objekts erstellt;
        unser Application Bootstrap verwendet standardmäßig das Modulpräfix "Application". Daher
        beginnen alle unsere Modelle, Formulare, und Tabellenklassen mit dem Klassenpräfix
        "Application_".
    </para>

    <para>
        Nehmen wir jetzt also an was ein Guestbook ausmacht. Typischerweise sind Sie einfach eine
        Liste ein Einträgen mit einem <emphasis>Kommentar</emphasis> (comment), einem
        <emphasis>Zeitpunkt</emphasis> (timestamp) und oft einer <emphasis>Email Adresse</emphasis>.
        Angenommen wir speichern diese in einer Datenbank, dann wollen wir auch einen
        <emphasis>eindeutigen Identifikator</emphasis> für jeden Eintrag. Wir wollen in der Lage
        sein einen Eintrag zu speichern, individuelle Einträge zu holen, und alle Einträge zu
        empfangen. Als solches könnte das Modell einer einfachen Guestbook API wie folgt aussehen:
    </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();

    public function save();
    public function find($id);
    public function fetchAll();
}
]]></programlisting>

    <para>
        <methodname>__get()</methodname> und <methodname>__set()</methodname> bieten uns bequeme
        Mechanismen an um auf individuelle Eigenschaften von Einträgen zuzugreifen und auf andere
        Getter und Setter zu verweisen. Sie stellen auch sicher das nur Eigenschaften im Objekt
        vorhanden sind die wir freigegeben haben.
    </para>

    <para>
        <methodname>find()</methodname> und <methodname>fetchAll()</methodname> bieten die Fähigkeit
        einen einzelnen Eintrag oder alle Einträge zu holen.
    </para>

    <para>
        Von hier an können wir über die Einrichtung unserer Datenbank nachdenken.
    </para>

    <para>
        Zuerst muss unsere <classname>Db</classname> Ressource initialisiert werden. Wie bei der
        <classname>Layout</classname> und <classname>View</classname> kann die Konfiguration für die
        <classname>Db</classname> Ressource angegeben werden. In der Datei
        <filename>application/configs/application.ini</filename> müssen die folgenden Zeilen in den
        richtigen Sektionen hinzugefügt werden.
    </para>

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

; Diese Zeile sind in den richtigen Sektionen hinzuzufügen:
[production]
resources.db.adapter       = "PDO_SQLITE"
resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

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

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

    <para>
        Die endgültige Konfigurationsdatei sollte wie folgt aussehen:
    </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"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
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.params.dbname = APPLICATION_PATH "/../data/db/guestbook-testing.db"

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

    <para>
        Es ist zu beachten das die Datenbank(en) unter <filename>data/db/</filename> gespeichert
        wird. Diese Verzeichnisse sind zu erstellen und weltweit-schreibbar zu machen. Auf
        Unix-artigen Systemen kann man das wie folgt durchführen:
    </para>

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

    <para>
        Unter Windows muss man die Verzeichnisse im Explorer erstellen und die Zugriffsrechte so zu
        setzen das jeder in das Verzeichnis schreiben darf.
    </para>

    <para>
        Ab diesem Punkt haben wir eine Verbindung zu einer Datenbank; in unserem Fall ist es eine
        verbindung zu einer Sqlite Datenbank die in unserem <filename>application/data/</filename>
        Verzeichnis ist. Designen wir also eine einfache Tabelle die unsere Guestbook Einträge
        enthalten wird.
    </para>

    <programlisting language="sql"><![CDATA[
-- scripts/schema.sqlite.sql
--
-- Man muss das Datenbank Schema mit diesem SQL laden.

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>
        Und damit wir gleich einige Arbeitsdaten haben, erstellen wir ein paar Zeilen an Information
        um unsere Anwendung interessant zu machen.
    </para>

    <programlisting language="sql"><![CDATA[
-- scripts/data.sqlite.sql
--
-- Man kann damit beginnen die Datenbank zu befüllen indem die folgenden SQL
-- Anweisungen ausgeführt werden.

INSERT INTO guestbook (email, comment, created) VALUES
    ('ralph.schindler@zend.com',
    'Hallo! Hoffentlich geniesst Ihr dieses Beispiel einer ZF Anwendung!
    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>
        Jetzt haben wir sowohl das Schema als auch einige Daten definiert. Schreiben wir also ein
        Skript das wir jetzt ausführen können um diese Datenbank zu erstellen. Natürlich wird das
        nicht in der Produktion benötigt, aber dieses Skriupt hilft Entwicklern die Notwendigkeiten
        der Datenbank lokal zu erstellen damit Sie eine voll funktionsfähige Anwendung haben. Das
        Skript ist als <filename>scripts/load.sqlite.php</filename> mit dem folgenden Inhalt zu
        erstellen:
    </para>

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

/**
 * Skript für das erstellen und Laden der Datenbank
 */

// Initialisiert den Pfad und das Autoloading der Anwendung
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();

// Definiert einige CLI Optionen
$getopt = new Zend_Console_Getopt(array(
    'withdata|w' => 'Datenbank mit einigen Daten laden',
    'env|e-s'    => "Anwendungsumgebung für welche die Datenbank "
                  . "erstellt wird (Standard ist Development)",
    'help|h'     => 'Hilfe -- Verwendung',
));
try {
    $getopt->parse();
} catch (Zend_Console_Getopt_Exception $e) {
    // Schlechte Option übergeben: Verwendung ausgeben
    echo $e->getUsageMessage();
    return false;
}

// Wenn Hilfe angefragt wurde, Verwendung ausgeben
if ($getopt->getOption('h')) {
    echo $getopt->getUsageMessage();
    return true;
}

// Werte basierend auf Ihrer Anwesenheit oder Abwesenheit von CLI Optionen initialisieren
$withData = $getopt->getOption('w');
$env      = $getopt->getOption('e');
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (null === $env) ? 'development' : $env);

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

// Die DB Ressource initialisieren und empfangen
$bootstrap = $application->getBootstrap();
$bootstrap->bootstrap('db');
$dbAdapter = $bootstrap->getResource('db');

// Den Benutzer informieren was abgeht
// (wir erstellen hier aktuell eine Datenbank)
if ('testing' != APPLICATION_ENV) {
    echo 'Schreiben in die Guestbook Datenbank (control-c um abzubrechen): ' . PHP_EOL;
    for ($x = 5; $x > 0; $x--) {
        echo $x . "\r"; sleep(1);
    }
}

// Prüfen um zu sehen ob wie bereits eine Datenbankdatei haben
$options = $bootstrap->getOption('resources');
$dbFile  = $options['db']['params']['dbname'];
if (file_exists($dbFile)) {
    unlink($dbFile);
}

// Dieser Block führt die aktuellen Statements aus welche von der Schemadatei
// geladen werden.
try {
    $schemaSql = file_get_contents(dirname(__FILE__) . '/schema.sqlite.sql');
    // Die Verbindung direkt verwenden um SQL im Block zu laden
    $dbAdapter->getConnection()->exec($schemaSql);
    chmod($dbFile, 0666);

    if ('testing' != APPLICATION_ENV) {
        echo PHP_EOL;
        echo 'Datenbank erstellt';
        echo PHP_EOL;
    }

    if ($withData) {
        $dataSql = file_get_contents(dirname(__FILE__) . '/data.sqlite.sql');
        // Die Verbindung direkt verwenden um SQL in Blöcken zu laden
        $dbAdapter->getConnection()->exec($dataSql);
        if ('testing' != APPLICATION_ENV) {
            echo 'Daten geladen.';
            echo PHP_EOL;
        }
    }

} catch (Exception $e) {
    echo 'EIN FEHLER IST AUFGETRETEN:' . PHP_EOL;
    echo $e->getMessage() . PHP_EOL;
    return false;
}

// Generell gesprochen wird dieses Skript von der Kommandozeile aus aufgerufen
return true;
]]></programlisting>

    <para>
        Jetzt führen wir dieses Skript aus. Von einem Terminal oder der DOS Kommandozeile ist das
        folgende zu tun:
    </para>

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

    <para>
        Man sollte eine ähnliche Ausgabe wie folgt sehen:
    </para>

    <programlisting language="text"><![CDATA[
path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata
Schreiben in die Guestbook Datenbank (control-c um abzubrechen):
1
Datenbank erstellt
Daten geladen.
]]></programlisting>

    <para>
        Jetzt haben wir eine voll funktionsfähige Datenbank und eine Tabelle für unsere Guestbook
        Anwendung. Unsere nächsten paar Schritte sind die Ausarbeitung unseres Anwendungscodes. Das
        inkludiert das Bauen einer Datenquelle (in unserem Fall verwenden wir
        <classname>Zend_Db_Table</classname>), und einen Daten Mapper um diese Datenquelle mit
        unserem Domain Modell zu verbinden. Letztendlich erstellen wir den Controller der mit diesem
        Modell interagiert damit sowohl existierende Einträge angezeigt als auch neue Einträge
        bearbeitet werden.
    </para>

    <para>
        Wir verwenden ein <ulink
            url="http://martinfowler.com/eaaCatalog/tableDataGateway.html">Table Data
            Gateway</ulink> um uns mit unserer Datenquelle zu verbinden;
        <classname>Zend_Db_Table</classname> bietet diese Funktionalität. Um anzufangen erstellen wir
        eine <classname>Zend_Db_Table</classname>-basierende Tabellenklasse. Zuerst erstellen wir
        das Verzeichnis <filename>application/models/DbTable/</filename>. Dann erstellen und
        bearbeiten wir die Datei <filename>Guestbook.php</filename> in Ihm und fügen die folgenden
        Inhalte ein:
    </para>

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

/**
 * Das ist die DbTable Klasse für die Guestbook Tabelle.
 */
class Application_Model_DbTable_Guestbook extends Zend_Db_Table_Abstract
{
    /** Tabellenname */
    protected $_name    = 'guestbook';
}
]]></programlisting>

    <para>
        Der Klassenpräfix ist zu beachten: <classname>Application_Model_DbTable</classname>. Der
        Klassenpräfix für unser Modul "Application" ist das erste Segment, und dann haben wir die
        Komponente "Model_DbTable"; die letztere verweist auf das Verzeichnis
        <filename>models/DbTable/</filename> des Moduls.
    </para>

    <para>
        Alles das ist wirklich notwendig wenn <classname>Zend_Db_Table</classname> erweitert wird
        um einen Tabellennamen anzubieten und optional den primären Schlüssel (wenn es nicht die
        "id" ist).
    </para>

    <para>
        Jetzt erstellen wir einen <ulink
            url="http://martinfowler.com/eaaCatalog/dataMapper.html">Daten Mapper</ulink>. Ein
        <emphasis>Daten Mapper</emphasis> bildet ein Domain Objekt in der Datenbank ab. In unserem
        Fall bildet es unser Modell <classname>Application_Model_Guestbook</classname> auf unsere
        Datenquelle, <classname>Application_Model_DbTable_Guestbook</classname>, ab. Eine typische
        API für einen Daten Mapper ist wie folgt:
    </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>
        Zusätzlich zu diesen Methoden, fügen wir Methoden für das Setzen und Holen des Table Data
        Gateways hinzu. Die endgültige Klasse, welche unter
        <filename>application/models/GuestbookMapper.php</filename> platziert ist, sieht wie folgt
        aus:
    </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('Ungültiges Table Data Gateway angegeben');
        }
        $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)
                  ->setMapper($this);
            $entries[] = $entry;
        }
        return $entries;
    }
}
]]></programlisting>

    <para>
        Jetzt ist es Zeit unsere Modellklasse leicht zu aktualisieren, um den Daten Mapper
        aufzunehmen. So wie der Daten Mapper eine Referenz zur Datenquelle enthält, enthält das
        Modell eine Referenz zum Daten Mapper. Zusätzlich machen wir es einfach das Modell
        bekanntzumachen indem ein Array an Daten entweder an den Constructor oder an die
        <methodname>setOptions()</methodname> Methode übergeben wird. Das endgültige Modell, welches
        in <filename>application/models/Guestbook.php</filename> ist, sieht wie folgt aus:
    </para>

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

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

    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('Ungültige Guestbook Eigenschaft');
        }
        $this->$method($value);
    }

    public function __get($name)
    {
        $method = 'get' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Ungültige Guestbook Eigenschaft');
        }
        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;
    }

    public function setMapper($mapper)
    {
        $this->_mapper = $mapper;
        return $this;
    }

    public function getMapper()
    {
        if (null === $this->_mapper) {
            $this->setMapper(new Application_Model_GuestbookMapper());
        }
        return $this->_mapper;
    }

    public function save()
    {
        $this->getMapper()->save($this);
    }

    public function find($id)
    {
        $this->getMapper()->find($id, $this);
        return $this;
    }

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

    <para>
        Letztendlich, um diese Elemente alle zusammen zu verbinden, erstellen wir einen Guestbook
        Controller der die Einträge auflistet welche aktuell in der Datenbank sind.
    </para>

    <para>
        Um einen neuen Controller zu erstellen muss ein Terminal oder eine DOS Konsole geöffnet,
        in das Projektverzeichnis navigiert und das folgende eingegeben werden:
    </para>

    <programlisting language="shell"><![CDATA[
# Unix-artige Systeme:
% zf.sh create controller guestbook

# DOS/Windows:
C:> zf.bat create controller guestbook
]]></programlisting>

    <para>
        Das erstellt einen neuen Controller, <classname>GuestbookController</classname>, in
        <filename>application/controllers/GuestbookController.php</filename> mit einer einzelnen
        Aktions Methode, <methodname>indexAction()</methodname>. Er erstellt auch ein View Skript
        Verzeichnis für den Controller, <filename>application/views/scripts/guestbook/</filename>,
        mit einem View Skript für die Index Aktion.
    </para>

    <para>
        Wir verwenden die "index" Aktion als Landeseite um alle Guestbook Einträge anzusehen.
    </para>

    <para>
        Jetzt betrachten wir die grundsätzliche Anwendungslogik. Bei einem Treffer auf
        <methodname>indexAction()</methodname> zeigen wir alle Guestbook Einträge an. Das würde wie
        folgt aussehen:
    </para>

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

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

    <para>
        Und natürlich benötigen wir ein View Skript um damit weiterzumachen.
        <filename>application/views/scripts/guestbook/index.phtml</filename> ist zu bearbeiten damit
        Sie wie folgt aussieht:
    </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) ?>">Im Guestbook eintragen</a></p>

Guestbook Einträge: <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>Checkpoint</title>

        <para>
            Jetzt gehen wir auf "http://localhost/guestbook". Man sollte das folgende im Browser
            sehen:
        </para>

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

    <note>
        <title>Das Datenlade Skript verwenden</title>

        <para>
            Das Datenlade Skript welches in diesem Kapitel beschrieben wird
            (<filename>scripts/load.sqlite.php</filename>) kann verwendet werden um die Datenbank,
            für jede Umgebung die man definiert hat, zu erstellen sowie Sie mit Beispieldaten zu
            laden. Intern verwendet es <classname>Zend_Console_Getopt</classname>, was es erlaubt
            eine Anzahl von Kommandozeilen Schalter anzubieten. Wenn man den "-h" oder "--help"
            Schalter übergibt, werden die folgenden Optionen angegeben:
        </para>

        <programlisting language="php"><![CDATA[
Usage: load.sqlite.php [ options ]
--withdata|-w         Datenbank mit einigen Daten laden
--env|-e [  ]         Anwendungsumgebung für welche die Datenbank erstellt wird
                      (Standard ist Development)
--help|-h             Hilfe -- Verwendung)]]
]]></programlisting>

        <para>
            Der "-e" Schalter erlaubt es den Wert zu spezifizieren der für die Konstante
            <constant>APPLICATION_ENV</constant> verwendet wird -- welcher es erlaubt eine SQLite
            Datenbank für jede Umgebung zu erstellen die man definiert. Man sollte sicherstellen
            dass das Skript für die Umgebung gestartet wird welche man für die eigene Anwendung
            ausgewählt hat wenn man in Betrieb geht.
        </para>
    </note>
</sect1>