NAME

Quiq::Sql - Klasse zur Generierung von SQL

BASE CLASS

Quiq::Dbms

SYNOPSIS

Das Programm

use Quiq::Sql;

my $sql = Quiq::Sql->new('Oracle');

my $stmt = $sql->createTable('person',
    ['per_id',type=>'INTEGER',primaryKey=>1],
    ['per_vorname',type=>'STRING(30)'],
    ['per_nachname',type=>'STRING(30)',notNull=>1],
);

say $stmt;

generiert das CREATE TABLE Statement

CREATE TABLE person (
    per_id NUMBER PRIMARY KEY,
    per_vorname VARCHAR2(30),
    per_nachname VARCHAR2(30) NOT NULL
)

(man beachte die Abbildung der Kolumnentypen)

Die Klasse stellt

DESCRIPTION

Zweck der Klasse

Die Klasse unterstützt die Entwicklung von portablen Datenbankanwendungen, d.h. Anwendungen, die unter mehreren DBMSen lauffähig sein sollen. Dies wird erreicht, indem die Klasse Methoden zur Verfügung stellt, die zum DBMS den passenden SQL-Code erzeugen.

Unterstützte Datenbanksysteme

Folgende DBMSe werden von der Klasse unterstützt:

Oracle
PostgreSQL
SQLite
MySQL

METHODS

Utilities

split() - Zerlege SQL-Statement in Rumpf und Stringliteral-Werte

Synopsis

($stmt1,@arr) = $this->split($stmt);

Description

Zerlege $stmt in den Statement-Rumpf und eine Liste von Stringliteral-Werten und liefere diese beiden Bestandteile zurück.

Statement-Rumpf und Stringliteralwerte können unabhängig bearbeitet und anschließend mit sprintf() wieder zusammengefügt werden.

Example

Zerlege Statement in Bestandteile:

$stmt1 = "SELECT 'a', 'b' FROM x WHERE x = 'c' AND y = 'd''e'";
($stmt2,@arr) = $class->split($stmt1);
=>
"SELECT '%s', '%s' FROM x WHERE x = '%s' AND y = '%s''%s'"
('a','b','c','d','e')

Füge Bestandteile wieder zusammen:

$stmt2 = sprintf($stmt2,@arr);
=>
"SELECT 'a', 'b' FROM x WHERE x = 'c' AND y = 'd''e'"

resolve() - Ersetze SQL-Platzhalter durch Werte

Synopsis

$stmtResolved = $sql->resolve($stmt,@vals);

Description

Ersetze die Platzhalter ? in SQL-Statement $stmt durch die Werte @val und liefere das resultierende Statement zurück.

Diese Methode ist für Debugging-Zwecke nützlich, wenn mit Platzhaltern gearbeitet wird, aber man das aufgelöste Statement sehen möchte.

Example

$stmt = 'SELECT * FROM t WHERE x = ? AND y > ?';
@vals = (47,11);
$stmtResolved = $sql->resolve($stmt,@vals);
=>
"SELECT * FROM t WHERE x = '47' AND y > '11'"

removeSelectClause() - Entferne SELECT-Klausel

Synopsis

$newStmt = $sql->removeSelectClause($stmt);

Description

Entferne die Select-Klausel am Anfang von Select-Statement $stmt und liefere das resultierende Statement zurück.

Als Select-Klausel wird alles vom Beginn des Statement bis zur FROM-Klausel angesehen.

removeOrderByClause() - Entferne ORDER BY-Klausel

Synopsis

$newStmt = $sql->removeOrderByClause($stmt);

Description

Entferne die Order By-Klausel vom Ende des Select-Statement $stmt und liefere das resultierende Statement zurück.

Als Select-Klausel wird alles von der ORDER BY-Klausel bis zum Ende des Statment angesehen.

checkName() - Prüfe Bezeichner

Synopsis

$name = $sql->checkName($name);
$sql->checkName(\$name);

Description

Prüfe und manipuliere Bezeichner $name, so dass er den Konventionen des DBMS entspricht.

Oracle

Ist der Bezeichner länger als 30 Zeichen, kürze ihn auf 29 Zeichen und ersetze das 30. Zeichen durch #.

stmtListToScript() - Generiere aus Liste von SQL-Statements ein Skript

Synopsis

$script = $class->stmtListToScript(@stmt)

Description

Erzeuge aus einer Liste von SQL-Statements ein einzelnes Skript, das von einem Client-Programm wie SQL*Plus, psql bzw. mysql ausgeführt werden kann.

Die SQL-Statements bzw. SQL-Kommentare in @stmt haben am Ende weder Newline noch Semikolon. Diese Methode fügt sie hinzu und konkateniert alle Statements zu einer Zeichenkette.

Folgende Manipulationen werden vorgenommen:

SQL-Statements erhalten am Ende ein Semikolon und ein Newline.
Kommentare erhalten am Ende ein Newline und werden von den umgebenden SQL-Statements abgesetzt, indem vor und nach ihnen eine Leerzeile eingefügt wird.

Diverse Details werden unterschieden (siehe EXAMPLES).

Example

So verhält es sich im Detail:

$script = Quiq::Sql->stmtListToScript(
    '-- TEXT1',
    'STMT1',
    "STMT2\n...',
    "STMT3 (\n....\n)",
    '-- TEXT2',
    'STMT4',
    '-- eof',
);

wird zu:

-- TEXT1     Kommentar am Anfang => danach "\n\n"

STMT1;       einzeiliges Statement => danach ";\n\n")

STMT2        mehrzeilges Statement => danach "\n;\n")
    ...
;
STMT3 (      mehrzeiles Statement mit ) => danach ";\n")
    ...
);

-- TEXT2     innerer Kommentar => davor "\n", danach "\n\n"

STMT4;       (wie einzeiliges Statement oben)

-- eof       Kommentar am Ende, nach einzeiligem Statement
             => davor nichts, danach "\n"

Commands

commands() - Liste der Kommandos des DBMS

Synopsis

@commands | $commandA = $sql->commands;

Data Types

Methoden für die portable Spezifikation von Kolumnen-Datentypen.

dataType() - Wandele portablen Datentyp-Bezeichner in DBMS-Typ-Bezeichner

Synopsis

$dbmsType = $sql->dataType($portableType);
($dbmsType,$args) = $sql->dataType($portableType);

Description

Wandele den portablen Datentyp $portableType in den entsprechenden DBMS-spezifischen Typ und liefere diesen zurück. Im Skalarkontext liefere den Typbezeichner einschließlich etwaiger Argumente, im Listkontext liefere Typ und Argumente getrennt.

Typ-Abbildung

Portabel   Oracle     PostgreSQL SQLite    MySQL
---------- ---------- ---------- --------- ----------
STRING     VARCHAR2   VARCHAR    TEXT      VARCHAR
TEXT       CLOB       TEXT       TEXT      LONGTEXT
INTEGER    NUMBER     NUMERIC    INTEGER   (TINY|SMALL|MEDIUM|BIG)INT
REAL       NUMBER     NUMERIC    REAL      DECIMAL
DATETIME   TIMESTAMP  TIMESTAMP  TIMESTAMP TIMESTAMP
BLOB       BLOB       BYTEA      BLOB      LONGBLOB

VARCHAR2 kann bei Oracle max 4000 Zeichen lang sein

Example

Einige Konvertierungen im Falle von Oracle:

$type = $sql->dataType('STRING');
# => 'VARCHAR2'

$type = $sql->dataType('STRING(20)');
# => 'VARCHAR2(20)'

($type,$args) = $sql->dataType('STRING');
# => ('VARCHAR2','')

($type,$args) = $sql->dataType('STRING(20)');
# => ('VARCHAR2','(20)')

($type,$args) = $sql->dataType('DATETIME');
# => ('TIMESTAMP','(0)')

columnDef() - Generiere Kolumnen-Definition

Synopsis

$colDef = $sql->columnDef(@colDef);
$colDef = $sql->columnDef($portableType,@colDef);

Description

Generiere aus der portablen Kolumnen-Spezifikation @colDef eine DBMS-spezifische Kolumnen-Definition, die als Zeichenkette nach dem Kolumnennamen in ein CREATE TABLE oder ALTER TABLE Statement eingesetzt werden kann, und liefere diese zurück.

Die Methode wird von den Methoden createTable() und addColumn() genutzt.

Die Kolumnen-Spezifikation @colDef besteht aus einer nicht-leeren Aufzählung von folgenden Schlüssel/Wert-Paaren:

default => $value: Defaultwert der Kolumne.
null => $bool: Kolumne ist kein Pflichtfeld. Diese explizite Setzung wird bei MySQL gebraucht, wenn ein TIMESTAMP-Feld nicht '0000-00-00 00:00:00' als Defaultwert erhalten soll.
notNull => $bool: Kolumne ist Pflichtfeld.
autoIncrement => $bool: Das DBMS erzeugt beim Einfügen eines Datensatzes einen eindeutigen Wert (SQLite und MySQL).
primaryKey => $bool: Kolumne ist Primärschlüsselkolumne.
type => $type: Portabler Kolumnentyp.
oracleType => $oracleType: Kolumnentyp für Oracle.
postgresqlType => $postgresqlType: Kolumnentyp für PostgreSQL.
sqliteType => $sqliteType: Kolumnentyp für SQLite.
mysqlType => $mysqlType: Kolumnentyp für MySQL.

Der Kolumnentyp ist für eine Kolumnenspezifikation zwingend. Er wird als portabler Typ (type=>$type) oder als DBMS-spezifischer Typ (<dbms>Type=>$type) angegeben. Ist beides angegeben, hat der DBMS-spezifische Typ Vorrang.

Das Attribut autoIncrement ist nicht portabel, es ist

Example

Portabler Typ wird verwendet, wenn nichts anderes für das DBMS angegeben ist:

$sql = Quiq::Sql->new('Oracle');
$type = $sql->columnDef(
    type => 'STRING(20)',
);
==>
'VARCHAR2(20)'

DBMS-Typ wird verwendet, wenn angegeben:

$sql = Quiq::Sql->new('Oracle');
$type = $sql->columnDef(
    type => 'INTEGER(5)',
    oracleType => 'NUMBER(5)',
);
==>
'NUMBER(5)'

Comments

comment() - Generiere SQL-Kommentar

Synopsis

$stmt = $sql->comment($text);

Description

Setze an den Anfang jeder Zeile in $text die Zeichenfolge '-- ' und liefert das Resultat zurück.

Whitespace am Ende wird entfernt, d.h. der SQL-Kommentar endet wie die SQL-Statements per Default nicht mit einem Newline.

Example

Lorem ipsum dolor sit amet, consetetur sadipscing
elitr, sed diam nonumy eirmod tempor invidunt ut
labore et dolore magna

wird zu

-- Lorem ipsum dolor sit amet, consetetur sadipscing
-- elitr, sed diam nonumy eirmod tempor invidunt ut
-- labore et dolore magna

Session

setDateFormat() - Generiere Statements zum Setzen des Datumsformats

Synopsis

@stmt = $class->setDateFormat;
@stmt = $class->setDateFormat($format);

Description

Setze als Default-Datumsformat $format. Ist $format nicht angegeben, setzte iso-Format.

Folgende Datumsformate sind definiert:

iso: YYYY-MM-DD HH:MM:SS

Oracle

(iso)
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'
ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SSXFF'

PostgreSQL

(iso)
SET datestyle TO iso, ymd

SQLite

unbekannt

MySQL

unbekannt

setNumberFormat() - Generiere Statements zum Setzen des Zahlenformats

Synopsis

@stmt = $class->setNumberFormat;
@stmt = $class->setNumberFormat($format);

Description

Setze als Default-Zahlenformat $format. Ist $format nicht angegeben, setzte angloamerikanisches Format.

Oracle

ALTER SESSION SET NLS_NUMERIC_CHARACTERS = '.,'

PostgreSQL

unbekannt

SQLite

unbekannt

MySQL

unbekannt

setSchema() - Generiere Statement zum Setzen des aktuellen Schema

Synopsis

$class->setSchema($schema);

Description

Oracle

ALTER SESSION SET CURRENT_SCHEMA = <schema>

PostgreSQL

SET search_path TO <schema>

Anstelle eines einzelnen Schema können mehrere Schemata, mit Komma getrennt, aufgezählt werden.
Die Setzung sollte sofort mit COMMIT bestätigt werden, da sie im Falle eines ROLLBACK sonst verfällt.

SQLite

<leer>

SQLite hat das Konzept mehrerer Schemata, von denen eins das Default-Schema ist, nicht.

Bei einer SQLite-Datenbank gibt es per Default keinen Schema-Präfix, dieser wird erst durch ATTACH einer Datenbank eingeführt.

Ein Tabellenname ohne Schema wird immer über allen Attachten Datenbanken aufgelöst. Die zuerst hinzugefügte Tabelle ist der Dafault.

MySQL

USE <schema>

setSearchPath() - Generiere Statement zum Setzen des Search Path

Synopsis

$stmt = $class->setSearchPath(@schemas);

Description

Oracle

<not implemented>

PostgreSQL

SET search_path TO SCHEMA, ...

SQLite

<not implemented>

MySQL

<not implemented>

setEncoding() - Generiere Statement zum Setzen des Client-Encodings

Synopsis

$stmt = $class->setEncoding($charset);

Description

Werte für $charset:

iso-8859-1
utf-8

Oracle

<not implemented>

PostgreSQL

SET client_encoding TO <charset>

SQLite

<not implemented>

MySQL

<not implemented>

Locking

lockTable() - Generiere LOCK TABLE Statement

Synopsis

$stmt = $class->lockTable($table);

Description

Oracle

LOCK TABLE <table> IN EXCLUSIVE MODE NOWAIT

PostgreSQL

LOCK TABLE <table> IN EXCLUSIVE MODE NOWAIT

SQLite

nicht implementiert

MySQL

nicht implementiert

User

createUser() - Generiere CREATE USER Statement

Synopsis

$stmt = $class->createUser($name,$password,@opt);

Options

-defaultTableSpace => $name (Default: keiner): Name des Default-Tablespace
-tempTableSpace => $name (Default: keiner): Name des Temporary-Tablespace

Schema

createSchema() - Generiere CREATE SCHEMA Statement

Synopsis

$stmt = $class->createSchema($name);

dropSchema() - Generiere DROP SCHEMA Statement

Synopsis

$stmt = $class->dropSchema($name);

Table

splitTableName() - Zerlege Tabellennamen

Synopsis

($schema,$table) = $class->splitTableName($name);
($schema,$table) = $class->splitTableName($name,$sloppy);

Alias

splitTablename()

Description

Zerlege den Tabellennamen $name in die Komponenten $schema und $table. Besitzt der Tabellennamen keinen Schema-Präfix, wird eine Exception geworfen. Dies geschieht nicht, wenn der Parameter $sloppy gesetzt und wahr ist. In dem Fall wird keine Exception geworfen, sondern als Schemaname undef geliefert.

createTable() - Generiere CREATE TABLE Statement

Synopsis

$stmt = $sql->createTable($table,
    [$colName,@colDef],
    ...
    @opt,
);

Options

-check => \@expr: Liste von CHECK-Contraints (Bedingungen).
-reference => [[\@cols => $refTable,@opt], ...]: Liste von Fremdschlüssel-Verweisen.
-tableSpace => $tableSpaceName (Default: keiner): Name des Tablespace, in dem die Tabelle erzeugt wird (Oracle und PostgreSQL).
-tableType => $tableType (Default: 'InnoDB'): Tabellentyp bei MySQL: 'InnoDb', 'MyISAM'.

Description

Generiere ein CREATE TABLE Statement und liefere dieses zurück.

Für jede Kolumne wird ihr Name $colName und ihr Typ.

Der Kolumnentyp wird als portabler Typ (type=>$type) oder als DBMS-spezifischer Typ (<dbms>Type=>$type) angegeben. Ist beides angegeben, hat der DBMS-spezifische Typ Priorität. Für die portablen Typen siehe Methode columnType().

Alle weiteren Angaben in @colOpts sind optional.

Folgende Kolumnen-Optionen sind definiert:

notNull => $bool: Kolumne ist Pflichtfeld.
autoIncrement => $bool: Das DBMS erzeugt beim Einfügen eines Datensatzes einen eindeutigen Wert (nicht Oracle und PostgreSQL, diese haben das Konzept der Sequenz).
primaryKey => $bool: Kolumne ist Primärschlüsselkolumne.
type => $type: Portabler Kolumnentyp.
oracleType => $oracleType: Kolumnentyp für Oracle.
postgresqlType => $postgresqlType: Kolumnentyp für PostgreSQL.
sqliteType => $sqliteType: Kolumnentyp für SQLite.
mysqlType => $mysqlType: Kolumnentyp für MySQL.

MySQL-Tabellen werden per Default als InnoDB-Tabellen erzeugt und erhalten als Zusatz die Angabe "TYPE = InnoDB". Der Tabellentyp kann mit der Option -tableType abweichend gesetzt werden.

Die Typ-Attribute type und <dbms>Type werden von columnTypeSpec() in den DBMS-Typ umgewandelt.

dropTable() - Generiere DROP TABLE Statement

Synopsis

$stmt = $sql->dropTable($table);

renameTable() - Benenne Tabelle um

Synopsis

$stmt = $sql->renameTable($oldName,$newName);

analyzeTable() - Generiere ANALYZE TABLE Statement

Synopsis

$stmt = $sql->analyzeTable($table);

legalizeTablename() - Legalisiere Tabellennamen

Synopsis

$table = $sql->legalizeTablename($table);

Description

Legalisiere Tabellennamen durch Quotierung, wenn dieser Sonderzeichen enthält. Dies geschieht bei MySQL durch Backticks, z.B. bei Tabellen, deren Name einen Bindestrich enthält:

Meine-Tabelle -> `Meine-Tabelle`
Mein-Schema.Meine-Tabelle -> `Meine-Schema`.`Meine-Tabelle`

Für die anderen DBMSe ist das Feature aktuell nicht implementiert, d.h. es wird immer der unveränderte Tabellenname zurückgegeben.

Columns

addColumn() - Generiere ALTER TABLE Statement, das eine Kolumne erzeugt

Synopsis

$stmt = $sql->addColumn($table,$column,@colDef);

Description

Erzeuge SQL-Statement, das der Tabelle $table die Kolumne $column mit der Spezifikation @colDef hinzufügt. Die portable Kolumnen-Spezifikation @colDef wird von Methode columnDef() in die DBMS-spezifische Zeichenkette gewandelt.

PostgreSQL Syntax

ALTER TABLE table ADD COLUMN column type ...

Oracle Syntax

ALTER TABLE table ADD (column type ...)

SQLite Syntax

ALTER TABLE table ADD COLUMN column type ...

MySQL Syntax

ALTER TABLE table ADD COLUMN column type ...

Die Punkte stehen für zusätzliche optionale Kolumnen-Angaben, wie "DEFAULT expr", "NOT NULL", "PRIMARY KEY" usw.

dropColumn() - Generiere ALTER TABLE Statement, das eine Kolumne entfernt

Synopsis

$stmt = $sql->dropColumn($table,$column);

Description

Erzeuge SQL-Statement, das aus der Tabelle $table die Kolumne $column entfernt.

Oracle, PostgreSQL, MySQL Syntax

ALTER TABLE table DROP COLUMN column

SQLite Syntax

Eine Kolumne kann nicht entfernt werden (geprüft 3.6.13)

modifyColumn() - Generiere ALTER TABLE Statement, das eine Kolumne modifiziert

Synopsis

$stmt = $sql->modifyColumn($table,$column,$property=>$value);

Description

Erzeuge SQL-Statement, das in Tabelle $table die Kolumne $column modifiziert. Verändert wird die Eigenschaft $property auf Wert $value.

NULL

PostgreSQL:

ALTER TABLE t ALTER COLUMN c DROP NOT NULL

Oracle:

ALTER TABLE t MODIFY c NULL

MySQL:

NOT NULL scheint nicht ohne Kenntnis des Kolumnentyps
manipuliert werden zu können (5.1.41).

SQLite:

Eine Kolumne kann nicht modifiziert werden (geprüft 3.6.22)

NOT NULL

PostgreSQL:

ALTER TABLE t ALTER COLUMN c SET NOT NULL

Oracle:

ALTER TABLE t MODIFY COLUMN c NULL

MySQL:

NOT NULL scheint nicht ohne Kenntnis des Kolumnentyps
manipuliert werden zu können (5.1.41).

SQLite:

Eine Kolumne kann nicht modifiziert werden (geprüft 3.6.22)

TYPE

PostgreSQL:

nicht implementiert

Oracle:

ALTER TABLE <t> MODIFY COLUMN <c> <type>

MySQL:

nicht implementiert

SQLite:

Eine Kolumne kann nicht modifiziert werden (geprüft 3.6.22)

renameColumn() - Generiere ALTER TABLE Statement, das eine Kolumne umbenennt

Synopsis

$stmt = $sql->renameColumn($table,$oldName,$newName)

Description

Erzeuge SQL-Statement, das in Tabelle $table die Kolumne $oldName in $newName umbenennt.

Syntax

PostgreSQL:

ALTER TABLE t RENAME COLUMN c1 TO c2

Oracle:

ALTER TABLE t RENAME COLUMN c1 TO c2

MySQL:

nicht implementiert

SQLite:

nicht implementiert

Constraints

addPrimaryKeyConstraint() - Generiere PRIMARY KEY Constraint Statement

Synopsis

$stmt = $sql->addPrimaryKeyConstraint($tableName,\@colNames,@opt);

Options

-constraintName => $str (Default: <TABLE>_PK): Name des Constraint.
-exceptionTable => $tableName (Default: keiner): Constraint-Verletzende Datensätze werden in Tabelle $tableName protokollliert (nur Oracle).
-tableSpace => $tableSpaceName (Default: keiner): Name des Tablespace, in dem der Index erzeugt wird (Oracle und PostgreSQL).

Description

Oracle Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    PRIMARY KEY (<TABLE_COLUMNS>)
    USING INDEX TABLESPACE <TABLESPACE_NAME>
    EXCEPTIONS INTO <EXCEPTION_TABLE_NAME>

PostgreSQL Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    PRIMARY KEY (<TABLE_COLUMNS>)
    USING INDEX TABLESPACE <TABLESPACE_NAME>

addForeignKeyConstraint() - Generiere FOREIGN KEY Constraint Statement

Synopsis

$stmt = $sql->addForeignKeyConstraint($tableName,\@tableCols,
    $refTableName,@opt);

Options

-constraintName => $str (Default: <TABLE>_FK_<REFTABLE>): Name des Constraint.
-defer => $bool (Default: 0): Constraint-Fehler wird verzögert gemeldet.
-disable => $bool (Default: 0): Constraint wird erzeugt, ist aber abgeschaltet.
-exceptionTable => $tableName (Default: keiner): Constraint-Verletzende Datensätze werden in Tabelle $tableName protokollliert (nur Oracle).
-onDelete => 'cascade'|'null' (Default: keiner): Legt fest, was bei Löschung des Parent-Datensatzes passieren soll.
-refTableCols => \@refTableCols (Default: undef): Liste der Kolumnen in der referenzierten Tabelle. Bei MySQL müssen die referenzierten Kolumnen aufgezählt werden, auch wenn ein Primary Key auf der referenzierten Tabelle definiert ist.

Description

Oracle Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    FOREIGN KEY (<TABLE_COLUMNS>)
    REFERENCES <REF_TABLE_NAME>
    ON DELETE <ACTION>
    DEFERRABLE INITIALLY DEFERRED
    EXCEPTIONS INTO <EXCEPTION_TABLE_NAME>
    DISABLE

PostgreSQL Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    FOREIGN KEY (<TABLE_COLUMNS>)
    REFERENCES <REF_TABLE_NAME>
    ON DELETE <ACTION>
    DEFERRABLE INITIALLY DEFERRED

MySQL Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    FOREIGN KEY (<TABLE_COLUMNS>)
    REFERENCES <REF_TABLE_NAME> (REF_TABLE_COLUMNS)
    ON DELETE <ACTION>

addNotNullConstraint() - Generiere NOT NULL Constraint Statement

Synopsis

$stmt = $sql->addNotNullConstraint($tableName,$colName,@opt);

Options

-constraintName => $str (Default: <TABLE>_CK): Name des Constraint (nicht PostgreSQL).
-exceptionTable => $tableName (Default: keiner): Constraint-Verletzende Datensätze werden in Tabelle $tableName protokollliert (nur Oracle).

Description

Oracle Syntax

ALTER TABLE <TABLE_NAME> MODIFY (
    <COLUMN NAME>
    CONSTRAINT <CONSTRAINT_NAME>
    NOT NULL
    EXCEPTIONS INTO <EXCEPTION_TABLE_NAME>
)

PostgreSQL Syntax

ALTER TABLE <TABLE_NAME>
    ALTER COLUMN <COLUMN_NAME>
    SET NOT NULL

addCheckConstraint() - Generiere CHECK Constraint Statement

Synopsis

$stmt = $sql->addCheckConstraint($tableName,$clause,@opt);

Options

-constraintName => $str (Default: <TABLE>_CK): Name des Constraint.
-exceptionTable => $tableName (Default: keiner): Constraint-Verletzende Datensätze werden in Tabelle $tableName protokollliert (nur Oracle).

Description

Oracle Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    CHECK (<CHECK_CLAUSE>)
    EXCEPTIONS INTO <EXCEPTION_TABLE_NAME>

PostgreSQL Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    CHECK (<CHECK_CLAUSE>)

SQLite Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    CHECK (<CHECK_CLAUSE>)

addUniqueConstraint() - Generiere UNIQUE Constraint Statement

Synopsis

$stmt = $sql->addUniqueConstraint($tableName,\@colNames,@opt);

Options

-constraintName => $str (Default: <TABLE>_UQ_<COLUMNS>): Name des Constraint.
-exceptionTable => $tableName (Default: keiner): Constraint-Verletzende Datensätze werden in Tabelle $tableName protokollliert (nur Oracle).
-tableSpace => $tableSpaceName (Default: keiner): Name des Tablespace, in dem der Index erzeugt wird (Oracle und PostgreSQL).

Description

Liefere ein SQL-Statement zur Erzeugung eines UNIQUE-Constraint auf Tabelle $tableName über den Kolumnen @colNames und liefere dieses zurück.

Oracle Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    UNIQUE (<TABLE_COLUMNS>)
    USING INDEX TABLESPACE <TABLESPACE_NAME>
    EXCEPTIONS INTO <EXCEPTION_TABLE_NAME>

PostgreSQL Syntax

ALTER TABLE <TABLE_NAME> ADD
    CONSTRAINT <CONSTRAINT_NAME>
    UNIQUE (<TABLE_COLUMNS>)
    USING INDEX TABLESPACE <TABLESPACE_NAME>

Index

indexName() - Liefere Namen für Index

Synopsis

$indexName = $sql->indexName($table,\@colNames);

createIndex() - Generiere CREATE INDEX Statement

Synopsis

$stmt = $sql->createIndex($tableName,\@colNames,@opt);

Options

-indexName => $str (Default: <TABLE>_ix_<COLUMNS>): Name des Index.
-tableSpace => $tableSpaceName (Default: keiner): Name des Tablespace, in dem der Index erzeugt wird (Oracle und PostgreSQL).
-unique => $bool (Default: 0): Statement für Unique Index.

Description

Generiere ein CREATE INDEX Statement und liefere dieses zurück.

Oracle Syntax

CREATE [UNIQUE] INDEX <INDEX_NAME> ON <TABLE_NAME>
    (<TABLE_COLUMNS>)
    TABLESPACE <TABLESPACE_NAME>

PostgreSQL Syntax

CREATE [UNIQUE] INDEX <INDEX_NAME> ON <TABLE_NAME>
    (<TABLE_COLUMNS>)
    TABLESPACE <TABLESPACE_NAME>

SQLite Syntax

CREATE [UNIQUE] INDEX <INDEX_NAME> ON <TABLE_NAME>
    (<TABLE_COLUMNS>)

MySQL Syntax

CREATE [UNIQUE] INDEX <INDEX_NAME> ON <TABLE_NAME>
    (<TABLE_COLUMNS>)

dropIndex() - Generiere DROP INDEX Statement

Synopsis

$stmt = $sql->dropIndex($tableName,\@colNames);

Description

Generiere ein DROP INDEX Statement und liefere dieses zurück.

Syntax

DROP INDEX <INDEX_NAME>

Sequence

createSequence() - Generiere SQL-Statements zur Erzeugung einer Sequenz

Synopsis

@stmt = $sql->createSequence($name,@opt);

Options

-startWith => $n (Default: 1): Lasse die Sequenz mit Startwert $n beginnen.

Description

Generiere Statements zur Erzeugung von Sequenz $name und liefere diese zurück.

Unter Oracle und PostgreSQL, die das Konzept der Sequenz haben, wird ein CREATE SEQUENCE Statement generiert.

Unter MySQL und SQLite, die das Konzept der Sequenz nicht haben, wird eine Tabelle (CREATE TABLE) mit Autoinkrement-Kolumne zur Simulation einer Sequenz erzeugt. Ist die Option -startWith angegeben, wird zusätzlich ein INSERT-Statement generiert.

dropSequence() - Generiere SQL-Statement zum Löschen einer Sequenz

Synopsis

$stmt = $sql->dropSequence($name);

Description

Generiere SQL-Statement zum Löschen von Sequenz $name und liefere dieses zurück.

Unter Oracle und PostgreSQL, die das Konzept der Sequenz haben, wird ein DROP SEQUENCE Statement generiert.

Unter MySQL und SQLite, die das Konzept der Sequenz nicht haben, wird ein DROP TABLE Statement generiert.

setSequence() - Generiere SQL-Statements zum Setzen einer Sequenz

Synopsis

@stmt = $sql->setSequence($name,$n);

Description

Generiere SQL-Statements zum Setzen von Sequenz $name auf Wert $n.

Unter Oracle wird die Sequenz gedroppt und neu erzeugt.
Unter PostgreSQL wird der Wert mit ALTER SEQUENCE gesetzt.
Unter MySQL und SQLite, die das Konzept der Sequenz nicht haben, wird die Sequenz-Tabelle geleert und der Wert als neuer Datensatz hinzugefügt. Einschränkung: Der Sequenzwert kann hochgesetzt, aber nicht verringert werden!

Function

createFunction() - Generiere Statement zum Erzeugen einer Funktion

Synopsis

$stmt = $sql->createFunction($signature,$body,@opt);

Arguments

$signature: Signatur der Funktion, also Name mit Typ-Parameterliste und ggf. Schema-Präfix.
$body: Rumpf der Funktion.

Options

-replace => $bool (Default: 0): Generiere "OR REPLACE" Klausel.
-returns => $type (Default: undef): Generiere "RETURNS $type" Klausel.

Description

PostgreSQL

CREATE OR REPLACE FUNCTION <signature>
RETURNS <returns>
AS $SQL$
  <body>
$SQL$ LANGUAGE plpgsql

<name> kann Schema enthalten

dropFunction() - Generiere Statement zum Entfernen einer Funktion

Synopsis

$stmt = $sql->dropFunction($signature);

Arguments

$signature: Signatur der Funktion, also Name mit Typ-Parameterliste und ggf. Schema-Präfix.

Description

PostgreSQL

DROP FUNCTION <signature> CASCADE

moveFunction() - Bewege Funktion in ein anderes Schema

Synopsis

$stmt = $sql->moveFunction($signature,$schema);

Arguments

$signature: Signatur der Funktion, also Name mit Typ-Parameterliste und Schema-Präfix.
$schema: Zielschema, in das die Funktion bewegt wird.

Description

PostgreSQL

ALTER FUNCTION <signature> SET SCHEMA <schema>

Trigger

createTrigger() - Generiere Statement zum Erzeugen eines Triggers

Synopsis

$stmt = $sql->createTrigger($table,$name,$when,$event,$level,
    $body,@opt);
$stmt = $sql->createTrigger($table,$name,$when,$event,$level,
    -execute => $proc,@opt);

Options

-replace => $bool (Default: 0): Generiere "OR REPLACE" Klausel (Oracle).
-execute => $proc (Default: undef): Generiere "EXECUTE PROCEDURE $proc()" Klausel.

Description

Oracle

$stmt = $sql->createTrigger(
    '<table>',
    '<name>',
    'before',
    'insert|update',
    'row',
    -replace => 1,'
    <body>
    '
);

CREATE OR REPLACE TRIGGER <name>
BEFORE INSERT OR UPDATE ON <table>
FOR EACH ROW
<body>

Oracle-Trigger können eine Prozedur können einen Trigger-Body definieren.

PostgreSQL

$stmt = $sql->createTrigger(
    '<table>',
    '<name>',
    'before',
    'insert|update',
    'row',
    -execute => '<proc>',
);

CREATE TRIGGER <name>
BEFORE INSERT OR UPDATE ON <table>
FOR EACH ROW
EXECUTE PROCEDURE <proc>()

Trigger können eine Prozedur aufrufen (-execute=>$proc) aber keinen Trigger-Body definieren.
Keine Klausel "OR REPLACE" bei Triggern (-replace=>1 wird ignoriert)

dropTrigger() - Generiere Statement zum Entfernen eines Triggers

Synopsis

$stmt = $sql->dropTrigger($name);

Description

Oracle

DROP TRIGGER <name>

enableTrigger() - Generiere Statement zum Anschalten eines Triggers

Synopsis

$stmt = $sql->enableTrigger($table,$tigger);

Description

PostgreSQL

ALTER TABLE <table> ENABLE TRIGGER <trigger>

disableTrigger() - Generiere Statement zum Abschalten eines Triggers

Synopsis

$stmt = $sql->disableTrigger($table,$tigger);

Description

PostgreSQL

ALTER TABLE <table> DISABLE TRIGGER <trigger>

View

createView() - Generiere CREATE VIEW Statement

Synopsis

$stmt = $sql->createView($viewName,$selectStmt);

Description

Generiere ein CREATE VIEW Statement und liefere dieses zurück.

dropView() - Generiere DROP VIEW Statement

Synopsis

$stmt = $sql->dropView($viewName);

Description

Generiere ein DROP VIEW Statement und liefere dieses zurück.

Privileges

grant() - Generiere GRANT Statement

Synopsis

$stmt = $sql->grant($objType,$objName,$privs,$roles);

Description

Generiere ein GRANT-Statement und liefere dieses zurück.

Example

PostgreSQL GRANT auf Tabelle

$stmt = $sql->grant('TABLE','tab1','ALL','PUBLIC');

generiert

GRANT ALL
    ON TABLE tab1
    TO PUBLIC

grantUser() - Generiere GRANT Statement für Benutzerrechte

Synopsis

$stmt = $sql->grantUser($userName,$privs);

Example

Oracle GRANT für Benutzer

$stmt = $sql->grantUser('user1','connect, resource, dba');

generiert

GRANT connect, resource, dba
    TO user1

Transactions

begin() - Generiere BEGIN Statement

Synopsis

$stmt = $sql->begin;

commit() - Generiere COMMIT Statement

Synopsis

$stmt = $sql->commit;

rollback() - Generiere ROLLBACK Statement

Synopsis

$stmt = $sql->rollback;

Data Manipulation

select() - Generiere SELECT Statement

Synopsis

$stmt = $sql->select($stmt,@opt);
$stmt = $sql->select($table,@opt);
$stmt = $sql->select(@opt);

Options

-comment => $text

Setze Kommentar mit dem ein- oder mehrzeiligen Text $text an den Anfang des Statement.

-with => @withElements

Liste von WITH-Elementen. Dies ist eine Liste von Schlüssel/Wert-Paaren der Art

$name => $select, ...

-select => @selectExpr (Default: '*')

Generiere eine SELECT-Klausel aus den Ausdrücken @selectExpr. Die Ausdrücke werden mit Komma separiert. Ist kein Select-Ausdrück spezifiziert, wird '*' angenommen.

Platzhalter: %SELECT%

-distinct => $bool

Generiere "SELECT DISTINCT" statement.

Schlüsselwort "DISTINCT" wird in %SELECT%-Platzhalter mit eingsetzt.

-hint => $hint

Setze im Statement hinter das Schlüsselwort SELECT einen Hint, d.h. einen Kommentar in der Form /*+ ... */. (nur Oracle)

hint wird in %SELECT%-Platzhalter mit eingsetzt.

-from => @fromExpr

Generiere eine FROM-Klausel aus den Ausdrücken @fromExpr. Die Ausdrücke werden mit Komma separiert. Die FROM-Klausel ist bei Oracle eine Pflichtangabe.

Platzhalter: %FROM%

-from ist die Defaultoption, d.h. ist als erster Parameter keine Option angegeben, werden die folgenden Parameter als Tabellennamen interpretiert.

-where => @whereExpr

Generiere eine WHERE-Klausel aus den Ausdrücken @whereExpr. Die Ausdrücke werden mit 'AND' separiert.

Platzhalter: %WHERE%

-groupBy => @groupExpr

Generiere eine GROUP BY-Klausel aus den Ausdrücken @groupExpr. Die Ausdrücke werden mit Komma separiert.

Platzhalter: %GROUPBY%

-having => @havingExpr

Generiere eine HAVING-Klausel aus den Ausdrücken @havingExpr. Die Ausdrücke werden mit Komma separiert.

Platzhalter: %HAVING%

-orderBy => @orderExpr

Generiere eine ORDER BY-Klausel aus den Ausdrücken @orderExpr. Die Ausdrücke werden mit Komma separiert.

Platzhalter: %ORDERBY%

-limit => $n

Generiere eine LIMIT-Klausel.

Platzhalter: %LIMIT%

-offset => $n

Generiere eine OFFSET-Klausel.

Platzhalter: %OFFSET%

-stmt => $stmt

Liefere $stmt als Statement. Enthält $stmt Platzhalter, werden diese durch die entsprechenden Komponenten ersetzt (noch nicht implementiert).

Description

Konstruiere ein SELECT-Statement aus den Parametern und liefere dieses zurück.

Ist das erste Argument keine Option und enthält es Whitespace, wird es als SQL-Statement interpretiert. Enthält es kein Whitespace, wird es als Tabellenname interpretiert.

Besonderheiten

Oracle: FROM-Klausel

Bei Oracle ist die FROM-Klausel eine Pflichtangabe, fehlt sie, wird "FROM dual" generiert.
Oracle: LIMIT und OFFSET

Oracle unterstützt weder LIMIT noch OFFSET.

Im Falle von Oracle wird keine LIMIT-Klausel generiert, sondern die WHERE-Klausel um "ROWNUM <= $n" erweitert.

Ist im Falle von Oracle OFFSET angegeben, wird eine Exception ausgelöst.

FROM-Aliase

Bei PostgreSQL ist ein FROM-Alias zwingend erforderlich, wenn die FROM-Klausel ein Ausdruck ist statt ein Tabellenname, z.B.

... FROM (<SELECT_STMT>) AS x ...

Bei Oracle ist ein Alias in dem Fall nicht erforderlich, kann aber angegeben werden. Ein FROM-Alias wird bei Oracle aber Iltnicht> mit "AS" eingeleitet. Das "AS" muss weggelassen werden.

Example

SELECT ohne Option mit einem Argument

$stmt = $sql->select('x');
=>
SELECT
    *
FROM
    x

SELECT ohne Option mit mehreren Argumenten

$stmt = $sql->select('x',vorname=>'Elli',nachname=>'Pirelli');
=>
SELECT
    *
FROM
    x
WHERE
    vorname = 'Elli'
    AND nachname = 'Pirelli'

SELECT mit Statement-Platzhaltern

$stmt = $sql->select("
    SELECT
        *
    FROM
        x
    WHERE
        vorname = '__VORNAME__'
        AND nachname = '__NACHNAME__'
    ",
    -placeholders =>
         __VORNAME__ => 'Elli',
         __NACHNAME__ => 'Pirelli'
);
=>
SELECT
    *
FROM
    x
WHERE
    vorname = 'Elli'
    AND nachname = 'Pirelli'

SELECT mit Statement-Muster

my $select = <<'__SQL__';
SELECT
    %SELECT%
FROM
    station sta LEFT JOIN parameter par
    ON par_station_id = sta_id
__SQL__

$stmt = $sql->select(
    -stmt => $select,
    -select => qw/sta_id sta_name par_id par_name/,
    -orderBy => qw/sta_name par_name/,
);
=>
SELECT
    sta_id,
    sta_name,
    par_id,
    par_name
FROM
    station sta LEFT JOIN parameter par
    ON par_station_id = sta_id
ORDER BY
    sta_name,
    par_name

insert() - Generiere INSERT-Statement

Synopsis

$stmt = $sql->insert($table,$row);
$stmt = $sql->insert($table,%keyVal);
$stmt = $sql->insert($table,@keyVal);
$stmt = $sql->insert($table,\@keys,\@vals);

Description

Generiere ein INSERT-Statement für Tabelle $table mit den Kolumnen und Werten %keyVal bzw. @keyVal bzw. @keys,@vals und liefere dieses zurück.

Schlüssel/Wert-Paare ohne Wert (Leerstring, undef) werden ausgelassen. Damit ist sichergestellt, dass der Defaultwert der Kolumne verwendet wird, wenn einer auf der Datenbank deklariert ist.

Ist der Kolumnenwert eine String-Referenz, wird der Wert ohne Anführungsstriche in das Statement eingesetzt. Auf diese Weise können per SQL berechnete Werte (Expressions) eingesetzt werden.

Ist die Liste der Schlüssel/Wert-Paare leer oder sind alle Werte leer, wird ein Null-Statement (Leerstring) geliefert.

Example

Normales INSERT, Schlüssel/Wert-Paare

$stmt = $sql->insert('person',
    per_id => 10,
    per_vorname => 'Hanno',
    per_nachname => 'Seitz',
    per_geburtstag => undef,
);

=>

INSERT INTO person
(
    per_id,
    per_vorname,
    per_nachname,
)
VALUES
(
    '10',
    'Hanno',
    'Seitz',
)

Normales Insert, Schlüssel und Werte als getrennte Listen

@keys = qw/per_id per_vorname per_nachname per_geburtstag/;
@vals = (10,'Hanno','Seitz',undef);
$stmt = $sql->insert('person',\@keys,\@vals);

=>

INSERT INTO person
(
    per_id,
    per_vorname,
    per_nachname,
)
VALUES
(
    '10',
    'Hanno',
    'Seitz',
)

INSERT mit berechnetem Kolumnenwert

$stmt = $sql->insert('objekt',
    obj_id => 4711,
    obj_letzteaenderung => \'SYSDATE',
);

=>

INSERT INTO objekt
(
    obj_id,
    obj_letzteaenderung
)
VALUES
(
    '4711',
    SYSDATE
)

Null-Statements

$stmt = $sql->insert('person');

=>

''

$stmt = $sql->insert('person',
    per_id => '',
    per_vorname => '',
    per_nachname => '',
    per_geburtstag => '',
);

=>

''

INSERT mit Platzhaltern

$stmt = $sql->insert('person',
    per_id => \'?',
    per_vorname => \'?',
    per_nachname => \'?',
    per_geburtstag => \'?',
);

INSERT INTO person
(
    per_id,
    per_vorname,
    per_nachname,
    per_geburtstag
)
VALUES
(
    ?,
    ?,
    ?,
    ?
)

insertMulti() - Generiere INSERT-Statement mit mehreren Zeilen

Synopsis

$stmt = $sql->insertMulti($table,\@keys,[
        [@vals1],
        [@vals2],
        ...
    ]
);

Description

Generiere ein INSERT-Statement für Tabelle $table mit den Kolumnen @keys und den Datensätzen @records. @records ist eine Liste von Arrays mit gleich vielen Elementen wie @keys.

Example

$stmt = $sql->insertMulti('person',
    [qw/per_id per_vorname per_nachname per_geburtstag/],[
        [qw/1 Linus Seitz 2002-11-11/],
        [qw/2 Hanno Seitz 2000-04-07/],
        [qw/3 Emily Philippi 1997-05-05/],
    ]
);
=>
INSERT INTO person
    (per_id, per_vorname, per_nachname, per_geburtstag)
VALUES
    ('1', 'Linus', 'Seitz', '2002-11-11'),
    ('2', 'Hanno', 'Seitz', '2000-04-07')
    ('3', 'Emily', 'Philippi', '1997-05-05')

update() - Generiere UPDATE Statement

Synopsis

$stmt = $sql->update($table,@keyVal,-where,@where);

Example

$stmt = $sql->update('person',
    per_geburtstag => '7.4.2000',
    -where,per_id => 4711,
);

delete() - Generiere DELETE Statement

Synopsis

$stmt = $sql->delete($table,@opt,@where);

Options

-hint => $hint (Default: undef): Füge Hint (Oracle) in Statement ein.

Operators and Functions

Vergleichsoperatoren: <EXPR> <OP> <EXPR>

!=
<
<=
=
>
>=
(NOT) BETWEEN
(NOT) IN
(NOT) LIKE

Aggregatfunktionen: <OP>(<EXPR>)

Implement.
------------
AVG
COUNT
MAX
MIN
SUM
              Oracle       PostgreSQL   SQLite       MySQL
              ------------ ------------ ------------ ------------
                                        GROUP_CONCAT
                                        TOTAL

Funktionen: <OP>(<EXPR>,...)

Implement.    Oracle       PostgreSQL   SQLite       MySQL
------------- ------------ ------------ ------------ ------------
                                        ABS
                                        COALESCE
                                        GLOB
                                        IFNULL
                                        HEX
                                        LENGTH
LOWER         LOWER        LOWER        LOWER
                                        LTRIM
                                        MAX
                                        MIN
                                        NULLIF
                                        QUOTE
                                        RANDOM
                                        RANDOMBLOB
                                        REPLACE
                                        ROUND
                                        RTRIM
SUBSTR        SUBSTR       SUBSTR       SUBSTR
                                        TRIM
                                        TYPEOF
UPPER         UPPER        UPPER        UPPER
CAT           ||                        ||

opFunc() - Generiere Funktionsaufruf

Synopsis

$sqlExpr = $sql->opFunc($op,@args);

Description

Generiere Funktionsaufruf "<OP>(<EXPR1>, <EXPR2>, ...)" und liefere diesen zurück.

Diese Methode wird zur Generierung von portablen Funktionsausdrücken wie UPPER, LOWER, MIN, MAX, SUBSTR, etc. benutzt.

opRel() - Generiere rechte Seite eines Vergleichsausdrucks

Synopsis

$sqlExpr = $sql->opRel($op,$arg);

Description

Generiere Ausdruck "<OP> <EXPR>" und liefere diesen zurück.

opAS() - Generiere AS-Ausdruck (Alias)

Synopsis

$sqlExpr = $sql->opAS($op,$arg,$name);

Description

Generiere Ausdruck "<EXPR> AS <NAME>" und liefere diesen zurück.

opBETWEEN() - Generiere BETWEEN-Ausdruck

Synopsis

$sqlExpr = $sql->opBETWEEN($op,$arg1,$arg2);

Description

Generiere Ausdruck "BETWEEN <EXPR1> AND <EXPR2>" und liefere diesen zurück.

opCASEXPR() - Generiere CASE-Ausdruck

Synopsis

$sqlExpr = $sql->opCASEXPR($op,@args);

Description

Für diff() implementiert, funktioniert aber nicht.

opCAST() - Generiere CAST-Ausdruck (Wandlung Datentyp)

Synopsis

$sqlExpr = $sql->opCAST($op,$dataType,$arg);

opIN() - Generiere IN- oder NOT IN-Ausdruck

Synopsis

$sqlExpr = $sql->opIN($op,@arr);

Description

Generiere Ausdruck "IN / NOT IN (VAL1, VAL2, ...)" und liefere diesen zurück.

Expressions

keyExpr() - Generiere SQL Identifier-Ausdruck

Synopsis

$sqlExpr = $sql->keyExpr($expr);

Description

Generiere einen SQL Bezeichner-Ausdruck zum portablen Ausdruck $expr und liefere den generierten Ausdruck zurück.

Ein Bezeichner-Ausdruck ist ein Ausdruck, wie er in der Select-Liste und auf der linken Seite von WHERE-Klausel-Bedingungen vorkommt. Er zeichnet sich dadurch aus, dass seine elementaren Komponenten ungequotete Bezeichner sind (und keine Werte).

Example

Einfacher Bezeichner
```
$sql->keyExpr('per_id');
==>
"per_id"
```

Ausdruck als Zeichenkette (nicht empfohlen, da nicht portabel)

$sql->keyExpr('UPPER(per_nachname)');
==>
"UPPER(per_nachname)"

Portabler Ausdruck

$sql->keyExpr(['UPPER',['per_nachname']]);
==>
"UPPER(per_nachname)"

Portabler Ausdruck mit Stringreferenz (wird String-Literal)

$sql->keyExpr(['UPPER',[\'Ratlos']]);
==>
"UPPER('Ratlos')"

valExpr() - Generiere SQL Wert-Ausdruck

Synopsis

$sqlExpr = $sql->valExpr($expr);

Description

Generiere einen SQL Wert-Ausdruck zum portablen Ausdruck $expr und liefere den generierten Ausdruck zurück.

Ein Wert-Ausdruck ist ein Ausdruck, wie er auf der rechten Seite von WHERE-Klausel-Bedingungen vorkommt. Er zeichnet sich dadurch aus, dass seine elementaren Komponenten Literale, keine Bezeichner sind.

Example

Literal

$sql->valExpr('Kai Nelust');
==>
"'Kai Nelust'"

Ausdruck

$sql->valExpr(\'USERNAME');
==>
"USERNAME"

Portabler Ausdruck

$sql->valExpr(['UPPER','Kai Nelust']);
==>
"UPPER('Kai Nelust')"

Portabler Ausdruck mit Stringreferenz (wird Identifier-Ausdruck)
```
$sql->valExpr(['LOWER',\'USERNAME']);
==>
"LOWER(USERNAME)"
```

whereExpr() - Generiere rechte Seite eines WHERE-Ausdrucks

Synopsis

$sqlExpr = $sql->whereExpr($expr);

Description

Generiere die rechte Seite eines WHERE-Ausdrucks zum portablen Ausdruck $expr und liefere den generierten Ausdruck zurück.

Der Ausdruck besteht aus einem Operator gefolgt von einem Wert-Ausdruck.

Example

Literal

$sql->whereExpr('Kai Nelust');
==>
"= 'Kai Nelust'"

Ausdruck

$sql->whereExpr(\'USERNAME');
==>
"= USERNAME"

Portabler Ausdruck

$sql->whereExpr(['!=',['UPPER','Kai Nelust']]);
==>
"!= UPPER('Kai Nelust')"

Portabler Ausdruck mit Stringreferenz (wird Identifier-Ausdruck)

$sql->whereExpr(['!=',['LOWER',\'USERNAME']]);
==>
"!= LOWER(USERNAME)"

expr() - Wandele portablen Ausdruck in SQL-Ausdruck

Synopsis

$str = $sql->expr($type,$op,@args);

stringLiteral() - Generiere SQL Stringliteral

Synopsis

$literal = $sql->stringLiteral($str);
$literal = $sql->stringLiteral($str,$default);

Description

Verdoppele alle in $str enthaltenen einfachen Anführungsstriche, fasse den gesamten String in einfache Anführungsstriche ein und liefere das Resultat zurück.

Ist der String leer ('' oder undef) liefere einen Leerstring (kein leeres String-Literal!). Ist $default angegeben, liefere diesen Wert.

Anmerkung: PostgreSQL erlaubt aktuell Escape-Sequenzen in String-Literalen. Wir behandeln diese nicht. Escape-Sequenzen sollten in postgresql.conf abgeschaltet werden mit der Setzung:

standard_conforming_strings = on

Examples

Eingebettete Anführungsstriche:

$sel->stringLiteral('Sie hat's');
=>
"'Sie hat''s'"

Leerstring, wenn kein Wert:

$sel->stringLiteral('');
=>
""

'NULL', wenn kein Wert:

$sel->stringLiteral('','NULL');
=>
"NULL"

withClause() - Liefere WITH-Klausel

Synopsis

$withClause = $sql->withClause(@keyVal);

Description

Wandele die Liste von Schlüssel/Wert-Paaren @keyVal in eine WITH-Klausel (ohne WITH-Schlüsselwort) und liefere diese zurück. Der Wert ist jeweils ein SELECT-Statement und der Schlüssel ein Bezeichner für das Statement.

Example

$sql->withClause(x=>'SELECT * FROM a',y=>'SELECT * FROM b');

liefert

x AS (
    SELECT * FROM a
),
y AS (
    SELECT * FROM b
)

selectClause() - Liefere SELECT-Klausel

Synopsis

$selectClause = $sql->selectClause(@select);

fromClause() - Liefere FROM-Klausel

Synopsis

$fromClause = $sql->fromClause(@from);

Description

Wandele die Liste von From-Elementen, @from, in eine FROM-Klausel und liefere diese zurück.

Die Elemente werden mit Komma als Trennzeichen konkateniert und folgendermaßen behandelt:

'string': Eine Zeichenkette wird nicht verändert.
['AS',$alias,$fromExpr]: Es wird ein FROM-Alias erzeugt. Dieser hat entweder den Aufbau "expr AS alias" oder "fromExpr alias", abhängig vom DBMS. Oracle akzeptiert "fromExpr AS alias" nicht.

whereClause() - Liefere WHERE-Klausel

Synopsis

$where = $sql->whereClause(@where);

Description

Wenn +null in @where vorkommt, werden alle folgenden leeren Bedingungen nicht übergangen.

setClause() - Liefere SET-Klausel für UPDATE-Statement

Synopsis

$set = $sql->setClause(@keyVal);

exists() - Liefere EXISTS-Klausel

Synopsis

$str = $sql->exists(@opt,@select);

Options

-active => $bool (Default: 1): Bedingung, unter der die EXISTS-Klausel gilt. Ist $bool falsch, liefert die Methode eine leere Liste (Array-Kontext) oder einen Leerstring (Skalar-Kontext), d.h. die Klausel kann in der Verarbeitung ignoriert werden.
-not => $bool (Default: 0): Liefere NOT EXISTS Klausel.

notExists() - Liefere NOT EXISTS-Klausel

Synopsis

$str = $sql->notExists(@select);

union() - Verknüpfe Statements mit UNION

Synopsis

$stmt = $sql->union(@stmts);

Arguments

@stmts: Statements, die mit UNION verknpft werden.

Returns

String

Description

Verknüpfe die (SELECT-)Statements @stmts per UNION und liefere das resultierende Statement zurück.

Spezielle Konstrukte

diff() - Liefere SELECT zur Differenzermittlung

Synopsis

$stmt = $sql->diff(
    $keyCol,
    $fromClause,
    [$type,$col1,$col2,$col2Expr],
    ...
    @where,
    @selOpts
);

Example

$tab = $db->diff(
    't.id',
    "de_ticket t LEFT OUTER JOIN spielgemeinschaftanteil s\n".
    'ON t.id = s.spielid*65536+1',
    ['N','t.subscription'=>'s.dauerschein'],
    ['N','t.product_id'=>'s.spielgemeinschaftid',
        \'CASE %C WHEN 9685 THEN 24 WHEN 9684 THEN 26 WHEN 9687 THEN 28 END',
    ],
    't.product_ticket_type'=>'LOTTERY_CLUB_TICKET',
    -limit => 100,
);

VERSION

1.220

AUTHOR

Frank Seitz, http://fseitz.de/

COPYRIGHT

LICENSE

This code is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

To install Quiq, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Quiq

CPAN shell

perl -MCPAN -e shell
install Quiq

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)