Beispiele
select rdb$get_context('SYSTEM', 'DB_NAME') from rdb$database
New.UserAddr = rdb$get_context('SYSTEM', 'CLIENT_ADDRESS');
insert into MyTable (TestField)
values (rdb$get_context('USER_SESSION', 'MyVar'))
Funktionen für Sequenzen (Generatoren)
select rdb$get_context('SYSTEM', 'DB_NAME') from rdb$database
New.UserAddr = rdb$get_context('SYSTEM', 'CLIENT_ADDRESS');
insert into MyTable (TestField)
values (rdb$get_context('USER_SESSION', 'MyVar'))
RDB$SET_CONTEXT()
DSQL, PSQL * Als deklariertes UDF sollte es in ESQL verfügbar sein
INTEGER
RDB$SET_CONTEXT ('<namespace>', <varname>, <value> | NULL) <namespace> ::= USER_SESSION | USER_TRANSACTION <varname> ::= Eine Zeichenfolge in Anführungszeichen von max. 80 Zeichen <value> ::= Ein Wert beliebiger Art, solange er umsetzbar ist zu einem VARCHAR(255)
Parameter | Beschreibung |
---|---|
namespace |
Namespace |
varname |
Variablenname.Groß-/Kleinschreibung beachten.Die maximale Länge beträgt 80 Zeichen |
value |
Daten eines beliebigen Typs, sofern sie in |
Erstellt, setzt oder hebt eine Variable in einem der vom Benutzer beschreibbaren Namensräume USER_SESSION
und USER_TRANSACTION
auf.
Die Namensräume USER_SESSION
und USER_TRANSACTION
sind zunächst leer.Der Benutzer kann mit RDB$SET_CONTEXT()
Variablen darin erstellen und setzen und mit RDB$GET_CONTEXT()
abrufen.Der Kontext USER_SESSION
ist an die aktuelle Verbindung gebunden.Variablen in USER_TRANSACTION
existieren nur in der Transaktion, in der sie gesetzt wurden.Wenn die Transaktion endet, werden der Kontext und alle darin definierten Variablen zerstört.
Die Funktion gibt 1
zurück, wenn die Variable bereits vor dem Aufruf existierte und 0
wenn dies nicht der Fall war.Um eine Variable aus einem Kontext zu entfernen, setzen Sie sie auf NULL
.Wenn der angegebene Namespace nicht existiert, wird ein Fehler ausgegeben.Sowohl Namensraum- als auch Variablennamen müssen in einfachen Anführungszeichen eingegeben werden, wobei die Groß-/Kleinschreibung beachtet werden muss, nicht NULL
-Zeichenfolgen.
Note
|
|
select rdb$set_context('USER_SESSION', 'MyVar', 493) from rdb$database
rdb$set_context('USER_SESSION', 'RecordsFound', RecCounter);
select rdb$set_context('USER_TRANSACTION', 'Savepoints', 'Yes')
from rdb$database
DECFLOAT
COMPARE_DECFLOAT()
DSQL, PSQL
SMALLINT
COMPARE_DECFLOAT (decfloat1, decfloat2)
Parameter | Beschreibung |
---|---|
decfloatn |
Wert oder Ausdruck vom Typ |
COMPARE_DECFLOAT
vergleicht zwei DECFLOAT
-Werte als gleich, unterschiedlich oder ungeordnet.Das Ergebnis ist ein SMALLINT
-Wert wie folgt:
0
|
Werte sind identisch |
1
|
Erster Wert ist kleiner als der zweite Wert |
2
|
Erster Wert ist größer als der zweite Wert |
3
|
Die Werte sind ungeordnet, d. h. einer oder beide sind |
Im Gegensatz zu den Vergleichsoperatoren (‘<
’, ‘=
’, ‘>
’ usw.) ist der Vergleich exakt: COMPARE_DECFLOAT(2.17, 2.170) ` gibt `2
zurück, nicht 0
.
NORMALIZE_DECFLOAT()
DSQL, PSQL
DECFLOAT
NORMALIZE_DECFLOAT (decfloat_value)
Parameter | Beschreibung |
---|---|
decfloat_value |
Wert oder Ausdruck vom Typ |
NORMALIZE_DECFLOAT
nimmt ein einzelnes DECFLOAT
-Argument und gibt es in seiner einfachsten Form zurück.Das bedeutet, dass für jeden Wert ungleich Null nachfolgende Nullen mit entsprechender Exponentenkorrektur entfernt werden.
NORMALIZE_DECFLOAT
-- Gibt 12 zurück
select normalize_decfloat(12.00)
from rdb$database;
-- Gibt 1.2E+2 zurück
select normalize_decfloat(120)
from rdb$database;
QUANTIZE()
DSQL, PSQL
QUANTIZE (decfloat_value, exp_value)
Parameter | Beschreibung |
---|---|
decfloat_value |
Wert oder Ausdruck zum Quantisieren;muss vom Typ |
exp_value |
Wert oder Ausdruck, der für seinen Exponenten verwendet werden soll;muss vom Typ |
QUANTIZE
gibt einen DECFLOAT
-Wert zurück, der in Wert und Vorzeichen (außer Rundung) gleich decfloat_value ist und der einen Exponenten hat, der gleich dem Exponenten von exp_value ist.Der Rückgabewert ist DECFLOAT(16)
, wenn beide Argumente DECFLOAT(16)
sind, andernfalls ist der Ergebnistyp DECFLOAT(34)
.
Note
|
Der Zielexponent ist der Exponent, der im Speicherformat |
Wenn der Exponent von decfloat_value größer als der von exp_value ist, wird der Koeffizient von decfloat_value mit einer Zehnerpotenz multipliziert und sein Exponent verringert, ist der Exponent kleiner, dann wird sein Koeffizient mit dem aktuellen decfloat-Rundungsmodus gerundet, und seine Exponent wird erhöht.
Wenn es nicht möglich ist, den Zielexponenten zu erreichen, weil der Koeffizient die Zielgenauigkeit (16 oder 34 Dezimalstellen) überschreiten würde, wird entweder ein Fehler “Decfloat float invalid operation” ausgegeben oder NaN
zurückgegeben (je nach aktuellem) Konfiguration der decfloat Traps).
Es gibt fast keine Einschränkungen für den exp_value.In fast allen Anwendungen erzeugt NaN
/sNaN
/Infinity
jedoch eine Ausnahme (sofern dies nicht durch die aktuelle decfloat-Traps-Konfiguration erlaubt ist), NULL
lässt die Funktion NULL
zurückgeben und so weiter.
QUANTIZE
select v, pic, quantize(v, pic) from examples;
V PIC QUANTIZE
====== ====== ========
3.16 0.001 3.160
3.16 0.01 3.16
3.16 0.1 3.2
3.16 1 3
3.16 1E+1 0E+1
-0.1 1 -0
0 1E+5 0E+5
316 0.1 316.0
316 1 316
316 1E+1 3.2E+2
316 1E+2 3E+2
TOTALORDER()
DSQL, PSQL
SMALLINT
TOTALORDER (decfloat1, decfloat2)
Parameter | Beschreibung |
---|---|
decfloatn |
Wert oder Ausdruck vom Typ |
TOTALORDER
vergleicht zwei DECFLOAT
-Werte einschließlich aller Sonderwerte.Der Vergleich ist genau und gibt ein SMALLINT
zurück, eines der folgenden:
-1
|
Erster Wert is kleiner als der zweite |
0
|
Werte sind identisch |
1
|
Erster Wert ist größer als der zweite |
Für TOTALORDER
-Vergleiche werden die DECFLOAT
-Werte wie folgt geordnet:
-NaN < -sNaN < -INF < -0.1 < -0.10 < -0 < 0 < 0.10 < 0.1 < INF < sNaN < NaN
DECRYPT()
DSQL, PSQL
VARBINARY
oder BLOB
DECRYPT ( encrypted_input
USING <algorithm> [MODE <mode>]
KEY key
[IV iv] [<ctr_type>] [CTR_LENGTH ctr_length]
[COUNTER initial_counter] )
!! Vgl. auch die Syntax von <<fblangref40-scalarfuncs-encrypt-de,ENCRYPT
>> für weitere Details !!
Parameter | Beschreibung |
---|---|
encrypted_input |
Verschlüsselte Eingabe als Blob oder (binärer) String |
Siehe auch [fblangref40-scalarfuncs-tbl-encrypt-de] für weitere Parameter |
DECRYPT
entschlüsselt Daten mit einer symmetrischen Verschlüsselung.
Note
|
|
DECRYPT
-Beispieleselect decrypt(x'0154090759DF' using sober128 key 'AbcdAbcdAbcdAbcd' iv '01234567')
from rdb$database;
select decrypt(secret_field using aes mode ofb key '0123456701234567' iv init_vector)
from secure_table;
ENCRYPT()
DSQL, PSQL
VARBINARY
oder BLOB
ENCRYPT ( input USING <algorithm> [MODE <mode>] KEY key [IV iv] [<ctr_type>] [CTR_LENGTH ctr_length] [COUNTER initial_counter] ) <algorithm> ::= <block_cipher> | <stream_cipher> <block_cipher> ::= AES | ANUBIS | BLOWFISH | KHAZAD | RC5 | RC6 | SAFER+ | TWOFISH | XTEA <stream_cipher> ::= CHACHA20 | RC4 | SOBER128 <mode> ::= CBC | CFB | CTR | ECB | OFB <ctr_type> ::= CTR_BIG_ENDIAN | CTR_LITTLE_ENDIAN
Parameter | Beschreibung |
---|---|
input |
Eingabe zum Verschlüsseln als Blob oder (binäre) Zeichenfolge |
algorithm |
Der für die Entschlüsselung zu verwendende Algorithmus |
mode |
Der Algorithmusmodus;nur für Blockchiffren |
key |
Der Verschlüsselungs-/Entschlüsselungsschlüssel |
iv |
Initialisierungsvektor oder Nonce;sollte für Blockchiffren in allen Modi außer „ECB“ und für alle Stromchiffren außer „RC4“ angegeben werden |
ctr_type |
Endianität des Zählers;nur für |
ctr_length |
Zählerlänge;nur für |
initial_counter |
Anfangszählerwert;nur für |
ENCRYPT
kann Daten mit einer symmetrischen Verschlüsselung verschlüsseln.
Note
|
|
Algorithm | Schlüsselgröße (Bytes) | Blockgröße (Bytes) | Hinweise |
---|---|---|---|
Blockchiffren |
|||
|
16, 24, 32 |
16 |
|
|
16 - 40, in 4er-Schritten |
16 |
|
|
8 - 56 |
8 |
|
|
16 |
8 |
|
|
8 - 128 |
8 |
|
|
8 - 128 |
16 |
|
|
16, 24, 32 |
16 |
|
|
16, 24, 32 |
16 |
|
|
16 |
8 |
|
Stream-Chiffren |
|||
|
16, 32 |
1 |
Die Nonce-Größe (IV) beträgt 8 oder 12 Byte.Für Nonce-Größe 8 ist initial_counter eine 64-Bit-Ganzzahl, für Größe 12 32-Bit. |
|
5 - 256 |
1 |
|
|
4x |
1 |
Nonce-Größe (IV) beträgt 4y Byte, die Länge ist unabhängig von der Schlüsselgröße. |
ENCRYPT
-Beispieleselect encrypt('897897' using sober128 key 'AbcdAbcdAbcdAbcd' iv '01234567')
from rdb$database;
RSA_DECRYPT()
DSQL, PSQL
VARBINARY
RSA_DECRYPT (encrypted_input KEY private_key [LPARAM tag_string] [HASH <hash>] [PKCS_1_5]) <hash> ::= MD5 | SHA1 | SHA256 | SHA512
Parameter | Beschreibung |
---|---|
encrypted_input |
Input data to decrypt |
private_key |
Anzuwendender privater Schlüssel, PKCS#1-Format |
tag_string |
Ein zusätzliches systemspezifisches Tag, um zu identifizieren, welches System die Nachricht verschlüsselt hat;Standard ist |
hash |
Der für OAEP-Padding verwendete Hash;Standard ist |
RSA_DECRYPT
entschlüsselt encrypted_input mit dem privaten RSA-Schlüssel und dann entpackt OAEP die resultierenden Daten.
Standardmäßig wird OAEP-Padding verwendet.Die Option „PKCS_1_5“ wechselt zum weniger sicheren PKCS 1.5-Padding.Diese Option wurde in Firebird 4.0.1 eingeführt.
Warning
|
Die Option |
Note
|
|
RSA_DECRYPT
-Beispiele
Tip
|
Führen Sie die Beispiele |
select cast(rsa_decrypt(rdb$get_context('USER_SESSION', 'msg')
key rdb$get_context('USER_SESSION', 'private_key')) as varchar(128))
from rdb$database;
RSA_ENCRYPT()
DSQL, PSQL
VARBINARY
RSA_ENCRYPT (input KEY public_key [LPARAM tag_string] [HASH <hash>] [PKCS_1_5]) <hash> ::= MD5 | SHA1 | SHA256 | SHA512
Parameter | Beschreibung |
---|---|
input |
Eingabedaten zum Verschlüsseln |
public_key |
Öffentlicher Schlüssel zum Anwenden, PKCS#1-Format |
tag_string |
Ein zusätzliches systemspezifisches Tag, um zu identifizieren, welches System die Nachricht verschlüsselt hat;Standard ist |
hash |
Der für OAEP-Padding verwendete Hash;Standard ist |
RSA_ENCRYPT
füllt input mit dem OAEP-Padding-Schema auf und verschlüsselt es dann mit dem angegebenen öffentlichen RSA-Schlüssel.Diese Funktion wird normalerweise verwendet, um kurze symmetrische Schlüssel zu verschlüsseln, die dann in Blockchiffren verwendet werden, um eine Nachricht zu verschlüsseln.
Standardmäßig wird OAEP-Padding verwendet.Die Option PKCS_1_5
wechselt zum weniger sicheren PKCS 1.5-Padding.Diese Option wurde in Firebird 4.0.1 eingeführt.
Warning
|
Die Option |
RSA_ENCRYPT
-Beispiele
Tip
|
Führen Sie zuerst die Beispiele der Funktionen |
select rdb$set_context('USER_SESSION', 'msg', rsa_encrypt('Some message'
key rdb$get_context('USER_SESSION', 'public_key'))) from rdb$database;
RSA_PRIVATE()
DSQL, PSQL
VARBINARY
RSA_PRIVATE (key_length)
Parameter | Beschreibung |
---|---|
key_length |
Schlüssellänge in Byte;mindestens 4, maximal 1024.Eine Größe von 256 Byte (2048 Bit) oder größer wird empfohlen. |
RSA_PRIVATE
generiert einen privaten RSA-Schlüssel der angegebenen Länge (in Bytes) im PKCS#1-Format.
Note
|
Je größer die angegebene Länge, desto länger dauert es, bis die Funktion einen privaten Schlüssel generiert. |
RSA_PRIVATE
-Beispielselect rdb$set_context('USER_SESSION', 'private_key', rsa_private(256))
from rdb$database;
Warning
|
Das Einfügen privater Schlüssel in die Kontextvariablen ist nicht sicher.SYSDBA und Benutzer mit der Rolle |
RSA_PUBLIC()
DSQL, PSQL
VARBINARY
RSA_PUBLIC (private_key)
Parameter | Beschreibung |
---|---|
private_key |
Privater RSA-Schlüssel im PKCS#1-Format |
RSA_PUBLIC
gibt den öffentlichen RSA-Schlüssel im PKCS#1-Format für den bereitgestellten privaten RSA-Schlüssel (auch PKCS#1-Format) zurück.
RSA_PUBLIC
-Beispiele
Tip
|
Führen Sie zuerst das Beispiel der Funktion |
select rdb$set_context('USER_SESSION', 'public_key',
rsa_public(rdb$get_context('USER_SESSION', 'private_key'))) from rdb$database;
RSA_SIGN_HASH()
DSQL, PSQL
VARBINARY
RSA_SIGN_HASH (message_digest KEY private_key [HASH <hash>] [SALT_LENGTH salt_length] [PKCS_1_5]) <hash> ::= MD5 | SHA1 | SHA256 | SHA512
Parameter | Beschreibung |
---|---|
message_digest |
Hash der zu unterschreibenden Nachricht.Der verwendete Hash-Algorithmus sollte mit hash übereinstimmen. |
private_key |
Privater RSA-Schlüssel im PKCS#1-Format |
hash |
Hash zum Generieren von PSS-Codierung;Standard ist |
salt_length |
Länge des gewünschten Salts in Bytes;Standard ist 8;mindestens 1, maximal 32.Der empfohlene Wert liegt zwischen 8 und 16. |
RSA_SIGN_HASH
führt die PSS-Kodierung des zu signierenden message_digest durch und signiert mit dem privaten RSA-Schlüssel.
Caution
|
Diese Funktion erwartet den Hash einer Nachricht (oder Message Digest), nicht die eigentliche Nachricht.Das Argument hash sollte den Algorithmus angeben, der auch verwendet wurde, um diesen Hash zu generieren. Eine Funktion, die die eigentliche Nachricht zum Hash akzeptiert, könnte in einer zukünftigen Version von Firebird eingeführt werden. |
Probabilistic Signature Scheme (PSS) ist ein kryptografisches Signaturschema, das speziell entwickelt wurde, um moderne Methoden der Sicherheitsanalyse zu ermöglichen, um zu beweisen, dass seine Sicherheit direkt mit der des RSA-Problems zusammenhängt.Es gibt keinen solchen Beweis für das traditionelle PKCS#1 v1.5-Schema.
RSA_SIGN_HASH
-Beispiele
Tip
|
Führen Sie zuerst das Beispiel der Funktion |
select rdb$set_context('USER_SESSION', 'msg',
rsa_sign_hash(crypt_hash('Test message' using sha256)
key rdb$get_context('USER_SESSION', 'private_key'))) from rdb$database;
RSA_VERIFY_HASH()
DSQL, PSQL
BOOLEAN
RSA_VERIFY_HASH (message_digest SIGNATURE signature KEY public_key [HASH <hash>] [SALT_LENGTH salt_length] [PKCS_1_5]) <hash> ::= MD5 | SHA1 | SHA256 | SHA512
Parameter | Beschreibung |
---|---|
message_digest |
Hash der zu überprüfenden Nachricht.Der verwendete Hash-Algorithmus sollte mit hash übereinstimmen. |
signature |
Erwartete Signatur von input generiert von |
public_key |
öffentlicher RSA-Schlüssel im PKCS#1-Format, der dem zum Signieren verwendeten privaten Schlüssel entspricht |
hash |
Hash für den Message Digest;Standard ist |
salt_length |
Länge des Salts in Bytes;Standard ist 8;mindestens 1, maximal 32.Der Wert muss der in |
RSA_VERIFY_HASH
führt die PSS-Kodierung des zu verifizierenden message_digest durch und verifiziert die digitale Signatur unter Verwendung des bereitgestellten öffentlichen RSA-Schlüssels.
Standardmäßig wird OAEP-Padding verwendet.Die Option PKCS_1_5
wechselt zum weniger sicheren PKCS 1.5-Padding.Diese Option wurde in Firebird 4.0.1 eingeführt.
Warning
|
Die Option |
Caution
|
Diese Funktion erwartet den Hash einer Nachricht (oder Message Digest), nicht die eigentliche Nachricht.Das Argument hash sollte den Algorithmus angeben, der auch verwendet wurde, um diesen Hash zu generieren. Eine Funktion, die die eigentliche Nachricht zum Hash akzeptiert, könnte in einer zukünftigen Version von Firebird eingeführt werden. |
RSA_VERIFY_HASH
-Beispiele
Tip
|
Führen Sie die Beispiele |
select rsa_verify_hash(
crypt_hash('Test message' using sha256)
signature rdb$get_context('USER_SESSION', 'msg')
key rdb$get_context('USER_SESSION', 'public_key'))
from rdb$database
Funktionen, die in keine andere Kategorie passen.
MAKE_DBKEY()
DSQL, PSQL
BINARY(8)
MAKE_DBKEY (relation, recnum [, dpnum [, ppnum]])
Parameter | Beschreibung |
---|---|
relation |
Relationsname oder Relations-ID |
recnum |
Datensatznummer.Entweder absolut (wenn dpnum und ppnum fehlen) oder relativ (wenn dpnum vorhanden) |
dpnum |
Datenseitennummer.Entweder absolut (wenn ppnum nicht vorhanden ist) oder relativ (wenn ppnum vorhanden ist) |
ppnum |
Seitennummer des Zeigers. |
MAKE_DBKEY
erstellt einen DBKEY-Wert unter Verwendung eines Beziehungsnamens oder einer ID, einer Datensatznummer und (optional) einer logischen Nummer der Datenseite und der Zeigerseite.
Note
|
|
MAKE_DBKEY
Wählen Sie den Datensatz mit dem Beziehungsnamen aus (beachten Sie, dass der Beziehungsname in Großbuchstaben geschrieben ist)
select *
from rdb$relations
where rdb$db_key = make_dbkey('RDB$RELATIONS', 0)
Datensatz mit Beziehungs-ID auswählen
select *
from rdb$relations
where rdb$db_key = make_dbkey(6, 0)
Wählen Sie alle Datensätze aus, die sich physisch auf der ersten Datenseite befinden
select *
from rdb$relations
where rdb$db_key >= make_dbkey(6, 0, 0)
and rdb$db_key < make_dbkey(6, 0, 1)
Wählen Sie alle Datensätze aus, die sich physisch auf der ersten Datenseite der 6. Zeigerseite befinden
select *
from SOMETABLE
where rdb$db_key >= make_dbkey('SOMETABLE', 0, 0, 5)
and rdb$db_key < make_dbkey('SOMETABLE', 0, 1, 5)
RDB$ERROR()
PSQL
Variiert (siehe Tabelle unten)
RDB$ERROR (<context>) <context> ::= GDSCODE | SQLCODE | SQLSTATE | EXCEPTION | MESSAGE
Kontext | Rückgabetyp | Beschreibung |
---|---|---|
|
|
Firebird-Fehlercode, siehe auch |
|
|
(veraltet) SQL-Code, siehe auch |
|
|
SQLstate, siehe auch |
|
|
Name der aktiven benutzerdefinierten Ausnahme oder |
|
|
Nachrichtentext der aktiven Ausnahme |
RDB$ERROR
gibt Daten des angegebenen Kontexts über die aktive PSQL-Ausnahme zurück.Sein Geltungsbereich ist auf Ausnahmebehandlungsblöcke in PSQL beschränkt (WHEN … DO
).Außerhalb der Ausnahmebehandlungsblöcke gibt RDB$ERROR
immer NULL
zurück.Diese Funktion kann nicht aus DSQL aufgerufen werden.
BEGIN
...
WHEN ANY DO
EXECUTE PROCEDURE P_LOG_EXCEPTION(RDB$ERROR(MESSAGE));
END
Abfangen und Behandeln von Fehlern, GDSCODE
, SQLCODE
, SQLSTATE
RDB$GET_TRANSACTION_CN()
DSQL, PSQL
BIGINT
RDB$GET_TRANSACTION_CN (transaction_id)
Parameter | Beschreibung |
---|---|
transaction_id |
Transaktions-ID |
RDB$GET_TRANSACTION_CN
gibt die Commit-Nummer (“CN”) der übergebenen Transaktion zurück.
Wenn der Rückgabewert größer als 1 ist, ist dies der tatsächliche CN der Transaktion, wenn sie nach dem Start der Datenbank festgeschrieben wurde.
Die Funktion kann auch eines der folgenden Ergebnisse zurückgeben, das den Commit-Status der Transaktion angibt:
-2
|
Transaktion ist tot (zurückgerollt) |
-1
|
Transaktion ist in der Schwebe |
0
|
Transaktion ist aktiv |
1
|
Transaktion, die vor dem Start der Datenbank festgeschrieben wurde oder weniger als die älteste interessante Transaktion für die Datenbank ist |
NULL
|
Die angegebene Transaktionsnummer ist NULL oder größer als Nächste Transaktion für die Datenbank |
Note
|
Weitere Informationen zu CN finden Sie in den Firebird 4.0 Release Notes. |
RDB$GET_TRANSACTION_CN
-Beispieleselect rdb$get_transaction_cn(current_transaction) from rdb$database;
select rdb$get_transaction_cn(123) from rdb$database;
RDB$ROLE_IN_USE()
DSQL, PSQL
BOOLEAN
RDB$ROLE_IN_USE (role_name)
Parameter | Beschreibung |
---|---|
role_name |
Zeichenfolgenausdruck für die zu prüfende Rolle.Groß-/Kleinschreibung muss mit dem in |
RDB$ROLE_IN_USE
gibt TRUE zurück, wenn die angegebene Rolle für die aktuelle Verbindung aktiv ist, andernfalls FALSE.Im Gegensatz zu CURRENT_ROLE
— das nur die explizit angegebene Rolle zurückgibt — kann diese Funktion verwendet werden, um nach Rollen zu suchen, die standardmäßig aktiv sind, oder auf kumulative Rollen, die von einem explizit aktiviert wurden angegebene Rolle.
RDB$ROLE_IN_USE
-Beispielselect rdb$role_name
from rdb$database
where rdb$role_in_use(rdb$role_name);
RDB$SYSTEM_PRIVILEGE()
DSQL, PSQL
BOOLEAN
RDB$SYSTEM_PRIVILEGE (<sys_privilege>)
<sys_privilege> ::=
!! Siehe auch CREATE ROLE
!!
Parameter | Beschreibung |
---|---|
sys_privilege |
Systemprivileg |
RDB$SYSTEM_PRIVILEGE
akzeptiert einen Systemprivilegnamen und gibt TRUE zurück, wenn der aktuelle Anhang das angegebene Systemprivileg hat, andernfalls FALSE.
RDB$SYSTEM_PRIVILEGE
-Beispielselect rdb$system_privilege(user_management) from rdb$database;
ABS()
DSQL, PSQL
YES → Details lesen
Numerisch
ABS (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt den absoluten Wert des Arguments zurück.
COS()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
COS (angle)
Parameter | Beschreibung |
---|---|
angle |
Ein Winkel im Bogenmaß |
Gibt den Kosinus eines Winkels zurück.Das Argument muss im Bogenmaß angegeben werden.
Jedes Ergebnis, das nicht NULL
ist, liegt — offensichtlich — im Bereich [-1, 1].
COSH()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
COSH (number)
Parameter | Beschreibung |
---|---|
number |
Eine Zahl eines numerischen Typs |
Gibt den hyperbolischen Kosinus des Arguments zurück.
Jedes Ergebnis, das nicht NULL
ist, liegt im Bereich [1, INF].
COT()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
COT (angle)
Parameter | Beschreibung |
---|---|
angle |
Ein Winkel im Bogenmaß |
Gibt den Kotangens eines Winkels zurück.Das Argument muss im Bogenmaß angegeben werden.
EXP()
DSQL, PSQL
DOUBLE PRECISION
EXP (number)
Parameter | Beschreibung |
---|---|
number |
Eine Zahl eines numerischen Typs |
Gibt die natürliche Exponentialfunktion zurück, enumber
FLOOR()
DSQL, PSQL
YES → Details lesen
BIGINT
für genaue numerische number, oder DOUBLE PRECISION
für fließkommagenaue number
FLOOR (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt die größte ganze Zahl zurück, die kleiner oder gleich dem Argument ist.
LN()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
LN (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt den natürlichen Logarithmus des Arguments zurück.
Ein Fehler wird ausgegeben, wenn das Argument negativ oder 0 ist.
LOG()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
LOG (x, y)
Parameter | Beschreibung |
---|---|
x |
Basis.Ein Ausdruck eines numerischen Typs |
y |
Ein Ausdruck eines numerischen Typs |
Gibt den x-basierten Logarithmus von y zurück.
Wenn eines der Argumente 0 oder kleiner ist, wird ein Fehler ausgegeben.(Vor 2.5 würde dies NaN
, +/-INF
oder 0 ergeben, abhängig von den genauen Werten der Argumente.)
Wenn beide Argumente 1 sind, wird NaN
zurückgegeben.
Wenn x = 1 und y < 1 ist, wird -INF
zurückgegeben.
Wenn x = 1 und y > 1 ist, wird INF
zurückgegeben.
LOG10()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
LOG10 (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt den 10-basierten Logarithmus des Arguments zurück.
Ein Fehler wird ausgegeben, wenn das Argument negativ oder 0 ist.(In Versionen vor 2.5 würden solche Werte zu NaN
bzw. -INF
führen.)
MOD()
DSQL, PSQL
YES → Details lesen
SMALLINT
, INTEGER
oder BIGINT
je nach Typ von a.Wenn a ein Gleitkommatyp ist, ist das Ergebnis ein BIGINT
.
MOD (a, b)
Parameter | Beschreibung |
---|---|
a |
Ein Ausdruck eines numerischen Typs |
b |
Ein Ausdruck eines numerischen Typs |
Gibt den Rest einer ganzzahligen Division zurück.
Nicht ganzzahlige Argumente werden vor der Division gerundet.“mod(7.5, 2.5)
” ergibt also 2 (“mod(8, 3)
”), nicht 0.
PI()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
PI ()
Gibt eine Annäherung an den Wert von pi zurück.
ACOS()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
ACOS (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs im Bereich [-1, 1] |
Gibt den Arkuskosinus des Arguments zurück.
Das Ergebnis ist ein Winkel im Bereich [0, pi].
POWER()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
POWER (x, y)
Parameter | Beschreibung |
---|---|
x |
Ein Ausdruck eines numerischen Typs |
y |
Ein Ausdruck eines numerischen Typs |
Gibt x hoch y (xy) zurück.
RAND()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
RAND ()
Gibt eine Zufallszahl zwischen 0 und 1 zurück.
ROUND()
DSQL, PSQL
YES → Details lesen
INTEGER
, (skaliert) BIGINT
oder DOUBLE PRECISION
ROUND (number [, scale])
Parameter | Description |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
scale |
Eine ganze Zahl, die die Anzahl der Nachkommastellen angibt, auf die gerundet werden soll, z. B.:
|
Rundet eine Zahl auf die nächste ganze Zahl.Wenn der Bruchteil genau '0,5' ist, wird bei positiven Zahlen nach oben und bei negativen Zahlen nach unten gerundet.Mit dem optionalen Argument scale kann die Zahl auf Zehnerpotenzen (Zehner, Hunderter, Zehntel, Hundertstel usw.) statt auf ganze Zahlen gerundet werden.
Important
|
Wenn Sie an das Verhalten der externen Funktion |
ROUND
-BeispieleWenn das Argument scale vorhanden ist, hat das Ergebnis normalerweise die gleiche Skalierung wie das erste Argument:
ROUND(123.654, 1) -- Ergebnis 123.700 (not 123.7)
ROUND(8341.7, -3) -- Ergebnis 8000.0 (not 8000)
ROUND(45.1212, 0) -- Ergebnis 45.0000 (not 45)
Andernfalls ist die Ergebnisskalierung 0:
ROUND(45.1212) -- Ergebnis 45
SIGN()
DSQL, PSQL
YES → Details lesen
SMALLINT
SIGN (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt das Vorzeichen des Arguments zurück: -1, 0 oder 1.
SIN()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
SIN (angle)
Parameter | Beschreibung |
---|---|
angle |
Ein Winkel im Bogenmaß |
Gibt den Sinus eines Winkels zurück.Das Argument muss im Bogenmaß angegeben werden.
Jedes Ergebnis, das nicht NULL
ist, liegt — offensichtlich — im Bereich [-1, 1].
SINH()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
SINH (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt den hyperbolischen Sinus des Arguments zurück.
SQRT()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
SQRT (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt die Quadratwurzel des Arguments zurück.
Wenn number negativ ist, wird ein Fehler ausgegeben.
TAN()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
TAN (angle)
Parameter | Beschreibung |
---|---|
angle |
Ein Winkel im Bogenmaß |
Gibt den Tangens eines Winkels zurück.Das Argument muss im Bogenmaß angegeben werden.
TANH()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
TANH (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt den hyperbolischen Tangens des Arguments zurück.
Aufgrund von Rundungen liegt jedes Ergebnis, das nicht NULL
ist, im Bereich [-1, 1] (mathematisch ist es <-1, 1>).
TRUNC()
DSQL, PSQL
INTEGER
, (scaled) BIGINT
or DOUBLE PRECISION
TRUNC (number [, scale])
Parameter | Description |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
scale |
Eine ganze Zahl, die die Anzahl der Dezimalstellen angibt, auf die abgeschnitten werden soll, z. B.:
|
Gibt den ganzzahligen Teil einer Zahl zurück.Mit dem optionalen Argument scale kann die Zahl auf Zehnerpotenzen (Zehner, Hunderter, Zehntel, Hundertstel usw.) statt auf ganze Zahlen gekürzt werden.
Note
|
|
Important
|
Wenn Sie an das Verhalten der externen Funktion |
ACOSH()
DSQL, PSQL
DOUBLE PRECISION
ACOSH (number)
Parameter | Beschreibung |
---|---|
number |
Jeder Nicht- |
Gibt den inversen hyperbolischen Kosinus des Arguments zurück.
Das Ergebnis liegt im Bereich [0, INF].
ASIN()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
ASIN (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs im Bereich [-1, 1] |
Gibt den Arkussinus des Arguments zurück.
Das Ergebnis ist ein Winkel im Bereich [-pi/2, pi/2].
ASINH()
DSQL, PSQL
DOUBLE PRECISION
ASINH (number)
Parameter | Beschreibung |
---|---|
number |
Jeder Nicht- |
Gibt den inversen hyperbolischen Sinus des Arguments zurück.
Das Ergebnis liegt im Bereich [-INF, INF].
ATAN()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
ATAN (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Die Funktion ATAN
gibt den Arkustangens des Arguments zurück.Das Ergebnis ist ein Winkel im Bereich <-pi/2, pi/2>.
ATAN2()
DSQL, PSQL
YES → Details lesen
DOUBLE PRECISION
ATAN2 (y, x)
Parameter | Beschreibung |
---|---|
y |
Ein Ausdruck eines numerischen Typs |
x |
Ein Ausdruck eines numerischen Typs |
Gibt den Winkel zurück, dessen Sinus-zu-Cosinus-Verhältnis durch die beiden Argumente gegeben ist und dessen Sinus- und Kosinus-Vorzeichen den Vorzeichen der Argumente entsprechen.Dies ermöglicht Ergebnisse über den gesamten Kreis, einschließlich der Winkel -pi/2 und pi/2.
Das Ergebnis ist ein Winkel im Bereich [-pi, pi].
Wenn x negativ ist, ist das Ergebnis pi, wenn y 0 ist, und -pi, wenn y -0 ist.
Wenn sowohl y als auch x 0 sind, ist das Ergebnis bedeutungslos.Ein Fehler wird ausgegeben, wenn beide Argumente 0 sind.
Eine vollständig äquivalente Beschreibung dieser Funktion ist die folgende: ATAN2(y, x)
ist der Winkel zwischen der positiven X-Achse und der Linie vom Ursprung zum Punkt (x, y).Damit ist auch klar, dass ATAN2(0, 0)
undefiniert ist.
Wenn x größer als 0 ist, ist ATAN2(y, x)
dasselbe wie ATAN(y/x)
.
Wenn sowohl Sinus als auch Kosinus des Winkels bereits bekannt sind, gibt ATAN2(sin, cos)
den Winkel an.
ATANH()
DSQL, PSQL
DOUBLE PRECISION
ATANH (number)
Parameter | Beschreibung |
---|---|
number |
Jeder Nicht- |
Gibt den inversen hyperbolischen Tangens des Arguments zurück.
Das Ergebnis ist eine Zahl im Bereich [-INF, INF].
CEIL()
, CEILING()
DSQL, PSQL
YES → Details lesen (Betrifft nur CEILING
)
BIGINT
für exakte numerische Zahl oder DOUBLE PRECISION
für Gleitkomma-Zahl
CEIL[ING] (number)
Parameter | Beschreibung |
---|---|
number |
Ein Ausdruck eines numerischen Typs |
Gibt die kleinste ganze Zahl zurück, die größer oder gleich dem Argument ist.
ASCII_CHAR()
DSQL, PSQL
YES → Details lesen
CHAR(1) CHARACTER SET NONE
ASCII_CHAR (code)
Parameter | Beschreibung |
---|---|
code |
Eine ganze Zahl im Bereich von 0 bis 255 |
Gibt das ASCII-Zeichen zurück, das der im Argument übergebenen Zahl entspricht.
Important
|
|
HEX_DECODE()
DSQL, PSQL
VARBINARY
oder BLOB
HEX_DECODE (hex_data)
Parameter | Beschreibung |
---|---|
hex_data |
Hex-kodierte Daten |
HEX_DECODE
decodiert einen String mit Hex-codierten Daten und gibt den decodierten Wert als VARBINARY
oder BLOB
entsprechend der Eingabe zurück.Wenn die Länge des Typs von hex_data kein Vielfaches von 2 ist, wird zur Vorbereitungszeit ein Fehler ausgegeben.Wenn die Länge des Wertes von hex_data kein Vielfaches von 2 ist, wird zur Ausführungszeit ein Fehler ausgegeben.
Wenn die Eingabe nicht 'BLOB' ist, wird die Länge des resultierenden Typs als 'type_length / 2' berechnet, wobei type_length die maximale Länge in Zeichen des Eingabetyps ist.
HEX_DECODE
select cast(hex_decode('48657861646563696D616C') as varchar(12))
from rdb$database;
CAST
============
Hexadecimal
HEX_ENCODE()
DSQL, PSQL
VARCHAR CHARACTER SET ASCII
oder BLOB SUB_TYPE TEXT CHARACTER SET ASCII
HEX_ENCODE (binary_data)
Parameter | Beschreibug |
---|---|
binary_data |
Binäre Daten (oder anderweitig in Binär umwandelbar) zum Codieren |
HEX_ENCODE
codiert binary_data mit Hex und gibt den codierten Wert als VARCHAR CHARACTER SET ASCII
oder BLOB SUB_TYPE TEXT CHARACTER SET ASCII
entsprechend der Eingabe zurück.
Wenn die Eingabe nicht 'BLOB' ist, wird die Länge des resultierenden Typs als 'type_length * 2' berechnet, wobei type_length die maximale Länge in Bytes des Eingabetyps ist.Überschreitet diese Länge die maximale Länge von VARCHAR
, gibt die Funktion ein BLOB
zurück.
HEX_ENCODE
select hex_encode('Hexadecimal')
from rdb$database;
HEX_ENCODE
======================
48657861646563696D616C
LEFT()
DSQL, PSQL
VARCHAR
oder BLOB
LEFT (string, length)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
length |
Ganzzahliger Ausdruck.Definiert die Anzahl der zurückzugebenden Zeichen |
Gibt den äußersten linken Teil der Argumentzeichenfolge zurück.Die Anzahl der Zeichen wird im zweiten Argument angegeben.
Diese Funktion unterstützt vollständig Text-BLOB
s jeder Länge, einschließlich solcher mit einem Multi-Byte-Zeichensatz.
Wenn string ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(n)
mit n der Länge des Eingabestrings.
Wenn das Argument length die Stringlänge überschreitet, wird der Eingabestring unverändert zurückgegeben.
Wenn das Argument length keine ganze Zahl ist, wird Banker-Rundung (auf gerade) angewendet, d. h. 0,5 wird zu 0, 1,5 wird zu 2, 2,5 wird zu 2, 3,5 wird zu 4 usw.
LOWER()
DSQL, ESQL, PSQL
(VAR)CHAR
, (VAR)BINARY
oder BLOB
LOWER (string)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
Gibt das Äquivalent der Eingabezeichenfolge in Kleinbuchstaben zurück.Das genaue Ergebnis hängt vom Zeichensatz ab.Bei ASCII
oder NONE
beispielsweise werden nur ASCII-Zeichen kleingeschrieben;mit OCTETS
wird der gesamte String unverändert zurückgegeben.Seit Firebird 2.1 unterstützt diese Funktion auch Text-BLOB
s beliebiger Länge und beliebigem Zeichensatz.
Note
|
Namenskonflikt
Da |
LOWER
-Beispieleselect Sheriff from Towns
where lower(Name) = 'cooper''s valley'
LPAD()
DSQL, PSQL
YES → Details lesen
VARCHAR
oder BLOB
LPAD (str, endlen [, padstr])
Parameter | Beschreibung |
---|---|
str |
Ein Ausdruck eines String-Typs |
endlen |
Länge der Ausgabezeichenfolge |
padstr |
Das Zeichen oder die Zeichenfolge, die verwendet werden soll, um die Quellzeichenfolge bis zur angegebenen Länge aufzufüllen.Standard ist Leerzeichen (“ |
Füllt eine Zeichenfolge mit der linken Maustaste mit Leerzeichen oder mit einer vom Benutzer angegebenen Zeichenfolge auf, bis eine bestimmte Länge erreicht ist.
Diese Funktion unterstützt vollständig Text BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn str ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(endlen)
.
Wenn padstr angegeben ist und gleich ''
(leerer String) ist, findet kein Auffüllen statt.
Wenn endlen kleiner als die aktuelle Stringlänge ist, wird der String auf endlen gekürzt, auch wenn padstr der leere String ist.
Note
|
In Firebird 2.1-2.1.3 waren alle Nicht- |
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Obwohl es versucht, den Speicherverbrauch zu begrenzen, kann dies die Leistung beeinträchtigen, wenn es um große |
LPAD
-Beispielelpad ('Hello', 12) -- Ergebnis ' Hello'
lpad ('Hello', 12, '-') -- Ergebnis '-------Hello'
lpad ('Hello', 12, '') -- Ergebnis 'Hello'
lpad ('Hello', 12, 'abc') -- Ergebnis 'abcabcaHello'
lpad ('Hello', 12, 'abcdefghij') -- Ergebnis 'abcdefgHello'
lpad ('Hello', 2) -- Ergebnis 'He'
lpad ('Hello', 2, '-') -- Ergebnis 'He'
lpad ('Hello', 2, '') -- Ergebnis 'He'
OCTET_LENGTH()
DSQL, PSQL
INTEGER
OCTET_LENGTH (string)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
Gibt die Länge des Eingabestrings in Bytes (Oktetts) an.Bei Mehrbyte-Zeichensätzen kann dies kleiner sein als die Anzahl der Zeichen mal der “formalen” Anzahl von Bytes pro Zeichen, wie in RDB$CHARACTER_SETS
gefunden.
Note
|
Bei Argumenten vom Typ |
BLOB
-UnterstützungSeit Firebird 2.1 unterstützt diese Funktion vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
OCTET_LENGTH
-Beispieleselect octet_length('Hello!') from rdb$database
-- Ergebnis 6
select octet_length(_iso8859_1 'Grüß di!') from rdb$database
-- Ergebnis 8: ü und ß belegen in ISO8859_1 jeweils ein Byte
select octet_length
(cast (_iso8859_1 'Grüß di!' as varchar(24) character set utf8))
from rdb$database
-- Ergebnis 10: ü und ß belegen in UTF8 jeweils zwei Byte
select octet_length
(cast (_iso8859_1 'Grüß di!' as char(24) character set utf8))
from rdb$database
-- Ergebnis 26: alle 24 CHAR-Positionen zählen, und zwei davon sind 2-Byte
OVERLAY()
DSQL, PSQL
VARCHAR
oder BLOB
OVERLAY (string PLACING replacement FROM pos [FOR length])
Parameter | Beschreibung |
---|---|
string |
Die Zeichenfolge, in die die Ersetzung erfolgt |
replacement |
Ersetzende Zeichenkette |
pos |
Die Position, von der aus ersetzt wird (Ausgangsposition) |
length |
Die Anzahl der zu überschreibenden Zeichen |
OVERLAY()
überschreibt einen Teil eines Strings mit einem anderen String.Standardmäßig entspricht die Anzahl der aus der Hostzeichenfolge entfernten (überschriebenen) Zeichen der Länge der Ersetzungszeichenfolge.Mit dem optionalen vierten Argument kann eine andere Anzahl von Zeichen zum Entfernen angegeben werden.
Diese Funktion unterstützt BLOB
s beliebiger Länge.
Wenn string oder replacement ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(n)
mit n der Summe der Längen von string und replacement.
Wie bei SQL-Stringfunktionen üblich, ist pos 1-basiert.
Wenn pos hinter dem Ende von string steht, wird replacement direkt nach string platziert.
Wenn die Anzahl der Zeichen von pos bis zum Ende von string kleiner ist als die Länge von replacement (oder als das length-Argument, falls vorhanden), wird string an pos abgeschnitten und replacement dahinter platziert.
Eine “FOR 0
”-Klausel bewirkt, dass replacement einfach in string eingefügt wird.
Wenn ein Argument NULL
ist, ist das Ergebnis NULL
.
Wenn pos oder length keine ganze Zahl ist, wird Banker-Rundung (auf-gerade) angewendet, d. h. 0,5 wird zu 0, 1,5 wird zu 2, 2,5 wird zu 2, 3,5 wird zu 4 usw.
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Dies kann die Leistung beeinträchtigen, wenn es um große |
OVERLAY
-Beispieleoverlay ('Goodbye' placing 'Hello' from 2) -- Ergebnis 'GHelloe'
overlay ('Goodbye' placing 'Hello' from 5) -- Ergebnis 'GoodHello'
overlay ('Goodbye' placing 'Hello' from 8) -- Ergebnis 'GoodbyeHello'
overlay ('Goodbye' placing 'Hello' from 20) -- Ergebnis 'GoodbyeHello'
overlay ('Goodbye' placing 'Hello' from 2 for 0) -- Ergebnis 'GHellooodbye'
overlay ('Goodbye' placing 'Hello' from 2 for 3) -- Ergebnis 'GHellobye'
overlay ('Goodbye' placing 'Hello' from 2 for 6) -- Ergebnis 'GHello'
overlay ('Goodbye' placing 'Hello' from 2 for 9) -- Ergebnis 'GHello'
overlay ('Goodbye' placing '' from 4) -- Ergebnis 'Goodbye'
overlay ('Goodbye' placing '' from 4 for 3) -- Ergebnis 'Gooe'
overlay ('Goodbye' placing '' from 4 for 20) -- Ergebnis 'Goo'
overlay ('' placing 'Hello' from 4) -- Ergebnis 'Hello'
overlay ('' placing 'Hello' from 4 for 0) -- Ergebnis 'Hello'
overlay ('' placing 'Hello' from 4 for 20) -- Ergebnis 'Hello'
POSITION()
DSQL, PSQL
INTEGER
POSITION (substr IN string) | POSITION (substr, string [, startpos])
Parameter | Beschreibung |
---|---|
substr |
Der Teilstring, dessen Position gesucht werden soll |
string |
Der zu suchende String |
startpos |
Die Position in string, an der die Suche beginnen soll |
Gibt die (1-basierte) Position des ersten Vorkommens einer Teilzeichenfolge in einer Hostzeichenfolge zurück.Mit dem optionalen dritten Argument beginnt die Suche an einem bestimmten Offset, wobei alle Übereinstimmungen ignoriert werden, die früher in der Zeichenfolge auftreten können.Wenn keine Übereinstimmung gefunden wird, ist das Ergebnis 0.
Note
|
|
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Dies kann die Leistung beeinträchtigen, wenn es um große |
POSITION
-Beispieleposition ('be' in 'To be or not to be') -- Ergebnis 4
position ('be', 'To be or not to be') -- Ergebnis 4
position ('be', 'To be or not to be', 4) -- Ergebnis 4
position ('be', 'To be or not to be', 8) -- Ergebnis 17
position ('be', 'To be or not to be', 18) -- Ergebnis 0
position ('be' in 'Alas, poor Yorick!') -- Ergebnis 0
REPLACE()
DSQL, PSQL
VARCHAR
oder BLOB
REPLACE (str, find, repl)
Parameter | Beschreibung |
---|---|
str |
Die Zeichenfolge, in der die Ersetzung erfolgen soll |
find |
Die Zeichenfolge, nach der gesucht werden soll |
repl |
Die Ersatzzeichenfolge |
Ersetzt alle Vorkommen einer Teilzeichenfolge in einer Zeichenfolge.
Diese Funktion unterstützt vollständig Text BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn ein Argument ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(n)
mit n, das aus den Längen von str, find und repl so berechnet wird, dass auch die maximal mögliche Anzahl von Ersetzungen das Feld nicht überläuft.
Wenn find der leere String ist, wird str unverändert zurückgegeben.
Wenn repl der leere String ist, werden alle Vorkommen von find aus str gelöscht.
Wenn ein Argument NULL
ist, ist das Ergebnis immer NULL
, auch wenn nichts ersetzt worden wäre.
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Dies kann die Leistung beeinträchtigen, wenn es um große |
REPLACE
-Beispielereplace ('Billy Wilder', 'il', 'oog') -- Ergebnis 'Boogly Woogder'
replace ('Billy Wilder', 'il', '') -- Ergebnis 'Bly Wder'
replace ('Billy Wilder', null, 'oog') -- Ergebnis NULL
replace ('Billy Wilder', 'il', null) -- Ergebnis NULL
replace ('Billy Wilder', 'xyz', null) -- Ergebnis NULL (!)
replace ('Billy Wilder', 'xyz', 'abc') -- Ergebnis 'Billy Wilder'
replace ('Billy Wilder', '', 'abc') -- Ergebnis 'Billy Wilder'
REVERSE()
DSQL, PSQL
VARCHAR
REVERSE (string)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
Gibt eine Zeichenfolge rückwärts zurück.
REVERSE
-Beispielereverse ('spoonful') -- Ergebnis 'lufnoops'
reverse ('Was it a cat I saw?') -- Ergebnis '?was I tac a ti saW'
Tip
|
Diese Funktion ist sehr praktisch, wenn Sie nach String-Endungen gruppieren, suchen oder sortieren möchten, z.B. beim Umgang mit Domainnamen oder E-Mail-Adressen:
|
ASCII_VAL()
DSQL, PSQL
YES → Details lesen
SMALLINT
ASCII_VAL (ch)
Parameter | Beschreibung |
---|---|
ch |
Ein String vom Datentyp |
Gibt den ASCII-Code des übergebenen Zeichens zurück.
Wenn das Argument ein String mit mehr als einem Zeichen ist, wird der ASCII-Code des ersten Zeichens zurückgegeben.
Wenn das Argument ein leerer String ist, wird 0 zurückgegeben.
Wenn das Argument NULL
ist, wird NULL
zurückgegeben.
Wenn das erste Zeichen der Argumentzeichenfolge aus mehreren Byte besteht, wird ein Fehler ausgegeben.(Ein Fehler in Firebird 2.1 - 2.1.3 und 2.5.0 führt zu einem Fehler, wenn beliebiges Zeichen in der Zeichenfolge aus mehreren Byte besteht.Dies ist in den Versionen 2.1.4 und 2.5.1 behoben.)
RIGHT()
DSQL, PSQL
YES → Details lesen
VARCHAR
oder BLOB
RIGHT (string, length)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
length |
Integer.Definiert die Anzahl der zurückzugebenden Zeichen |
Gibt den ganz rechten Teil der Argumentzeichenfolge zurück.Die Anzahl der Zeichen wird im zweiten Argument angegeben.
Diese Funktion unterstützt Text BLOB`s' beliebiger Länge, hat aber einen Fehler in den Versionen 2.1 - 2.1.3 und 2.5.0, der dazu führt, dass es bei Text
BLOB``s fehlschlägt, die größer als 1024 Bytes sind, die ein Multi haben -Byte-Zeichensatz.Dies wurde in den Versionen 2.1.4 und 2.5.1 behoben.
Wenn string ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(n)
mit n der Länge des Eingabestrings.
Wenn das Argument length die Stringlänge überschreitet, wird der Eingabestring unverändert zurückgegeben.
Wenn das Argument Länge keine ganze Zahl ist, wird Banker-Rundung (auf-gerade) angewendet, d. h. 0,5 wird zu 0, 1,5 wird zu 2, 2,5 wird zu 2, 3,5 wird zu 4 usw.
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Dies kann die Leistung beeinträchtigen, wenn es um große |
RPAD()
DSQL, PSQL
YES → Details lesen
VARCHAR
oder BLOB
RPAD (str, endlen [, padstr])
Parameter | Beschreibung |
---|---|
str |
Ein Ausdruck eines String-Typs |
endlen |
Länge der Ausgabezeichenfolge |
endlen |
Das Zeichen oder die Zeichenfolge, die verwendet werden soll, um die Quellzeichenfolge bis zur angegebenen Länge aufzufüllen.Standard ist Leerzeichen ( |
Füllt eine Zeichenfolge mit der rechten Maustaste mit Leerzeichen oder mit einer vom Benutzer angegebenen Zeichenfolge auf, bis eine bestimmte Länge erreicht ist.
Diese Funktion unterstützt vollständig Text BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn str ein BLOB
ist, ist das Ergebnis ein BLOB
.Andernfalls ist das Ergebnis ein VARCHAR(endlen)
.
Wenn padstr angegeben ist und gleich ''
(leerer String) ist, findet kein Auffüllen statt.
Wenn endlen kleiner als die aktuelle Stringlänge ist, wird der String auf endlen gekürzt, auch wenn padstr der leere String ist.
Note
|
In Firebird 2.1-2.1.3 waren alle Nicht- |
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Obwohl es versucht, den Speicherverbrauch zu begrenzen, kann dies die Leistung beeinträchtigen, wenn es um große |
RPAD
-Beispielerpad ('Hello', 12) -- Ergebnis 'Hello '
rpad ('Hello', 12, '-') -- Ergebnis 'Hello-------'
rpad ('Hello', 12, '') -- Ergebnis 'Hello'
rpad ('Hello', 12, 'abc') -- Ergebnis 'Helloabcabca'
rpad ('Hello', 12, 'abcdefghij') -- Ergebnis 'Helloabcdefg'
rpad ('Hello', 2) -- Ergebnis 'He'
rpad ('Hello', 2, '-') -- Ergebnis 'He'
rpad ('Hello', 2, '') -- Ergebnis 'He'
SUBSTRING()
DSQL, PSQL
VARCHAR
oder BLOB
SUBSTRING ( <substring-args> ) <substring-args> ::= str FROM startpos [FOR length] | str SIMILAR <similar-pattern> ESCAPE <escape> <similar-pattern> ::= <similar-pattern-R1> <escape> " <similar-pattern-R2> <escape> " <similar-pattern-R3>
Parameter | Beschreibung |
---|---|
str |
Ein Ausdruck eines String-Typs |
startpos |
Ganzzahliger Ausdruck, die Position, von der aus mit dem Abrufen der Teilzeichenfolge begonnen werden soll |
length |
Die Anzahl der abzurufenden Zeichen nach dem startpos |
similar-pattern |
Muster für reguläre SQL-Ausdrücke, um nach der Teilzeichenfolge zu suchen |
escape |
Escape-Zeichen |
Gibt die Teilzeichenfolge einer Zeichenfolge beginnend an der angegebenen Position zurück, entweder bis zum Ende der Zeichenfolge oder mit einer bestimmten Länge, oder extrahiert eine Teilzeichenfolge mithilfe eines Musters für reguläre SQL-Ausdrücke.
Wenn ein Argument NULL
ist, ist das Ergebnis auch NULL
.
Warning
|
Bei Verwendung auf einem |
SUBSTRING
In ihrer einfachen Positionsform (mit FROM
) gibt diese Funktion den Teilstring ab der Zeichenposition startpos zurück (das erste Zeichen ist 1).Ohne das Argument FOR
gibt es alle verbleibenden Zeichen in der Zeichenfolge zurück.Bei FOR
gibt es length Zeichen oder den Rest des Strings zurück, je nachdem welcher kürzer ist.
Seit Firebird 4.0 kann startpos kleiner als 1 sein.Wenn startpos kleiner als 1 ist, verhält sich Teilzeichenfolge so, als ob die Zeichenfolge 1 - startpos
zusätzliche Positionen vor dem eigentlichen ersten Zeichen an Position 1
hätte.Die Länge wird von diesem imaginären Anfang der Zeichenfolge aus betrachtet, sodass die resultierende Zeichenfolge kürzer als die angegebene Länge oder sogar leer sein kann.
Die Funktion unterstützt vollständig binäre und Text BLOB
s beliebiger Länge und mit jedem Zeichensatz.Wenn str ein BLOB
ist, ist das Ergebnis auch ein BLOB
.Bei jedem anderen Argumenttyp ist das Ergebnis ein VARCHAR
.
Bei Nicht-BLOB
-Argumenten entspricht die Breite des Ergebnisfelds immer der Länge von str, unabhängig von startpos und length.substring('pinhead' from 4 for 2)
gibt also ein VARCHAR(7)
zurück, das den String 'he'
enthält.
insert into AbbrNames(AbbrName)
select substring(LongName from 1 for 3) from LongNames;
select substring('abcdef' from 1 for 2) from rdb$database;
-- Ergebnis: 'ab'
select substring('abcdef' from 2) from rdb$database;
-- Ergebnis: 'bcdef'
select substring('abcdef' from 0 for 2) from rdb$database;
-- Ergebnis: 'a'
-- und NICHT 'ab', da "nichts" an Position 0 existiert
select substring('abcdef' from -5 for 2) from rdb$database;
-- Egebnis: ''
-- length endet vor dem eigentlichen Anfang des Strings
SUBSTRING
In der Form des regulären Ausdrucks (mit SIMILAR
) gibt die Funktion SUBSTRING
einen Teil des Strings zurück, der einem Muster eines regulären SQL-Ausdrucks entspricht.Wenn keine Übereinstimmung gefunden wird, wird NULL
zurückgegeben.
Das Muster "SIMILAR" wird aus drei Mustern für reguläre SQL-Ausdrücke gebildet, R1, R2 und R3.Das gesamte Muster hat die Form R1 || '<Escape>"' || R2 || '<Escape>"' || R3
, wobei <escape> das in der ESCAPE
-Klausel definierte Escape-Zeichen ist.R2 ist das Muster, das mit der zu extrahierenden Teilzeichenfolge übereinstimmt, und wird zwischen doppelten Anführungszeichen mit Escapezeichen eingeschlossen (<escape>"
, zB “#"
” mit Escape-Zeichen ‘ ##+
’).R1 entspricht dem Präfix des Strings und R3 dem Suffix des Strings.Sowohl R1 als auch R3 sind optional (sie können leer sein), aber das Muster muss mit der gesamten Zeichenfolge übereinstimmen.Mit anderen Worten, es reicht nicht aus, ein Muster anzugeben, das nur die zu extrahierende Teilzeichenfolge findet.
Tip
|
Die mit Escapezeichen versehenen doppelten Anführungszeichen um R2 können mit der Definition einer einzelnen Erfassungsgruppe in einer gängigeren Syntax für reguläre Ausdrücke wie PCRE verglichen werden.Das heißt, das vollständige Muster entspricht |
Note
|
Wenn einer von R1, R2 oder R3 keine Zeichenfolge der Länge Null ist und nicht das Format eines regulären SQL-Ausdrucks hat, wird eine Ausnahme ausgelöst. |
Das vollständige Format für reguläre SQL-Ausdrücke wird in Syntax: Reguläre SQL-Ausdrücke beschrieben
substring('abcabc' similar 'a#"bcab#"c' escape '#') -- bcab
substring('abcabc' similar 'a#"%#"c' escape '#') -- bcab
substring('abcabc' similar '_#"%#"_' escape '#') -- bcab
substring('abcabc' similar '#"(abc)*#"' escape '#') -- abcabc
substring('abcabc' similar '#"abc#"' escape '#') -- <null>
TRIM()
DSQL, PSQL
VARCHAR
or BLOB
TRIM ([<adjust>] str) <adjust> ::= {[<where>] [what]} FROM <where> ::= BOTH | LEADING | TRAILING
Parameter | Beschreibung |
---|---|
str |
Ein Ausdruck eines String-Typs |
where |
Die Position, aus der der Teilstring entfernt werden soll — |
what |
Die Teilzeichenfolge, die am Anfang, am Ende oder auf beiden Seiten der Eingabezeichenfolge str entfernt werden soll (mehrmals bei mehreren Übereinstimmungen).Standardmäßig ist es Leerzeichen ( |
Entfernt führende und/oder nachgestellte Leerzeichen (oder optional andere Zeichenfolgen) aus der Eingabezeichenfolge.Seit Firebird 2.1 unterstützt diese Funktion vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Note
|
Wenn str ein |
Warning
|
Bei Verwendung auf einem 'BLOB' muss diese Funktion möglicherweise das gesamte Objekt in den Speicher laden.Dies kann die Leistung beeinträchtigen, wenn es um große |
TRIM
-Beispieleselect trim (' Waste no space ') from rdb$database
-- Ergebnis 'Waste no space'
select trim (leading from ' Waste no space ') from rdb$database
-- Ergebnis 'Waste no space '
select trim (leading '.' from ' Waste no space ') from rdb$database
-- Ergebnis ' Waste no space '
select trim (trailing '!' from 'Help!!!!') from rdb$database
-- Ergebnis 'Help'
select trim ('la' from 'lalala I love you Ella') from rdb$database
-- Ergebnis ' I love you El'
select trim ('la' from 'Lalala I love you Ella') from rdb$database
-- Ergebnis 'Lalala I love you El'
UPPER()
DSQL, ESQL, PSQL
(VAR)CHAR
, (VAR)BINARY
oder BLOB
UPPER (str)
Parameter | Beschreibung |
---|---|
str |
Ein Ausdruck eines String-Typs |
Gibt das Äquivalent der Eingabezeichenfolge in Großbuchstaben zurück.Das genaue Ergebnis hängt vom Zeichensatz ab.Bei ASCII
oder NONE
beispielsweise werden nur ASCII-Zeichen groß geschrieben;mit dem Zeichensatz OCTETS
/(VAR)BINARY
wird der gesamte String unverändert zurückgegeben.Seit Firebird 2.1 unterstützt diese Funktion auch Text-BLOB
s beliebiger Länge und beliebigem Zeichensatz.
UPPER
-Beispieleselect upper(_iso8859_1 'Débâcle')
from rdb$database
-- Ergebnis 'DÉBÂCLE' (vor Firebird 2.0: 'DéBâCLE')
select upper(_iso8859_1 'Débâcle' collate fr_fr)
from rdb$database
-- Ergebnis 'DEBACLE', nach französischen Großbuchstabenregeln
BASE64_DECODE()
DSQL, PSQL
VARBINARY
oder BLOB
BASE64_DECODE (base64_data)
Parameter | Beschreibung |
---|---|
base64_data |
Base64-codierte Daten, aufgefüllt mit |
BASE64_DECODE
decodiert einen String mit base64-codierten Daten und gibt den decodierten Wert je nach Eingabe als VARBINARY
oder BLOB
zurück.Wenn die Länge des Typs von base64_data kein Vielfaches von 4 ist, wird zur Vorbereitungszeit ein Fehler ausgegeben.Wenn die Länge des Werts von base64_data kein Vielfaches von 4 ist, wird zur Ausführungszeit ein Fehler ausgegeben.
Wenn die Eingabe nicht BLOB
ist, wird die Länge des resultierenden Typs als type_length * 3 / 4
berechnet, wobei type_length die maximale Länge in Zeichen des Eingabetyps ist.
BASE64_DECODE
select cast(base64_decode('VGVzdCBiYXNlNjQ=') as varchar(12))
from rdb$database;
CAST
============
Test base64
BASE64_ENCODE()
DSQL, PSQL
VARCHAR CHARACTER SET ASCII
oder BLOB SUB_TYPE TEXT CHARACTER SET ASCII
BASE64_ENCODE (binary_data)
Parameter | Beschreibung |
---|---|
binary_data |
Binäre Daten (oder anderweitig in Binär umwandelbar) zum Codieren |
BASE64_ENCODE
codiert binary_data mit base64 und gibt den codierten Wert je nach Eingabe als VARCHAR CHARACTER SET ASCII
oder BLOB SUB_TYPE TEXT CHARACTER SET ASCII
zurück.Der zurückgegebene Wert wird mit ‘=
’ aufgefüllt, sodass seine Länge ein Vielfaches von 4 ist.
Wenn die Eingabe nicht 'BLOB' ist, wird die Länge des resultierenden Typs berechnet als 'type_length * 4 / 3', aufgerundet auf ein Vielfaches von vier, wobei type_length die maximale Länge in Bytes des Eingabetyps ist.Überschreitet diese Länge die maximale Länge von VARCHAR
, gibt die Funktion ein BLOB
zurück.
BASE64_ENCODE
select base64_encode('Test base64')
from rdb$database;
BASE64_ENCODE
================
VGVzdCBiYXNlNjQ=
BIT_LENGTH()
DSQL, PSQL
INTEGER
BIT_LENGTH (string)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
Gibt die Länge des Eingabestrings in Bits an.Bei Mehrbyte-Zeichensätzen kann dies kleiner sein als die Anzahl der Zeichen mal 8 mal die “formale” Anzahl von Bytes pro Zeichen wie in RDB$CHARACTER_SETS
gefunden.
Note
|
Bei Argumenten vom Typ |
BLOB
-UnterstützungSeit Firebird 2.1 unterstützt diese Funktion vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
BIT_LENGTH
-Beispieleselect bit_length('Hello!') from rdb$database
-- Ergebnis 48
select bit_length(_iso8859_1 'Grüß di!') from rdb$database
-- Ergebnis 64: ü und ß belegen in ISO8859_1 jeweils ein Byte
select bit_length
(cast (_iso8859_1 'Grüß di!' as varchar(24) character set utf8))
from rdb$database
-- Ergebnis 80: ü und ß belegen in ISO8859_1 jeweils ein Byte
select bit_length
(cast (_iso8859_1 'Grüß di!' as char(24) character set utf8))
from rdb$database
-- Ergebnis 208: alle 24 CHAR-Positionen zählen, und zwei davon sind 16-Bit
BLOB_APPEND()
DSQL, PSQL
4.0.2
BLOB
BLOB_APPEND(expr1, expr2 [, exprN ... ])
Parameter | Beschreibung |
---|---|
exprN |
Ein Ausdruck eines Typs, der in |
Die BLOB_APPEND
-Funktion verkettet Blobs, ohne zwischenzeitliche BLOB
s zu erstellen, wodurch übermäßiger Speicherverbrauch und Wachstum der Datenbankdatei vermieden werden.Die Funktion BLOB_APPEND
nimmt zwei oder mehr Argumente und fügt sie zu einem BLOB
hinzu, der für eine weitere Modifikation durch einen nachfolgenden Aufruf von BLOB_APPEND
offen bleibt.
Das resultierende BLOB
wird zum Schreiben offen gelassen, anstatt geschlossen zu werden, wenn die Funktion zurückkehrt.Mit anderen Worten, das BLOB
kann beliebig oft angehängt werden.Die Engine markiert das von BLOB_APPEND
zurückgegebene BLOB
mit einem internen Flag BLB_close_on_read
und schließt es bei Bedarf automatisch.
Das erste Argument bestimmt das Verhalten der Funktion:
NULL
: neues, leeres BLOB SUB_TYPE TEXT CHARACTER SET NONE
wird erstellt
In Firebird 5.0 (und — vielleicht — Firebird 4.0.3) wird dies geändert, um den Verbindungszeichensatz anstelle von NONE
zu verwenden.
permanentes BLOB
(aus einer Tabelle) oder temporäres BLOB
, das bereits geschlossen war: neues BLOB SUB_TYPE TEXT
wird erstellt, gefüllt mit dem Inhalt des ursprünglichen BLOB
.Wenn das ursprüngliche BLOB
SUB_TYPE TEXT
ist, wird dessen Zeichensatz verwendet, andernfalls der Zeichensatz OCTETS
.
In Firebird 5.0 (und -– vielleicht -– Firebird 4.0.3) wird sich dies dahingehend ändern, dass der Untertyp des anfänglichen BLOB
verwendet wird.
temporäres, nicht geschlossenes BLOB
mit dem BLB_close_on_read
-Flag (z. B. erstellt durch einen anderen Aufruf von BLOB_APPEND
): unverändert verwendet, verbleibende Argumente werden an dieses BLOB
angehängt
andere Datentypen: ein neuer BLOB SUB_TYPE TEXT
wird erstellt, gefüllt mit dem ursprünglichen Argument, das in einen String umgewandelt wurde.Wenn der Originalwert ein Zeichentyp ist, wird dessen Zeichensatz verwendet (bei String-Literalen der Verbindungszeichensatz), ansonsten Zeichensatz NONE
(wird in Firebird 5.0 und — vielleicht — Firebird 4.0.3 geändert, um den Verbindungszeichensatz zu verwenden).
Andere Argumente können von beliebigem Typ sein.Für sie ist folgendes Verhalten definiert:
NULL
s werden ignoriert (verhält sich wie ein leerer String)
BLOB
s werden ggf. in den Zeichensatz des ersten Arguments transliteriert und ihr Inhalt an das Ergebnis angehängt
andere Datentypen werden (wie üblich) in Strings umgewandelt und an das Ergebnis angehängt
Die Funktion BLOB_APPEND
gibt einen vorübergehend nicht geschlossenen BLOB
mit dem Flag BLB_close_on_read
zurück.Wenn das erste Argument ein solches temporäres, nicht geschlossenes BLOB
ist (z. B. durch einen vorherigen Aufruf von BLOB_APPEND
erstellt), wird es so verwendet, wie es ist, andernfalls wird ein neues BLOB
erstellt.Daher führt eine Reihe von Operationen wie blob = BLOB_APPEND (blob, …)
zur Erstellung von höchstens einem BLOB
(es sei denn, Sie versuchen, ein BLOB
an sich selbst anzuhängen).Dieses Blob wird automatisch von der Engine geschlossen, wenn der Client es liest, es einer Tabelle zuweist oder es in anderen Ausdrücken verwendet, die das Lesen des Inhalts erfordern.
Warning
|
Wichtige Einschränkungen für
BLOB_APPEND
|
Note
|
Der eines Blobs auf |
Tip
|
Verwenden Sie die Funktionen |
BLOB_APPEND
-Beispieleexecute block
returns (b blob sub_type text)
as
begin
-- creates a new temporary not closed BLOB
-- and writes the string from the 2nd argument into it
b = blob_append(null, 'Hello ');
-- adds two strings to the temporary BLOB without closing it
b = blob_append(b, 'World', '!');
-- comparing a BLOB with a string will close it, because the BLOB needs to be read
if (b = 'Hello World!') then
begin
-- ...
end
-- creates a temporary closed BLOB by adding a string to it
b = b || 'Close';
suspend;
end
CHAR_LENGTH()
, CHARACTER_LENGTH()
DSQL, PSQL
INTEGER
CHAR_LENGTH (string) | CHARACTER_LENGTH (string)
Parameter | Beschreibung |
---|---|
string |
Ein Ausdruck eines String-Typs |
Gibt die Länge des Eingabestrings in Zeichen an.
Note
|
|
CHAR_LENGTH
-Beispieleselect char_length('Hello!') from rdb$database
-- Ergebnis 6
select char_length(_iso8859_1 'Grüß di!') from rdb$database
-- Ergebnis 8
select char_length
(cast (_iso8859_1 'Grüß di!' as varchar(24) character set utf8))
from rdb$database
-- Ergebnis 8; dass ü und ß jeweils zwei Bytes belegen ist irrelevant
select char_length
(cast (_iso8859_1 'Grüß di!' as char(24) character set utf8))
from rdb$database
-- Ergebnis 24: alle 24 CHAR-Positionen zählen
CRYPT_HASH()
DSQL, PSQL
VARBINARY
CRYPT_HASH (value USING <hash>) <hash> ::= MD5 | SHA1 | SHA256 | SHA512
Parameter | Beschreibung |
---|---|
value |
Ausdruck von Werten jeglicher Art;Nicht-String- oder Nicht-Binär-Typen werden in Strings konvertiert |
hash |
Anzuwendender kryptografischer Hash-Algorithmus |
CRYPT_HASH
gibt einen kryptografischen Hash zurück, der aus dem Eingabeargument mit dem angegebenen Algorithmus berechnet wurde.Wenn das Eingabeargument kein String- oder Binärtyp ist, wird es vor dem Hashing in einen String konvertiert.
Diese Funktion gibt ein VARBINARY
mit der Länge abhängig vom angegebenen Algorithmus zurück.
Note
|
|
CRYPT_HASH
x
mit dem SHA512-Algorithmusselect crypt_hash(x using sha512) from y;
HASH()
DSQL, PSQL
INTEGER
,BIGINT
HASH (value [USING <hash>]) <hash> ::= CRC32
Parameter | Beschreibung |
---|---|
value |
Ausdruck von Werten jeglicher Art;Nicht-String- oder Nicht-Binär-Typen werden in Strings konvertiert |
hash |
Anzuwendender nicht-kryptografischer Hash-Algorithmus |
HASH
gibt einen Hash-Wert für das Eingabeargument zurück.Wenn das Eingabeargument kein String- oder Binärtyp ist, wird es vor dem Hashing in einen String konvertiert.
Die optionale USING
-Klausel gibt den anzuwendenden nicht-kryptografischen Hash-Algorithmus an.Wenn die USING
-Klausel fehlt, wird der Legacy-PJW-Algorithmus angewendet;dies ist identisch mit dem Verhalten in früheren Firebird-Versionen.
Diese Funktion unterstützt vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn kein Algorithmus angegeben ist, wendet Firebird die 64-Bit-Variante der nicht-kryptografischen PJW-Hash-Funktion (auch bekannt als ELF64) an.Dies ist ein sehr schneller Algorithmus für allgemeine Zwecke (Hash-Tabellen usw.), aber seine Kollisionsqualität ist nicht optimal.Andere Hashfunktionen – die explizit in der USING
-Klausel angegeben sind, oder kryptografische Hashes durch [fblangref40-scalarfuncs-crypthash-de] – sollten für zuverlässigeres Hashing verwendet werden.
Die Funktion HASH
gibt BIGINT
für diesen Algorithmus zurück
CRC32
Mit CRC32
wendet Firebird den CRC32-Algorithmus unter Verwendung des Polynoms 0x04C11DB7 an.
Die Funktion HASH
gibt INTEGER
für diesen Algorithmus zurück.
HASH
Hashing x
mit dem CRC32-Algorithmus
select hash(x using crc32) from y;
Hashing x
mit dem Legacy-PJW-Algorithmus
select hash(x) from y;
DATEADD()
DSQL, PSQL
DATE
, TIME
oder TIMESTAMP
DATEADD (<args>) <args> ::= <amount> <unit> TO <datetime> | <unit>, <amount>, <datetime> <amount> ::= ein ganzzahliger Ausdruck (negativ zum Subtrahieren) <unit> ::= YEAR | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND | MILLISECOND <datetime> ::= ein DATE-, TIME- oder TIMESTAMP-Ausdruck
Parameter | Beschreibung |
---|---|
amount |
Ein ganzzahliger Ausdruck vom Typ |
unit |
Datum/Uhrzeit-Einheit |
datetime |
Ein Ausdruck vom Typ |
Addiert die angegebene Anzahl von Jahren, Monaten, Wochen, Tagen, Stunden, Minuten, Sekunden oder Millisekunden zu einem Datums-/Uhrzeitwert.
Der Ergebnistyp wird durch das dritte Argument bestimmt.
Mit den Argumenten TIMESTAMP
und DATE
können alle Einheiten verwendet werden.
Bei TIME
-Argumenten können nur HOUR
, MINUTE
, SECOND
und MILLISECOND
verwendet werden.
DATEADD
dateadd (28 day to current_date)
dateadd (-6 hour to current_time)
dateadd (month, 9, DateOfConception)
dateadd (-38 week to DateOfBirth)
dateadd (minute, 90, cast('now' as time))
dateadd (? year to date '11-Sep-1973')
select
cast(dateadd(-1 * extract(millisecond from ts) millisecond to ts) as varchar(30)) as t,
extract(millisecond from ts) as ms
from (
select timestamp '2014-06-09 13:50:17.4971' as ts
from rdb$database
) a
T MS ------------------------ ------ 2014-06-09 13:50:17.0000 497.1
DATEDIFF()
DSQL, PSQL
BIGINT
, oder — seit Firebird 4.0.1 — NUMERIC(18,1)
für MILLISECOND
DATEDIFF (<args>) <args> ::= <unit> FROM <moment1> TO <moment2> | <unit>, <moment1>, <moment2> <unit> ::= YEAR | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND | MILLISECOND <momentN> ::= ein DATE-, TIME- oder TIMESTAMP-Ausdruck
Parameter | Beschreibung |
---|---|
unit |
Datum/Uhrzeit-Einheit |
moment1 |
Ein Ausdruck vom Typ |
moment2 |
Ein Ausdruck vom Typ |
Gibt die Anzahl der Jahre, Monate, Wochen, Tage, Stunden, Minuten, Sekunden oder Millisekunden zurück, die zwischen zwei Datums-/Uhrzeitwerten verstrichen sind.(Die Einheit WOCHE
ist neu in 2.5.)
Die Argumente DATE
und TIMESTAMP
können kombiniert werden.Andere Mischungen sind nicht erlaubt.
Mit den Argumenten TIMESTAMP
und DATE
können alle Einheiten verwendet werden.(Vor Firebird 2.5 waren Einheiten, die kleiner als DAY
waren, für DATE
s nicht zulässig.)
Bei TIME
-Argumenten können nur HOUR
, MINUTE
, SECOND
und MILLISECOND
verwendet werden.
DATEDIFF
betrachtet keine kleineren Einheiten als die im ersten Argument angegebene.Als Ergebnis,
datediff (Jahr, Datum '1-Jan-2009', Datum '31-Dez-2009')
gibt 0 zurück, aber
`datediff (Jahr, Datum '31-Dez-2009', Datum '1-Jan-2010')' gibt 1 zurück
Es betrachtet jedoch alle größeren Einheiten. So:
`datediff (Tag, Datum '26-Jun-1908', Datum '11-Sep-1973')' gibt 23818 zurück
Ein negativer Ergebniswert bedeutet, dass moment2 vor moment1 liegt.
DATEDIFF
-Beispieledatediff (hour from current_timestamp to timestamp '12-Jun-2059 06:00')
datediff (minute from time '0:00' to current_time)
datediff (month, current_date, date '1-1-1900')
datediff (day from current_date to cast(? as date))
EXTRACT()
DSQL, ESQL, PSQL
SMALLINT
or NUMERIC
EXTRACT (<part> FROM <datetime>) <part> ::= YEAR | MONTH | WEEK | DAY | WEEKDAY | YEARDAY | HOUR | MINUTE | SECOND | MILLISECOND | TIMEZONE_HOUR | TIMEZONE_MINUTE <datetime> ::= ein DATE-, TIME- oder TIMESTAMP-Ausdruck
Parameter | Beschreibung |
---|---|
part |
Datum/Uhrzeit-Einheit |
datetime |
Ein Ausdruck vom Typ |
Extrahiert ein Element aus einem DATE
, TIME
oder TIMESTAMP
Ausdruck und gibt es zurück.
Die zurückgegebenen Datentypen und möglichen Bereiche sind in der folgenden Tabelle aufgeführt.Wenn Sie versuchen, einen Teil zu extrahieren, der nicht im Datum/Uhrzeit-Argument vorhanden ist (z. B. SECOND
aus einem DATE
oder YEAR
aus einer TIME
), tritt ein Fehler auf.
Teil | Typ | Bereich | Anmerkung |
---|---|---|---|
|
|
1-9999 |
|
|
|
1-12 |
|
|
|
1-53 |
|
|
|
1-31 |
|
|
|
0-6 |
0 = Sonntag |
|
|
0-365 |
0 = 1. Januar |
|
|
0-23 |
|
|
|
0-59 |
|
|
|
0.0000-59.9999 |
beinhaltet Millisekunden als Bruch |
|
|
0.0-999.9 |
fehlerhaft in 2.1, 2.1.1 |
|
|
-23 - +23 |
|
|
|
-59 - +59 |
|
MILLISECOND
Firebird 2.1 und höher unterstützen die Extraktion der Millisekunde aus einer TIME
oder TIMESTAMP
.Der zurückgegebene Datentyp ist NUMERIC(9,1)
.
Note
|
Wenn Sie die Millisekunde aus [fblangref40-contextvars-current-time-de] extrahieren, beachten Sie, dass diese Variable standardmäßig auf die Sekundengenauigkeit eingestellt ist, sodass das Ergebnis immer 0 ist.Extrahieren Sie aus |
WEEK
Firebird 2.1 und höher unterstützen die Extraktion der ISO-8601-Wochennummer aus einem "DATE" oder "TIMESTAMP".ISO-8601-Wochen beginnen an einem Montag und haben immer die vollen sieben Tage.Woche 1 ist die erste Woche mit einem Großteil (mindestens 4) der Tage im neuen Jahr.Die ersten 1-3 Tage des Jahres können zur letzten Woche (52 oder 53) des Vorjahres gehören.Ebenso können die letzten 1-3 Tage eines Jahres zur ersten Woche des Folgejahres gehören.
Caution
|
Seien Sie vorsichtig, wenn Sie die Ergebnisse von Bitte beachten Sie auch, dass |
FIRST_DAY()
DSQL, PSQL
DATE
, TIMESTAMP
(mit oder ohne Zeitzone)
FIRST_DAY(OF <period> FROM date_or_timestamp) <period> ::= YEAR | MONTH | WEEK
Parameter | Beschreibung |
---|---|
date_or_timestamp |
Ausdruck vom Typ |
FIRST_DAY
gibt ein Datum oder einen Zeitstempel (gleich dem Typ von date_or_timestamp) mit dem ersten Tag des Jahres, des Monats oder der Woche eines gegebenen Datums- oder Zeitstempelwerts zurück.
Note
|
|
FIRST_DAY
select first_day(of month from current_date) from rdb$database;
select first_day(of year from current_timestamp) from rdb$database;
select first_day(of week from date '2017-11-01') from rdb$database;
LAST_DAY()
DSQL, PSQL
DATE
, TIMESTAMP
(mit oder ohne Zeitzone)
LAST_DAY(OF <period> FROM date_or_timestamp) <period> ::= YEAR | MONTH | WEEK
Parameter | Beschreibung |
---|---|
date_or_timestamp |
Ausdruck vom Typ |
LAST_DAY
gibt ein Datum oder einen Zeitstempel (gleich dem Typ von date_or_timestamp) mit dem letzten Tag des Jahres, des Monats oder der Woche eines gegebenen Datums- oder Zeitstempelwerts zurück.
Note
|
|
LAST_DAY
select last_day(of month from current_date) from rdb$database;
select last_day(of year from current_timestamp) from rdb$database;
select last_day(of week from date '2017-11-01') from rdb$database;
CAST()
DSQL, ESQL, PSQL
Wie von target_type angegeben
CAST (<expression> AS <target_type>) <target_type> ::= <domain_or_non_array_type> | <array_datatype> <domain_or_non_array_type> ::= !! Siehe auch Syntax für skalare Datentypen !! <array_datatype> ::= !! Siehe auch Syntax der Array-Datentypen !!
Parameter | Beschreibung |
---|---|
expression |
SQL-Ausdruck |
sql_datatype |
SQL-Datentyp |
CAST
wandelt einen Ausdruck in den gewünschten Datentyp oder die gewünschte Domäne um.Wenn die Konvertierung nicht möglich ist, wird ein Fehler ausgegeben.
BLOB
sErfolgreiches Casting zu und von BLOB
s ist seit Firebird 2.1 möglich.
Alternative Syntax, die nur unterstützt wird, wenn ein Stringliteral in ein DATE
, TIME
oder TIMESTAMP
umgewandelt wird:
datatype 'date/timestring'
Diese Syntax war bereits in InterBase verfügbar, wurde jedoch nie richtig dokumentiert.Im SQL-Standard heißt diese Funktion “datetime literals”.
Note
|
Seit Firebird 4.0 ist die Verwendung von |
Die folgende Tabelle zeigt die mit CAST
möglichen Typkonvertierungen.
Von | Nach |
---|---|
Numerische Typen |
Numerische Typen |
|
|
|
|
|
|
Denken Sie daran, dass manchmal Informationen verloren gehen, zum Beispiel wenn Sie einen TIMESTAMP
in ein DATE
umwandeln.Auch die Tatsache, dass Typen CAST
-kompatibel sind, ist noch keine Garantie dafür, dass eine Konvertierung erfolgreich ist.“CAST(123456789 as SMALLINT)
” führt definitiv zu einem Fehler, ebenso wie “CAST('Judgement Day' as DATE)
”.
Seit Firebird 2.0 können Sie Anweisungsparameter in einen Datentyp umwandeln:
cast (? as integer)
Dies gibt Ihnen die Kontrolle über den Typ des Parameters, der von der Engine eingerichtet wird.Bitte beachten Sie, dass Sie bei Anweisungsparametern immer eine vollständige Syntaxumwandlung benötigen – Kurzformumwandlungen werden nicht unterstützt.
Firebird 2.1 und höher unterstützen das Casting in eine Domäne oder deren Basistyp.Beim Casting in eine Domain müssen alle für die Domain deklarierten Constraints (NOT NULL
und/oder CHECK
) erfüllt sein, sonst schlägt das Casting fehl.Bitte beachten Sie, dass ein CHECK
erfolgreich ist, wenn es als TRUE
oder NULL
ausgewertet wird!Also folgende Aussagen gegeben:
create domain quint as int check (value >= 5000);
select cast (2000 as quint) from rdb$database; -- (1)
select cast (8000 as quint) from rdb$database; -- (2)
select cast (null as quint) from rdb$database; -- (3)
nur die Besetzungsnummer 1 führt zu einem Fehler.
Wenn der Modifikator TYPE OF
verwendet wird, wird der Ausdruck in den Basistyp der Domäne umgewandelt, wobei alle Einschränkungen ignoriert werden.Mit der oben definierten Domain 'quint' sind die folgenden beiden Casts äquivalent und werden beide erfolgreich sein:
select cast (2000 as type of quint) from rdb$database;
select cast (2000 as int) from rdb$database;
Wenn TYPE OF
mit einem (VAR)CHAR
-Typ verwendet wird, werden sein Zeichensatz und seine Kollatierung beibehalten:
create domain iso20 varchar(20) character set iso8859_1;
create domain dunl20 varchar(20) character set iso8859_1 collate du_nl;
create table zinnen (zin varchar(20));
commit;
insert into zinnen values ('Deze');
insert into zinnen values ('Die');
insert into zinnen values ('die');
insert into zinnen values ('deze');
select cast(zin as type of iso20) from zinnen order by 1;
-- Ergebnis Deze -> Die -> deze -> die
select cast(zin as type of dunl20) from zinnen order by 1;
-- Ergebnis deze -> Deze -> die -> Die
Warning
|
Wenn die Definition einer Domain geändert wird, können bestehende |
In Firebird 2.5 und höher ist es möglich, Ausdrücke in den Typ einer vorhandenen Tabelle oder Ansichtsspalte umzuwandeln.Nur der Typ selbst wird verwendet;bei String-Typen umfasst dies den Zeichensatz, aber nicht die Kollatierung.Einschränkungen und Standardwerte der Quellspalte werden nicht angewendet.
create table ttt (
s varchar(40) character set utf8 collate unicode_ci_ai
);
commit;
select cast ('Jag har många vänner' as type of column ttt.s)
from rdb$database;
Warning
|
Warnungen
Wenn die Definition einer Spalte geändert wird, können vorhandene |
Ein Vollsyntax Cast:
select cast ('12' || '-June-' || '1959' as date) from rdb$database
Eine Kurzschreibweise zur Umwandlung von String zu Datum:
update People set AgeCat = 'Old'
where BirthDate < date '1-Jan-1943'
Beachten Sie, dass Sie sogar die Kurzform aus dem obigen Beispiel weglassen können, da die Engine aus dem Kontext (Vergleich mit einem DATE
-Feld) versteht, wie die Zeichenfolge zu interpretieren ist:
update People set AgeCat = 'Old'
where BirthDate < '1-Jan-1943'
Jedoch ist dies nicht immer möglich.Der folgende Cast kann nicht weggelassen werden, sonst würde sich die Engine mit einer Ganzzahl wiederfinden, die von einer Zeichenfolge subtrahiert werden soll:
select cast('today' as date) - 7 from rdb$database
BIN_AND()
DSQL, PSQL
YES → Details lesen
SMALLINT
, INTEGER
oder BIGINT
Note
|
Das Ergebnis |
BIN_AND (number, number [, number ...])
Parameter | Beschreibung |
---|---|
number |
Beliebige ganze Zahl (literal, smallint/integer/bigint, numerisch/dezimal mit Skalierung 0) |
Gibt das Ergebnis der bitweisen AND-Operation für die Argumente zurück.
BIN_NOT()
DSQL, PSQL
SMALLINT
, INTEGER
oder BIGINT
Note
|
Das Ergebnis |
BIN_NOT (number)
Parameter | Beschreibung |
---|---|
number |
Beliebige ganze Zahl (literal, smallint/integer/bigint, numerisch/dezimal mit Skala 0) |
Gibt das Ergebnis der bitweisen NOT-Operation für das Argument zurück, d.h. das Einser-Komplement.
[fblangref40-scalarfuncs-bin-or-de], [fblangref40-scalarfuncs-bin-xor-de] und weitere.
BIN_OR()
DSQL, PSQL
YES → Details lesen
SMALLINT
, INTEGER
oder BIGINT
Note
|
Das Ergebnis |
BIN_OR (number, number [, number ...])
Parameter | Beschreibung |
---|---|
number |
Beliebige ganze Zahl (literal, smallint/integer/bigint, numerisch/dezimal mit Skalierung 0) |
Gibt das Ergebnis der bitweisen OR-Operation für die Argumente zurück.
BIN_SHL()
DSQL, PSQL
BIGINT
BIN_SHL (number, shift)
Parameter | Beschreibung |
---|---|
number |
Eine Zahl eines ganzzahligen Typs |
shift |
Die Anzahl der Bits, um die der Zahlenwert verschoben wird |
Gibt das erste Argument bitweise linksverschoben um das zweite Argument zurück, d. h. a << b
oder a·2b
.
BIN_SHR()
DSQL, PSQL
BIGINT
BIN_SHR (number, shift)
Parameter | Beschreibung |
---|---|
number |
Eine Zahl eines ganzzahligen Typs |
shift |
Die Anzahl der Bits, um die der Zahlenwert verschoben wird |
Gibt das erste Argument bitweise nach rechts verschoben um das zweite Argument zurück, d. h. a >> b
oder a/2b
.
Die ausgeführte Operation ist eine arithmetische Rechtsverschiebung (SAR), dh das Vorzeichen des ersten Operanden bleibt immer erhalten.
BIN_XOR()
DSQL, PSQL
YES → Details lesen
SMALLINT
, INTEGER
oder BIGINT
Note
|
Das Ergebnis |
BIN_XOR (number, number [, number ...])
Parameter | Beschreibung |
---|---|
number |
Beliebige ganze Zahl (literal, smallint/integer/bigint, numerisch/dezimal mit Skalierung 0) |
Gibt das Ergebnis der bitweisen XOR-Operation für die Argumente zurück.
CHAR_TO_UUID()
DSQL, PSQL
BINARY(16)
CHAR_TO_UUID (ascii_uuid)
Parameter | Beschreibung |
---|---|
ascii_uuid |
Eine 36-stellige Darstellung der UUID.‘ |
Konvertiert eine für Menschen lesbare 36-stellige UUID-Zeichenfolge in die entsprechende 16-Byte-UUID.
CHAR_TO_UUID
-Beispieleselect char_to_uuid('A0bF4E45-3029-2a44-D493-4998c9b439A3') from rdb$database
-- Ergebnis A0BF4E4530292A44D4934998C9B439A3 (16-Byte String)
select char_to_uuid('A0bF4E45-3029-2A44-X493-4998c9b439A3') from rdb$database
-- Fehler: - Menschlich lesbares UUID-Argument für CHAR_TO_UUID
muss eine Hex-Ziffer an Position 20 anstelle von "X (ASCII 88)" haben
GEN_UUID()
DSQL, PSQL
BINARY(16)
GEN_UUID ()
Gibt eine universell eindeutige ID als 16-Byte-Zeichenfolge zurück.
GEN_UUID
-Beispielselect gen_uuid() from rdb$database
-- Ergebnis e.g. 017347BFE212B2479C00FA4323B36320 (16-Byte String)
UUID_TO_CHAR()
DSQL, PSQL
CHAR(36)
UUID_TO_CHAR (uuid)
Parameter | Beschreibung |
---|---|
uuid |
16-Byte UUID |
Konvertiert eine 16-Byte-UUID in ihre 36-stellige, für Menschen lesbare ASCII-Darstellung.
UUID_TO_CHAR
-Beispieleselect uuid_to_char(x'876C45F4569B320DBCB4735AC3509E5F') from rdb$database
-- Ergebnis '876C45F4-569B-320D-BCB4-735AC3509E5F'
select uuid_to_char(gen_uuid()) from rdb$database
-- Ergebnis e.g. '680D946B-45FF-DB4E-B103-BB5711529B86'
select uuid_to_char('Firebird swings!') from rdb$database
-- Ergebnis '46697265-6269-7264-2073-77696E677321'
GEN_ID()
DSQL, ESQL, PSQL
BIGINT
— Dialect 2 und 3INTEGER
— Dialect 1
GEN_ID (generator-name, step)
Parameter | Beschreibung |
---|---|
generator-name |
Name eines vorhandenen Generators (Sequenz).Wenn er in doppelten Anführungszeichen mit einem Bezeichner definiert wurde, bei dem die Groß-/Kleinschreibung beachtet wird, muss er in derselben Form verwendet werden, es sei denn, der Name wird ausschließlich in Großbuchstaben geschrieben. |
step |
Ein ganzzahliger Ausdruck |
Erhöht einen Generator oder eine Sequenz und gibt den neuen Wert zurück.Wenn Schritt gleich 0 ist, lässt die Funktion den Wert des Generators unverändert und gibt seinen aktuellen Wert zurück.
Ab Firebird 2.0 wird die SQL-kompatible Syntax NEXT VALUE FOR
bevorzugt, außer wenn eine andere Erhöhung als 1 benötigt wird.
Warning
|
Wenn der Wert des Schrittparameters kleiner als Null ist, wird der Wert des Generators verringert.Achtung! Bei solchen Manipulationen in der Datenbank sollten Sie äußerst vorsichtig sein, da sie die Datenintegrität beeinträchtigen könnten. |
Note
|
In Dialekt 1 ist der Ergebnistyp |
GEN_ID
-Beispielnew.rec_id = gen_id(gen_recnum, 1);
COALESCE()
DSQL, PSQL
Abhängig von der Eingabe
COALESCE (<exp1>, <exp2> [, <expN> ... ])
Parameter | Beschreibung |
---|---|
exp1, exp2 … expN |
Eine Liste von Ausdrücken aller kompatiblen Typen |
Die Funktion COALESCE
nimmt zwei oder mehr Argumente und gibt den Wert des ersten Nicht-NULL
-Arguments zurück.Wenn alle Argumente NULL
ergeben, ist das Ergebnis NULL
.
COALESCE
-BeispieleDieses Beispiel wählt den Nickname
aus der Persons
-Tabelle.Wenn es NULL
ist, geht es weiter zu FirstName
.Ist auch dieser NULL
, wird “'Mr./Mrs.'
” verwendet.Schließlich fügt es den Familiennamen hinzu.Insgesamt wird versucht, aus den verfügbaren Daten einen möglichst informellen vollständigen Namen zusammenzustellen.Beachten Sie, dass dieses Schema nur funktioniert, wenn fehlende Spitznamen und Vornamen wirklich NULL
sind: Wenn einer von ihnen stattdessen ein leerer String ist, wird COALESCE
diesen glücklich an den Aufrufer zurückgeben.
select
coalesce (Nickname, FirstName, 'Mr./Mrs.') || ' ' || LastName
as FullName
from Persons
DECODE()
DSQL, PSQL
Abhängig von der Eingabe
DECODE(<testexpr>, <expr1>, <result1> [<expr2>, <result2> …] [, <defaultresult>])
Das äquivalente CASE
-Konstrukt:
CASE <testexpr> WHEN <expr1> THEN <result1> [WHEN <expr2> THEN <result2> …] [ELSE <defaultresult>] END
Parameter | Beschreibung |
---|---|
testexpr |
Ein Ausdruck eines beliebigen kompatiblen Typs, der mit den Ausdrücken expr1, expr2 … exprN . verglichen wird |
expr1, expr2, … exprN |
Ausdrücke beliebiger kompatibler Typen, mit denen der Ausdruck testexpr verglichen wird |
result1, result2, … resultN |
Rückgabewerte jeglichen Typs |
defaultresult |
Der Ausdruck, der zurückgegeben werden soll, wenn keine der Bedingungen erfüllt ist |
DECODE
ist eine Abkürzung für das sogenannte “Einfaches CASE
”-Konstrukt, in dem ein gegebener Ausdruck mit einer Anzahl von andere Ausdrücke, bis eine Übereinstimmung gefunden wird.Das Ergebnis wird durch den Wert bestimmt, der nach dem übereinstimmenden Ausdruck aufgeführt ist.Wenn keine Übereinstimmung gefunden wird, wird das Standardergebnis zurückgegeben, falls vorhanden.Andernfalls wird NULL
zurückgegeben.
Caution
|
Der Abgleich erfolgt mit dem Operator ‘ |
DECODE
-Beispieleselect name,
age,
decode(upper(sex),
'M', 'Male',
'F', 'Female',
'Unknown'),
religion
from people
IIF()
DSQL, PSQL
Abhängig von der Eingabe
IIF (<condition>, ResultT, ResultF)
Parameter | Beschreibung |
---|---|
condition |
Ein wahrer|falscher Ausdruck |
resultT |
Der zurückgegebene Wert, wenn die Bedingung wahr ist |
resultF |
Der zurückgegebene Wert, wenn die Bedingung falsch ist |
IIF
benötigt drei Argumente.Wenn das erste Argument true
ergibt, wird das zweite Argument zurückgegeben;andernfalls wird die dritte zurückgegeben.
IIF
könnte in C-ähnlichen Sprachen mit dem ternären Operator “?:
” verglichen werden.
Note
|
|
IIF
-Beispieleselect iif( sex = 'M', 'Sir', 'Madam' ) from Customers
MAXVALUE()
DSQL, PSQL
Variiert je nach Eingabe — das Ergebnis hat denselben Datentyp wie der erste Ausdruck in der Liste (expr1).
MAXVALUE (<expr1> [, ... , <exprN> ])
Parameter | Beschreibung |
---|---|
expr1 … exprN |
Liste der Ausdrücke kompatibler Typen |
Gibt den Höchstwert aus einer Liste von numerischen, Zeichenfolgen- oder Datums-/Uhrzeitausdrücken zurück.Diese Funktion unterstützt vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn ein oder mehrere Ausdrücke in NULL
aufgelöst werden, gibt MAXVALUE
NULL
zurück.Dieses Verhalten unterscheidet sich von der Aggregatfunktion MAX
.
MAXVALUE
-BeispieleSELECT MAXVALUE(PRICE_1, PRICE_2) AS PRICE
FROM PRICELIST
MINVALUE()
DSQL, PSQL
Variiert je nach Eingabe — das Ergebnis hat denselben Datentyp wie der erste Ausdruck in der Liste (expr1).
MINVALUE (<expr1> [, ... , <exprN> ])
Parameter | Beschreibung |
---|---|
expr1 … exprN |
Liste der Ausdrücke kompatibler Typen |
Gibt den Mindestwert aus einer Liste von numerischen, Zeichenfolgen- oder Datums-/Uhrzeitausdrücken zurück.Diese Funktion unterstützt vollständig Text-BLOB
s jeder Länge und jedes beliebigen Zeichensatzes.
Wenn ein oder mehrere Ausdrücke in NULL
aufgelöst werden, gibt MINVALUE
NULL
zurück.Dieses Verhalten unterscheidet sich von der Aggregatfunktion MIN
.
MINVALUE
-BeispieleSELECT MINVALUE(PRICE_1, PRICE_2) AS PRICE
FROM PRICELIST
NULLIF()
DSQL, PSQL
Abhängig von der Eingabe
NULLIF (<exp1>, <exp2>)
Parameter | Beschreibung |
---|---|
exp1 |
Ein Ausdruck |
exp2 |
Ein anderer Ausdruck eines Datentyps, der mit exp1 kompatibel ist |
NULLIF
gibt den Wert des ersten Arguments zurück, es sei denn, es ist gleich dem zweiten.In diesem Fall wird NULL
zurückgegeben.
NULLIF
-Beispielselect avg( nullif(Weight, -1) ) from FatPeople
Dadurch wird das durchschnittliche Gewicht der in FatPeople aufgelisteten Personen zurückgegeben, mit Ausnahme derer mit einem Gewicht von -1, da "AVG" "NULL"-Daten überspringt.Vermutlich bedeutet -1 in dieser Tabelle “Gewicht unbekannt”.Ein einfaches AVG(Weight)
würde die -1 Gewichte enthalten, wodurch das Ergebnis verzerrt wird.