GlossarWiki - Benutzerbeiträge [de-formal]

SQLite Foreign Keys erzwingen

2008-07-14T22:26:01Z

Jrdesign:

{{In Bearbeitung}}

=Problem =
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

=Lösung =
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
CREATE TABLE kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Das UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>

=Online Generator für Fremdschlüssel =
Für SQLite gibt es einen Online-Fremdschlüssel-Generator, der die eingegebnenen Tabellen-Deklarationen, wie im obrigen Beispiel erklärt, automatisch mitsamt dem dazugehörigen TRIGGER ausgibt.
Zu finden ist der Generator unter [http://www.rcs-comp.com/site/index.php/view/Utilities-SQLite_foreign_key_trigger_generator RCS Computers].

=Quellen =

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]
*[http://de.wikipedia.org/wiki/Datenbanktrigger Wikipedia: Datenbanktrigger]
*[http://www.rcs-comp.com/site/index.php/view/Utilities-SQLite_foreign_key_trigger_generator Online FOREIGN KEY Generator]

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Foreign Keys erzwingen

2008-07-14T22:21:06Z

Jrdesign:

{{In Bearbeitung}}

=Problem =
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

=Lösung =
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
CREATE TABLE kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Das UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>
=Quellen =

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]
*[http://de.wikipedia.org/wiki/Datenbanktrigger Wikipedia: Datenbanktrigger]

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Foreign Keys erzwingen

2008-07-14T22:19:49Z

Jrdesign:

{{In Bearbeitung}}

== Problem ==
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

== Lösung ==
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
CREATE TABLE kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Das UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>
==Quellen==

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]
*[http://de.wikipedia.org/wiki/Datenbanktrigger Wikipedia: Datenbanktrigger]

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Foreign Keys erzwingen

2008-07-14T21:51:09Z

Jrdesign:

{{In Bearbeitung}}

= Problem =
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

= Lösung =
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
CREATE TABLE kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Das UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>
=Quellen=

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Foreign Keys erzwingen

2008-07-14T21:43:38Z

Jrdesign:

{{In Bearbeitung}}

= Problem =
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

= Lösung =
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
create table kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
DaS UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>
=Quellen=

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Foreign Keys erzwingen

2008-07-14T21:42:08Z

Jrdesign:

{{In Bearbeitung}}

= Problem =
SQLite unterstützt standartmäßig keine FOREIGN KEYS (Fremdschlüssel). Man kann diese zwar bei erstellen von Tabellen definieren, jedoch werden diese, wie gesagt, ignoriert.

= Lösung =
Es ist möglich, SQLite dazu zu zwingen, Fremdschlüssel zu akzeptieren. Um das zu erreichen werden TRIGGER verwendet.
TRIGGER werden zum Einfügen, Löschen oder Ändern von Referenzdaten eingesetzt. Der TRIGGER wird ausgeführt, entweder bevor Änderungen an der Tabelle vorgenommen werden oder danach. TRIGGER können selbst Datensätze einfügen, ändern oder löschen und durch seine Ausführung weitere TRIGGER auslösen.
Nun zum Beispiel:
Nehmen wir an wie haben 2 Tabellen-Deklarationen:
<pre>
create table kontakt (
id INTEGER NOT NULL PRIMARY KEY
);

CREATE TABLE termin (
id INTEGER NOT NULL PRIMARY KEY,
kontakt_id INTEGER NOT NULL
CONSTRAINT fk_kontakt_id REFERENCES a(id) ON DELETE CASCADE
);
</pre>
Die Tabelle termin hat einen Fremdschlüssel, der auf die Primär-Schlüssel-Spalte in der kontakt-Tabelle verweist. Obwohl SQLite diese Syntax unterstützt, wird sie einfach ignoriert. Wenn man also eine Referenz erzwingen will, muss man TRIGGER erstellen, die das erledigen. Jede Bedingung muss einen eigenen TRIGGER haben, also einen für INSERT, DELETE und UPDATE.
Der INSERT-TRIGGER sieht folgendermaßen aus:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = NEW.kontakt_id) IS NULL)
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Wenn man die Fremdschlüssel-Spalte als NOT NULL definiert haben will/sollte, muss der INSERT-TRIGGER SELECT CASE ein wenig anders aussehen:
<pre>
CREATE TRIGGER fki_termin_kontakt_id
BEFORE INSERT ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘insert on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
DaS UPDATE-Statement ist fast identisch, wenn die Fremdschlüssel-Spalte NOT NULL ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
und wenn NULL erlaubt ist:
<pre>
CREATE TRIGGER fku_termin_kontakt_id
BEFORE UPDATE ON termin
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((new.kontakt_id IS NOT NULL)
AND ((SELECT id FROM kontakt WHERE id = new.kontakt_id) IS NULL))
THEN RAISE(ABORT, ‘update on table "termin" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Der DELETE TRIGGER wird zur Primär-Sclüssel-Tabelle hinzugefügt und überwacht DELETEs auf der kontakt-Tabelle:
<pre>
CREATE TRIGGER fkd_termin_kontakt_id
BEFORE DELETE ON kontakt
FOR EACH ROW BEGIN
SELECT CASE
WHEN ((SELECT kontakt_id FROM termin WHERE kontakt_id = OLD.id) IS NOT NULL)
THEN RAISE(ABORT, ‘delete on table "kontakt" violates foreign key‘ || ‘constraint "fk_kontakt_id"’)
END;
END;
</pre>
Dieser TRIGGER verhindert Löschvorgänge in der kontakt-Tabelle, wenn es Fremdschlüssel gibt, die auf die termin-Tabelle verweisen.
Eine weitere, etwas übersichtlichere Lösung:
<pre>
CREATE TABLE departments (
dept_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
dept_name TEXT NOT NULL UNIQUE
);

CREATE TABLE employees (
emp_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
emp_name TEXT NOT NULL UNIQUE,
dept_id INTEGER NOT NULL,
CONSTRAINT fkey_dept_id FOREIGN KEY (dept_id) REFERENCES departments (dept_id)
);
</pre>
und die zugehörigen TRIGGER:
<pre>
CREATE TRIGGER fkey_dept_id_ins BEFORE INSERT ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'insert on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_upd BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'update on table "employees" violates foreign key constraint "fkey_dept_id"')
WHERE (SELECT dept_id FROM departments
WHERE dept_id = new.dept_id) IS NULL;
END;

CREATE TRIGGER fkey_dept_id_del BEFORE DELETE ON departments
FOR EACH ROW
BEGIN
SELECT
RAISE(ABORT,
'delete on table "departments" violates foreign key constraint "fkey_dept_id" on "employees"')
WHERE (SELECT dept_id from employees
WHERE dept_id = old.dept_id) IS NOT NULL;
END;
</pre>
Die INSERT-Befehle und SELECT-Ausgaben sehen dann so aus:
<pre>
INSERT INTO departments (dept_name) VALUES ('Marketing');
INSERT INTO departments (dept_name) VALUES ('MIS');
INSERT INTO departments (dept_name) VALUES ('Accounting');

SELECT * FROM departments;

1|Marketing
2|MIS
3|Accounting

INSERT INTO employees (emp_name, dept_id) VALUES ('John', 1);
INSERT INTO employees (emp_name, dept_id) VALUES ('Tim', 2);
INSERT INTO employees (emp_name, dept_id) VALUES ('Gene', 3);

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|1
2|Tim|2
3|Gene|3

UPDATE employees set dept_id = 2 WHERE emp_id = 1;
UPDATE employees set dept_id = 3 WHERE emp_id = 2;

SELECT emp_id, emp_name, dept_id FROM employees;

1|John|2
2|Tim|3
3|Gene|3

DELETE FROM departments WHERE dept_id = 1;
DELETE FROM departments WHERE dept_id = 2;
// hier müsste nach dem 2. Statement ein Fehler auftreten, weil Department mit ID=2 noch von einem Mitarbeiter belegt ist
// das ist völlig OK

SELECT * FROM departments;

2|MIS
3|Accounting
</pre>
=Quellen=

*[http://www.sqlite.org/cvstrac/wiki?p=ForeignKeyTriggers SQLite Homepage]

=Siehe auch=

[[Kategorie:Glossar]]

[[Kategorie:Informatik]]

SQLite Manager für Firefox

2008-06-09T19:56:15Z

Jrdesign:

{{In Bearbeitung}}

=Einleitung =
SQLite Manager ist eine von zahlreichen freien Erweiterungen für den Webbrowser Firefox. Mit diesem Tool ist es möglich, SQLite Datenbanken auf dem lokalen Rechner, zu managen. Das Tool ist unter [http://code.google.com/p/sqlite-manager/downloads/list Google Code] erhältlich.

=Download und Installation =
Unter Google Code die Datei SQLiteManager_0.2.43.xpi anklicken und downloaden. Danach im Firefox unter "Extras" -> "Add-ons" auswählen. Per Drag&Drop die zuvor heruntergeladene *.xpi-Datei ins Add-on Fenster ziehen. Es erscheint ein Dialogfenster, welches man bestätigen sollte, um das Add-on zu installieren.

[[Medium:SQLlite-Manager-Dialog.png]]

Nach erfolgreicher Installation muss man Firefox neustarten. Den erscheinenden Dialog einfach bestätigen, Firefox startet automatisch neu.
Nachdem Firefox neugestartet wurde, findet man unter Extras den SQLite Manager.

=Programmfunktionen =
==kurzer Überblick==
Nachdem man den SQLite Manager gestartet hat, öffnet sich automatisch ein neues Browserfenster.

[[Medium:SQLiteManager-Window.png]]

Nun kann man eine neue SQLite-Datenbank anlegen, eine bereits angelegte Datenbank öffnen und andere Funktionen ausführen.
Die Buttons und Menüeinträge sind selbsterklärend. Um eine neue Datenbank anzulegen klickt man einfach auf den Button "New Database". Im darauffolgenden Fenster gibt man den neuen Datenbanknamen, bestätigt mit OK und wählt nachfolgend den Speicherort für die Datenbank aus. Wie man SQLite Statements ausführt, um zum Beispel Tabellen anzulegen wird im Artikel [[SQLite]] erklärt.

==Datenbank öffnen und managen==
Im Beispiel [[Lokale Datenbank erstellen (Flex und AIR)]] wurde bereits eine Test-Datenbank angelegt. Diese Datenbank öffnet man jetzt im SQLite Manager über den Button "Connect Database" oder über das Menü Database -> Connect Database. Über den Dialog navigiert man nun zur auf dem Desktop liegenden Testdatenbank "DB_Test.db" und öffnet diese. ACHTUNG: sollte der Manager die Dateiendung .db nicht finden, muss man über das Hauptmenü den Punkt "Tools" -> "Options" auswählen und in das Feld "Default file Extension for SQLite files" anstelle von "sqlite", "db" eintragen.

[[Medium:SQLlite-Manager-Options.png]]

Die geöffnete Datenbank sieht wie folgt im SQLite Manager aus:

[[Medium:Datenbank_geoeffnet.png]]

Im linken Teil des Programms sieht man die angelegte Tabelle "person" sowie eine Zweite, die intern verwendet wird. Der rechte Fensterbereich zeigt, bei Klick auf die "person"-Tabelle, die Struktur dieser an. Interessant ist auch, das man zusätzlich Informationen angezeigt bekommt, wie man z.B. über ein Statement diese Tabelle anlegen kann. Wenn man nun den Reiter "Browse & Search" anklickt (bei vorher ausgewählter "person"-Tabelle) erhält man einen Überblick der Einträge in dieser Tabelle.

[[Medium:Tabelle_ausgewaehlt.png]]

Um SQL-Statements auszuführen, wählt man den Reiter "Execute SQL" und kann im nun im kleinen Fenster SQL-Befehle ausführen.
Zum Beispiel einen Insert in die Tabelle: Den Reiter "Data Manipulation" auswählen und dann "Insert values", das Statement eintragen und über den Button "Run SQL" ausführen. Fertig. Ein Klick auf "Browse & Search" zeigt nun auch den neuen Eintrag an.

[[Medium:SQL-Insert.png]]

=Quellen=

*[http://code.google.com/p/sqlite-manager/ Google Code]

=Siehe auch=

*[[SQLite]]

[[Kategorie:Glossar]]

Datei:SQL-Insert.png

2008-06-09T19:51:09Z

Jrdesign: Insertbefehl im SQLite Manager

Insertbefehl im SQLite Manager

Datei:Tabelle ausgewaehlt.png

2008-06-09T19:35:40Z

Jrdesign: ausgewählte Tabelle im SQLite Manager

ausgewählte Tabelle im SQLite Manager

Datei:Datenbank geoeffnet.png

2008-06-09T19:17:06Z

Jrdesign: eine geöffnete Datenbank im SQLite Manager

eine geöffnete Datenbank im SQLite Manager

Datei:SQLlite-Manager-Options.png

2008-06-09T19:07:44Z

Jrdesign: Optionsdialog des SQLite Managers

Optionsdialog des SQLite Managers

Datei:SQLiteManager-Window.png

2008-06-09T18:14:54Z

Jrdesign: Programmoberfläche des SQLite Managers

Programmoberfläche des SQLite Managers

Datei:SQLlite-Manager-Dialog.png

2008-06-09T17:35:03Z

Jrdesign: Installationsdialog für die Installation des SQLite Manager Addons für Firefox.

Installationsdialog für die Installation des SQLite Manager Addons für Firefox.

Datei:New Flex Project 2.png

2008-04-30T19:35:43Z

Jrdesign: Tutorial zum Erstellen eines neuen Flex Projektes (Bild 2)

Tutorial zum Erstellen eines neuen Flex Projektes (Bild 2)

Datei:New Flex Project 1.png

2008-04-30T19:27:11Z

Jrdesign: Tutorial zum Erstellen eines neuen Flex-Projektes (Bild1)

Tutorial zum Erstellen eines neuen Flex-Projektes (Bild1)