Fonctions pour traiter les variables contextuelles
Fonctions pour travailler avec des chaînes de caractères
Fonctions pour travailler avec la date et l'heure
Fonctions permettant de travailler avec le type BLOB
Fonctions permettant de travailler avec le type DECFLOAT
Fonctions de conversion de type
Fonctions d'opérations binaires
Fonctions pour traiter les UUID
RDB$GET_CONTEXT()
DSQL, PSQL
RDB$GET_CONTEXT('<namespace>', 'varname') <namespace> ::= SYSTEM | DDL_TRIGGER | USER_SESSION | USER_TRANSACTION
Paramètre | Description |
---|---|
namespace |
Namespace. |
varname |
Le nom de la variable.Sensible à la casse.La longueur maximale est de 80 octets. |
VARCHAR(255) CHARACTER SET NONE
La fonction RDB$GET_CONTEXT
renvoie la valeur d’une variable contextuelle de l’un des espaces de noms.
Les espaces de noms suivants existent actuellement :
SYSTEM
— fournit un accès aux variables du contexte système. Ces variables sont en lecture seule ;
USER_SESSION
— fournit un accès aux variables de contexte utilisateur définies via la fonction RDB$SET_CONTEXT
. Les variables existent pour la durée de la connexion ;
USER_TRANSACTION
— Fournit un accès aux variables de contexte utilisateur définies via la fonction RDB$SET_CONTEXT
. Les variables existent pendant la transaction ;
DL_TRIGGER
— fournit un accès aux variables de contexte du système disponibles uniquement pendant l’exécution du trigger DDL. Ces variables sont en lecture seule.
Les espaces de noms USER_SESSION
et USER_TRANSACTION
sont initialement vides et l’utilisateur crée les variables et les remplit avec la fonction RDB$SET_CONTEXT
.
Note
|
Pour éviter les attaques DoS, il y a une limite de 1000 variables dans un "espace de noms". |
Si la variable demandée par la fonction existe dans l’espace de noms, elle est retournée sous la forme d’une chaîne VARCHAR(255) CHARACTER SET NONE
. Si une variable inexistante dans l’espace de noms SYSTEM
est référencée, il y a une erreur si cela se produit dans les espaces de noms USER_SESSION
ou USER_TRANSACTION
- la fonction retourne NULL.
SYSTEM
CLIENT_ADDRESS
Adresse du client. Pour TCPv4 - adresse IP, pour XNET - ID du processus local. Pour les autres cas NULL
.
CLIENT_HOST
Le nom d’hôte du protocole réseau du client distant. La valeur est renvoyée pour tous les protocoles pris en charge.
CLIENT_OS_USER
Le nom d’utilisateur du système d’exploitation de l’ordinateur client.
CLIENT_PID
Le PID du processus sur l’ordinateur client.
CLIENT_PROCESS
Chemin complet de l’application client se connectant à la base de données.
CLIENT_VERSION
La version de la bibliothèque client (fbclient) utilisée par l’application client.
CURRENT_ROLE
La variable globale CURRENT_ROLE
.
CURRENT_USER
La variable globale CURRENT_USER
.
DB_NAME
Le nom canonique de la base de données actuelle. C’est soit un nom d’alias (si la connexion au nom de fichier est interdite DatabaseAccess = NONE
) ou, sinon, un nom de fichier de base de données entièrement étendu.
DB_FILE_ID
Identifiant unique de la base de données actuelle au niveau du système de fichiers.
DB_GUID
GUID de la base de données.
EFFECTIVE_USER
L’utilisateur effectif à l’heure actuelle. Indique l’utilisateur avec des privilèges dont la procédure, la fonction ou le déclencheur est en cours d’exécution.
ENGINE_VERSION
Version du serveur Firebird.
EXT_CONN_POOL_SIZE
Taille du pool de connexions externes.
EXT_CONN_POOL_LIFETIME
La durée de vie des connexions inactives dans le pool de connexion externe.
EXT_CONN_POOL_IDLE_COUNT
Le nombre actuel de connexions inactives dans le pool de connexions externes.connexions.
EXT_CONN_POOL_ACTIVE_COUNT
Le nombre actuel de connexions actives dans le pool de connexions externes.
GLOBAL_CN
Dernière valeur du compteur global actuel de Commit Number
ISOLATION_LEVEL
Le niveau d’isolement de la transaction actuelle — CURRENT_TRANSACTION
. Valeurs : 'READ_COMMITED'
, 'SNAPSHOT'
ou 'CONSISTENCY'
.
LOCK_TIMEOUT
Le temps qu’une transaction attend pour que la ressource soit libérée lorsqu’elle est bloquée, en secondes.
NETWORK_PROTOCOL
Le protocole utilisé pour se connecter à la base de données. Valeurs possibles : 'TCPv4'
, 'TCPv6'
, 'WNET'
, 'XNET'
, NULL
.
PARALLEL_WORKERS
Nombre maximal de flux de travail parallèles dans la connexion actuelle.
READ_ONLY
Indique si la transaction est une transaction en lecture seule. 'FALSE'
pour les transactions en lecture-écriture 'TRUE'
pour la lecture seule.
REPLICA_MODE
Mode de réplication : chaîne vide ou NULL
--base de données primaire, READ-ONLY
--réplique en lecture seule, READ-WRITE
--réplique en lecture-écriture.
REPLICATION_SEQUENCE
La valeur actuelle de la séquence de réplication (le numéro du dernier segment écrit dans le journal de réplication).
SESSION_ID
Variable globale CURRENT_CONNECTION
.
SESSION_IDLE_TIMEOUT
Contient la valeur actuelle du délai d’inactivité de la connexion en secondes, qui a été définie au niveau de la connexion, ou zéro si aucun délai n’a été défini.
SESSION_TIMEZONE
Le fuseau horaire actuel défini dans la session en cours.
SNAPSHOT_NUMBER
Nombre d’instantanés de la base de données : niveau transaction (pour la transaction SNAPSHOT
ou CONSISTENCY
) ou niveau requête (pour la transaction READ COMMITTED READ CONSISTENCY
). NULL si le snapshot n’existe pas.
STATEMENT_TIMEOUT
Contient la valeur actuelle du délai d’exécution de l’opérateur en millisecondes, qui a été défini au niveau de la connexion, ou zéro si aucun délai n’a été défini.
TRANSACTION_ID
Variable globale CURRENT_TRANSACTION
.
WIRE_COMPRESSED
Si la compression du trafic réseau est utilisée ou non. Si la compression du trafic réseau est utilisée, elle renvoie 'TRUE'
, sinon 'FALSE'
. Pour les connexions embarquées — renvoie NULL
.
WIRE_ENCRYPTED
Si le cryptage du trafic réseau est utilisé. Si le cryptage du trafic réseau est utilisé, renvoie "VRAI", sinon "FAUX". Pour les connexions embarquées — renvoie NULL
.
WIRE_CRYPT_PLUGIN
Si le cryptage du trafic réseau est utilisé, renvoie le nom du plugin de cryptage actuel, sinon NULL
.
L’utilisation de l’espace de nom DDL_TRIGGER
n’est autorisée que pendant l’exécution du déclencheur DDL. Son utilisation est également autorisée dans les procédures stockées et les fonctions appelées par les déclencheurs DDL.
Le contexte DDL_TRIGGER
fonctionne comme une pile. Avant que le trigger DDL ne soit déclenché, les valeurs liées à la commande en cours d’exécution sont placées sur cette pile. Lorsque le trigger est terminé, les valeurs sont éjectées.Ainsi, dans le cas d’instructions DDL en cascade, lorsque chaque commande DDL utilisateur déclenche un trigger DDL et que ce trigger déclenche d’autres commandes DDL, avec EXECUTE STATEMENT
, les valeurs des variables dans l’espace de noms DDL_TRIGGER
correspondront à la commande qui a déclenché le dernier trigger DDL dans la pile d’appels.
DDL_TRIGGER
EVENT_TYPE
type d’événement (CREATE
, ALTER
, DROP
).
OBJECT_TYPE
type d’objet (TABLE
, VIEW
et al.).
DDL_EVENT
(<ddl event item>
), où <ddl_event_item>
c’est EVENT_TYPE || ' ' || OBJECT_TYPE
OBJECT_NAME
le nom de l’objet de métadonnées.
OLD_OBJECT_NAME
le nom de l’objet de métadonnées avant son renommage.
NEW_OBJECT_NAME
le nom de l’objet de métadonnées après renommage.
SQL_TEXT
le texte de la requête SQL.
Note
|
Une fois de plus, notez que les noms d’espaces de noms et de variables sont sensibles à la casse, doivent être des chaînes de caractères non vides, et sont entourés de guillemets ! |
NEW.USER_ADR = RDB$GET_CONTEXT ('SYSTEM', 'CLIENT_ADDRESS');
RDB$SET_CONTEXT()
DSQL, PSQL
RDB$SET_CONTEXT('<namespace>', 'varname', {<value> | NULL}) <namespace> ::= USER_SESSION | USER_TRANSACTION
Paramètre | Description |
---|---|
namespace |
Namespace. |
varname |
Nom de la variable, sensible à la casse. Longueur maximale de 80 octets. |
value |
Données de tout type, à condition qu’elles puissent être converties en CHARACTER SET NONE de type VARCHAR(255). |
INTEGER
La fonction RDB$SET_CONTEXT
crée, définit ou efface une variable dans l’un des espaces de noms utilisés par l’utilisateur : USER_SESSION
ou USER_TRANSACTION
.
La fonction renvoie 1 si la variable existait déjà avant l’appel et 0 si ce n’est pas le cas. Pour supprimer une variable, mettez-la à NULL
. Si l’espace de noms donné n’existe pas, la fonction renverra une erreur. L’espace de noms et le nom de la variable sont sensibles à la casse, doivent être des chaînes de caractères non vides, et entourées de guillemets.
Note
|
|
RDB$SET_CONTEXT
SELECT RDB$SET_CONTEXT ('USER_SESSION', 'DEBUGL', 3)
FROM RDB$DATABASE;
-- la syntaxe suivante est disponible dans PSQL
RDB$SET_CONTEXT('USER_SESSION', 'RECORDSFOUND', RECCOUNTER);
SELECT RDB$SET_CONTEXT ('USER_TRANSACTION', 'SAVEPOINTS', 'YES')
FROM RDB$DATABASE;
SET TERM ^;
CREATE PROCEDURE set_context(User_ID VARCHAR(40),
Trn_ID INT) AS
BEGIN
RDB$SET_CONTEXT('USER_TRANSACTION', 'Trn_ID', Trn_ID);
RDB$SET_CONTEXT('USER_TRANSACTION', 'User_ID', User_ID);
END^
SET TERM ;^
CREATE TABLE journal (
jrn_id INTEGER NOT NULL PRIMARY KEY,
jrn_lastuser VARCHAR(40),
jrn_lastaddr VARCHAR(255),
jrn_lasttran INTEGER
);
SET TERM ^;
CREATE TRIGGER UI_JOURNAL
FOR JOURNAL BEFORE INSERT OR UPDATE
AS
BEGIN
new.jrn_lastuser = RDB$GET_CONTEXT('USER_TRANSACTION',
'User_ID');
new.jrn_lastaddr = RDB$GET_CONTEXT('SYSTEM',
'CLIENT_ADDRESS');
new.jrn_lasttran = RDB$GET_CONTEXT('USER_TRANSACTION',
'Trn_ID');
END^
SET TERM ;^
EXECUTE PROCEDURE set_context('skidder', 1);
INSERT INTO journal(jrn_id) VALUES(0);
COMMIT;
CHAR_TO_UUID()
DSQL, PSQL
CHAR_TO_UUID (ascii_uuid)
Paramètre | Description |
---|---|
ascii_uuid |
Représentation de l’UUID en 36 caractères : “ |
BINARY(16)
La fonction CHAR_TO_UUID
convertit un UUID lisible de 36 caractères en la valeur UUID correspondante de 16 octets.
CHAR_TO_UUID
CHAR_TO_UUID
SELECT CHAR_TO_UUID('A0bF4E45-3029-2a44-D493-4998c9b439A3') FROM rdb$database
-- returns A0BF4E4530292A44D4934998C9B439A3 (16-byte string)
SELECT CHAR_TO_UUID('A0bF4E45-3029-2A44-X493-4998c9b439A3') FROM rdb$database
-- erreur : -L'argument UUID lisible par l'homme pour CHAR_TO_UUID doit être
-- un chiffre hexagonal à la position 20 au lieu de "X (ASCII 88)"
GEN_UUID()
DSQL, PSQL
GEN_UUID()
BINARY(16)
La fonction renvoie un identifiant unique universel sous la forme d’une chaîne de caractères de 16 octets conforme à la norme RFC-4122. La fonction renvoie une chaîne UUID de version 4, où quelques bits sont réservés et le reste est aléatoire.
GEN_UUID
GEN_UUID
SELECT GEN_UUID() AS GUID FROM RDB$DATABASE
GUID ======== 017347BFE212B2479C00FA4323B36320
UUID_TO_CHAR()
DSQL, PSQL
UUID_TO_CHAR (uuid)
Paramètre | Description |
---|---|
uuid |
UUID à 16 octets. |
CHAR(36)
La fonction UID_TO_CHAR
convertit un UUID de 16 octets en sa représentation lisible par l’homme de 36 caractères ASCII. Le type de valeur de retour est CHAR(36)
.
UUID_TO_CHAR
UUID_TO_CHAR
SELECT UUID_TO_CHAR(GEN_UUID()) FROM RDB$DATABASE;
SELECT UUID_TO_CHAR(x'876C45F4569B320DBCB4735AC3509E5F') FROM RDB$DATABASE;
-- returns '876C45F4-569B-320D-BCB4-735AC3509E5F'
SELECT UUID_TO_CHAR(GEN_UUID()) FROM RDB$DATABASE;
-- returns e.g. '680D946B-45FF-DB4E-B103-BB5711529B86'
SELECT UUID_TO_CHAR('Firebird swings!') FROM RDB$DATABASE;
-- returns '46697265-6269-7264-2073-77696E677321'
GEN_ID()
DSQL, PSQL
GEN_ID (generator-name, step)
Paramètre | Description |
---|---|
generator-name |
Nom du générateur (séquence). |
step |
Increment Step. |
BIGINT
La fonction GEN_ID
incrémente la valeur du générateur ou de la séquence et renvoie la nouvelle valeur.
Si step est 0, la fonction ne fera rien avec la valeur du générateur et retournera sa valeur actuelle.
Depuis Firebird 2.0, il est désormais possible d’utiliser un générateur conforme aux normes SQL pour récupérer la valeur de la séquence suivante (générateur).Opérateur compatible avec SQL NEXT VALUE FOR
.
Si la valeur de step est inférieure à zéro, la valeur du générateur sera diminuée. Soyez extrêmement prudent avec de telles manipulations dans la base de données, elles peuvent entraîner une perte d’intégrité des données.
GEN_ID
GEN_ID
NEW.ID = GEN_ID (GEN_TABLE_ID, 1);
NEXT VALUE FOR
,SEQUENCE (GENERATOR),ALTER SEQUENCE
,SET GENERATOR
.
COALESCE()
DSQL, PSQL
COALESCE (<exp1>, <exp2> [, <expN> ... ])
Paramètre | Description |
---|---|
exp1, exp2 … expN |
Expressions de tout type compatible. |
dépend des types d’arguments d’entrée
La fonction COALESCE
prend deux arguments ou plus et retourne la valeur du premier argument non NULL
. Si tous les arguments sont NULL
, le résultat est également NULL
.
COALESCE
Cet exemple tente d’utiliser toutes les données disponibles pour composer un nom complet. Le champ NICKNAME
de la table PERSONS
est sélectionné. S’il est NULL
, la valeur du champ FIRSTNAME
est prise. S’il est également NULL
, la chaîne de caractères "Mr./Mrs.`" est utilisée. Ensuite le nom de famille (le champ `LASTNAME
) est ajouté à la valeur de la fonction COALESCE
. Notez que ce schéma ne fonctionne correctement que si les champs à sélectionner sont NULL
ou non vides : si l’un d’eux est une chaîne vide, c’est ce qui sera renvoyé comme valeur de la fonction COALESCE
.
SELECT
COALESCE(PE.NICKNAME, PE.FIRSTNAME, 'Mr./Mrs.') ||
' ' || PE.LASTNAME AS FULLNAME
FROM PERSONS PE
Dans cet exemple, si la requête renvoie NULL
lors du calcul de la somme, elle renverra 0
.
SELECT coalesce (sum (q), 0)
FROM bills
WHERE ...
CASE
.
DECODE()
DSQL, PSQL
DECODE(<testexpr>, <expr1>, <result1> [<expr2>, <result2> …] [, <defaultresult>])
construction équivalente CASE
CASE <testexpr> WHEN <expr1> THEN <result1> [WHEN <expr2> THEN <result2> …] [ELSE <defaultresult>] END
Paramètre | Description |
---|---|
testexpr |
Expressions de tout type compatible qui sont comparées à des expressions |
expr1, expr2, … exprN |
Expressions de tout type compatible par rapport à l’expression |
result1, result2, … resultN |
Retourne des expressions de n’importe quel type. |
defaultresult |
Une expression renvoyée si aucune des conditions n’a été remplie. |
dépend des types d’arguments d’entrée
Cette fonction est équivalente à la construction Simple CASE
, dans laquelle une expression donnée est comparée à d’autres expressions avant qu’une correspondance soit trouvée.Le résultat est la valeur donnée après l’expression avec laquelle la correspondance est trouvée.Si aucune correspondance n’est trouvée, la valeur par défaut est retournée (si elle est, bien sûr, donnée — sinon NULL
est retourné).
Caution
|
Une correspondance est équivalente à l’opérateur ‘ |
DECODE
DECODE
select name,
age,
decode(upper(sex),
'M', 'Male',
'F', 'Female',
'Unknown'),
religion
from people
CASE
.
IIF()
DSQL, PSQL
IIF (<condition>, ResultT, ResultF)
Paramètre | Description |
---|---|
condition |
Une expression du type logique. |
resultT |
Valeur de retour si condition est vraie. |
resultF |
Valeur de retour si condition est fausse. |
dépend des types d’arguments d’entrée
La fonction IIF
a trois arguments. Si le premier argument est vrai, le résultat est le deuxième paramètre, sinon le résultat est le troisième paramètre.
L’opérateur IIF
peut également être comparé à l’opérateur triple “?:
” dans les langages C-like.
Note
|
Essentiellement, la fonction CASE WHEN <condition> THEN resultT ELSE resultF END |
IIF
IIF
SELECT IIF(SEX = 'M', 'Sir', 'Madam') FROM CUSTOMERS
CASE
.
MAXVALUE()
DSQL, PSQL
MAXVALUE (<expr1> [, ... , <exprN> ])
Paramètre | Description |
---|---|
expr1 … exprN |
Expressions de tout type compatible. |
est le même que le premier argument de expr1.
Renvoie la valeur maximale d’une liste de nombres, de chaînes de caractères ou de paramètres de type DATE
/ TIME
/ TIMESTAMP
.
Note
|
Si un ou plusieurs paramètres d’entrée sont |
MAXVALUE
MAXVALUE
SELECT MAXVALUE(PRICE_1, PRICE_2) AS PRICE
FROM PRICELIST
MINVALUE()
DSQL, PSQL
MINVALUE (<expr1> [, ... , <exprN> ])
Paramètre | Description |
---|---|
expr1 … exprN |
Expressions de tout type compatible. |
est le même que le premier argument de expr1.
Renvoie la valeur minimale d’une liste de nombres, de chaînes de caractères ou de paramètres de type DATE
/ TIME
/ TIMESTAMP
.
Note
|
Si un ou plusieurs paramètres d’entrée sont |
MINVALUE
MINVALUE
SELECT MINVALUE(PRICE_1, PRICE_2) AS PRICE
FROM PRICELIST
NULLIF()
DSQL, PSQL
NULLIF (<exp1>, <exp2>)
Paramètre | Description |
---|---|
expr1, expr2 |
Expressions de tout type compatible. |
dépend des types d’arguments d’entrée
La fonction retourne la valeur du premier argument s’il n’est pas égal au second. Si les arguments sont égaux, NULL
est retourné.
NULLIF
NULLIF
SELECT AVG(NULLIF(weight, -1)) FROM cargo;
Cette requête renvoie la valeur moyenne du champ weight
sur la table, sauf pour les lignes où il n’est pas spécifié (égal à -1). S’il n’y avait pas cette fonction, le simple opérateur avg(weight)
renverrait une valeur incorrecte.
Cette section contient des caractéristiques difficiles à catégoriser.
MAKE_DBKEY()
DSQL, PSQL
MAKE_DBKEY (<relation>, recnum [, dpnum [, ppnum]]}) <relation> ::= rel_name | rel_id
Paramètre | Description |
---|---|
rel_name |
Nom de la table. |
rel_id |
ID de la table. Peut être trouvé dans `RDB$RELATIONS.RDB$RELATION_ID'. |
recnum |
Numéro d’enregistrement, soit absolu (si dpnum et ppnum sont absents), soit relatif (si dpnum est présent). |
dpnum |
Numéro de page des données DP, soit absolu (si ppnum est absent), soit relatif (si ppnum est présent). |
ppnum |
Numéro de page des pointeurs vers les données PP. |
La fonction MAKE_DBKEY
crée une valeur DBKEY
en utilisant le nom ou l’identifiant de la table, le numéro d’enregistrement et, en option, un numéro de page de données logique et un numéro de page de pointeur.
Note
|
Remarques
|
La requête sélectionne un enregistrement en utilisant le nom de la table (nom de la table en majuscules).
select * from rdb$relations where rdb$db_key = make_dbkey('RDB$RELATIONS', 0)
La requête sélectionne un enregistrement en utilisant l’identifiant de la table
select * from rdb$relations where rdb$db_key = make_dbkey(6, 0)
La requête sélectionne tous les enregistrements qui sont physiquement sur la première page des données dans la table
select * from rdb$relations
where rdb$db_key >= make_dbkey(6, 0, 0)
and rdb$db_key < make_dbkey(6, 0, 1)
La requête sélectionne tous les enregistrements qui sont physiquement sur la première page de données de la page d’index 6 dans la table
select * from SOMETABLE
where rdb$db_key >= make_dbkey('SOMETABLE', 0, 0, 5)
and rdb$db_key < make_dbkey('SOMETABLE', 0, 1, 5)
Voir aussi: [fblangref-appx-supp-rdb-dbkey].
RDB$ERROR()
PSQL
RDB$ERROR (<context>) <context> ::= GDSCODE | SQLCODE | SQLSTATE | EXCEPTION | MESSAGE
Cela dépend du contexte
Renvoie la valeur du contexte de l’exception active. Le type de retour dépend du contexte.
Note
|
La fonction |
Contextes disponibles comme argument de la fonction RDB$ERROR
:
EXCEPTION
La fonction renvoie un nom d’exception si une exception définie par l’utilisateur est active, ou NULL
si une des exceptions du système est active.Pour le contexte EXCEPTION
, le type de valeur de retour : VARCHAR(63) JEU DE CARACTÈRES UTF8
.
MESSAGE
la fonction retourne le texte interprété d’une exception active.Pour le contexte MESSAGE
, le type de valeur de retour : VARCHAR(1024) JEU DE CARACTÈRES UTF8
.
GDSCODE
la fonction retourne la valeur de la variable contextuelle GDSCODE
.
SQLCODE
la fonction retourne la valeur de la variable contextuelle SQLCODE
.
SQLSTATE
la fonction retourne la valeur de la variable de contexte SQLSTATE
.
RDB$ERROR
pour sauvegarder le texte de l’erreur dans le journal de bord...
BEGIN
...
WHEN ANY DO
EXECUTE PROCEDURE P_LOG_EXCEPTION(RDB$ERROR(MESSAGE));
END
...
RDB$GET_TRANSACTION_CN()
DSQL, PSQL
RDB$GET_TRANSACTION_CN (transaction_id)
Paramètre | Description |
---|---|
transaction_id |
Numéro de transaction (identifiant) |
BIGINT
Renvoie le numéro d’engagement pour une transaction donnée.
Note
|
Les mécanismes internes de Firebird utilisent un entier non signé de 8 octets pour le Commit Number et un entier non signé de 6 octets pour le numéro de transaction. Par conséquent, même si le langage SQL n’a pas d’entiers non signés, et que |
Si la fonction RDB$GET_TRANSACTION_CN
renvoie une valeur supérieure à 1, il s’agit du (Commit Number) réel de la transaction, c’est-à-dire que la transaction a été validée après le démarrage de la base de données.
Dans d’autres cas, la fonction peut renvoyer l’un des résultats suivants indiquant l’état de validation de la transaction :
-2
|
transactions mortes (annulées) ; |
-1
|
Transactions suspendues (en état de limbo 2PC transactions) ; |
0
|
transactions actives ; |
1
|
pour les transactions validées avant le démarrage de la base de données ou avec un numéro inférieur à OIT (Oldest Interesting Transaction) ; |
NULL
|
: Si le numéro de transaction est |
RDB$GET_TRANSACTION_CN
select rdb$get_transaction_cn(current_transaction) from rdb$database;
select rdb$get_transaction_cn(123) from rdb$database;
Retourne le numéro de commit de la transaction donnée. Le type de résultat est BIGINT.
Note
|
Remarques :
le moteur utilise en interne des entiers non signés de 8 octets pour les numéros de commit, et des entiers non signés de 6 octets pour les numéros de transaction. Ainsi, malgré que le langage SQL n'ait pas d'entiers non signés et que RDB$GET_TRANSACTION_CN retourne BIGINT signés, il est impossible de voir des nombres de commit négatifs à l'exception des quelques valeurs spéciales utilisées pour les transactions non commises. En résumé, les nombres retournés par RDB$GET_TRANSACTION_CN peuvent avoir les valeurs suivantes : -2 - la transaction est morte (annulée) -1 - la transaction est dans les limbes 0 - la transaction est active, 1 - la transaction a été effectuée avant le démarrage de la base de données ou moins que la base de données. Transaction intéressante la plus ancienne >1 - transaction effectuée après le démarrage de la base de données NULL - le numéro de transaction donné est NULL ou supérieur à celui de la base de données Next Transaction (Transaction suivante) |
Voir aussi README.read_consistency.md
Format : RDB$GET_TRANSACTION_CN( <numéro de transaction> )
Exemples :
select rdb$get_transaction_cn(current_transaction) from rdb$database ;
select rdb$get_transaction_cn(123) from rdb$database ;
Note
|
Pour plus d’informations sur le Commit Number, reportez-vous aux Firebird 4.0 Release Notes. |
RDB$ROLE_IN_USE()
DSQL, PSQL
RDB$ROLE_IN_USE (role_name)
Paramètre | Description |
---|---|
role_name |
Le nom du rôle dont l’utilisation est contrôlée. |
BOOLEAN
La fonction RDB$ROLE_IN_USE
retourne si le rôle est utilisé par l’utilisateur actuel.
Note
|
Cette fonction vous permet de vérifier l’utilisation de n’importe quel rôle : ceux spécifiés explicitement (lors de la connexion ou modifiés à l’aide de l’instruction SET ROLE) et ceux attribués implicitement (rôles attribués à un utilisateur à l’aide de la clause DEFAULT). |
RDB$ROLE_IN_USE
-- Vérifier si l'attribut explicitement attribué ou
-- rôle de MANAGER obtenu implicitement
IF (RDB$ROLE_IN_USE('MANAGER')) THEN
BEGIN
...
END
SELECT * FROM RDB$ROLES WHERE RDB$ROLE_IN_USE(RDB$ROLE_NAME)
RDB$SYSTEM_PRIVILEGE()
DSQL, PSQL
RDB$SYSTEM_PRIVILEGE (<privilege>)
Paramètre | Description |
---|---|
privilege |
Privilège système vérifiable |
BOOLEAN
La fonction RDB$SYSTEM_PRIVILEGE
utilise le privilège système de la connexion actuelle. Pour obtenir une liste des privilèges système, consultez la rubrique CREATE ROLE.
RDB$SYSTEM_PRIVILEGE
SELECT RDB$SYSTEM_PRIVILEGE(USER_MANAGEMENT) FROM RDB$DATABASE;
ABS()
DSQL, PSQL
ABS (number)
Paramètre | Description |
---|---|
number |
Expression de type numérique |
est le même que l’argument d’entrée.
La fonction ABS
renvoie la valeur absolue (modulo) de l’argument.
COS()
DSQL, PSQL
COS (angle)
Paramètre | Description |
---|---|
angle |
Angle exprimé en radians. |
DOUBLE PRECISION
La fonction COS
renvoie le cosinus d’un angle. L’argument doit être donné en radians.
Tout résultat NOT NULL
se situe dans l’intervalle [-1, 1].
COSH()
DSQL, PSQL
COSH (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction COSH
renvoie le cosinus hyperbolique de l’argument.
Tout résultat NOT NULL
se situe dans l’intervalle [1, +∞].
COT()
DSQL, PSQL
COT (angle)
Paramètre | Description |
---|---|
angle |
Angle exprimé en radians. |
DOUBLE PRECISION
La fonction COT
renvoie la cotangente de l’angle. L’argument doit être donné en radians.
EXP()
DSQL, PSQL
EXP (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction EXP
retourne la valeur de l’exposant naturel, enombre
.
FLOOR()
DSQL, PSQL
FLOOR (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
BIGINT
, INT128
, DECFLOAT
ou DOUBLE PRECISION
selon le type d’argument.
La fonction FLOOR
renvoie un entier inférieur ou égal à l’argument.
[fblangref-scalarfuncs-ceil], [fblangref-scalarfuncs-trunc].
LN()
DSQL, PSQL
LN (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction LN
renvoie le logarithme naturel de l’argument.
Note
|
Si un argument négatif ou nul est passé, la fonction renvoie une erreur. |
LOG()
DSQL, PSQL
LOG (x, y)
Paramètre | Description |
---|---|
x |
Base. Expression de type numérique. |
y |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction LOG
renvoie le logarithme de y (deuxième argument) sur la base de x (premier argument).
Particularités d’utilisation :
Si l’un des arguments est inférieur ou égal à 0, une erreur se produit ;
Si les deux arguments valent 1, le résultat de la fonction est NaN
(Not-a-Number — pas un nombre) ;
Si x = 1 et y < 1, le résultat de la fonction est -INF
(-∞) ;
Si x = 1 et y > 1, le résultat de la fonction est `INF` (∞).
LOG10()
DSQL, PSQL
LOG10 (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction `LOG10' renvoie le logarithme décimal de l’argument.
Note
|
Si l’argument d’entrée est négatif ou égal à 0, une erreur se produit. |
MOD()
DSQL, PSQL
MOD (a, b)
Paramètre | Description |
---|---|
a |
Expression est de type numérique. |
b |
Expression est de type numérique. |
INTEGER
, BIGINT
ou INT128
selon les types d’arguments.
La fonction MOD
renvoie le reste d’une division d’un nombre entier.
Note
|
Les nombres réels sont arrondis avant d’effectuer la division. Par exemple, le résultat de “`mod(7,5, 2,5)`” serait 2 (" |
PI()
DSQL, PSQL
PI ()
DOUBLE PRECISION
La fonction PI
renvoie le nombre π.
ACOS()
DSQL, PSQL
ACOS (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique dans la plage [-1 ; 1]. |
DOUBLE PRECISION
La fonction ACOS
retourne l’arc cosinus (en radians) de l’argument.
Si l’argument de la fonction est en dehors de l’intervalle [-1, 1], la fonction renverra une valeur indéfinie NaN
.
POWER()
DSQL, PSQL
POWER (x, y)
Paramètre | Description |
---|---|
x |
Expression est de type numérique. |
y |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction POWER
renvoie le résultat de l’élévation de x à la puissance de y, c’est-à-dire (xy).
Note
|
Si x est inférieur à zéro, une erreur se produit. |
RAND()
DSQL, PSQL
RAND ()
DOUBLE PRECISION
La fonction RAND
renvoie un nombre pseudo-aléatoire entre 0 et 1.
ROUND()
DSQL, PSQL
ROUND (number [, scale])
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
scale |
L’échelle est un nombre entier définissant le nombre de décimales auquel l’arrondi doit être effectué, soit
La valeur par défaut est 0. |
entier mis à l’échelle (INTEGER
, BIGINT
ou INT128
) ou DECFLOAT
ou DOUBLE PRECISION
selon le type de number.
La fonction ROUND
arrondit le nombre au nombre entier le plus proche. Si la partie fractionnaire est égale à 0,5, elle est arrondie au nombre entier supérieur le plus proche pour les nombres positifs et au nombre entier inférieur le plus proche pour les nombres négatifs. Avec le paramètre optionnel scale, le nombre peut être arrondi à l’une des puissances de 10 (dizaines, centaines, dixièmes, centièmes, etc.) au lieu d’un simple nombre entier.
Note
|
Si le paramètre scale est utilisé, le résultat a la même échelle que le premier paramètre number. |
ROUND
ROUND
ROUND(123.654, 1) -- Résultat : 123.700 (pas 123.7)
ROUND(8341.7, -3) -- Résultat : 8000.0 (pas 8000)
ROUND(45.1212, 0) -- Résultat : 45.0000 (pas 45)
ROUND(45.1212) -- Résultat : 45
SIGN()
DSQL, PSQL
SIGN (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
SMALLINT
La fonction SIGN
renvoie le signe du paramètre d’entrée.
-1 — le nombre est inférieur à zéro
0 — le nombre est zéro
1 — le nombre est plus grand que zéro
SIN()
DSQL, PSQL
SIN (angle)
Paramètre | Description |
---|---|
angle |
Angle exprimé en radians. |
DOUBLE PRECISION
La fonction SIN
renvoie le sinus d’un angle. L’argument doit être donné en radians.
Tout résultat NOT NULL
se situe dans l’intervalle [-1, 1].
SINH()
DSQL, PSQL
SINH (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction SINH
renvoie le sinus hyperbolique de l’argument.
SQRT()
DSQL, PSQL
SQRT (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction SQRT
renvoie la racine carrée de l’argument.
TAN()
DSQL, PSQL
TAN (angle)
Paramètre | Description |
---|---|
angle |
Angle exprimé en radians. |
DOUBLE PRECISION
La fonction TAN
renvoie la tangente de l’angle. L’argument doit être donné en radians.
[fblangref-scalarfuncs-atan], [fblangref-scalarfuncs-atan2].
TANH()
DSQL, PSQL
TANH (number)
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
DOUBLE PRECISION
La fonction TANH
renvoie la tangente hyperbolique de l’argument.
Tout résultat NOT NULL
se situe dans l’intervalle [-1, 1].
TRUNC()
DSQL, PSQL
TRUNC (number [, scale])
Paramètre | Description |
---|---|
number |
Expression est de type numérique. |
scale |
L’échelle est un nombre entier définissant le nombre de décimales auquel la troncature doit être effectuée, c’est à dire
La valeur par défaut est 0. |
entier mis à l’échelle (INTEGER
, BIGINT
ou INT128
) ou DECFLOAT
ou DOUBLE PRECISION
selon le type de number.
La fonction TRUNC
tronque le nombre à l’entier le plus proche. Avec le paramètre optionnel scale, le nombre peut être tronqué à l’une des puissances de 10 (dizaines, centaines, dixièmes, centièmes, etc.) au lieu d’un simple nombre entier.
Note
|
Si le paramètre scale est utilisé, le résultat a la même échelle que le premier paramètre number. |
Important
|
La fonction incrémente toujours les nombres négatifs car elle rogne la partie fractionnaire. |
TRUNC
TRUNC(789.2225, 2) -- Résultat : 789.2200 (pas 789.22)
TRUNC(345.4, -2) -- Résultat : 300.0 (pas 300)
TRUNC(-163.41, 0) -- Résultat : -163.00 (pas -163)
TRUNC(-163.41) -- Résultat : -163
ACOSH()
DSQL, PSQL
ACOSH (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique dans la plage [1 ; +∞]. |
DOUBLE PRECISION
La fonction ACOSH
retourne l’arc cosinus hyperbolique (en radians) de l’argument.
ASIN()
DSQL, PSQL
ASIN (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique dans l’intervalle [-1 ; 1]. |
DOUBLE PRECISION
La fonction ASIN
renvoie l’arcsine (en radians) de l’argument.
Si l’argument de la fonction est en dehors de l’intervalle [-1, 1], la fonction renverra une valeur indéfinie NaN
.
ASINH()
DSQL, PSQL
ASIN (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique. |
DOUBLE PRECISION
La fonction ASINH
renvoie l’arcsinus hyperbolique (en radians) de l’argument.
ATAN()
DSQL, PSQL
ATAN (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique. |
DOUBLE PRECISION
La fonction ATAN
retourne l’arctangente de l’argument.
La fonction renvoie l’angle en radians dans l’intervalle [-π/2 ; π/2].
ATAN2()
DSQL, PSQL
ATAN2 (y, x)
Paramètre | Description |
---|---|
y |
Une expression de type numérique. |
x |
Une expression de type numérique. |
DOUBLE PRECISION
La fonction ATAN2
retourne l’angle comme le rapport du sinus au cosinus, avec les arguments donnés par ces deux paramètres, et les signes du sinus et du cosinus correspondant aux signes des paramètres.Cela permet d’obtenir des résultats pour le cercle entier, y compris pour les angles de -π/2 et π/2.
Caractéristiques d’utilisation :
Le résultat est un angle dans l’intervalle [-π, π] radians ;
Si x est négatif, le résultat est π lorsque y est nul et -π lorsqu’il est égal à 0 ;
Si y et x sont tous deux égaux à 0, le résultat n’a pas de sens.
Note
|
|
ATANH()
DSQL, PSQL
ATANH (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique. |
DOUBLE PRECISION
La fonction ATANH
retourne l’arctangente hyperbolique (en radians) de l’argument.
CEIL()
, CEILING()
DSQL, PSQL
CEIL[ING] (number)
Paramètre | Description |
---|---|
number |
Une expression de type numérique. |
BIGINT
, INT128
, DECFLOAT
ou DOUBLE PRECISION
selon le type d’argument.
La fonction CEIL
renvoie le plus petit entier supérieur ou égal à l’argument.
[fblangref-scalarfuncs-floor], [fblangref-scalarfuncs-trunc].
ASCII_CHAR()
DSQL, PSQL
ASCII_CHAR (code)
Paramètre | Description |
---|---|
code |
Un nombre entier compris entre 0 et 255. |
CHAR(1) CHARACTER SET NONE
.
La fonction ASCII_CHAR renvoie un caractère ASCII correspondant au nombre passé en argument.
LEFT()
DSQL, PSQL
LEFT (string, length)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
length |
Nombre entier. Spécifie le nombre de caractères retournés. |
VARCHAR
ou BLOB
.
La fonction LEFT
retourne le côté gauche de la chaîne de caractères, le nombre de caractères retournés est déterminé par le deuxième paramètre.
Caractéristiques d’utilisation :
La fonction prend en charge les blocs de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères ;
Si l’argument chaîne est BLOB
, le résultat sera BLOB, sinon le résultat sera VARCHAR(N), avec N étant la longueur du paramètre chaîne ;
Si le paramètre numérique dépasse la longueur du texte, le résultat sera le texte original.
Warning
|
Lorsque vous utilisez |
SELECT LEFT('ABC', 2) FROM rdb$database;
-- Résultat AB
[fblangref-scalarfuncs-right], [fblangref-scalarfuncs-substring].
LOWER()
DSQL, PSQL, ESQL
LOWER (string)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
VAR[CHAR]
ou BLOB
La fonction LOWER
retourne la chaîne de caractères d’entrée en minuscules. Le résultat exact dépend du jeu de caractères de la chaîne d’entrée. Par exemple, pour les jeux de caractères NONE et ASCII, seuls les caractères ASCII sont convertis en minuscules ; pour les jeux de caractères OCTETS — la chaîne d’entrée entière est retournée inchangée.
LOWER
LOWER
select Sherifffrom Townswhere lower(Name) = 'cooper''s valley'
LPAD()
DSQL, PSQL
LPAD (str, endlen [, padstr])
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
endlen |
La longueur de la chaîne de sortie. |
padstr |
Une chaîne de caractères qui est ajoutée à la chaîne de caractères d’origine jusqu’à la longueur spécifiée. (“ |
VARCHAR
ou BLOB
.
La fonction LPAD
étend la chaîne d’entrée vers la gauche avec des espaces ou une chaîne définie par l’utilisateur jusqu’à une longueur spécifiée.
Caractéristiques d’utilisation :
La fonction prend en charge les blocs de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères ;
Si la chaîne d’entrée est de type BLOB
, le résultat sera également BLOB
, sinon le résultat sera VARCHAR(endlen)
.
Si l’argument padstr est donné mais est `
(chaîne vide), aucune chaîne n’est ajoutée ! Dans le cas où endlen est inférieur à la longueur de la chaîne d’entrée, le résultat est tronqué à la longueur de endlen, même si padstr est une chaîne vide.
Warning
|
Lorsque vous utilisez |
LPAD
LPAD
LPAD ('Hello', 12) -- renvoie ' Hello'
LPAD ('Hello', 12, '-') -- renvoie '-------Hello'
LPAD ('Hello', 12, '') -- renvoie 'Hello'
LPAD ('Hello', 12, 'abc') -- renvoie 'abcabcaHello'
LPAD ('Hello', 12, 'abcdefghij') -- renvoie 'abcdefgHello'
LPAD ('Hello', 2) -- renvoie 'He'
LPAD ('Hello', 2, '-') -- renvoie 'He'
LPAD ('Hello', 2, '') -- renvoie 'He'
OCTET_LENGTH()
DSQL, PSQL
OCTET_LENGTH (string)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
BIGINT
La fonction OCTET_LENGTH
renvoie le nombre d’octets occupés par la chaîne de caractères.
Lorsqu’il s’agit de paramètres de type CHAR
, la fonction renvoie la longueur totale de la chaîne formelle. Pour connaître la longueur logique
de la chaîne en octets, RIGHT TRIM doit être appliqué avant de passer l’argument à la fonction.
Note
|
Notez que tous les jeux de caractères n’ont pas le même nombre d’octets que le nombre de caractères. |
OCTET_LENGTH
OCTET_LENGTH
SELECT OCTET_LENGTH('Hello!')
FROM rdb$database
-- retournera 6
SELECT OCTET_LENGTH(_iso8859_1 'Grüß di!')
FROM rdb$database
-- retournera 8 : ü et ß n'occupent pas plus d'un octet en ISO8859_1
SELECT
OCTET_LENGTH(CAST(_iso8859_1 'Grüß di!' AS VARCHAR(24) CHARACTER SET utf8))
FROM rdb$database
-- retournera 10 : ü et ß occupent 2 octets en UTF8
SELECT
OCTET_LENGTH(CAST(_iso8859_1 'Grüß di!' AS CHAR(24) CHARACTER SET utf8))
FROM rdb$database
-- retournera 26 : un total de 24 positions CHAR et deux d'entre elles occupent 2 octets.
OVERLAY()
DSQL, PSQL
OVERLAY (string PLACING replacement FROM pos [FOR length])
Paramètre | Description |
---|---|
string |
La ligne dans laquelle le remplacement a lieu. |
replacement |
La ligne à remplacer par. |
pos |
La position à partir de laquelle le remplacement a lieu. |
length |
Le nombre de caractères à supprimer de la chaîne originale. |
VARCHAR
ou BLOB
La fonction OVERLAY
est utilisée pour remplacer une partie d’une chaîne de caractères par une autre chaîne.
Par défaut, le nombre de caractères à supprimer d’une chaîne est égal à la longueur de la chaîne à remplacer.Un quatrième paramètre facultatif permet à l’utilisateur de définir son propre nombre de caractères à supprimer.
Caractéristiques d’utilisation :
La fonction supporte entièrement le test BLOB
avec n’importe quel jeu de caractères et n’importe quelle longueur ;
Si la chaîne d’entrée est de type BLOB
, alors le résultat sera également de type BLOB
. Sinon, le type de résultat sera VARCHAR(n)
, où n est la somme des longueurs des paramètres string et replacement ;
Comme dans toutes les fonctions de chaîne SQL, pos est le paramètre déterminant ;
Si pos est plus long que la longueur de la chaîne, remplacement est placé immédiatement après la fin de la chaîne ;
Si le nombre de caractères entre pos et la fin de la chaîne est inférieur à la longueur de remplacement (ou au paramètre length, s’il est spécifié), la chaîne est tronquée à pos et remplacement est placé après elle ;
Si le paramètre length est égal à zéro (FOR 0), replacement est simplement inséré dans la chaîne, en commençant à la position pos ;
Si l’un des paramètres a la valeur NULL
, le résultat est NULL
;
Si les paramètres pos et length ne sont pas des entiers, l’arrondi bancaire (à un nombre pair) est utilisé : 0,5 devient 0, 1,5 devient 2, 2,5 devient 2, 3,5 devient 4, etc.
Warning
|
Lors de l’utilisation d’une fonction |
OVERLAY
OVERLAY
OVERLAY ('Goodbye' PLACING 'Hello' FROM 2) -- Résultat: 'GHelloe'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 5) -- Résultat: 'GoodHello'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 8) -- Résultat: 'GoodbyeHello'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 20) -- Résultat: 'GoodbyeHello'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 2 FOR 0) -– Résultat: 'GHellooodbye'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 2 FOR 3) -- Résultat: 'GHellobye'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 2 FOR 6) -- Résultat: 'GHello'
OVERLAY ('Goodbye' PLACING 'Hello' FROM 2 FOR 9) -- Résultat: 'Ghello'
OVERLAY ('Goodbye' PLACING '' FROM 4) -- Résultat: 'Goodbye'
OVERLAY ('Goodbye' PLACING '' FROM 4 FOR 3) -- Résultat: 'Gooe'
OVERLAY ('Goodbye' PLACING '' FROM 4 FOR 20) -- Résultat: 'Goo'
OVERLAY ('' PLACING 'Hello' FROM 4) -- Résultat: 'Hello'
OVERLAY ('' PLACING 'Hello' FROM 4 FOR 0) -- Résultat: 'Hello'
OVERLAY ('' PLACING 'Hello' FROM 4 FOR 20) -- Résultat: 'Hello'
[fblangref-scalarfuncs-substring], [fblangref-scalarfuncs-replace].
POSITION()
DSQL, PSQL
POSITION (substr IN string) | POSITION (substr, string [, startpos])
Paramètre | Description |
---|---|
substr |
Sous-chaîne dont la position est recherchée. |
string |
La ligne dans laquelle la position est recherchée. |
startpos |
La position à laquelle la recherche de sous-chaîne commence. |
INTEGER
La fonction POSITION
renvoie la position de la première occurrence d’une sous-chaîne dans la chaîne.Il commence par 1.Le troisième argument (facultatif) indique la position dans la chaîne à laquelle la recherche de la sous-chaîne commence, ignorant ainsi toutes les occurrences de la sous-chaîne dans la chaîne avant cette position.Si aucune correspondance n’est trouvée, la fonction renvoie 0.
Caractéristiques d’utilisation :
Un troisième paramètre facultatif n’est pris en charge que par la deuxième variante de la syntaxe (syntaxe à virgules séparées) ;
Une chaîne vide, la fonction la traite comme une sous-chaîne de n’importe quelle chaîne. Par conséquent, avec un paramètre d’entrée substr égal à '
(chaîne vide), et avec un paramètre string autre que NULL
, le résultat sera :
1, si le paramètre startpos n’est pas donné ;
startpos, si startpos ne dépasse pas la longueur du paramètre string ;
0 si startpos est supérieur à la longueur du paramètre string.
POSITION
POSITION
POSITION ('be' IN 'To be or not to be') -- Résultat: 4
POSITION ('be', 'To be or not to be') -- Résultat: 4
POSITION ('be', 'To be or not to be', 4) -- Résultat: 4
POSITION ('be', 'To be or not to be', 8) -- Résultat: 17
POSITION ('be', 'To be or not to be', 18) -- Résultat: 0
POSITION ('be' in 'Alas, poor Yorick!') -- Résultat: 0
REPLACE()
DSQL, PSQL
REPLACE (str, find, repl)
Paramètre | Description |
---|---|
str |
La ligne dans laquelle le remplacement est effectué. |
find |
La chaîne de caractères qui fait l’objet de la recherche. |
repl |
La ligne sur laquelle s’effectue le remplacement. |
VARCHAR
ou BLOB
La fonction REPLACE
remplace toutes les occurrences d’une chaîne par une autre.
Caractéristiques d’utilisation :
La fonction prend en charge les blocs de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères ;
Si l’un des arguments est de type BLOB
, le résultat sera de type BLOB
. Sinon, le résultat sera de type VARCHAR(N)
, où N est calculé à partir des longueurs de str, find et repl de telle sorte que même le nombre maximal de substitutions ne provoquera pas de dépassement de champ.
Si le paramètre find est une chaîne vide, str est retourné inchangé ;
Si le paramètre repl est une chaîne vide, toutes les occurrences de find sont supprimées de la chaîne str ;
Si l’un des arguments est NULL
, le résultat est toujours NULL
, même si aucune substitution n’a été faite.
Warning
|
Lorsque vous utilisez |
REPLACE
REPLACE
REPLACE ('Billy Wilder', 'il', 'oog') -- retourne 'Boogly Woogder'
REPLACE ('Billy Wilder', 'il', '') -- retourne 'Bly Wder'
REPLACE ('Billy Wilder', null, 'oog') -- retourne NULL
REPLACE ('Billy Wilder', 'il', null) -- retourne NULL
REPLACE ('Billy Wilder', 'xyz', null) -- retourne NULL (!)
REPLACE ('Billy Wilder', 'xyz', 'abc') -- retourne 'Billy Wilder'
REPLACE ('Billy Wilder', '', 'abc') -- retourne 'Billy Wilder'
REVERSE()
DSQL, PSQL
REVERSE (string)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
VARCHAR
La fonction REVERSE
renvoie la chaîne de caractères inversée "à l’envers".
REVERSE
REVERSE
REVERSE ('spoonful') -- retourne 'lufnoops'
REVERSE ('Was it a cat I saw?') -- retourne '?was I tac a ti saW'
Tip
|
Cette fonction est très utile si vous souhaitez traiter (trier ou grouper) des informations qui se trouvent à la fin d’une chaîne de caractères, par exemple des noms de domaine ou des adresses électroniques.
|
RIGHT()
DSQL, PSQL
RIGHT (string, length)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
length |
Nombre entier. Spécifie le nombre de caractères retournés. |
VARCHAR
ou BLOB
La fonction RIGHT
renvoie la partie finale (droite) de la chaîne de caractères d’entrée.La longueur de la sous-chaîne retournée est déterminée par le deuxième paramètre.
Caractéristiques d’utilisation :
La fonction prend en charge les blocs de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères ;
Si l’argument chaîne est BLOB
, le résultat est BLOB
, sinon le résultat est VARCHAR(N)
, avec N — égal à la longueur du paramètre chaîne ;
Si le paramètre numérique dépasse la longueur du texte, le résultat sera le texte original.
Warning
|
Lorsque vous utilisez |
RIGHT
SELECT RIGHT('ABC', 1) FROM rdb$database;
-- Résultat C
[fblangref-scalarfuncs-left], [fblangref-scalarfuncs-substring].
RPAD()
DSQL, PSQL
RPAD (str, endlen [, padstr])
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
endlen |
La longueur de la chaîne de sortie. |
padstr |
Une chaîne de caractères qui est ajoutée à la chaîne de caractères d’origine jusqu’à la longueur spécifiée ( |
VARCHAR
ou BLOB
La fonction RPAD
complète la chaîne d’entrée de droite avec des espaces ou une chaîne définie par l’utilisateur jusqu’à une longueur spécifiée.
Caractéristiques d’utilisation :
La fonction prend en charge les blocs de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères ;
Si la chaîne d’entrée est de type BLOB
, le résultat sera également BLOB, sinon le résultat sera VARCHAR(endlen)
.
Si l’argument padstr est donné mais est ''
(chaîne vide), aucune chaîne n’est ajoutée ! Dans le cas où endlen est inférieur à la longueur de la chaîne d’entrée, le résultat est tronqué à la longueur de endlen, même si padstr est une chaîne vide.
Warning
|
Lorsque vous utilisez |
RPAD
RPAD
RPAD ('Hello', 12) -- retourne 'Hello '
RPAD ('Hello', 12, '-') -- retourne 'Hello-------'
RPAD ('Hello', 12, '') -- retourne 'Hello'
RPAD ('Hello', 12, 'abc') -- retourne 'Helloabcabca'
RPAD ('Hello', 12, 'abcdefghij') -- retourne 'Helloabcdefg'
RPAD ('Hello', 2) -- retourne 'He'
RPAD ('Hello', 2, '-') -- retourne 'He'
RPAD ('Hello', 2, '') -- retourne 'He'
ASCII_VAL()
DSQL, PSQL
ASCII_VAL (ch)
Paramètre | Description |
---|---|
ch |
Type de données string [VAR]CHAR ou text BLOB d’une taille maximale de 32767 octets. |
SMALLINT
La fonction ASCII_VAL
renvoie le code ASCII du caractère passé en argument.
Caractéristiques d’utilisation :
Si la chaîne contient plus d’un caractère, le code du premier caractère de la chaîne est renvoyé ;
Si la chaîne est vide, elle renvoie null ;
Si l’argument est NULL
, la valeur de retour est également NULL
.
SUBSTRING()
DSQL, PSQL
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>
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
startpos |
La position à laquelle l’extraction de la sous-chaîne commence. Expression entière. |
length |
Longueur de la sous-chaîne retournée. Expression entière. |
similar-pattern |
Le modèle de l’expression SQL régulière utilisée pour rechercher la sous-chaîne. |
escape |
Symbole d’échappement |
VARCHAR
ou BLOB
La fonction SUBSTRING
renvoie une sous-chaîne de caractères à partir d’une position donnée jusqu’à la fin de la chaîne ou jusqu’à une longueur spécifiée, ou extrait une sous-chaîne en utilisant un motif SQL régulier.
Si l’un des paramètres d’entrée est défini comme NULL
, le résultat sera également défini comme NULL
.
Warning
|
Lorsque vous utilisez |
SUBSTRING
Sous une forme positionnelle simple (avec FROM
), cette fonction renvoie une sous-chaîne commençant à la position du caractère startpos (la position du premier caractère est 1). Sans l’argument FOR
, il retourne tous les caractères restants dans la chaîne.Avec FOR, il renvoie les caractères longueur ou le reste de la chaîne, selon ce qui est le plus court.
A partir de Firebird 4.0, startpos peut être inférieur à 1.Lorsque startpos est inférieur à 1, la sous-chaîne se comporte comme si elle avait un 1 - startpos
supplémentaire devantle premier caractère réel à la position 1
.La valeur de length est comptée à partir de ce début imaginaire de la chaîne, donc la chaîne résultante peut être plus courte que la length spécifiée ou même vide.
La fonction prend entièrement en charge les BLOB binaires et textuels de n’importe quelle longueur et avec n’importe quel jeu de caractères.Si le paramètre str est de type BLOB
, le résultat sera également de type BLOB
.Pour tout autre type, le résultat est de type VARCHAR
.
Pour un paramètre d’entrée str qui n’est pas BLOB
, la longueur du résultat de la fonction sera toujours égale à la longueur de la chaîne str, quelles que soient les valeurs des paramètres startpos et length.
SUBSTRING
select substring('abcdef' from 1 for 2) from rdb$database;
-- Résultat: 'ab'
select substring('abcdef' from 2) from rdb$database;
-- Résultat: 'bcdef'
select substring('abcdef' from 0 for 2) from rdb$database;
-- Résultat: 'a'
-- pas "ab", car il n'y a pas de "rien" en position 0
select substring('abcdef' from -5 for 2) from rdb$database;
-- Résultat: ''
-- la longueur se termine avant le début réel de la ligne
SUBSTRING
par une expression régulièreLa fonction SUBSTRING
avec une expression régulière (avec SIMILAR
) retourne une partie d’une chaîne de caractères correspondant au modèle d’expression régulière du SQL. Si aucune correspondance n’est trouvée, NULL
est retourné.
Le motif SIMILAR
est formé de trois motifs d’expression régulière SQL : R1, R2 et R3. Le modèle complet a la forme R1 || '<escape>' || R2 || '<escape>' || R3
, où <escape> est le caractère d’échappement défini dans la clause ESCAPE
.R2 est le motif qui correspond à la sous-chaîne à extraire et qui est entouré de guillemets doubles échappés (<escape>
, par exemple, #"
avec le caractère d’échappement ‘`#’). R1 correspond au préfixe de la chaîne, et R3 au suffixe de la chaîne. R1 et R3 sont tous deux facultatifs (ils peuvent être vides), mais le motif doit correspondre à la chaîne entière. En d’autres termes, il ne suffit pas de spécifier un motif qui ne trouve qu’une sous-chaîne à extraire.
Tip
|
Les guillemets doubles échappés autour de R2 peuvent être comparés à la définition d’un groupe de capture unique dans une syntaxe d’expression régulière plus commune telle que PCRE. C’est-à-dire que le motif complet est équivalent à La valeur de retour correspond à la partie R2 de l’expression régulière. Pour cette valeur, l’expression est vraie.
|
Note
|
Si une partie d’un motif de R1, R2 ou R3 n’est pas une chaîne vide et n’a pas de format d’expression régulière SQL, une exception est levée. |
Le format complet des instructions SQL régulières est décrit dans le document suivant Syntaxe des expressions régulières SQL.
SUBSTRING
avec des expressions régulièresSUBSTRING('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
TRIM ([<adjust>] str) <adjust> ::= {[<where>] [what]} FROM <where> ::= BOTH | LEADING | TRAILING
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
where |
De quel endroit la sous-chaîne doit être retirée — |
what |
Une sous-chaîne à supprimer (plusieurs fois, s’il y a plus d’une occurrence) de la chaîne d’entrée str au début et/ou à la fin. Par défaut, il s’agit d’un espace. ( |
VARCHAR
ou BLOB
La fonction TRIM
supprime les espaces de début et/ou de fin (ou le texte tel que configuré) de la chaîne d’entrée.
Note
|
Caractéristiques d’utilisation
|
Warning
|
Lorsque vous utilisez |
TRIM
TRIM
SELECT TRIM (' Waste no space ')
FROM RDB$DATABASE -- Résultat: 'Waste no space'
SELECT TRIM (LEADING FROM ' Waste no space ')
FROM RDB$DATABASE -- Résultat: 'Waste no space '
SELECT TRIM (LEADING '.' FROM ' Waste no space ')
FROM RDB$DATABASE -- Résultat: ' Waste no space '
SELECT TRIM (TRAILING '!' FROM 'Help!!!!')
FROM RDB$DATABASE -- Résultat: 'Help'
SELECT TRIM ('la' FROM 'lalala I love you Ella')
FROM RDB$DATABASE -- Résultat: ' I love you El'
[fblangref-scalarfuncs-overlay], [fblangref-scalarfuncs-replace].
UNICODE_CHAR()
DSQL, PSQL
UNICODE_CHAR (number)
Paramètre | Description |
---|---|
number |
Un point de code UTF-32 acceptable se situe en dehors de la plage supérieure/inférieure des substituts (0xD800 à 0xDFFF). Sinon, une erreur sera émise. |
CHAR CHARACTER SET UTF8
La fonction UNICODE_CHAR
renvoie le caractère UNICODE pour un point de code donné.
UNICODE_CHAR
UNICODE_CHAR
select unicode_char(x) from y;
UNICODE_VAL()
DSQL, PSQL
UNICODE_VAL (string)
Paramètre | Description |
---|---|
string |
chaine de caractères. |
INTEGER
La fonction UNICODE_VAL
renvoie le point de code UTF-32 du premier caractère de la chaîne. Renvoie 0 pour une chaîne vide.
UNICODE_VAL
UNICODE_VAL
select unicode_val(x) from y;
UPPER()
DSQL, PSQL
UPPER (str)
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
[VAR]CHAR
ou BLOB
La fonction UPPER
renvoie la chaîne de caractères d’entrée en majuscules. Le résultat exact dépend du jeu de caractères de la chaîne d’entrée. Par exemple, pour les jeux de caractères NONE et ASCII, seuls les caractères ASCII sont mis en majuscules ; pour les jeux de caractères OCTETS — la chaîne d’entrée entière est renvoyée inchangée.
UPPER
UPPER
select upper(_iso8859_1 'Débâcle')
from rdb$database
-- retourne 'DÉBÂCLE'
select upper(_iso8859_1 'Débâcle' collate fr_fr)
from rdb$database
-- retourne 'DEBACLE', Règles de mise en majuscules en français
-- résultat valide quand la BD est par défaut en UTF8 et le client configuré en iso8859_1
BASE64_DECODE()
DSQL, PSQL
BASE64_DECODE (base64_data)
Paramètre | Description |
---|---|
base64_data |
Données codées en base64 augmentées de |
`BLOB' ou `VARBINARY'.
BASE64_DECODE
décode une chaîne avec des données codées par l’algorithme base64et retourne la valeur décodée sous forme de VARBINARY
ou de BLOB
selon l’argument d’entrée.
Si la longueur du type base64_data n’est pas un multiple de 4, une erreur se produit pendant la préparation.Si la longueur de base64_data n’est pas un multiple de 4, une erreur se produit au moment de l’exécution.
Lorsque l’argument d’entrée n’est pas BLOB
, la longueur du type résultant est calculée comme suittype_length * 3/4
, où type_length est la longueur maximale en octets du type de l’argument d’entrée.
BASE64_DECODE
BASE64_DECODE
select cast(base64_decode('VGVzdCBiYXNlNjQ=') as varchar(12))
from rdb$database;
CAST ============ Test base64
BASE64_ENCODE()
DSQL, PSQL
BASE64_ENCODE (binary_data)
Paramètre | Description |
---|---|
binary_data |
Données binaires pour le codage |
VARCHAR CHARACTER SET ASCII
ou BLOB SUB_TYPE TEXT CHARACTER SET ASCII
.
La fonction BASE64_ENCODE
encode les données_binaires en utilisant l’algorithme base64 etrenvoie la valeur encodée sous la forme VARCHAR CHARACTER SET ASCII
ou BLOB SUB_TYPE TEXT CHARACTER SET ASCII
.selon le type de l’argument d’entrée.La valeur de retour est complétée par “`=`” afin que sa longueur soit un multiple de 4.
Lorsque l’argument d’entrée n’est pas BLOB
, la longueur du type résultant est calculée comme type_length * 4 / 3
, arrondie à un multiple de quatre, où type_length est la longueur maximale du type d’entrée en octets.
BASE64_ENCODE
BASE64_ENCODE
select base64_encode('Test base64')
from rdb$database;
BASE64_ENCODE ================ VGVzdCBiYXNlNjQ=
BIT_LENGTH()
DSQL, PSQL
BIT_LENGTH (string)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
BIGINT
La fonction BIT_LENGTH
renvoie la longueur de la chaîne d’entrée en bits.Pour les jeux de caractères multi-octets, le résultat peut être 8 fois le nombre de caractères dans le nombre formel
d’octets par caractère écrit dans RDB$CHARACTER_SETS
.
Avec les paramètres de type CHAR, cette fonction prend en compte la longueur totale de la chaîne formelle (par exemple, la longueur déclarée d’un champ ou d’une variable). Si vous voulez obtenir la longueur `logique' en bits, sans compter les espaces, vous devez effectuer une opération RIGHT TRIM sur l’argument avant de le passer à `BIT_LENGTH'.
BIT_LENGTH
BIT_LENGTH
SELECT BIT_LENGTH ('Hello!') FROM RDB$DATABASE
-- renvoie 48
SELECT BIT_LENGTH (_ISO8859_1 'Grüß Di!')
FROM RDB$DATABASE
-- retourne 64 : chacun, ü et ß occupent un octet en ISO8859_1
SELECT BIT_LENGTH (
CAST (_ISO8859_1 'Grüß di!' AS VARCHAR (24)
CHARACTER SET UTF8))
FROM RDB$DATABASE
-- renvoie 80 : ü et ß occupent chacun deux octets en UTF8.
SELECT BIT_LENGTH (
CAST (_ISO8859_1 'Grüß di!' AS CHAR (24)
CHARACTER SET UTF8))
FROM RDB$DATABASE
-- renvoie 208 : la taille de l'ensemble des 24 positions CHAR et deux d'entre elles sont de 16 bits
CHAR_LENGTH()
, CHARACTER_LENGTH()
DSQL, PSQL
CHAR_LENGTH (string) | CHARACTER_LENGTH (string)
Paramètre | Description |
---|---|
string |
Une expression de type chaîne de caractères. |
BIGINT
La fonction CHAR_LENGTH
renvoie la longueur (en caractères) de la chaîne passée en argument.
Note
|
Avec des paramètres de type |
HASH()
DSQL, PSQL
HASH (str [USING <algorithm>]) <algorithm> ::= { CRC32 }
Paramètre | Description |
---|---|
str |
Une expression de type chaîne de caractères. |
BIGINT
La fonction HASH
renvoie un hachage non cryptographique de la chaîne d’entrée.Cette fonction prend entièrement en charge les `BLOB' de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères.
La clause facultative USING
spécifie l’algorithme de hachage non cryptographique à appliquer.Lorsque la clause USING
n’est pas présente, l’algorithme PJW est appliqué, comme dans les versions précédentes de Firebird.
Si aucun algorithme n’est spécifié, une version 64 bits de l’algorithme non cryptographique est utilisée.https://en.wikipedia.org/wiki/PJW_hash_function [fonction de hachage PJW^] (également connue sous le nom de ELF64) est utilisée.Cette fonction est très rapide et peut être utilisée à des fins générales (tables de hachage, etc.) mais présente un grand nombre de collisions.Pour un hachage plus sûr, vous devriez utiliser d’autres fonctions de hachage, explicitement spécifiées dans la clause USING, ou des hachages cryptographiques avec [fblangref-scalarfuncs-crypthash].
Pour cet algorithme de hachage, la fonction renvoie le type BIGINT
.
CRC32
Si la clause USING
spécifie l’algorithme CRC32
, Firebird applique l’algorithme CRC32 en utilisant le polynôme 0x04C11DB7.
Pour cet algorithme, la fonction HASH
renvoie un résultat de type INTEGER
.
HASH
SELECT HASH(x) FROM MyTable;
-- résultat du type BIGINT
SELECT HASH(x USING CRC32) FROM MyTable;
-- résultat du type INTEGER
Voir aussi :[fblangref-scalarfuncs-crypthash]
HEX_DECODE()
DSQL, PSQL
HEX_DECODE (hex_data)
Paramètre | Description |
---|---|
hex_data |
Données en représentation hexadécimale. |
VARBINARY
ou BLOB
.
La fonction HEX_DECODE
décode une chaîne de caractères avec des données hexadécimales et retourne la valeur décodée.comme VARBINARY
ou BLOB
selon le type d’entrée et la taille de l’argument.Si la longueur du type hex_data n’est pas un multiple de 2, une erreur se produit pendant la préparation.Si la longueur de hex_data n’est pas un multiple de 2, une erreur se produit au moment de l’exécution.
Lorsque l’argument d’entrée n’est pas BLOB
, la longueur du type résultant est calculée comme type_length / 2
,où type_longueur est la longueur maximale en octets du type de l’argument d’entrée.
HEX_DECODE
HEX_DECODE
select cast(hex_decode('48657861646563696D616C') as varchar(12))
from rdb$database;
CAST ============ Hexadecimal
HEX_ENCODE()
DSQL, PSQL
HEX_ENCODE (binary_data)
Paramètre | Description |
---|---|
binary_data |
Données binaires pour le codage |
VARCHAR CHARACTER SET ASCII
ou BLOB SUB_TYPE TEXT CHARACTER SET ASCII
La fonction HEX_ENCODE
encode les données binaires avec un nombre hexadécimal et retourne la valeur encodée sous forme de VARCHAR CHARACTER SET ASCII
ou de BLOB SUB_TYPE TEXT CHARACTER SET ASCII
selon l’argument d’entrée.
Lorsque l’argument d’entrée n’est pas BLOB
, la longueur du type résultant est calculée comme type_length * 2
, où type_length est la longueur maximale en octets du type de l’argument d’entrée.
HEX_ENCODE
HEX_ENCODE
select hex_encode('Hexadecimal')
from rdb$database;
HEX_ENCODE ====================== 48657861646563696D616C
DATEADD()
DSQL, PSQL
DATEADD (<args>) <args> ::= <amount> <unit> TO <datetime> | <unit>, <amount>, <datetime> <unit> ::= YEAR | MONTH | WEEK | DAY | WEEKDAY | YEARDAY | HOUR | MINUTE | SECOND | MILLISECOND
Paramètre | Description |
---|---|
amount |
Une expression de type |
unit |
Composante date/heure. |
datetime |
Une expression de type |
DATE
, TIME
ou TIMESTAMP
.
La fonction DATEADD
vous permet d’ajouter un nombre donné d’années, de mois, de semaines, d’heures, de minutes, de secondes, de millisecondes à une valeur de date/heure donnée.
Note
|
|
DATEADD
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
DATEDIFF (<args>) <args> ::= <unit> FROM <moment_1> TO <moment_2> | <unit>, <moment_1>, <moment_2> <unit> ::= YEAR | MONTH | WEEK | DAY | WEEKDAY | YEARDAY | HOUR | MINUTE | SECOND | MILLISECOND
Paramètre | Description |
---|---|
unit |
Composante date/heure. |
monent_1 |
Une expression de type |
monent_2 |
Une expression de type |
BIGINT
La fonction DATEDIFF
renvoie le nombre d’années, de mois, de semaines, de jours, d’heures, de minutes, de secondes ou de millisecondes entre deux valeurs de date/heure.
Caractéristiques d’utilisation :
Les paramètres DATE
et TIMESTAMP
peuvent être utilisés ensemble. La co-utilisation du type TIME
avec le type DATE
et TIMESTAMP
n’est pas autorisée ;
Avec un argument de type TIMESTAMP
et DATE
, n’importe quel composant date/heure <unit> peut être utilisé ;
Seuls HOUR
, MINUTE
, SECOND
et MILLISECOND
peuvent être utilisés pour le type de données TIME.
Note
|
|
DATEDIFF
DATEDIFF
DATEDIFF (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, PSQL
EXTRACT (<part> FROM <datetime>) <part> ::= YEAR | MONTH | WEEK | DAY | WEEKDAY | YEARDAY | HOUR | MINUTE | SECOND | MILLISECOND | TIMEZONE_HOUR | TIMEZONE_MINUTE
Paramètre | Description |
---|---|
part |
Composante date/heure. |
datetime |
Une expression de type |
SMALLINT
ou NUNERIC
.
La fonction EXTRACT
extrait les composants de date et d’heure des types de données DATE
, TIME
et TIMESTAMP
.
Composant date/heure | Type | Plage | Commentaire |
---|---|---|---|
|
|
1–9999 |
L’année |
|
|
1-4 |
Trimestre |
|
|
1–12 |
Mois |
|
|
1–53 |
Numéro de la semaine de l’année |
|
|
1–31 |
Jour |
|
|
0–6 |
Jour de la semaine. 0 — Dimanche |
|
|
0–365 |
Le numéro du jour de l’année. 0 = 1 janvier |
|
|
0–23 |
Heure |
|
|
0–59 |
Minute |
|
|
0.0000–59.9999 |
Secondes. Inclut les millisecondes |
|
|
0.0–999.9 |
Millisecondes |
|
|
de -14 à +14 |
Décalage des heures du fuseau horaire |
|
|
de -59 à +59 |
Décalage des minutes du fuseau horaire |
Note
|
Si le composant date/heure n’est pas présent dans l’argument date/heure, par exemple SECOND dans un argument de type DATE ou YEAR dans TIME, la fonction provoquera une erreur. |
À partir d’un argument de type DATE
ou TIMESTAMP
, vous pouvez extraire le numéro de la semaine. Selon la norme ISO-8601, la semaine commence le lundi et comprend toujours 7 jours. La première semaine de l’année est celle qui compte le plus de jours dans la nouvelle année (au moins 4) : les jours 1-3 peuvent appartenir à la semaine précédente (52 ou 53) de l’année précédente. Par analogie, les jours 1-3 de l’année en cours peuvent appartenir à la semaine 1 de l’année suivante.
EXTRACT
/* récupérer le numéro du trimestre par la date */
SELECT (EXTRACT(MONTH FROM CURRENT_TIMESTAMP)-1)/3+1
FROM RDB$DATABASE
FIRST_DAY()
DSQL, PSQL
FIRST_DAY(OF <period> FROM date_or_timestamp) <period> ::= YEAR | QUARTER | MONTH | WEEK
Paramètre | Description |
---|---|
date_or_timestamp |
Une expression de type |
DATE
ou TIMESTAMP [WITH | WITHOUT] TIME ZONE
.
Renvoie le premier jour de l’année, du mois ou de la semaine pour une date donnée.
Note
|
|
FIRST_DAY
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 '2022-11-01') FROM rdb$database;
LAST_DAY()
DSQL, PSQL
LAST_DAY(OF <period> FROM date_or_timestamp) <period> ::= YEAR | QUARTER | MONTH | WEEK
Paramètre | Description |
---|---|
date_or_timestamp |
Une expression de type |
DATE
ou TIMESTAMP [WITH | WITHOUT] TIME ZONE
.
Renvoie le dernier jour de l’année, du mois ou de la semaine pour une date donnée.
Note
|
|
LAST_DAY
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;
BLOB_APPEND()
DSQL, PSQL
BLOB_APPEND(<blob> [, <value1>, ... <valueN>]
Paramètre | Description |
---|---|
blob |
BLOB ou NULL. |
value |
La valeur de n’importe quel type. |
BLOB temporaire non fermée avec l’indicateur BLB_close_on_read
.
La fonction BLOB_APPEND
est conçue pour concaténer des BLOBs sans créer deBLOBs intermédiaires. Une opération de concaténation normale avec des arguments de type BLOB créera toujours autant de BLOB temporaires,autant de fois qu’il est utilisé.
Arguments d’entrée :
Le comportement suivant de la fonction est défini pour le premier argument en fonction de sa valeur :
NULL : un nouveau BLOB vide et non fermé sera créé
BLOB permanent (de la table) ou BLOB temporaire déjà fermé :un nouveau BLOB vide et non fermé sera créé et le contenu de l’espace de stockage du premier BLOB y sera ajouté.
BLOB temporaire non fermé : il sera utilisé ultérieurement
les autres types de données sont convertis en chaîne, un BLOB temporaire non fermé sera créé avec le contenu de cette chaîne.
Le reste des arguments peut être de n’importe quel type. Le comportement suivant est défini pour eux :
NULL est ignoré
les non-BLOB sont convertis en chaînes de caractères (selon les règles normales) et ajoutés au contenu du résultat.résultats
Les BLOB, si nécessaire, sont translittérés dans le jeu de caractères du premier argument et leur contenuleur contenu est ajouté au résultat
Comme valeur de sortie, la fonction BLOB_APPEND
renvoie un BLOB temporaire non fermé avec l’indicateur BLOB_close_on_read
.Il s’agit soit d’un nouveau BLOB, soit du même que dans le premier argument. Ainsi, une série d’opérations commeblob = BLOB_APPEND(blob, …)
créera au maximum un BLOB (sauf si vous essayez d’ajouter un BLOB à lui-même).Cette BLOB sera automatiquement fermée par le moteur lorsqu’une tentative est faite pour la lire par le client, l’écrire dans une table ou l’utiliser dans d’autres expressions qui nécessitent la lecture de son contenu.
Note
|
La vérification d’un BLOB pour NULL en utilisant l’opérateur |
execute block
returns (b blob sub_type text)
as
begin
-- créera un nouveau BLOB temporaire non fermé.
-- et y écrira la chaîne de caractères du 2ème argument
b = blob_append(null, 'Hello ');
-- ajoute deux lignes au BLOB temporaire sans la fermer
b = blob_append(b, 'World', '!');
-- la comparaison d'une BLOB à une chaîne de caractères la fermera, car elle doit lire le contenu du BLOB
if (b = 'Hello World!') then
begin
-- ...
end
-- va créer un BLOB fermé temporaire en y ajoutant une ligne
b = b || 'Close';
suspend;
end
Tip
|
Utilisez les fonctions |
BLOB_APPEND
Supposons que vous ayez besoin de construire du JSON du côté du serveur. Nous avons un paquet PSQL JSON_UTILS avec un ensemble de fonctions pour convertir les types de données élémentaires en notation JSON. Ensuite, la construction du JSON en utilisant la fonction BLOB_APPEND
ressemblera à ceci
EXECUTE BLOCK
RETURNS (
JSON_STR BLOB SUB_TYPE TEXT CHARACTER SET UTF8)
AS
DECLARE JSON_M BLOB SUB_TYPE TEXT CHARACTER SET UTF8;
BEGIN
FOR
SELECT
HORSE.CODE_HORSE,
HORSE.NAME,
HORSE.BIRTHDAY
FROM HORSE
WHERE HORSE.CODE_DEPARTURE = 15
FETCH FIRST 1000 ROW ONLY
AS CURSOR C
DO
BEGIN
SELECT
LIST(
'{' ||
JSON_UTILS.NUMERIC_PAIR('age', MEASURE.AGE) ||
',' ||
JSON_UTILS.NUMERIC_PAIR('height', MEASURE.HEIGHT_HORSE) ||
',' ||
JSON_UTILS.NUMERIC_PAIR('length', MEASURE.LENGTH_HORSE) ||
',' ||
JSON_UTILS.NUMERIC_PAIR('chestaround', MEASURE.CHESTAROUND) ||
',' ||
JSON_UTILS.NUMERIC_PAIR('wristaround', MEASURE.WRISTAROUND) ||
',' ||
JSON_UTILS.NUMERIC_PAIR('weight', MEASURE.WEIGHT_HORSE) ||
'}'
) AS JSON_M
FROM MEASURE
WHERE MEASURE.CODE_HORSE = :C.CODE_HORSE
INTO JSON_M;
JSON_STR = BLOB_APPEND(
JSON_STR,
IIF(JSON_STR IS NULL, '[', ',' || ascii_char(13)),
'{',
JSON_UTILS.INTEGER_PAIR('code_horse', C.CODE_HORSE),
',',
JSON_UTILS.STRING_PAIR('name', C.NAME),
',',
JSON_UTILS.TIMESTAMP_PAIR('birthday', C.BIRTHDAY),
',',
JSON_UTILS.STRING_VALUE('measures') || ':[', JSON_M, ']',
'}'
);
END
JSON_STR = BLOB_APPEND(JSON_STR, ']');
SUSPEND;
END
Un exemple similaire utilisant l’opérateur de concaténation conventionnel ||
est 18 fois plus lent, et effectue 1000 fois plus d’opérations d’écriture sur le disque.
COMPARE_DECFLOAT()
DSQL, PSQL
COMPARE_DECFLOAT (decfloat1, decfloat2)
Paramètre | Description |
---|---|
decfloat1, decfloat2 |
Les valeurs ou expressions de type |
SMALLINT
La fonction COMPARE_DECFLOAT
compare deux valeurs de type DECFLOAT
, qui peuvent être identiques, différentes ou non ordonnées. Les zéros de fermeture sont pris en compte dans la comparaison.
La fonction renvoie :
0
|
Les valeurs sont égales ; |
1
|
La première valeur est inférieure à la seconde ; |
2
|
La première valeur est supérieure à la seconde ; |
3
|
Les valeurs ne sont pas ordonnées (une ou les deux |
Contrairement aux opérateurs de comparaison (‘<
’, ‘=
’, ‘>
’ etc.) la comparaison est exacte,i.e., COMPARE_DECFLOAT(2.17, 2.170)
retournera 2
, et non 0
.
Voir aussi :[fblangref-scalarfuncs-totalorder]
NORMALIZE_DECFLOAT()
DSQL, PSQL
NORMALIZE_DECFLOAT (decfloat_value)
Paramètre | Description |
---|---|
decfloat_value |
Une valeur ou une expression de type |
DECFLOAT
La fonction NORMALIZE_DECFLOAT
renvoie le nombre sous forme normalisée, ce qui signifie que pour toute valeur non nulle, les zéros de fin sont supprimés avec la correction appropriée de l’exposant.
NORMALIZE_DECFLOAT
DECFLOAT
.NORMALIZE_DECFLOAT(12.00) -- renvoi 12
NORMALIZE_DECFLOAT(120) -- renvoi 1.2E+2
QUANTIZE()
DSQL, PSQL
QUANTIZE (decfloat_value, exp_value)
Paramètre | Description |
---|---|
decfloat_value |
Une valeur ou une expression de type |
exp_value |
Une valeur ou une expression à utiliser comme exposant ; doit être de type |
DECFLOAT
La fonction QUANTIZE
renvoie la valeur du premier argument mise à l’échelle en utilisant la deuxième valeur comme modèle. En d’autres termes, la fonction QUANTIZE
renvoie la valeur de DECFLOAT
égale en valeur (à l’exception de tout arrondi) et en signe à decfloat_value, et l’exposant égal en valeur à l’exposant exp_value.La fonction QUANTIZE
peut être utilisée pour implémenter l’arrondi au chiffre le plus proche, comme l’arrondi au cent le plus proche en utilisant le mode d’arrondi défini DECFLOAT
.
Le type de la valeur de retour est DECFLOAT(16)
si les deux arguments sont DECFLOAT(16)
, sinon le type du résultat est DECFLOAT(34)
.
Note
|
La cible est l’exposant utilisé dans le format de stockage |
Si la valeur decfloat est supérieure à la valeur exp, la valeur decfloat est multipliée par une puissance de dix et sa valeur est diminuée, si la valeur est inférieure, sa valeur est arrondie en utilisant le mode d’arrondi decfloat actuel et sa valeur est augmentée.
Lorsque l’exposant cible ne peut pas être atteint parce que le quotient dépasse la précision cible (16 ou 34 décimales), alors soit l’erreur “Decfloat float invalid operation”, soit NaN
est retournée (selon la configuration actuelle des pièges decfloat).
Il n’y a pratiquement aucune restriction sur les exp_value.Cependant, dans presque tous les cas où NaN
/sNaN
/Infinity
est utilisé, une exception sera levée(sauf si cela est autorisé par la configuration actuelle des pièges decfloat)
Si l’une des valeurs est NULL
, le résultat de la fonction sera NULL
, etc.
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
TOTALORDER (decfloat1, decfloat2)
Paramètre | Description |
---|---|
decfloat1, decfloat2 |
Une valeur ou une expression de type |
SMALLINT
La fonction TOTALORDER
compare deux valeurs de type DECFLOAT
, y compris les valeurs spéciales.La comparaison est exacte. Les zéros de queue sont pris en compte dans la comparaison.
La fonction renvoie :
-1 — si la première valeur est inférieure à la seconde ;
0 — si les valeurs sont égales ;
1 — si la première valeur est supérieure à la seconde.
Les comparaisons des valeurs DEFLOAT
se font dans l’ordre suivant :
-nan < -snan < -inf < -0.1 < -0.10 < -0 < 0 < 0.10 < 0.1 < inf < snan < nan
Voir aussi :[fblangref-scalarfuncs-comparedecfloat]
Firebird 5.0 ne prend en charge qu’un sous-ensemble d’algorithmes de chiffrement symétrique (à la fois par blocs et par flux), et RSA.
CRYPT_HASH()
DSQL, PSQL
CRYPT_HASH (value USING <algorithm>) <algorithm> ::= { MD5 | SHA1 | SHA256 | SHA512 | SHA3_224 | SHA3_256 | SHA3_384 | SHA3_512 }
Paramètre | Description |
---|---|
value |
Une expression de n’importe quel type. Les types non-voyants et non-binaires sont convertis en chaînes de caractères. |
algorithm |
Algorithme de hachage. |
VARBINARY
La fonction CRYPT_HASH
renvoie un hachage cryptographique de la chaîne d’entrée en utilisant l’algorithme spécifié. Cette fonction supporte entièrement les BLOB
de texte de n’importe quelle longueur et avec n’importe quel jeu de caractères. La clause USING
vous permet de spécifier l’algorithme par lequel le hachage est calculé.
Note
|
L’utilisation des algorithmes |
CRYPT_HASH
CRYPT_HASH
SELECT CRYPT_HASH(x USING SHA256) FROM MyTable;
-- Résultat de type VARBINARY
DECRYPT()
DSQL, PSQL
DECRYPT (encrypted_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
Paramètre | Description |
---|---|
encrypted_input |
BLOB crypté ou chaîne de caractères (binaire) |
algorithm |
Algorithme de cryptage. Les algorithmes de bloc et de flux sont pris en charge. |
mode |
Mode de chiffrement. Obligatoire pour les algorithmes de chiffrement par blocs. |
key |
Clé de cryptage. |
iv |
Vecteur d’initialisation (IV). Doit être spécifié pour tous les ciphers de bloc sauf |
ctr_type |
Ordre des octets du compteur. Ne peut être spécifié qu’en mode |
ctr_length |
Longueur du compteur en octets. Ne peut être spécifié qu’en mode |
initial_counter |
Valeur initiale du compteur. Ne peut être spécifiée que pour l’algorithme |
BLOB
ou VARBINARY
.
La fonction DECRYPT
décrypte les données à l’aide d’un chiffrement symétrique. La taille des chaînes transmises à cette fonction doit répondre aux exigences de l’algorithme et du mode sélectionnés.
DECRYPT
select 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
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
Paramètre | Description |
---|---|
input |
Une expression de type chaîne ou |
algorithm |
Algorithme de cryptage. Les algorithmes de bloc et de flux sont pris en charge. |
mode |
Mode de chiffrement. Obligatoire pour les algorithmes de chiffrement par blocs. |
key |
Clé de cryptage. |
iv |
Vecteur d’initialisation (IV). Doit être spécifié pour tous les ciphers de bloc sauf |
ctr_type |
Ordre des octets du compteur. Ne peut être spécifié qu’en mode |
ctr_length |
Longueur du compteur en octets. Ne peut être spécifié qu’en mode |
initial_counter |
Valeur initiale du compteur. Ne peut être spécifiée que pour l’algorithme |
BLOB
ou VARBINARY
.
La fonction ENCRYPT
permet de crypter des données en utilisant un chiffrement symétrique.
Note
|
|
Les caractéristiques des différents algorithmes et modes dépassent le cadre de ce guide linguistique.
Algorithme | Taille de la clé (octet) | Taille du bloc (octet) | Note |
---|---|---|---|
Cryptage par blocs |
|||
|
16, 24, 32 |
16 |
|
|
16 - 40, par incréments 4 |
16 |
|
|
8 - 56 |
8 |
|
|
16 |
8 |
|
|
8 - 128 |
8 |
|
|
8 - 128 |
16 |
|
|
16, 24, 32 |
16 |
|
|
16, 24, 32 |
16 |
|
|
16 |
8 |
|
Cryptage en ligne |
|||
|
16, 32 |
1 |
La taille (IV) est de 8 ou 12 octets. Pour la taille 8, initial_counter est un entier de 64 bits, pour la taille 12, c’est un entier de 32 bits. |
|
5 - 256 |
1 |
|
|
4x |
1 |
La taille (IV) est de 4y octets, la longueur est indépendante de la taille de la clé. |
ENCRYPT
select encrypt('897897' using sober128 key 'AbcdAbcdAbcdAbcd' iv '01234567')
from rdb$database;
RSA_PRIVATE()
DSQL, PSQL
RSA_PRIVATE (size)
Paramètre | Description |
---|---|
size |
Taille de la clé en octets. |
VARBINARY
La fonction RSA_PRIVATE
renvoie la clé privée RSA d’une longueur donnée (en octets) au format PKCS#1 sous forme de chaîne VARBINARY
.
RSA_PRIVATE
select rdb$set_context('USER_SESSION', 'private_key', rsa_private(256))
from rdb$database;
RSA_PUBLIC()
DSQL, PSQL
RSA_PUBLIC (private-key)
Paramètre | Description |
---|---|
private-key |
Clé privée RSA. |
VARBINARY
La fonction RSA_PUBLIC
renvoie la clé publique RSA pour une clé privée RSA donnée. Les deux clés doivent être au format PKCS#1.
RSA_PUBLIC
La clé privée doit être initialisée auparavant, voir l’exemple dans RSA_PRIVATE
select rdb$set_context('USER_SESSION', 'public_key',
rsa_public(rdb$get_context('USER_SESSION', 'private_key')))
from rdb$database;
RSA_ENCRYPT()
DSQL, PSQL
RSA_ENCRYPT (<data> KEY <public_key> [LPARAM <tag>] [HASH <hash>]) <hash> ::= { MD5 | SHA1 | SHA256 | SHA512 }
Paramètre | Description |
---|---|
data |
Données (chaîne ou BLOB) à crypter. |
public_key |
La clé publique RSA retournée par la fonction |
tag |
Une balise système facultative qui peut être utilisée pour déterminer quel système a encodé le message. La valeur par défaut est |
hash |
Algorithme de hachage. La valeur par défaut est SHA256. |
VARBINARY
Remplit les données à l’aide de la complétion OAEP et les crypte à l’aide de la clé publique RSA. Généralement utilisé pour crypter des clés symétriques courtes, qui sont ensuite utilisées dans des ciphers de bloc pour crypter le message.
RSA_ENCRYPT
La clé publique doit être initialisée auparavant, voir l’exemple dans [fblangref-scalarfuncs-rsa_public]
select rdb$set_context('USER_SESSION', 'msg',
rsa_encrypt('Some message' key rdb$get_context('USER_SESSION', 'public_key')))
from rdb$database;
RSA_DECRYPT()
DSQL, PSQL
RSA_DECRYPT (<data> KEY <private_key> [LPARAM <tag>] [HASH <hash>]) <hash> ::= { MD5 | SHA1 | SHA256 | SHA512 }
Paramètre | Description |
---|---|
data |
Données (chaîne ou BLOB) à décrypter. |
private_key |
La clé privée RSA retournée par la fonction |
tag |
Balise système optionnelle. Doit être la même valeur que celle passée à |
hash |
Algorithme de hachage. La valeur par défaut est SHA256. |
VARCHAR
Déchiffre à l’aide d’une clé privée RSA et supprime les données augmentées par l’OAEP.
La clé privée doit être initialisée plus tôt, voir l’exemple dans [fblangref-scalarfuncs-rsa_private]. Les données de déchiffrement sont utilisées à partir de l’exemple dans [fblangref-scalarfuncs-rsa_encrypt].
select RSA_DECRYPT(rdb$get_context('USER_SESSION', 'msg')
key rdb$get_context('USER_SESSION', 'private_key'))
from RDB$DATABASE;
RSA_SIGN_HASH()
DSQL, PSQL
RSA_SIGN_HASH (<data> KEY <private_key> [HASH <hash>] [SALT_LENGTH <length>]) <hash> ::= { MD5 | SHA1 | SHA256 | SHA512 }
Paramètre | Description |
---|---|
data |
Données (chaîne ou BLOB) à encoder. |
private_key |
La clé privée RSA retournée par la fonction |
hash |
Algorithme de hachage. La valeur par défaut est SHA256. |
length |
Indique la longueur du sel souhaité et doit généralement être petite. Une bonne valeur se situe entre 8 et 16. |
VARBINARY
Effectue le codage PSS du condensé du message pour la signature et le signe en utilisant la clé privée RSA. Renvoie la signature du message.
RSA_SIGN_HASH
La clé privée doit être initialisée plus tôt voir l’exemple dans [fblangref-scalarfuncs-rsa_private].
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
RSA_VERIFY_HASH (<data> SIGNATURE <signature> KEY <public_key> [HASH <hash>] [SALT_LENGTH <length>]) <hash> ::= { MD5 | SHA1 | SHA256 | SHA512 }
Paramètre | Description |
---|---|
data |
Données (chaîne ou BLOB) à encoder. |
signature |
Signature. Doit être la valeur renvoyée par la fonction |
public_key |
La clé publique RSA retournée par la fonction |
hash |
Algorithme de hachage. La valeur par défaut est |
length |
Indique la longueur du sceau souhaité et doit généralement être petite.Une bonne valeur se situe entre 8 et 16. |
BOOLEAN
Effectue le codage PSS du condensé du message pour la signature et vérifie sa signature numérique en utilisant la clé publique RSA. Renvoie le résultat de la vérification de la signature.
RSA_VERIFY_HASH
La clé publique doit être initialisée plus tôt voir exemple dans [fblangref-scalarfuncs-rsa_public]. La signature numérique est obtenue plus tôt avec [fblangref-scalarfuncs-rsa_sign_hash].
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;
CAST()
DSQL, PSQL
CAST(value | NULL AS <type>) <type> ::= <datatype> | [TYPE OF] domain | TYPE OF COLUMN relname.colname <datatype> ::= <scalar_datatype> | <blob_datatype> | <array_datatype> <scalar_datatype> ::= Voir Syntaxe des types de données scalaires. <blob_datatype> ::= Voir Syntaxe du type de données BLOB. <array_datatype> ::= Voir syntaxe des tableaux.
Paramètre | Description |
---|---|
value |
Expression SQL. |
datatype |
Type de données SQL. |
domain |
Domaine. |
relname |
Le nom d’une table ou d’une vue. |
colname |
Le nom de la colonne de la table ou de la vue. |
<type>
.
La fonction CAST est utilisée pour convertir explicitement des données d’un type de données vers un autre type de données ou un autre domaine. Si cela n’est pas possible, une erreur sera émise.
Type d’origine | Type en sortie |
---|---|
Type numérique |
Types numériques, |
|
|
|
|
|
|
|
|
Notez que parfois des informations peuvent être perdues, par exemple lorsque vous convertissez le type TIMESTAMP
en DATE
.De plus, le fait que les types soient compatibles pour la fonction CAST
ne garantit pas que la conversion sera réussie.“CAST (123456789 AS SMALLINT)” provoquera certainement une erreur, tout comme “CAST('Judgement Day' as DATE)”.
Vous pouvez appliquer une conversion de type aux paramètres de l’opérateur :
CAST (? AS INTEGER)
Cela vous permet de contrôler le type de champs de saisie.
Lors de la conversion vers un domaine, toute restriction (NOT NULL et/ou CHECK) déclarée pour le domaine doit être satisfaite, sinon la conversion n’aura pas lieu. Rappelez-vous que la vérification CHECK passe si son calcul donne VRAI ou UNKNOWN (NULL). Pour les opérateurs suivants :
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)
seul (1) se terminera par une erreur.
Si le modificateur TYPE OF
est utilisé, l’expression sera convertie au type de base du domaine, en ignorant les contraintes. Pour le domaine quint déclaré ci-dessus, les deux conversions seront équivalentes et les deux réussiront :
SELECT CAST (2000 AS TYPE OF quint) FROM rdb$database
SELECT CAST (2000 AS INT) FROM rdb$database
Lorsque TYPE OF
est utilisé avec le type [VAR]CHAR
, son jeu de caractères et son ordre de tri (collate) sont conservés.
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;
-- returns Deze -> Die -> deze -> die
SELECT CAST(zin AS TYPE OF dunl20) FROM zinnen ORDER BY 1;
-- returns deze -> Deze -> die -> Die
Warning
|
Si la définition du domaine est modifiée, les conversions existantes du domaine ou de son type peuvent devenir erronées. Si de telles conversions se produisent dans les modules PSQL, leurs erreurs peuvent être détectées. Champ d’application RDB$VALID_BLR. |
Permet de convertir une expression en un type de colonne d’une table ou d’une vue existante. Seul le type lui-même sera utilisé, pour les types de chaînes de caractères, le même jeu de caractères sera utilisé, mais pas la séquence de tri. Les restrictions et les valeurs par défaut de la colonne originale ne sont pas appliquées.
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
|
Si la définition d’une colonne est modifiée, les conversions existantes de son type peuvent devenir erronées. Si de telles conversions se produisent dans les modules PSQL, leurs erreurs peuvent être détectées. Champ RDB$VALID_BLR. |
SELECT CAST ('12' || '-June-' || '1959' AS DATE) FROM rdb$database
Notez que dans certains cas, vous n’aurez pas besoin d’utiliser la syntaxe de conversion comme dans l’exemple ci-dessus, car Firebird comprendra à partir du contexte (comparaison avec un champ DATE
) comment interpréter la chaîne :
UPDATE People SET AgeCat = 'Old'
WHERE BirthDate < '1-Jan-1943'
Mais cela n’est pas toujours possible. La conversion dans l’exemple ci-dessous ne peut pas être omise car le système essaiera de convertir la chaîne en un nombre afin de lui soustraire un nombre :
SELECT CAST('TODAY' AS DATE) - 7 FROM rdb$database
BIN_AND()
DSQL, PSQL
BIN_AND (number, number [, number ...])
Paramètre | Description |
---|---|
number |
Entier. |
SMALLINT
, INTEGER
, BIGINT
ou INT128
La fonction BIN_AND
renvoie le résultat de l’opération ET binaire des arguments.
[fblangref-scalarfuncs-bin-or], [fblangref-scalarfuncs-bin-xor].
BIN_NOT()
DSQL, PSQL
BIN_NOT (number)
Paramètre | Description |
---|---|
number |
Entier. |
SMALLINT
, INTEGER
, BIGINT
ou INT128
La fonction BIN_NOT
renvoie le résultat d’une opération NOT
au sens du bit sur l’argument.
[fblangref-scalarfuncs-bin-or], [fblangref-scalarfuncs-bin-and].
BIN_OR()
DSQL, PSQL
BIN_OR (number, number [, number ...])
Paramètre | Description |
---|---|
number |
Entier. |
SMALLINT
, INTEGER
, BIGINT
ou INT128
La fonction BIN_OR
renvoie le résultat de l’opération "bitwise OR" des arguments.
[fblangref-scalarfuncs-bin-and], [fblangref-scalarfuncs-bin-xor].
BIN_SHL()
DSQL, PSQL
BIN_SHL (number, shift)
Paramètre | Description |
---|---|
number |
Entier. |
shift |
Le nombre de bits par lequel la valeur number est décalée. |
BIGINT
ou INT128
.
La fonction BIN_SHL
renvoie le premier paramètre décalé bit à bit de la valeur du second paramètre, c’est-à-dire a << b
ou a-2b
.
BIN_SHR()
DSQL, PSQL
BIN_SHR (number, shift)
Paramètre | Description |
---|---|
number |
Entier. |
shift |
Le nombre de bits par lequel la valeur numérique est décalée. |
BIGINT
ou INT128
.
La fonction BIN_SHR
renvoie le premier paramètre décalé bit à bit de la valeur du second paramètre, c’est-à-dire a >> b
ou a/2b
.
L’opération effectuée est un décalage arithmétique vers la droite (SAR), ce qui signifie que le signe du premier opérande est toujours conservé.
BIN_XOR()
DSQL, PSQL
BIN_XOR (number, number [, number ...])
Paramètre | Description |
---|---|
number |
Entier. |
SMALLINT
, INTEGER
, BIGINT
ou INT128
La fonction BIN_XOR
renvoie le résultat de l’opération XOR
bit à bit des arguments.
[fblangref-scalarfuncs-bin-and], [fblangref-scalarfuncs-bin-or].