orafce
4.13.5
Funciones y operadores que emulan un subconjunto de funciones y paquetes de Oracle RDBMS.
Hay un grupo de Google asociado: https://groups.google.com/forum/?hl=en#!forum/orafce-general
Orafce es compatible con AWS Aurora con compatibilidad con PostgreSQL y también con Azure Database para PostgreSQL.
Este módulo contiene algunas funciones útiles que pueden ayudar a migrar la aplicación Oracle a PostgreSQL o que pueden ser útiles en general.
Las funciones de fecha integradas de Oracle se han probado con Oracle 10 para comprobar su conformidad. Los rangos de fechas de 1960 a 2070 funcionan correctamente. Las fechas anteriores al 1582-10-05 con el formato 'J' y anteriores al 1100-03-01 con otros formatos no se pueden verificar debido a un error en Oracle.
Todas las funciones son totalmente compatibles con Oracle y respetan todas las cadenas de formato conocidas. Se pueden encontrar descripciones detalladas en Internet. Utilice palabras clave como: fecha trunc redonda de Oracle iyyy.
Y,AA,AAAA,AAAA,SYAA,SYAÑO año I,IY,IYY,IYYY iso año Q, cuarto Semana WW, día como primer día del año. Semana IW, comenzando el lunes Semana W, día como primer día del mes. DAY,DY,D primer día de la semana, domingo MES,MON,MM,RM mes CC, SCC siglo DDD,DD,J día HH, HH12, HH24 horas MI minuto
Funciones redondeadas. Es decir, una fecha del 1 de julio se redondeará al año siguiente. El 16 de julio se redondeará a agosto.
add_months(date, integer) date - Devuelve la fecha más n meses
add_months(fecha '2005-05-31',1) -> 2005-06-30
last_date(date) fecha: devuelve el último día del mes según un valor de fecha
último_día (fecha '2005-05-24') -> 2005-05-31
next_day(fecha, texto) fecha: devuelve el primer día de la semana mayor que un valor de fecha
next_day(fecha '2005-05-24', 'lunes') -> 2005-05-30
next_day(fecha, entero) fecha: igual que el anterior. El segundo argumento debe ser 1..7 e interpretarse como domingo...sábado.
día_siguiente(fecha '2005-05-24', 1) -> 2005-05-30
meses_entre(fecha, fecha) numérico: devuelve el número de meses entre la fecha1 y la fecha2. Si se calcula un mes fraccionario, la función meses_entre calcula la fracción basándose en un mes de 31 días.
meses_entre (fecha '1995-02-02', fecha '1995-01-01') -> 1.0322580645161
trunc(fecha, texto) fecha: trunca la fecha según el formato especificado
trunc(fecha '2005-07-12', 'iw') -> 2005-07-11
fecha redonda (fecha, texto): redondeará las fechas de acuerdo con el formato especificado
ronda (fecha '2005-07-12', 'aaaa') -> 2006-01-01
to_date(text) marca de tiempo: encasillará el texto de entrada en la marca de tiempo. GUC orafce.nls_date_format se utiliza para especificar el formato de texto de entrada para esta función. Si el valor se deja en blanco o se establece como DEFAULT, ingrese el formato de texto de acuerdo con la configuración GUC de estilo de fecha de PostgreSQL.
valor de orafce.nls_date_format a PREDETERMINADO
hasta_fecha('2014-05-19 17:23:53+5:30') -> 2014-05-19 17:23:53orafce.nls_date_format='AAAA-MMDD HH24:MI:SS'
hasta_fecha('2014-0519 17:23:53+5:30') -> 2014-05-19 17:23:53 to_date(texto, texto) marca de tiempo: encasillará el texto de entrada con el formato especificado en la marca de tiempo. El GUC orafce.orafce_emit_error_on_date_bug se usa para especificar si se informa un error cuando el valor de fecha alcanza el error de Oracle en las fechas. Este error aparece con fechas anteriores al 1582-10-05 cuando se utiliza el formato 'J' ( 'J2299159' ) y anteriores 1100-03-01 con otros formatos. Se informa un error de forma predeterminada; para deshabilitar este comportamiento, set orafce.orafce_emit_error_on_date_bug to off .
SELECCIONE oracle.to_date('112012', 'J');
ERROR: Las fechas anteriores al 1582-10-05 ("J2299159") no se pueden verificar debido a un error en Oracle.
SELECCIONE oracle.to_date('1003-03-15', 'aaaa-mm-dd');
ERROR: Las fechas anteriores al 1100-03-01 no se pueden verificar debido a un error en Oracle.
ESTABLECER orafce.oracle_compatibility_date_limit TO desactivado;
SELECCIONE oracle.to_date('112012', 'J');
hasta la fecha
------------------------
4407-07-30 00:00:00 aC
(1 fila)
SELECCIONE oracle.to_date('1003/03/15', 'aaaa/mm/dd');
hasta la fecha
---------------------
1003-03-15 00:00:00
(1 fila)Este módulo contiene la implementación del tipo de datos DATE compatible con Oracle "oracle.date" y funciones que utilizan el tipo de datos DATE como oracle.add_months,oracle.last_day(),oracle.next_day(),oracle.months_between(), etc.
Ejemplo:
establezca search_path en oracle, "$ usuario", público, pg_catalog;
crear tabla oracle_date(fecha col1);
insertar en valores de fecha_oracle('2014-06-24 12:12:11'::fecha);
seleccione * de oracle_date;
col1
---------------------
2014-06-24 12:12:11
(1 fila)oracle.add_months(marca de tiempo con zona horaria, número entero): devuelve fecha y hora más n meses
oracle.add_months(oracle.date'2005-05-31 10:12:12',1) -> 2005-06-30 10:12:12
oracle.last_day(marca de tiempo con zona horaria): devuelve el último día del mes según un valor de fecha
oracle.last_day(oracle.date '2005-05-24 11:12:12') -> 2005-05-31 11:12:12
oracle.next_day(marca de tiempo con zona horaria, texto): devuelve el primer día de la semana mayor que un valor de fecha
oracle.next_day(oracle.date '2005-05-24 10:12:12', 'lunes') -> 2005-05-30 10:12:12
oracle.next_day(marca de tiempo con zona horaria, número entero): igual que el anterior. El segundo argumento debe ser 1..7 e interpretarse como domingo...sábado.
oracle.next_day(oracle.date '2005-05-24 11:21:12', 1) -> 2005-05-29 11:21:12
oracle.months_between(marca de tiempo con zona horaria, marca de tiempo con zona horaria): devuelve el número de meses entre marca de tiempo1 y marca de tiempo2. Si se calcula un mes fraccionario, la función meses_entre calcula la fracción basándose en un mes de 31 días.
oracle.months_between(oracle.date '1995-02-02 10:00:00', oracle.date '1995-01-01 10:21:11') -> 1.03225806451613
oracle.to_date(texto,texto): devuelve la marca de tiempo sin zona horaria.
oracle.to_date('16/02/09 04:12:12', 'DD/MM/AA HH24:MI:SS') -> 2009-02-16 04:12:12oracle.to_date(texto) - Devuelve oracle.date
oracle.to_date('16/02/09 04:12:12') -> 2009-02-16 04:12:12oracle.sysdate(): devuelve la marca de tiempo de la declaración en la zona horaria del servidor (orafce.timezone)
oracle.sysdate() -> 2015-12-09 17:47:56
oracle.dbtimezone: devuelve la zona horaria del servidor, emulada a través de orafce.timezone
oracle.dbtimezone() -> GMT
oracle.sessiontimezone() - Devuelve la zona horaria de la sesión - zona horaria actual de PostgreSQL
oracle.sessiontimezone() -> Europa/Praga
oracle.sys_extract_utc(marca de tiempo con zona horaria): devuelve la marca de tiempo en la zona horaria utc
oracle.sys_extract_utc (marca de tiempo actual)
oracle.sys_extract_utc(oracle.date): devuelve la marca de tiempo en la zona horaria utc; cuando no se especifica la zona horaria, se utiliza la zona horaria de la sesión (PostgreSQL actual)
oracle.sys_extract_utc(oracle.date '2005-05-24 11:21:12', 1) -> 2005-05-24 09:21:12
oracle.to_char(timestamp): devuelve la marca de tiempo en nls_date_format.
orafce.nls_date_format='AA-MonDD HH24:MI:SS'
oracle.to_char(to_date('14-ene08 11:44:49+05:30')) -> 14-ene08 11:44:49
orafce.nls_date_format='AA-MonDD HH24:MI:SS'
oracle.to_char(oracle.to_date('21052014 12:13:44+05:30','DDMMAAAA HH24:MI:SS')) -> 14-21 de mayo 12:13:44 oracle.+(oracle.date,smallint) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::smallint -> 2014-07-11 10:08:55oracle.+(oracle.date,integer) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::entero -> 2014-07-11 10:08:55oracle.+(oracle.date,bigint) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::bigint -> 2014-07-11 10:08:55oracle.+(oracle.date,numeric) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::numérico -> 2014-07-11 10:08:55oracle.-(oracle.date,smallint) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::smallint -> 2014-06-23 10:08:55oracle.-(oracle.date,integer) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::entero -> 2014-06-23 10:08:55oracle.-(oracle.date,bigint) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::bigint -> 2014-06-23 10:08:55oracle.-(oracle.date,numeric) - Devuelve oracle.date
oracle.to_date('2014-07-02 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::numérico -> 2014-06-23 10:08:55oracle.-(oracle.date,oracle.date) - Devuelve doble precisión
oracle.to_date('2014-07-17 11:10:15', 'aaaa-mm-dd hh24:mi:ss') - oracle.to_date('2014-02-01 10:00:00', 'aaaa -mm-dd hh24:mi:ss') -> 166.048785Debe configurar search_path TO oracle,"$user", public, pg_catalog porque funciones como oracle.add_months,oracle.last_day,oracle.next_day,oracle.months_between se instalan en paralelo con pg_catalog.add_months,pg_catalog.last_day,pg_catalog.next_day,pg_catalog.months_between.
PostgreSQL no necesita la tabla 'dual' de Oracle, pero como los usuarios de Oracle la utilizan intensivamente, se ha agregado en orafce. Esta tabla está en el esquema oracle . Por lo general, desea permitir el acceso no calificado, por lo que debe agregar este esquema a la configuración search_path (como search_path = 'oracle, pg_catalog, "$user", public' en postgresql.conf ).
PostgreSQL envía información al cliente a través de RAISE NOTICE. Oracle usa dbms_output.put_line(). Esto funciona de manera diferente a LEVANTAR AVISO. Oracle tiene una cola de sesiones, put_line() agrega una línea a la cola y la función get_line() lee desde la cola. Si se establece el indicador 'serveroutput', el cliente sobre todas las declaraciones SQL lee la cola. Puedes usar:
seleccione dbms_output.enable();
seleccione dbms_output.put_line('primera_línea');
seleccione dbms_output.put_line('next_line');
seleccione * de dbms_output.get_lines(0);o
seleccione dbms_output.enable();
seleccione dbms_output.serveroutput('t');
seleccione dbms_output.put_line('primera_línea');Este paquete contiene las siguientes funciones: enable(), enable(), serveroutput(), put(), put_line(), new_line(), get_line(), get_lines(). La cola de paquetes se implementa en la memoria local de la sesión.
Este paquete permite que los programas PL/pgSQL lean y escriban en cualquier archivo al que se pueda acceder desde el servidor. Cada sesión puede abrir un máximo de diez archivos y el tamaño máximo de línea es 32K. Este paquete contiene las siguientes funciones:
utl_file.fclose(archivo utl_file.file_type) - cerrar archivo
utl_file.fclose_all() - cierra todos los archivos
utl_file.fcopy(src_location, src_filename, dest_location, dest_filename[, start_line][, end_line]) - copiar archivo de texto
utl_file.fflush(archivo utl_file.file_type): vacía todos los datos de los buffers
utl_file.fgetattr(ubicación, nombre de archivo) - obtiene atributos de archivo
utl_file.fopen(texto de ubicación, texto de nombre de archivo, texto de modo de archivo [, tamaño máximo de línea int] [, nombre de codificación]) utl_file.file_type - abrir archivo
utl_file.fremove(ubicación, nombre de archivo) - eliminar archivo
utl_file.frename(ubicación, nombre de archivo, dest_dir, dest_file[, sobrescribir]) - cambiar el nombre del archivo
utl_file.get_line(file utl_file.file_type) texto - lee una línea del archivo
utl_file.get_nextline(file utl_file.file_type) texto: lee una línea del archivo o devuelve NULL
utl_file.is_open(file utl_file.file_type) bool - devuelve verdadero, si el archivo está abierto
utl_file.new_line(file utl_file.file_type [,rows int]) - coloca algunos caracteres de nueva línea en el archivo
utl_file.put(archivo utl_file.file_type, texto del búfer): coloca el búfer en el archivo
utl_file.put_line(archivo utl_file.file_type, texto del búfer): coloca la línea en el archivo
utl_file.putf(archivo utl_file.file_type, búfer de formato [,arg1 texto][,arg2 texto][..][,arg5 texto]) - coloca texto formateado en el archivo
utl_file.tmpdir() - obtiene la ruta del directorio temporal
Debido a que PostgreSQL no admite llamadas por referencia, algunas funciones son ligeramente diferentes: fclose y get_line.
declarar f utl_file.file_type;
comenzar
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
<<lectura>>
bucle
comenzar
generar aviso '%', utl_file.get_line(f);
excepción
cuando no_data_found entonces
salir de lectura;
fin;
bucle final;
f := fcerrar(f);
fin;o segundo (con la función específica de PostgreSQL get_nextline)
declarar
f utl_file.tipo_archivo;
texto de línea;
comenzar
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
bucle
línea := utl_file.get_nextline(f);
salir cuando la línea es NULL;
aviso de aumento '%', línea;
excepción
cuando otros entonces
utl_file.fclose_all();
fin;Antes de usar el paquete, debe configurar la tabla utl_file.utl_file_dir. Contiene todos los directorios permitidos sin símbolo final ('/' o ''). En la plataforma WinNT, las rutas deben terminar siempre con el símbolo ''.
Las entradas del directorio pueden tener nombre (segunda columna de la tabla utl_file.utl_file_dir ). El parámetro location puede ser el nombre del directorio o la ruta del diccionario. La ubicación se interpreta y comprueba primero como un nombre de directorio. Si no se encuentra (en la segunda columna), la ubicación se interpreta y verifica como una ruta.
Las funciones del paquete utl_file (esquema en Postgres) requieren acceso a la tabla utl_file.utl_file_dir. Este hecho se puede utilizar para controlar qué usuarios pueden utilizar estas funciones o no. La configuración predeterminada es LEER para PÚBLICO. INSERTAR, ACTUALIZAR solo lo puede hacer un usuario privilegiado (superusuario). Por lo tanto, un usuario sin privilegios puede utilizar funciones de este paquete, pero no puede cambiar la lista de directorios seguros (contenido de la tabla utl_file.utl_file_dir). El contenido de esta tabla es visible para PUBLIC (o debería ser visible para los usuarios que usan funciones de este paquete).
Esta es la implementación de la API de Oracle del paquete DBMS_SQL.
No garantiza una compatibilidad total, pero debería reducir el trabajo necesario para una migración exitosa.
Atención: la arquitectura de PostgreSQL es diferente a la arquitectura de Oracle. PL/pgSQL se ejecuta en el mismo contexto que el motor SQL. Entonces no hay ninguna razón para utilizar los patrones de Oracle como la recopilación masiva y la iteración sobre la recopilación en Postgres para obtener un buen rendimiento. Este código está diseñado para reducir el trabajo relacionado con la migración de algunas aplicaciones de Oracle a Postgres y puede funcionar bien. Pero no habrá ninguna ventaja de rendimiento frente a las declaraciones PL/pgSQL integradas. La emulación de la API de Oracle tiene una sobrecarga de memoria y CPU, lo que puede ser significativo en datos más grandes.
Esta extensión implementa un subconjunto de la interfaz dbms_sql de Oracle. El objetivo de esta extensión no es la compatibilidad con Oracle, sino que está diseñado para reducir parte del trabajo relacionado con la migración de las aplicaciones de Oracle a Postgres. Se admiten algunas funciones DML masivas básicas:
hacer $$
declarar
cint;
un entero[];
bvarchar[];
ca numérico[];
comenzar
c := dbms_sql.open_cursor();
llame a dbms_sql.parse(c, 'insertar en valores foo(:a, :b, :c)');
a := ARRAY[1, 2, 3, 4, 5];
b := ARRAY['Ahoj', 'Nazdar', 'Bazar'];
ca := ARRAY[3.14, 2.22, 3.8, 4];
llame a dbms_sql.bind_array(c, 'a', a, 2, 3);
llamar a dbms_sql.bind_array(c, 'b', b, 3, 4);
llamar a dbms_sql.bind_array(c, 'c', ca);
generar aviso 'filas insertadas %d', dbms_sql.execute(c);
fin;
$$;
hacer $$
declarar
cint;
un entero[];
bvarchar[];
ca numérico[];
comenzar
c := dbms_sql.open_cursor();
llame a dbms_sql.parse(c, 'select i, ''Ahoj'' || i, i + 0.003 from generate_series(1, 35) g(i)');
llamar a dbms_sql.define_array(c, 1, a, 10, 1);
llamar a dbms_sql.define_array(c, 2, b, 10, 1);
llamar a dbms_sql.define_array(c, 3, ca, 10, 1);
realizar dbms_sql.execute(c);
mientras dbms_sql.fetch_rows(c) > 0
bucle
llamar a dbms_sql.column_value(c, 1, a);
llamar a dbms_sql.column_value(c, 2, b);
llamar a dbms_sql.column_value(c, 3, ca);
levantar aviso 'a = %', a;
levantar aviso 'b = %', b;
levantar aviso 'c = %', ca;
bucle final;
llamar a dbms_sql.close_cursor(c);
fin;
$$; Existe la función dbms_sql.describe_columns_f , que es como el procedimiento dbms_sql.describe_columns . Atención, los identificadores de tipo están relacionados con el sistema de tipos PostgreSQL. Los valores no se convierten a los números de Oracle.
hacer $$
declarar
cint;
registro;
d dbms_sql.desc_rec;
comenzar
c := dbms_sql.open_cursor();
llamar a dbms_sql.parse(c, 'seleccionar * de pg_class');
r := dbms_sql.describe_columns(c);
generar aviso '%', r.col_cnt;
foreach d en la matriz r.desc_t
bucle
generar aviso '% %', d.col_name, d.col_type::regtype;
bucle final;
llamar a dbms_sql.close_cursor(c);
fin;
$$;
hacer $$
declarar
cint;
nint;
d dbms_sql.desc_rec;
de dbms_sql.desc_rec[];
comenzar
c := dbms_sql.open_cursor();
llamar a dbms_sql.parse(c, 'seleccionar * de pg_class');
llamar a dbms_sql.describe_columns(c, n, da);
aviso de aumento '%', n;
foreach d en matriz da
bucle
generar aviso '% %', d.col_name, d.col_type::regtype;
bucle final;
llamar a dbms_sql.close_cursor(c);
fin;
$$;Este paquete es una emulación del paquete dbms_pipe de Oracle. Proporciona comunicación entre sesiones. Puedes enviar y leer cualquier mensaje con o sin espera; enumerar tuberías activas; configurar una tubería como privada o pública; y utilizar canalizaciones explícitas o implícitas.
El número máximo de tubos es 50.
La memoria compartida se utiliza para enviar mensajes.
A continuación se muestra un ejemplo:
-- Sesión A
seleccione dbms_pipe.create_pipe('my_pipe',10,true); -- creación explícita de tuberías
seleccione dbms_pipe.pack_message('neco je jinak');
seleccione dbms_pipe.pack_message('cualquier cosa es otra cosa');
seleccione dbms_pipe.send_message('my_pipe',20,0); -- cambiar límite y enviar sin esperar
seleccione * de dbms_pipe.db_pipes; -- lista de tuberías actuales
-- Sesión B
seleccione dbms_pipe.receive_message('my_pipe',1); -- espere máximo 1 segundo para recibir el mensaje
seleccione dbms_pipe.next_item_type(); -- -> 11, texto
seleccione dbms_pipe.unpack_message_text();
seleccione dbms_pipe.next_item_type(); -- -> 11, texto
seleccione dbms_pipe.unpack_message_text();
seleccione dbms_pipe.next_item_type(); -- -> 0, no más elementos
seleccione dbms_pipe.remove_pipe('my_pipe');Sin embargo, existen algunas diferencias en comparación con Oracle:
El límite para las tuberías no está en bytes sino en elementos en la tubería.
puedes enviar mensaje sin esperar
puedes enviar mensajes vacíos
next_item_type conoce TIMESTAMP (tipo 13)
PostgreSQL no conoce el tipo RAW, use bytea en su lugar
Otro medio de comunicación entre procesos.
-- Sesión A
seleccione dbms_alert.register('boo');
seleccione * de dbms_alert.waitany(10);
-- Sesión B
seleccione dbms_alert.register('boo');
seleccione * de dbms_alert.waitany(10);
-- Sesión C
seleccione dbms_alert.signal('boo','Buen día');Este módulo contiene algunas funciones para trabajar con días hábiles del paquete PLVdate. La documentación detallada se puede encontrar en la biblioteca PLVision. Este paquete es multicultural, pero las configuraciones predeterminadas son solo para países europeos (ver código fuente).
Debes definir tus propios días no laborables (máximo 50 días) y festivos (máximo 30 días). Un feriado es cualquier día inhábil, que es el mismo todos los años. Por ejemplo, el día de Navidad en los países occidentales.
plvdate.add_bizdays(día fecha, días int) fecha: obtiene la fecha creada agregando <n> días hábiles a una fecha
plvdate.nearest_bizday(día fecha) fecha: obtiene la fecha comercial más cercana a una fecha determinada, definida por el usuario
plvdate.next_bizday(day date) date: obtiene la siguiente fecha hábil a partir de una fecha determinada, definida por el usuario
plvdate.bizdays_between(día1 fecha, día2 fecha) int: obtiene el número de días hábiles entre dos fechas
plvdate.prev_bizday(día fecha) fecha: obtiene la fecha comercial anterior a partir de una fecha determinada
plvdate_isbizday(date) bool: llame a esta función para determinar si una fecha es un día hábil
plvdate.set_nonbizday(dow varchar): establece el día de la semana como día no laborable
plvdate.unset_nonbizday(dow varchar): no configura el día de la semana como día no laborable
plvdate.set_nonbizday(fecha del día): establece el día como día no laborable
plvdate.unset_nonbizday (fecha del día): día no establecido como día no laborable
plvdate.set_nonbizday(día fecha, repetir bool): establece el día como día no comercial; si 'repetir' es verdadero, entonces el día no es comercial todos los años.
plvdate.unset_nonbizday(día fecha, repetir bool) - Desconfigura el día como día no comercial, si 'repetir' es verdadero, entonces el día no es comercial cada año
plvdate.use_easter() - El domingo de Pascua y el lunes de Pascua serán festivos
plvdate.unuse_easter();
plvdate.use_easter(useit booleano);
plvdate.using_easter() bool - Si usamos pascua entonces devuelve verdadero
plvdate.use_great_friday() - El Gran Viernes de Pascua será festivo
plvdate.unuse_easter();
plvdate.use_easter(useit boolean);
plvdate.using_easter() bool - Si usamos el Gran Viernes de Pascua como feriado, devuelve verdadero
plvdate.include_start(): incluye la fecha de inicio en el cálculo de bizdays_between
plvdate.noinclude_start();
plvdate.include_start(incluye booleano);
plvdate.incluido_start() bool;
plvdate.default_holidays(varchar): carga las configuraciones predeterminadas. Puedes utilizar las siguientes configuraciones: checa, alemana, Austria, Polonia, Eslovaquia, Rusia, GB y EE. UU. en este momento.
La configuración contiene solo días festivos comunes para todas las regiones. Puede agregar su propio feriado regional con plvdate.set_nonbizday(nonbizday, true)
Ejemplo:
postgres=# seleccione plvdate.default_holidays('checo');
vacaciones_por defecto
-----------------
(1 fila)
postgres=# seleccione to_char(fecha_actual, 'día'),
plvdate.next_bizday(fecha_actual),
to_char(plvdate.next_bizday(current_date),'día');
a_char | next_bizday | to_char
-+-------------+-----------
sábado | 2006-03-13 | lunes
(1 fila)Cambio para entorno no europeo:
seleccione plvdate.unset_nonbizday('sábado');
seleccione plvdate.unset_nonbizday('domingo');
seleccione plvdate.set_nonbizday('viernes');
seleccione plvdate.set_nonbizday('2006-05-19', verdadero);
seleccione plvdate.unuse_easter(); Este paquete contiene algunas funciones útiles de cadenas y caracteres. Cada función admite desplazamientos positivos y negativos, es decir, desplazamiento desde el final de la cadena. Por ejemplo:
plvstr.left('abcdef',2) -> ab
plvstr.left('abcdef',-2) -> abcd
plvstr.substr('abcdef',1,1) -> a
plvstr.substr('abcdef',-1,1) -> f
plvstr.substr('abcde',-2,1) -> dLista de funciones:
plvstr.normalize(str text) - Normalizar cadena - Reemplazar caracteres blancos por espacio, reemplazar espacios por espacio
plvstr.is_prefix(str text, prefix text, cs bool): devuelve verdadero, si el prefijo es el prefijo de str
plvstr.is_prefix(texto de cadena, texto de prefijo): devuelve verdadero, si el prefijo es el prefijo de cadena
plvstr.is_prefix(str int, prefix int): devuelve verdadero, si el prefijo es el prefijo de str
plvstr.is_prefix(str bigint, prefix bigint) - Devuelve verdadero, si el prefijo es el prefijo de str
plvstr.substr(str text, start int, len int) - Devuelve la subcadena iniciada en start_in hasta el final
plvstr.substr(str text, start int) - Devuelve la subcadena iniciada en start_in hasta el final
plvstr.instr(str text, patt text, start int, nth int) - Patrón de búsqueda en cadena
plvstr.instr(str text, patt text, start int) - Patrón de búsqueda en cadena
plvstr.instr(str text, patt text) - Patrón de búsqueda en cadena
plvstr.lpart(str text, div text, start int, nth int, all_if_notfound bool): llame a esta función para devolver la parte izquierda de una cadena
plvstr.lpart(str text, div text, start int, nth int): llame a esta función para devolver la parte izquierda de una cadena
plvstr.lpart(str text, div text, start int): llame a esta función para devolver la parte izquierda de una cadena
plvstr.lpart(str text, div text): llame a esta función para devolver la parte izquierda de una cadena
plvstr.rpart(str text, div text, start int, nth int, all_if_notfound bool): llame a esta función para devolver la parte derecha de una cadena
plvstr.rpart(str text, div text, start int, nth int): llame a esta función para devolver la parte derecha de una cadena
plvstr.rpart(str text, div text, start int): llame a esta función para devolver la parte derecha de una cadena
plvstr.rpart(str text, div text): llame a esta función para devolver la parte derecha de una cadena
plvstr.lstrip(str text, substr text, num int): llame a esta función para eliminar caracteres del principio
plvstr.lstrip(str text, substr text): llame a esta función para eliminar caracteres desde el principio
plvstr.rstrip(str text, substr text, num int): llame a esta función para eliminar caracteres del final
plvstr.rstrip(str text, substr text): llame a esta función para eliminar caracteres del final
plvstr.rvrs(str text, start int, _end int) - Cadena inversa o parte de la cadena
plvstr.rvrs(str text, start int) - Cadena inversa o parte de la cadena
plvstr.rvrs(texto cadena): cadena inversa o parte de la cadena
plvstr.left(str text, n int): devuelve los primeros num_in caracteres. Puedes usar num_in negativo
plvstr.right(str text, n int): devuelve los últimos num_in caracteres. Puedes usar num_ni negativo
plvstr.swap (texto de cadena, texto de reemplazo, int de inicio, int de longitud): reemplaza una subcadena en una cadena con una cadena especificada
plvstr.swap(texto cadena, reemplazar texto): reemplaza una subcadena en una cadena con una cadena especificada
plvstr.betwn(str text, start int, _end int, inclusive bool) - Encuentra la subcadena entre las ubicaciones inicial y final
plvstr.betwn(str text, start text, _end text, startnth int, endnth int, inclusive bool, gotoend bool) - Encuentra la subcadena entre las ubicaciones inicial y final
plvstr.betwn(str text, start text, _end text): busque la subcadena entre las ubicaciones inicial y final
plvstr.betwn(str text, start text, _end text, startnth int, endnth int) - Encuentra la subcadena entre las ubicaciones inicial y final
plvchr.nth(str text, n int): llame a esta función para devolver el enésimo carácter en una cadena
plvchr.first(str text): llame a esta función para devolver el primer carácter de una cadena
plvchr.last(str text): llame a esta función para devolver el último carácter de una cadena
plvchr.is_blank(c int) - Está en blanco
plvchr.is_blank(texto c) - Está en blanco
plvchr.is_digit(c int) - Es dígito
plvchr.is_digit(c texto) - Es dígito
plvchr.is_quote(c int) - Es cotización
plvchr.is_quote(c texto) - Es cita
plvchr.is_other(c int) - Es otro
plvchr.is_other(c texto) - Es otro
plvchr.is_letter(c int) - Es letra
plvchr.is_letter(texto c) - Es letra
plvchr.char_name(c text): devuelve el nombre del carácter al código ascii como VARCHAR.
plvchr.quoted1(str text) - Texto citado entre '''
plvchr.quoted2(str text) - Texto citado entre '"'
plvchr.stripped(str text, char_in text): elimina una cadena de todas las instancias de los caracteres especificados
El paquete PLVsubst realiza sustituciones de cadenas basándose en una palabra clave de sustitución.
plvsubst.string(template_in text, vals_in text[]): escanea una cadena en busca de todas las instancias de la palabra clave de sustitución y la reemplaza con el siguiente valor en la lista de valores de sustitución.
plvsubst.string(texto_plantilla_en, texto_vals_en[], texto_subst_en)
plvsubst.string(template_in texto, vals_in texto, delim_in texto)
plvsubst.string(template_in texto, vals_in texto, delim_in texto, subst_in texto)
plvsubst.setsubst(str text): establece la palabra clave de sustitución en el valor predeterminado '%s'
plvsubst.subst() - Recuperar palabra clave de sustitución
Ejemplos:
select plvsubst.string('Mi nombre es %s %s.', ARRAY['Pavel','Stěhule']);
cadena
--------------------------
Mi nombre es Pavel Stěhule.
(1 fila)
select plvsubst.string('Mi nombre es %s %s.', 'Pavel,Stěhule');
cadena
--------------------------
Mi nombre es Pavel Stěhule.
(1 fila)
select plvsubst.string('Mi nombre es $$ $$.', 'Pavel|Stěhule','|','$$');
cadena
--------------------------
Mi nombre es Pavel Stěhule.
(1 fila)dms_utility.format_call_stack() — devuelve una cadena formateada con el contenido de la pila de llamadas
postgres=# seleccione foo2();
foo2
---------------------------------
----- Pila de llamadas -----
objeto de línea
nombre de la declaración numérica
1 función de retorno foo
1 función de retorno foo1
1 función de retorno foo2
(1 fila)Este paquete no es compatible con PLVlex original.
postgres=# seleccionar * de
plvlex.tokens('select * from abc join d ON x=y', verdadero, verdadero);
posición | ficha | código | clase | separador | modo
----+--------+------+---------+-----------+------
0 | seleccionar | 527 | PALABRA CLAVE | |
7 | * | 42 | OTROS | | ser
9 | de | 377 | PALABRA CLAVE | |
25 | abc | | IDENTIFICACIÓN | |
20 | unirse | 418 | PALABRA CLAVE | |
25 | re | | IDENTIFICACIÓN | |
27 | en | 473 | PALABRA CLAVE | |
30 | x | | IDENTIFICACIÓN | |
31 | = | 61 | OTROS | | ser
32 | y | | IDENTIFICACIÓN | |
(10 filas)Advertencia: ¡Los códigos de palabras clave se pueden cambiar entre versiones de PostgreSQL! o plvlex.tokens(str text, skip_spaces bool, Qualified_names bool): devuelve una tabla de elementos léxicos en str.
Este paquete protege la entrada del usuario contra la inyección de SQL.
dbms_assert.enquote_literal(varchar) varchar: agregue comillas iniciales y finales, verifique que todas las comillas simples estén emparejadas con comillas simples adyacentes.
dbms_assert.enquote_name(varchar [, boolean]) varchar: incluya el nombre entre comillas dobles. El segundo parámetro opcional garantiza la reducción del nombre. Atención: ¡en Oracle el segundo parámetro está en mayúscula!
dbms_assert.noop(varchar) varchar: devuelve el valor sin ninguna comprobación.
dbms_assert.qualified_sql_name(varchar) varchar: esta función verifica que la cadena de entrada sea un nombre SQL calificado.
dbms_assert.schema_name(varchar) varchar: la función verifica que la cadena de entrada sea un nombre de esquema existente.
dbms_assert.simple_sql_name(varchar) varchar: esta función verifica que la cadena de entrada sea un nombre SQL simple.
dbms_assert.object_name(varchar) varchar: verifica que la cadena de entrada sea un identificador SQL calificado de un objeto SQL existente.
Esta unidad contiene algunas funciones de afirmación.
plunit.assert_true(bool [, varchar]): afirma que la condición es verdadera.
plunit.assert_false(bool [, varchar]): afirma que la condición es falsa.
plunit.assert_null(anyelement [, varchar]): afirma que lo real es nulo.
plunit.assert_not_null(anyelement [, varchar]): afirma que lo real no es nulo.
plunit.assert_equals(anyelement, anyelement [, double precision] [, varchar]): afirma que lo esperado y lo real son iguales.
plunit.assert_not_equals(anyelement, anyelement [, double precision] [, varchar]): afirma que lo esperado y lo real son iguales.
plunit.fail([varchar]): Fail se puede utilizar para provocar que un procedimiento de prueba falle inmediatamente utilizando el mensaje proporcionado.
dbms_random.initialize(int): inicializa el paquete con un valor inicial.
dbms_random.normal(): devuelve números aleatorios en una distribución normal estándar.
dbms_random.random(): devuelve un número aleatorio de -2^31 .. 2^31.
dbms_random.seed(int)
dbms_random.seed(texto): restablece el valor inicial.
dbms_random.string(opt text(1), len int) - Crear cadena aleatoria
dbms_random.terminate() - Terminar paquete (no hacer nada en Pg)
dbms_random.value() - Devuelve un número aleatorio de [0.0 - 1.0)
dbms_random.value(precisión doble baja, precisión doble alta): devuelve un número aleatorio de [baja - alta)
Este módulo contiene la implementación de funciones: concat, nvl, nvl2, lnnvl, decodificar, mayor, menor, bitand, nanvl, sinh, cosh, tanh, oracle.substr y oracle.mod.
oracle.substr(str text, start int, len int) - Subcadena compatible con Oracle
oracle.substr(str text, start int) - Subcadena compatible con Oracle
oracle.substr(str numérico, inicio numérico) - Subcadena compatible con Oracle
oracle.substr(str numérico, inicio numérico, len numérico) - subcadena compatible con Oracle
oracle.substr(str varchar, start numeric) - Subcadena compatible con Oracle
oracle.substr(str varchar, start numeric,len numeric) - Subcadena compatible con Oracle
oracle.lpad(cadena, longitud [, relleno]) - lpad compatible con Oracle
oracle.rpad(cadena, longitud [, relleno]) - rpad compatible con Oracle
oracle.ltrim(texto de cadena [, texto de caracteres]) - ltrim compatible con Oracle
oracle.rtrim(texto de cadena [, texto de caracteres]) - rtrim compatible con Oracle
oracle.btrim(texto de cadena [, texto de caracteres]) - btrim compatible con Oracle
oracle.length(string char): longitud compatible con Oracle
oracle.listagg(str text [, separator text]) - valores agregados a la lista
oracle.wm_concat(str text): agrega valores a una lista separada por comas
oracle.median(float4) - calcula una mediana
oracle.median(float8) - calcula una mediana
oracle.to_number(texto): convierte una cadena en un número
oracle.to_number(numeric) - convierte una cadena en un número
oracle.to_number(numeric,numeric) - convierte una cadena en un número
public.to_multi_byte(text): convierte todos los caracteres de un solo byte en sus correspondientes caracteres multibyte
public.to_single_byte(text) - Convierte todos los caracteres multibyte a sus correspondientes caracteres de un solo byte
oracle.greatest(anyelement, anyelement[]) - Mayor compatibilidad con Oracle, devuelve NULL en una entrada NULL
oracle.least(anyelement, anyelement[]) - Compatibilidad mínima con Oracle, devuelve NULL en una entrada NULL
oracle.mod(int, int) - Mod de compatibilidad de Oracle. Si el segundo parámetro es cero, devuelve el primer parámetro
Oracle.Remainder (int, int) - Devuelve el resto del número dividido por otro número
Oracle.Remainder (numérico, numérico) - Devuelve el resto del número dividido por otro número
oracle.sys_guid () - Devuelve bytea - 16 bytes de ID de uniq global
Es posible que deba establecer Search_Path en 'Oracle, PG_CATALOG, "$ user", público' porque Oracle.substr, Oracle.lpad, Oracle.rpad, Oracle.ltrim, Oracle.rtrim, Oracle.btrim, Oracle.length están instalados de lado -By-Side con pg_catalog.substr, pg_catalog.lpad, pg_catalog.rpad, pg_catalog.ltrim, pg_catalog.rtrim, pg_catalog.btrim, pg_catalog.length respectivamente.
Funciones Oracle.Decode, Oracle.Greatest y Oracle. El tiempo siempre debe estar prefijado por el nombre del esquema, incluso si el Oracle está antes de PG_CATALOG en el Search_Path porque estas funciones se implementan dentro del analizador y analizador Postgresql. Sin el nombre del esquema, las funciones internas siempre se utilizarán.
Tenga en cuenta que en el caso de LPAD y RPAD, la cadena y el relleno de los parámetros pueden ser de tipos Char, Varchar, Text, VARCHAR2 o NVARCHAR2 (tenga en cuenta que los dos últimos son tipos proporcionados por ORAFCE). El personaje de relleno predeterminado es un espacio de medio ancho. De manera similar para Ltrim, Rtrim y Btrim.
Tenga en cuenta que Oracle.length tiene una limitación de que funciona solo en unidades de caracteres porque el tipo de char PostgreSQL solo admite la semántica de caracteres.
El Oracle.Substr con tres argumentos puede devolver un resultado diferente (cadena nula o vacía) en la dependencia a la configuración de ORAFCE.USING_SUBSTRING_ZERO_WIDTH_IN_SUBSTR Variable (Oracle, Warning_oracle, ORAFCE, Warning_orafce). Este resultado diferente se devuelve solo cuando el tercer argumento (substring_length) es cero. El valor predeterminado es advertir_oracle, eso significa aumentar la advertencia y regresar nulo.
Esto funciona devuelve la identificación única global. Llama a las funciones especificadas de la extensión "UUID-OSSP", y luego esta función debe instalarse antes de que se use la función SYS_GUID. Por defecto, esta función usa la función UUID_GENERATE_V1, pero la función UUID_GENERATE_V1MC, UUID_GENERATE_V4 también se puede usar (configurando ORAFCE.SYS_GUID_SOURCE). Oracle.sys_guid también puede usar Builin Gen_random_uuid Func. En este caso, no se requiere la extensión "UUID-ASSP".
VARCHAR2 de ORAFCE implementa partes de la especificación de la base de datos Oracle sobre VARCHAR2:
Unidad de tipo modificador = 'bytes' (para la semántica de caracteres, ver nvarchar2)
A diferencia de PostgreSQL Varchar, el lanzamiento implícito a VARCHAR2 no trunca los espacios blancos sobre la longitud máxima declarada
Para estos tipos es posible usar NULL Safe || Operador, cuando habilita orafce.varchar2_null_safe_concat a verdadero. El comportamiento es muy similar a Oracle.
Atención: - Cuando el resultado es una cadena vacía, entonces el resultado es nulo. Este comportamiento es deshabilitado por defecto.
Atención: - Existe una posible incompatibilidad entre 3.7 y más ORAFCE liberaciones. Una función de operador ahora está marcada como estable (era inmutable antes). No es posible crear índices funcionales sobre expresiones estables o volátiles.
- Concat nulo seguro (deshabilitado por defecto) Seleccione NULL || 'Hola' :: varchar2 || NULO; Establecer ORAFCE.VARCHAR2_NULL_SAFE_CONCAT en true; Seleccione NULL || 'Hola' :: varchar2 || NULO;
Tenga en cuenta que PostgreSQL no permite especificar dinámicamente cómo interpretamos las cadenas Varchar. Siempre las interpreta como cadenas de 'carácter' según lo determinado por la codificación de la base de datos. Por lo tanto, no podemos admitir la semántica de bytes y caracteres para un tipo VARCHAR dado en la misma base de datos. Elegimos implementar la semántica de bytes, ya que es predeterminado en Oracle. Para la semántica de personajes, consulte NVARCHAR2 que, por defecto, siempre implementa la semántica de los personajes.
Tenga cuidado al usar el tipo anterior para almacenar cadenas que consisten en caracteres codificados multibyte en el que cada personaje puede estar compuesto por un número arbitrario de bytes.
Nvarchar2 implementa lo siguiente:
Unidad de tipo modificador = 'caracteres' (usando el conjunto/codificación de caracteres de la base de datos)
Use este tipo si se prefiere la semántica de caracteres.
Tenga en cuenta que, a diferencia de Oracle, VARCHAR2 y NVARCHAR2 de ORAFCE no imponen el límite de 4000 bytes en el tamaño 'declarado'. De hecho, es lo mismo que el de PostgreSQL Varchar, que es aproximadamente 10 MB (aunque Varchar puede almacenar valores de tamaño en teoría de hasta 1 GB)
Algunas funciones de cadena basadas en bytes se utilizarán con cadenas Varchar2
subStrB (varchar2, int [, int]) - extra de una subcadena de longitud especificada (en bytes) que comienza en una posición de byte dada (contando desde uno); Si el tercer argumento no se especifica, entonces se considera la longitud al final de la cadena
STRposB (VARCHAR2, VARCHAR2): devuelve la ubicación de la subcadena especificada en una cadena dada (contando desde uno)
longitudb (varchar2): devuelve la longitud (en bytes) de una cadena dada
Oracle no hace diferencias entre una cadena nula y vacía (cuando se usa un valor como texto). Para Postgres Null y String String son valores diferentes. Para simplificar, es bueno asegurarse (en la base de datos de Postgres), use solo nulos (y no use cadenas vacías) o use solo cadenas vacías (y no use nulos) para columnas de tipo de texto. Ambas variantes tienen algunas ventajas y desventajas.
Esto se puede enojar con funciones de activación:
oracle.replace_empty_strings (['en' | 'verdadero' | 'Advertencia' | 'Error']) oracle.replace_null_strings (['en' | 'True' | 'Advertencia' | 'Error'])
El argumento de cadena opcional se usa como indicador, por lo que estas funciones deben aumentar la advertencia (posiblemente error) cuando la fila se cambió dentro de estas funciones.
Crear prueba de tabla (ID serial, nombre Varchar, Apellido Varchar);
Crear gatillo test_trg
Antes de insertar o actualizar
En prueba
Para cada fila
Ejecutar procedimiento oracle.replace_empty_strings ();
Insertar en valores de prueba (nombre, apellido) ('' ',' Stehule ');
- El nombre será reemplazado por NULLoracle.user_tab_columns
oracle.user_tables
oracle.user_cons_columns
oracle.user_constraints
oracle.product_componenent_version
oracle.user_objects
oracle.dba_segments
mejor documentación
Mejor seralización en dbms_pipe (a través de _send y _recv funciones)
alterar estructuras de memoria compartida mediante tablas temporales: solo los bloqueos están en shmem, (mapas de bits), datos en TMP TBL
Este módulo se libera bajo la licencia BSD.
El proyecto fue fundado en 2008 por Pavel Stehule <[email protected]>.
Otros contribuyentes:
Gabriele Bartolini (Gbartolini)
Jeffrey Cohen (Jcohen)
Giles Darold (Darold)
Pavan Deolasee (Pavanvd)
Peter Eisentraut (Petere)
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)
