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.