orafce
4.13.5
Fonctions et opérateurs qui émulent un sous-ensemble de fonctions et de packages du SGBDR Oracle.
Il existe un groupe Google associé - https://groups.google.com/forum/?hl=en#!forum/orafce-general
Orafce est pris en charge dans AWS Aurora avec compatibilité PostgreSQL ainsi que dans Azure Database pour PostgreSQL.
Ce module contient quelques fonctions utiles qui peuvent aider au portage de l'application Oracle vers PostgreSQL ou qui peuvent être généralement utiles.
Les fonctions de date Oracle intégrées ont été testées par rapport à Oracle 10 pour vérifier leur conformité. Les plages de dates de 1960 à 2070 fonctionnent correctement. Les dates antérieures au 1582-10-05 avec le format 'J' et avant le 1100-03-01 avec d'autres formats ne peuvent pas être vérifiées en raison d'un bug dans Oracle.
Toutes les fonctions sont entièrement compatibles avec Oracle et respectent toutes les chaînes de format connues. Des descriptions détaillées peuvent être trouvées sur Internet. Utilisez des mots-clés tels que : oracle round trunc date iyyy.
A,AA,AAAA,AAAA,SYAA,ANNÉE année I,IY,IYY,IYYY année iso Q, trimestre Semaine WW, jour comme premier jour de l'année Semaine IW, commençant lundi Semaine W, jour comme premier jour du mois DAY,DY,D premier jour de la semaine, dimanche MOIS, LUN, MM, RM mois CC, SCC siècle JJJ,JJ,J jour HH, HH12, HH24 heures Minute MI
Les fonctions sont arrondies. Autrement dit, la date du 1er juillet sera arrondie à l’année suivante. Le 16 juillet sera arrondi au mois d'août.
add_months(date, integer) date - Renvoie la date plus n mois
add_months(date '2005-05-31',1) -> 2005-06-30
last_date(date) date - Renvoie le dernier jour du mois en fonction d'une valeur de date
dernier_jour(date '2005-05-24') -> 2005-05-31
next_day(date, text) date - Renvoie le premier jour de la semaine supérieur à une valeur de date
next_day(date '2005-05-24', 'lundi') -> 2005-05-30
next_day(date, integer) date - Identique à ci-dessus. Le deuxième argument doit être 1..7 et interprété comme dimanche..samedi.
next_day(date '2005-05-24', 1) -> 2005-05-30
months_between(date, date) numeric - Renvoie le nombre de mois entre date1 et date2. Si un mois fractionnaire est calculé, la fonctionmonths_between calcule la fraction sur la base d'un mois de 31 jours.
mois_entre(date '02/02/1995', date '01/01/1995') -> 1.0322580645161
trunc(date, text) date - tronque la date selon le format spécifié
tronc(date '2005-07-12', 'iw') -> 2005-07-11
round(date, text) date - arrondira les dates selon le format spécifié
tour(date '2005-07-12', 'aaaa') -> 2006-01-01
to_date(text) timestamp - transtypera le texte d'entrée en horodatage. Le GUC orafce.nls_date_format est utilisé pour spécifier le format de texte d'entrée pour cette fonction. Si la valeur est laissée vide ou définie sur DEFAULT, saisissez le format de texte conformément au paramètre GUC de style de date de PostgreSQL.
valeur orafce.nls_date_format sur DEFAULT
to_date('19/05/2014 17:23:53+5:30') -> 19/05/2014 17:23:53orafce.nls_date_format='AAAA-MMJJ HH24:MI:SS'
to_date('2014-0519 17:23:53+5:30') -> 2014-05-19 17:23:53 to_date(text, text) timestamp - transtypera le texte d'entrée avec le format spécifié pour l'horodater. Le GUC orafce.orafce_emit_error_on_date_bug est utilisé pour spécifier si une erreur est signalée lorsque la valeur de la date atteint le bogue Oracle sur les dates. Ce bug apparaît avec les dates antérieures au 1582-10-05 lorsque le format 'J' est utilisé ( 'J2299159' ) et avant 1100-03-01 avec les autres formats. Une erreur est signalée par défaut, pour désactiver ce comportement, set orafce.orafce_emit_error_on_date_bug to off .
SELECT oracle.to_date('112012', 'J');
ERREUR : Les dates antérieures au 1582-10-05 (« J2299159 ») ne peuvent pas être vérifiées en raison d'un bug dans Oracle.
SELECT oracle.to_date('1003-03-15', 'aaaa-mm-jj');
ERREUR : Les dates antérieures au 1100-03-01 ne peuvent pas être vérifiées en raison d'un bug dans Oracle.
SET orafce.oracle_compatibility_date_limit TO off ;
SELECT oracle.to_date('112012', 'J');
à ce jour
--------------------
4407-07-30 00:00:00 avant JC
(1 rangée)
SELECT oracle.to_date('1003/03/15', 'aaaa/mm/jj');
à ce jour
---------------------
1003-03-15 00:00:00
(1 rangée)Ce module contient l'implémentation du type de données DATE compatible avec Oracle "oracle.date" et des fonctions qui utilisent le type de données DATE comme oracle.add_months, oracle.last_day(),oracle.next_day(),oracle.months_between() etc.
Exemple:
définir search_path TO oracle, "$user", public, pg_catalog ;
créer une table oracle_date(col1 date);
insérer dans les valeurs oracle_date('2014-06-24 12:12:11'::date);
sélectionnez * dans oracle_date ;
col1
---------------------
2014-06-24 12:12:11
(1 rangée)oracle.add_months (horodatage avec fuseau horaire, entier) - Renvoie la date et l'heure plus n mois
oracle.add_months(oracle.date'2005-05-31 10:12:12',1) -> 2005-06-30 10:12:12
oracle.last_day(timestamp with time zone) - Renvoie le dernier jour du mois en fonction d'une valeur de date
oracle.last_day(oracle.date '2005-05-24 11:12:12') -> 2005-05-31 11:12:12
oracle.next_day(timestamp with time zone, text) - Renvoie le premier jour de la semaine supérieur à une valeur de date
oracle.next_day(oracle.date '2005-05-24 10:12:12', 'lundi') -> 2005-05-30 10:12:12
oracle.next_day(horodatage avec fuseau horaire, entier) - Identique à ci-dessus. Le deuxième argument doit être 1..7 et interprété comme dimanche..samedi.
oracle.next_day(oracle.date '2005-05-24 11:21:12', 1) -> 2005-05-29 11:21:12
oracle.months_between(timestamp with time zone, timestamp with time zone) - Renvoie le nombre de mois entre timestamp1 et timestamp2. Si un mois fractionnaire est calculé, la fonctionmonths_between calcule la fraction sur la base d'un mois de 31 jours.
oracle.months_between(oracle.date '1995-02-02 10:00:00', oracle.date '1995-01-01 10:21:11') -> 1.03225806451613
oracle.to_date(text,text) - Renvoie l'horodatage sans fuseau horaire.
oracle.to_date('16/02/09 04:12:12', 'MM/JJ/AA HH24:MI:SS') -> 16/02/2009 04:12:12oracle.to_date(text) - Renvoie oracle.date
oracle.to_date('16/02/09 04:12:12') -> 16/02/2009 04:12:12oracle.sysdate() - Renvoie l'horodatage de l'instruction dans le fuseau horaire du serveur (orafce.timezone)
oracle.sysdate() -> 09/12/2015 17:47:56
oracle.dbtimezone - Renvoie le fuseau horaire du serveur - émulé via orafce.timezone
oracle.dbtimezone() -> GMT
oracle.sessiontimezone() - Renvoie le fuseau horaire de la session - le fuseau horaire actuel de PostgreSQL
oracle.sessiontimezone() -> Europe/Prague
oracle.sys_extract_utc(timestamp with timezone) - Renvoie l'horodatage dans le fuseau horaire utc
oracle.sys_extract_utc (current_timestamp)
oracle.sys_extract_utc(oracle.date) - Renvoie l'horodatage dans le fuseau horaire utc, lorsque le fuseau horaire n'est pas spécifié, le fuseau horaire de la session (PostgreSQL actuel) est utilisé
oracle.sys_extract_utc(oracle.date '2005-05-24 11:21:12', 1) -> 2005-05-24 09:21:12
oracle.to_char(timestamp) - Renvoie l'horodatage au format nls_date_format.
orafce.nls_date_format='AA-MonJJ HH24:MI:SS'
oracle.to_char(to_date('14-Jan08 11:44:49+05:30')) -> 14-Jan08 11:44:49
orafce.nls_date_format='AA-MonJJ HH24:MI:SS'
oracle.to_char(oracle.to_date('21052014 12:13:44+05:30','DDMMYYYY HH24:MI:SS')) -> 14-Mai21 12:13:44 oracle.+(oracle.date,smallint) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') + 9::smallint -> 11/07/2014 10:08:55oracle.+(oracle.date,integer) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') + 9 ::entier -> 11/07/2014 10:08:55oracle.+(oracle.date,bigint) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') + 9::bigint -> 11/07/2014 10:08:55oracle.+(oracle.date,numeric) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') + 9::numérique -> 11/07/2014 10:08:55oracle.-(oracle.date,smallint) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') - 9::smallint -> 23/06/2014 10:08:55oracle.-(oracle.date,integer) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') - 9::entier -> 23/06/2014 10:08:55oracle.-(oracle.date,bigint) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') - 9::bigint -> 23/06/2014 10:08:55oracle.-(oracle.date,numeric) - Renvoie oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-JJ HH:MI:SS') - 9::numérique -> 23/06/2014 10:08:55oracle.-(oracle.date,oracle.date) - Renvoie la double précision
oracle.to_date('2014-07-17 11:10:15', 'aaaa-mm-jj hh24:mi:ss') - oracle.to_date('2014-02-01 10:00:00', 'aaaa -mm-jj hh24:mi:ss') -> 166.048785Vous devez définir search_path TO oracle, "$user", public, pg_catalog car des fonctions comme oracle.add_months, oracle.last_day, oracle.next_day, oracle.months_between sont installées côte à côte avec pg_catalog.add_months,pg_catalog.last_day,pg_catalog.next_day,pg_catalog.months_between.
PostgreSQL n'a pas besoin de la table 'dual' d'Oracle, mais comme elle est intensivement utilisée par les utilisateurs d'Oracle, elle a été ajoutée dans orafce. Ce tableau est dans le schéma oracle . Habituellement, vous souhaitez autoriser un accès non qualifié - vous devez donc ajouter ce schéma à la configuration search_path (comme search_path = 'oracle, pg_catalog, "$user", public' dans postgresql.conf ).
PostgreSQL envoie des informations au client via RAISE NOTICE. Oracle utilise dbms_output.put_line(). Cela fonctionne différemment de RAISE NOTICE. Oracle a une file d'attente de session, put_line() ajoute une ligne à la file d'attente et la fonction get_line() lit dans la file d'attente. Si l'indicateur 'serveroutput' est défini, le client sur toutes les instructions SQL lit la file d'attente. Vous pouvez utiliser :
sélectionnez dbms_output.enable();
sélectionnez dbms_output.put_line('first_line');
sélectionnez dbms_output.put_line('next_line');
sélectionnez * depuis dbms_output.get_lines(0);ou
sélectionnez dbms_output.enable();
sélectionnez dbms_output.serveroutput('t');
sélectionnez dbms_output.put_line('first_line');Ce package contient les fonctions suivantes : Enable(), Disable(), serveroutput(), put(), put_line(), new_line(), get_line(), get_lines(). La file d'attente des packages est implémentée dans la mémoire locale de la session.
Ce package permet aux programmes PL/pgSQL de lire et d'écrire dans tous les fichiers accessibles depuis le serveur. Chaque session peut ouvrir un maximum de dix fichiers et la taille maximale de la ligne est de 32 Ko. Ce package contient les fonctions suivantes :
utl_file.fclose(file utl_file.file_type) - fermer le fichier
utl_file.fclose_all() - ferme tous les fichiers
utl_file.fcopy(src_location, src_filename, dest_location, dest_filename[, start_line][, end_line]) - copier le fichier texte
utl_file.fflush(file utl_file.file_type) - vide toutes les données des tampons
utl_file.fgetattr(location, filename) - récupère les attributs du fichier
utl_file.fopen (texte d'emplacement, texte du nom de fichier, texte du mode fichier [, maxlinesize int] [, nom d'encodage]) utl_file.file_type - fichier ouvert
utl_file.fremove(emplacement, nom de fichier) - supprimer le fichier
utl_file.frename(location, filename, dest_dir, dest_file[, overwrite]) - renommer le fichier
utl_file.get_line(file utl_file.file_type) text - lit une ligne du fichier
utl_file.get_nextline(file utl_file.file_type) text - lit une ligne du fichier ou renvoie NULL
utl_file.is_open(file utl_file.file_type) bool - renvoie vrai si le fichier est ouvert
utl_file.new_line(file utl_file.file_type [,rows int]) - met de nouveaux caractères de ligne dans un fichier
utl_file.put(file utl_file.file_type, buffer text) - place le tampon dans le fichier
utl_file.put_line(file utl_file.file_type, buffer text) - place la ligne dans le fichier
utl_file.putf(file utl_file.file_type, format buffer [,arg1 text][,arg2 text][..][,arg5 text]) - met le texte formaté dans un fichier
utl_file.tmpdir() - récupère le chemin du répertoire temporaire
Étant donné que PostgreSQL ne prend pas en charge l'appel par référence, certaines fonctions sont légèrement différentes : fclose et get_line.
déclarer f utl_file.file_type;
commencer
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
<<lire>>
boucle
commencer
augmenter l'avis '%', utl_file.get_line(f);
exception
quand no_data_found alors
quitter readl ;
fin;
terminer la boucle ;
f := fclose(f);
fin;ou deuxième (avec la fonction spécifique get_nextline de PostgreSQL)
déclarer
f utl_file.file_type;
texte de ligne ;
commencer
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
boucle
ligne := utl_file.get_nextline(f);
quitter lorsque la ligne est NULL ;
augmenter l'avis '%', ligne ;
exception
quand d'autres alors
utl_file.fclose_all();
fin;Avant d'utiliser le package, vous devez définir la table utl_file.utl_file_dir. Il contient tous les répertoires autorisés sans symbole de fin ('/' ou ''). Sur la plateforme WinNT, les chemins doivent à chaque fois se terminer par le symbole ''.
Les entrées du répertoire peuvent être nommées (deuxième colonne du tableau utl_file.utl_file_dir ). Le paramètre location peut être soit le nom du répertoire, soit le chemin du dictionnaire. L'emplacement est d'abord interprété et vérifié comme un nom de répertoire. S'il n'est pas trouvé (dans la 2ème colonne), alors l'emplacement est interprété et vérifié comme un chemin.
Les fonctions du package utl_file (schéma sur Postgres) nécessitent un accès à la table utl_file.utl_file_dir. Ce fait peut être utilisé pour contrôler quels utilisateurs peuvent ou non utiliser ces fonctions. Le paramètre par défaut est READ pour PUBLIC. INSERT, UPDATE ne peut le faire qu'en tant qu'utilisateur privilégié (super utilisateur). Ainsi, un utilisateur non privilégié peut utiliser les fonctions de ce package, mais ne peut pas modifier la liste des répertoires sécurisés (contenu de la table utl_file.utl_file_dir). Le contenu de ce tableau est visible pour PUBLIC (ou devrait être visible pour les utilisateurs qui utilisent les fonctions de ce package).
Il s'agit d'une implémentation de l'API Oracle du package DBMS_SQL
Cela ne garantit pas une compatibilité totale, mais devrait diminuer le travail nécessaire à une migration réussie.
Attention : l'architecture PostgreSQL est différente de l'architecture d'Oracle. PL/pgSQL est exécuté dans le même contexte que le moteur SQL. Il n'y a alors aucune raison d'utiliser les modèles d'Oracle tels que la collecte en masse et l'itération sur la collecte dans Postgres pour obtenir de bonnes performances. Ce code est conçu pour réduire le travail lié au portage de certaines applications d'Oracle vers Postgres, et il peut bien fonctionner. Mais il n'y aura aucun avantage en termes de performances par rapport à la construction d'instructions PL/pgSQL. L'émulation de l'API d'Oracle entraîne une surcharge de mémoire et de processeur, qui peut être importante sur des données plus volumineuses.
Cette extension implémente un sous-ensemble de l'interface dbms_sql d'Oracle. Le but de cette extension n'est pas une compatibilité avec Oracle, elle est conçue pour réduire certaines tâches liées à la migration des applications Oracle vers Postgres. Certaines fonctionnalités DML en masse de base sont prises en charge :
faire $$
déclarer
cint;
un int[];
bvarchar[];
ca numérique[];
commencer
c := dbms_sql.open_cursor();
appelez dbms_sql.parse(c, 'insérer dans les valeurs foo(:a, :b, :c)');
a := TABLEAU[1, 2, 3, 4, 5];
b := ARRAY['Ahoj', 'Nazdar', 'Bazar'];
ca := ARRAY[3.14, 2.22, 3.8, 4];
appelez dbms_sql.bind_array(c, 'a', a, 2, 3);
appelez dbms_sql.bind_array(c, 'b', b, 3, 4);
appelez dbms_sql.bind_array(c, 'c', ca);
augmenter l'avis 'lignes insérées %d', dbms_sql.execute(c);
fin;
$$ ;
faire $$
déclarer
cint;
un int[];
bvarchar[];
ca numérique[];
commencer
c := dbms_sql.open_cursor();
appelez dbms_sql.parse(c, 'select i, ''Ahoj'' || i, i + 0.003 from generate_series(1, 35) g(i)');
appelez dbms_sql.define_array(c, 1, a, 10, 1);
appelez dbms_sql.define_array(c, 2, b, 10, 1);
appelez dbms_sql.define_array(c, 3, ca, 10, 1);
exécutez dbms_sql.execute(c);
tandis que dbms_sql.fetch_rows(c) > 0
boucle
appelez dbms_sql.column_value(c, 1, a);
appelez dbms_sql.column_value(c, 2, b);
appelez dbms_sql.column_value(c, 3, ca);
augmenter l'avis 'a = %', a;
augmenter l'avis 'b = %', b;
augmenter l'avis 'c = %', ca;
terminer la boucle ;
appelez dbms_sql.close_cursor(c);
fin;
$$ ; Il existe une fonction dbms_sql.describe_columns_f , qui ressemble à la procédure dbms_sql.describe_columns . Attention, les identifiants de type sont liés au système de types PostgreSQL. Les valeurs ne sont pas converties en nombres Oracle
faire $$
déclarer
cint;
r enregistrer;
d dbms_sql.desc_rec;
commencer
c := dbms_sql.open_cursor();
appelez dbms_sql.parse(c, 'select * from pg_class');
r := dbms_sql.describe_columns(c);
augmenter l'avis '%', r.col_cnt;
foreach d dans le tableau r.desc_t
boucle
augmenter l'avis '% %', d.col_name, d.col_type::regtype;
terminer la boucle ;
appelez dbms_sql.close_cursor(c);
fin;
$$ ;
faire $$
déclarer
cint;
n entier ;
d dbms_sql.desc_rec;
par dbms_sql.desc_rec[];
commencer
c := dbms_sql.open_cursor();
appelez dbms_sql.parse(c, 'select * from pg_class');
appelez dbms_sql.describe_columns(c, n, da);
augmenter l'avis '%', n ;
foreach d dans le tableau da
boucle
augmenter l'avis '% %', d.col_name, d.col_type::regtype;
terminer la boucle ;
appelez dbms_sql.close_cursor(c);
fin;
$$ ;Ce package est une émulation du package Oracle dbms_pipe. Il assure la communication inter-sessions. Vous pouvez envoyer et lire n'importe quel message avec ou sans attendre ; lister les canaux actifs ; définir un canal comme privé ou public ; et utilisez des canaux explicites ou implicites.
Le nombre maximum de tuyaux est de 50.
La mémoire partagée est utilisée pour envoyer des messages.
Un exemple suit :
-- Séance A
select dbms_pipe.create_pipe('my_pipe',10,true); -- création de canal explicite
select dbms_pipe.pack_message('neco je jinak');
select dbms_pipe.pack_message('tout est autre chose');
sélectionnez dbms_pipe.send_message('my_pipe',20,0); - modifier la limite et envoyer sans attendre
sélectionnez * dans dbms_pipe.db_pipes ; -- liste des canalisations actuelles
-- Séance B
sélectionnez dbms_pipe.receive_message('my_pipe',1); -- attendez maximum 1 seconde pour le message
sélectionnez dbms_pipe.next_item_type(); -> 11, texte
sélectionnez dbms_pipe.unpack_message_text();
sélectionnez dbms_pipe.next_item_type(); -> 11, texte
sélectionnez dbms_pipe.unpack_message_text();
sélectionnez dbms_pipe.next_item_type(); -> 0, plus d'éléments
sélectionnez dbms_pipe.remove_pipe('my_pipe');Il existe cependant quelques différences par rapport à Oracle :
la limite pour les tuyaux n'est pas en octets mais en éléments dans le tuyau
vous pouvez envoyer un message sans attendre
tu peux envoyer des messages vides
next_item_type connaît TIMESTAMP (type 13)
PostgreSQL ne connaît pas le type RAW, utilisez plutôt bytea
Un autre moyen de communication inter-processus.
-- Séance A
sélectionnez dbms_alert.register('boo');
sélectionnez * dans dbms_alert.waitany(10);
-- Séance B
sélectionnez dbms_alert.register('boo');
sélectionnez * dans dbms_alert.waitany(10);
-- Séance C
select dbms_alert.signal('boo','Belle journée');Ce module contient quelques fonctions pour travailler avec les jours ouvrables du package PLVdate. Une documentation détaillée peut être trouvée dans la bibliothèque PLVision. Ce package est multiculturel, mais les configurations par défaut sont uniquement pour les pays européens (voir code source).
Vous devez définir vos propres jours non ouvrables (max 50 jours) et vos propres jours fériés (max 30 jours). Un jour férié est un jour non ouvrable, le même chaque année. Par exemple, le jour de Noël dans les pays occidentaux.
plvdate.add_bizdays(day date,days int) date - Obtenez la date créée en ajoutant <n> jours ouvrables à une date
plvdate.nearest_bizday(day date) date - Obtenez la date ouvrable la plus proche d'une date donnée, définie par l'utilisateur
plvdate.next_bizday(day date) date - Obtenez la prochaine date ouvrable à partir d'une date donnée, définie par l'utilisateur
plvdate.bizdays_between(day1 date, day2 date) int - Récupère le nombre de jours ouvrables entre deux dates
plvdate.prev_bizday(day date) date - Obtenez la date ouvrable précédente à partir d'une date donnée
plvdate_isbizday(date) bool - Appelez cette fonction pour déterminer si une date est un jour ouvrable
plvdate.set_nonbizday(dow varchar) - Définir le jour de la semaine comme jour non ouvrable
plvdate.unset_nonbizday(dow varchar) - Jour de la semaine non défini comme jour non ouvrable
plvdate.set_nonbizday(day date) - Définir le jour comme jour non ouvré
plvdate.unset_nonbizday(day date) - Jour non défini comme jour non ouvrable
plvdate.set_nonbizday(day date, repeat bool) - Définit le jour comme jour non professionnel, si 'repeat' est vrai, alors le jour est non professionnel chaque année
plvdate.unset_nonbizday(day date, repeat bool) - Jour non défini comme jour non professionnel, si 'repeat' est vrai, alors le jour est non professionnel chaque année
plvdate.use_easter() - Le dimanche et le lundi de Pâques seront fériés
plvdate.unuse_easter();
plvdate.use_easter(useit booléen);
plvdate.using_easter() bool - Si nous utilisons Pâques, renvoie vrai
plvdate.use_great_friday() - Le Grand Vendredi de Pâques sera un jour férié
plvdate.unuse_easter();
plvdate.use_easter(useit booléen);
plvdate.using_easter() bool - Si nous utilisons le Grand Vendredi de Pâques comme jour férié, cela renvoie vrai
plvdate.include_start() - Inclut la date de début dans le calcul bizdays_between
plvdate.noinclude_start();
plvdate.include_start (inclure booléen);
plvdate.incluant_start() bool;
plvdate.default_holidays(varchar) - charge les configurations par défaut. Vous pouvez actuellement utiliser les configurations suivantes : tchèque, allemand, Autriche, Pologne, Slovaquie, Russie, Grande-Bretagne et États-Unis.
la configuration ne contient que les jours fériés communs à toutes les régions. Vous pouvez ajouter vos propres jours fériés régionaux avec plvdate.set_nonbizday(nonbizday, true)
Exemple:
postgres=# select plvdate.default_holidays('czech');
vacances_par défaut
-----------------
(1 rangée)
postgres=# sélectionnez to_char(current_date, 'day'),
plvdate.next_bizday(current_date),
to_char(plvdate.next_bizday(current_date),'day');
to_char | prochain_bizday | to_char
----------+-------------+----------------
samedi | 2006-03-13 | lundi
(1 rangée)Modification pour environnement non européen :
sélectionnez plvdate.unset_nonbizday('samedi');
sélectionnez plvdate.unset_nonbizday('dimanche');
sélectionnez plvdate.set_nonbizday('vendredi');
sélectionnez plvdate.set_nonbizday('2006-05-19', true);
sélectionnez plvdate.unuse_easter(); Ce paquet contient des fonctions utiles de chaînes et de caractères. Chaque fonction prend en charge les décalages positifs et négatifs, c'est-à-dire le décalage par rapport à la fin de la chaîne. Par exemple:
plvstr.left('abcdef',2) -> ab
plvstr.left('abcdef',-2) -> abcd
plvstr.substr('abcdef',1,1) -> un
plvstr.substr('abcdef',-1,1) -> f
plvstr.substr('abcde',-2,1) -> dListe des fonctions :
plvstr.normalize(str text) - Normaliser la chaîne - Remplacer les caractères blancs par un espace, remplacer les espaces par un espace
plvstr.is_prefix(str text, prefix text, cs bool) - Renvoie vrai, si le préfixe est le préfixe de str
plvstr.is_prefix(str text, prefix text) - Renvoie vrai, si le préfixe est le préfixe de str
plvstr.is_prefix(str int, prefix int) - Renvoie vrai, si le préfixe est le préfixe de str
plvstr.is_prefix(str bigint, prefix bigint) - Renvoie vrai, si le préfixe est le préfixe de str
plvstr.substr(str text, start int, len int) - Renvoie la sous-chaîne commencée sur start_in pour se terminer
plvstr.substr(str text, start int) - Renvoie la sous-chaîne commencée sur start_in pour se terminer
plvstr.instr(str text, patt text, start int, nth int) - Modèle de recherche dans une chaîne
plvstr.instr(str text, patt text, start int) - Modèle de recherche dans une chaîne
plvstr.instr(str text, patt text) - Modèle de recherche dans une chaîne
plvstr.lpart(str text, div text, start int, nth int, all_if_notfound bool) - Appelez cette fonction pour renvoyer la partie gauche d'une chaîne
plvstr.lpart(str text, div text, start int, nth int) - Appelez cette fonction pour renvoyer la partie gauche d'une chaîne
plvstr.lpart(str text, div text, start int) - Appelez cette fonction pour renvoyer la partie gauche d'une chaîne
plvstr.lpart(str text, div text) - Appelez cette fonction pour renvoyer la partie gauche d'une chaîne
plvstr.rpart(str text, div text, start int, nth int, all_if_notfound bool) - Appelez cette fonction pour renvoyer la partie droite d'une chaîne
plvstr.rpart(str text, div text, start int, nth int) - Appelez cette fonction pour renvoyer la partie droite d'une chaîne
plvstr.rpart(str text, div text, start int) - Appelez cette fonction pour renvoyer la partie droite d'une chaîne
plvstr.rpart(str text, div text) - Appelez cette fonction pour renvoyer la partie droite d'une chaîne
plvstr.lstrip(str text, substr text, num int) - Appelez cette fonction pour supprimer les caractères du début
plvstr.lstrip(str text, substr text) - Appelez cette fonction pour supprimer les caractères du début
plvstr.rstrip(str text, substr text, num int) - Appelez cette fonction pour supprimer les caractères de la fin
plvstr.rstrip(str text, substr text) - Appelez cette fonction pour supprimer les caractères de la fin
plvstr.rvrs(str text, start int, _end int) - Chaîne inversée ou partie de chaîne
plvstr.rvrs(str text, start int) - Chaîne inversée ou partie de chaîne
plvstr.rvrs(str text) - Chaîne inversée ou partie de chaîne
plvstr.left(str text, n int) - Renvoie les premiers caractères num_in. Vous pouvez utiliser un num_in négatif
plvstr.right(str text, n int) - Renvoie les derniers caractères num_in. Vous pouvez utiliser num_ni négatif
plvstr.swap(str text, replace text, start int, length int) - Remplace une sous-chaîne dans une chaîne par une chaîne spécifiée
plvstr.swap(str text, replace text) - Remplace une sous-chaîne dans une chaîne par une chaîne spécifiée
plvstr.betwn(str text, start int, _end int, inclusive bool) - Rechercher la sous-chaîne entre les emplacements de début et de fin
plvstr.betwn(str text, start text, _end text, startnth int, endnth int, inclusive bool, gotoend bool) - Rechercher la sous-chaîne entre les emplacements de début et de fin
plvstr.betwn(str text, start text, _end text) - Rechercher la sous-chaîne entre les emplacements de début et de fin
plvstr.betwn(str text, start text, _end text, startnth int, endnth int) - Rechercher la sous-chaîne entre les emplacements de début et de fin
plvchr.nth(str text, n int) - Appelez cette fonction pour renvoyer le Nième caractère d'une chaîne
plvchr.first(str text) - Appelez cette fonction pour renvoyer le premier caractère d'une chaîne
plvchr.last(str text) - Appelez cette fonction pour renvoyer le dernier caractère d'une chaîne
plvchr.is_blank(c int) - Est vide
plvchr.is_blank(c text) - Est vide
plvchr.is_digit(c int) - Est un chiffre
plvchr.is_digit(c text) - Est un chiffre
plvchr.is_quote(c int) - Est une citation
plvchr.is_quote(c text) - Est une citation
plvchr.is_other(c int) - Est-ce autre
plvchr.is_other(c text) - Est-ce autre
plvchr.is_letter(c int) - Est une lettre
plvchr.is_letter(c text) - Est une lettre
plvchr.char_name(c text) - Renvoie le nom du caractère en code ascii sous forme de VARCHAR.
plvchr.quoted1(str text) - Texte cité entre '''
plvchr.quoted2(str text) - Texte cité entre '"'
plvchr.stripped(str text, char_in text) - Supprime une chaîne de toutes les instances des caractères spécifiés
Le package PLVsubst effectue des substitutions de chaînes basées sur un mot-clé de substitution.
plvsubst.string(template_in text, vals_in text[]) - Analyse une chaîne pour toutes les instances du mot-clé de substitution et la remplace par la valeur suivante dans la liste des valeurs de substitution
plvsubst.string(texte modèle_in, texte vals_in[], texte subst_in)
plvsubst.string (texte template_in, texte vals_in, texte delim_in)
plvsubst.string (texte template_in, texte vals_in, texte delim_in, texte subst_in)
plvsubst.setsubst(str text) - Définir le mot-clé de substitution sur '%s' par défaut
plvsubst.subst() - Récupère le mot-clé de substitution
Exemples :
select plvsubst.string('Je m'appelle %s %s.', ARRAY['Pavel','Stěhule']);
chaîne
--------------------------
Je m'appelle Pavel Stěhule.
(1 rangée)
select plvsubst.string('Je m'appelle %s %s.', 'Pavel,Stěhule');
chaîne
--------------------------
Je m'appelle Pavel Stěhule.
(1 rangée)
select plvsubst.string('Mon nom est $$ $$.', 'Pavel|Stěhule','|','$$');
chaîne
--------------------------
Je m'appelle Pavel Stěhule.
(1 rangée)dms_utility.format_call_stack() — renvoie une chaîne formatée avec le contenu de la pile d'appels
postgres=# select foo2();
foo2
---------------------------------
----- Pile d'appels -----
objet ligne
numéro nom de l'instruction
1 fonction de retour foo
1 fonction de retour foo1
1 fonction de retour foo2
(1 rangée)Ce package n'est pas compatible avec le PLVlex original.
postgres=# sélectionnez * à partir de
plvlex.tokens('select * from abc join d ON x=y', true, true);
position | jeton | codes | classe | séparateur | module
----+--------+------+---------+---------------+------
0 | sélectionner | 527 | MOT CLÉ | |
7 | * | 42 | AUTRES | | soi
9 | de | 377 | MOT CLÉ | |
25 | abc | | IDENTIFIANT | |
20 | rejoindre | 418 | MOT CLÉ | |
25 | ré | | IDENTIFIANT | |
27 | sur | 473 | MOT CLÉ | |
30 | X | | IDENTIFIANT | |
31 | = | 61 | AUTRES | | soi
32 | y | | IDENTIFIANT | |
(10 lignes)Attention : les codes des mots clés peuvent être modifiés entre les versions de PostgreSQL ! o plvlex.tokens(str text, skip_spaces bool, qualifier_names bool) - Renvoie le tableau des éléments lexicaux dans str.
Ce package protège les entrées utilisateur contre l’injection SQL.
dbms_assert.enquote_literal(varchar) varchar - Ajoutez des guillemets de début et de fin, vérifiez que tous les guillemets simples sont associés à des guillemets simples adjacents.
dbms_assert.enquote_name(varchar [, boolean]) varchar - Mettez le nom entre guillemets doubles. Le deuxième paramètre facultatif garantit la réduction du nom. Attention - Sur Oracle, le deuxième paramètre est en majuscule !
dbms_assert.noop(varchar) varchar - Renvoie la valeur sans aucune vérification.
dbms_assert.qualified_sql_name(varchar) varchar - Cette fonction vérifie que la chaîne d'entrée est un nom SQL qualifié.
dbms_assert.schema_name(varchar) varchar - La fonction vérifie que la chaîne d'entrée est un nom de schéma existant.
dbms_assert.simple_sql_name(varchar) varchar -Cette fonction vérifie que la chaîne d'entrée est un simple nom SQL.
dbms_assert.object_name(varchar) varchar - Vérifie que la chaîne d'entrée est un identifiant SQL qualifié d'un objet SQL existant.
Cette unité contient quelques fonctions d'assertion.
plunit.assert_true(bool [, varchar]) - Affirme que la condition est vraie.
plunit.assert_false(bool [, varchar]) - Affirme que la condition est fausse.
plunit.assert_null(anyelement [, varchar]) - Affirme que le réel est nul.
plunit.assert_not_null(anyelement [, varchar]) - Affirme que le réel n'est pas nul.
plunit.assert_equals(anyelement, anyelement [, double précision] [, varchar]) - Affirme que les attentes et les réalités sont égales.
plunit.assert_not_equals(anyelement, anyelement [, double précision] [, varchar]) - Affirme que les attentes et les réalités sont égales.
plunit.fail([varchar]) - Fail peut être utilisé pour provoquer l'échec immédiat d'une procédure de test à l'aide du message fourni.
dbms_random.initialize(int) - Initialise le package avec une valeur de départ.
dbms_random.normal() - Renvoie des nombres aléatoires dans une distribution normale standard.
dbms_random.random() - Renvoie un nombre aléatoire de -2^31 .. 2^31.
dbms_random.seed(int)
dbms_random.seed(text) - Réinitialise la valeur de départ.
dbms_random.string(opt text(1), len int) - Créer une chaîne aléatoire
dbms_random.terminate() - Terminer le package (ne rien faire dans Pg)
dbms_random.value() - Renvoie un nombre aléatoire compris entre [0,0 et 1,0)
dbms_random.value(faible double précision, haute double précision) - Renvoie un nombre aléatoire de [faible - élevé)
Ce module contient l'implémentation des fonctions : concat, nvl, nvl2, lnnvl, decode, plus grand, moins, bitand, nanvl, sinh, cosh, tanh, oracle.substr et oracle.mod.
oracle.substr(str text, start int, len int) - Sous-chaîne compatible Oracle
oracle.substr(str text, start int) - Sous-chaîne compatible Oracle
oracle.substr(str numeric, start numeric) - Sous-chaîne compatible Oracle
oracle.substr(str numeric, start numeric, len numeric) - Sous-chaîne compatible Oracle
oracle.substr(str varchar, start numeric) - Sous-chaîne compatible Oracle
oracle.substr(str varchar, start numeric,len numeric) - Sous-chaîne compatible Oracle
oracle.lpad(string, length [, fill]) - lpad compatible Oracle
oracle.rpad(string, length [, fill]) - rpad compatible Oracle
oracle.ltrim (texte de chaîne [, texte de caractères]) - ltrim compatible Oracle
oracle.rtrim (texte de chaîne [, texte de caractères]) - rtrim compatible Oracle
oracle.btrim(texte de chaîne [, texte de caractères]) - btrim compatible Oracle
oracle.length(string char) - Longueur compatible Oracle
oracle.listagg(str text [, separator text]) - agréger les valeurs à lister
oracle.wm_concat(str text) - agréger les valeurs dans une liste séparée par des virgules
oracle.median(float4) - calculer une médiane
oracle.median(float8) - calculer une médiane
oracle.to_number(text) - convertit une chaîne en nombre
oracle.to_number(numeric) - convertit une chaîne en nombre
oracle.to_number(numeric,numeric) - convertit une chaîne en nombre
public.to_multi_byte(text) - Convertit tous les caractères à un octet en caractères multi-octets correspondants
public.to_single_byte(text) - Convertit tous les caractères multi-octets en caractères mono-octets correspondants
oracle.greatest(anyelement, anyelement[]) - Meilleure compatibilité Oracle, renvoie NULL sur une entrée NULL
oracle.least(anyelement, anyelement[]) - Compatibilité Oracle minimale, renvoie NULL sur l'entrée NULL
oracle.mod(int, int) - Mod de compatibilité Oracle, si le deuxième paramètre est zéro, il renvoie le premier paramètre
Oracle.Remainder (int, int) - Renvoie le reste du nombre divisé par un autre numéro
Oracle.Remainder (numérique, numérique) - Renvoie le reste du nombre divisé par un autre numéro
Oracle.sys_guid () - Renvoie Bytea - 16 octets d'identification mondiale UNIQ
Vous devrez peut-être définir Search_Path sur 'Oracle, PG_CATALOG, "$ USER", public' parce que Oracle.substr, Oracle.lpad, Oracle.rpad, Oracle.ltrim, Oracle.rtrim, Oracle.btrim, Oracle.length sont installés côté installé -par-côté avec pg_catalog.substr, pg_catalog.lpad, pg_catalog.rpad, pg_catalog.ltrim, pg_catalog.rtrim, pg_catalog.btrim, pg_catalog.length respectivement.
Fonctions Oracle.decode, Oracle.Greatest et Oracle.least doivent toujours être préfixées par le nom du schéma même si l'Oracle est avant PG_CATALOG dans la Search_Path car ces fonctions sont implémentées dans PostgreSQL PARSER et analyseur. Sans le nom du schéma, les fonctions internes seront toujours utilisées.
Notez que dans le cas de LPAD et RPAD, les paramètres de la chaîne et du remplissage peuvent être de types char, varchar, text, varchar2 ou nvarchar2 (notez que les deux derniers sont des types fournis par ORAFCE). Le caractère de remplissage par défaut est un espace demi-largeur. De même pour Ltrim, Rtrim et Btrim.
Notez qu'Oracle.Length a une limitation qu'il fonctionne uniquement en unités de caractères car le type de Char PostgreSQL ne prend en charge que la sémantique de caractères.
L'Oracle.substr avec trois arguments peut renvoyer un résultat différent (chaîne nul ou vide) en dépendance pour définir la variable ORAFCE.using_substring_zero_width_in_substr (Oracle, Warning_oracle, ORAFCE, WARNING_ORAFCE). Ce résultat différent n'est renvoyé que lorsque le troisième argument (substring_length) est zéro. La valeur par défaut est Warning_oracle, cela signifie augmenter l'avertissement et retourner null.
Cette fonction renvoie un ID unique global. Il appelle les fonctions spécifiées à partir de l'extension "UUID-OSSP", puis cette fonction doit être installée avant que la fonction SYS_GUID soit utilisée. Par défaut, cette fonction utilise la fonction uuid_generate_v1, mais la fonction uuid_generate_v1mc, uuid_generate_v4 peut également être utilisée (en définissant ORAFCE.SYS_GUID_SOURCE). Oracle.Sys_Guid peut également utiliser Builin Gen_Random_uuid Func. Dans ce cas, l'extension "UUID-OSSP" n'est pas requise.
VarChar2 d'Orafce implémente des parties de la spécification de la base de données Oracle sur Varchar2:
Unité de type modificateur = 'octets' (pour la sémantique des caractères, voir nvarchar2)
Contrairement à PostgreSQL VARCHAR, le casting implicite à Varchar2 ne tronque pas les espaces blancs sur une longueur maximale déclarée
Pour ces types, il est possible d'utiliser Null Safe || Opérateur, lorsque vous activez ORAFCE.VARCHAR2_NULL_SAFE_CONCAT TO TRUE. Le comportement est très similaire à Oracle.
Attention: - Lorsque le résultat est une chaîne vide, le résultat est nul. Ce comportement est désactivé par défaut.
Attention: - Il y a une incompatibilité possible entre 3,7 et ORAFCE plus ancienne libère. Une fonction d'opérateur est désormais marquée comme stable (était immuable avant). Il n'est pas possible de créer des index fonctionnels sur des expressions stables ou volatiles.
- Null Safe Concat (désactivé par défaut) Sélectionnez NULL || 'Bonjour' :: Varchar2 || NUL; Définissez ORAFCE.VARCHAR2_NULL_SAFE_CONCAT TO TRUE; Sélectionnez NULL || 'Bonjour' :: Varchar2 || NUL;
Veuillez noter que PostgreSQL ne permet pas de spécifier dynamiquement comment nous interprétons les chaînes VARCHAR. Il les interprète toujours comme des chaînes de «caractère» déterminées par le codage de la base de données. Ainsi, nous ne pouvons pas prendre en charge la sémantique BYTE et les caractères pour un type VARCHAR donné dans la même base de données. Nous avons choisi d'implémenter la sémantique d'octets car c'est par défaut dans Oracle. Pour la sémantique des personnages, veuillez consulter Nvarchar2 qui, par défaut, implémente toujours la sémantique de personnage.
Veuillez être prudent lorsque vous utilisez le type ci-dessus pour stocker les chaînes composées de caractères codés à plusieurs sites dans lesquels chaque caractère peut être composé d'un nombre arbitraire d'octets.
Nvarchar2 implémente ce qui suit:
Unité de type modificateur = 'caractères' (en utilisant le jeu de caractères / codage de la base de données)
Utilisez ce type si la sémantique de caractères est préférée.
Veuillez noter que, contrairement à Oracle, Varchar2 et Nvarchar2 d'Orafce n'imposent pas la limite de 4000 octets à la taille «déclarée». En fait, c'est le même que celui de PostgreSQL Varchar, qui est d'environ 10 Mo (bien que Varchar puisse théoriquement stocker des valeurs de taille jusqu'à 1 Go)
Certaines fonctions de chaîne basées sur des octets à utiliser avec les chaînes VARCHAR2
substrb (varchar2, int [, int]) - extraire une sous-chaîne de longueur spécifiée (en octets) commençant à une position d'octet donnée (comptant à partir d'un); Si le troisième argument n'est pas spécifié, la longueur à la fin de la chaîne est considérée
STRPOSB (VARCHAR2, VARCHAR2) - Renvoie l'emplacement de la sous-chaîne spécifiée dans une chaîne donnée (compter à partir d'un)
LongueurB (Varchar2) - Renvoie la longueur (en octets) d'une chaîne donnée
Oracle ne fait pas de différences entre la chaîne nul et vide (lorsqu'une valeur est utilisée comme texte). Pour Postgres NULL et la chaîne vide sont des valeurs différentes. Pour la simplicité, il est bon pour vous assurer (dans la base de données Postgres), utilisez uniquement des nuls (et n'utilisez pas de chaînes vides) ou utilisez uniquement des chaînes vides (et n'utilisez pas Nulls) pour les colonnes de type de texte. Les deux variantes présente certains avantages et inconvénients.
Cela peut être énuméré avec des fonctions de déclenchement:
oracle.replace_empty_strings (['on' | 'true' | 'avertissement' | 'error']) oracle.replace_null_strings (['on' | 'true' | 'avertissement' | 'error'])
L'argument de chaîne facultatif est utilisé comme indicateur, ces fonctions devraient donc augmenter l'avertissement (éventuellement une erreur) lorsque la ligne a été modifiée à l'intérieur de ces fonctions.
Créer un test de table (id serial, name varchar, nom de famille varchar);
Créer Triger Test_Trg
Avant d'insérer ou de mettre à jour
À l'épreuve
Pour chaque ligne
Exécuter la procédure oracle.replace_empty_strings ();
Insérer dans Test (nom, nom de famille) Valeurs ('', 'Stehule');
- Le nom sera remplacé par nulloracle.user_tab_columns
oracle.user_tables
oracle.user_cons_columns
oracle.user_constaints
oracle.product_componenent_version
oracle.user_objects
oracle.dba_segments
meilleure documentation
meilleure séralisation dans DBMS_PIPE (via _Send et _recv Fonctions)
modifier les structures de mémoire partagées par des tables temporaires: seules les verrous sont en shmem (bitmaps), les données dans TMP TBL
Ce module est libéré sous la licence BSD.
Le projet a été fondé en 2008 par Pavel Stehule <[email protected]>.
Autres contributeurs:
Gabriele Bartolini (Gbartolini)
Jeffrey Cohen (Jcohen)
Giles Darold (Darold)
Pavan Deolasee (Pavanvd)
Peter Eisentraut (Perere)
Beena Emerson (B-emerson)
Takahiro Itagaki (Itagaki)
Zdenek Kotala (Hlipa)
Amit Langote (Amitlan)
Heikki Linnakangas (Hlinnaka)
Fujii Masao
Marco Nenciarini (Mnencia)
Vinayak Pokale
Gavin Sherry (SWM)
Pavel Stehule (Okbob)
Rahila Syed (Rahila)
