orafce
4.13.5
Funções e operadores que emulam um subconjunto de funções e pacotes do Oracle RDBMS.
Existe um grupo do Google associado - https://groups.google.com/forum/?hl=en#!forum/orafce-general
O Orafce é compatível com AWS Aurora com compatibilidade PostgreSQL e também no banco de dados Azure para PostgreSQL.
Este módulo contém algumas funções úteis que podem ajudar na portabilidade de aplicativos Oracle para PostgreSQL ou que podem ser úteis em geral.
As funções de data integradas do Oracle foram testadas no Oracle 10 quanto à conformidade. Os intervalos de datas de 1960 a 2070 funcionam corretamente. Datas anteriores a 1582-10-05 com o formato 'J' e anteriores a 1100-03-01 com outros formatos não podem ser verificadas devido a um bug no Oracle.
Todas as funções são totalmente compatíveis com Oracle e respeitam todas as strings de formato conhecidas. Descrições detalhadas podem ser encontradas na internet. Use palavras-chave como: oracle round trunc date iyyy.
Y,YY,YYY,YYYY,SYYY,SYEAR ano I,IY,IYY,IYYY iso ano Q, quarto Semana WW, dia como primeiro dia do ano Semana IW, começando na segunda-feira Semana W, dia como primeiro dia do mês DAY,DY,D primeiro dia da semana, domingo MÊS, SEG, MM, RM mês Século CC, SCC DDD, DD, J dia HH,HH12,HH24 horas MI minuto
Funções completadas. Ou seja, a data de 1º de julho será arredondada para o ano seguinte. O dia 16 de julho será arredondado para agosto.
add_months(data, inteiro) data - Retorna a data mais n meses
add_meses(data '31/05/2005',1) -> 30/06/2005
last_date(date) date - Retorna o último dia do mês com base em um valor de data
último_dia(data '24/05/2005') -> 31/05/2005
next_day(date, text) date - Retorna o primeiro dia da semana maior que um valor de data
próximo_dia(data '24/05/2005', 'segunda-feira') -> 30/05/2005
next_day(data, inteiro) data - O mesmo que acima. O segundo argumento deve ser 1..7 e interpretado como domingo..sábado.
próximo_dia(data '2005-05-24', 1) -> 2005-05-30
meses_between(data, data) numérico - Retorna o número de meses entre data1 e data2. Se um mês fracionário for calculado, a função meses_entre calcula a fração com base em um mês de 31 dias.
meses_entre(data '02/02/1995', data '01/01/1995') -> 1.0322580645161
trunc(data, texto) data - trunca a data de acordo com o formato especificado
trunc(data '12/07/2005', 'iw') -> 11/07/2005
round(date, text) date - arredondará as datas de acordo com o formato especificado
rodada (data '12/07/2005', 'aaaa') -> 01/01/2006
to_date(text) timestamp - irá digitar o texto de entrada para timestamp. O GUC orafce.nls_date_format é usado para especificar o formato do texto de entrada para esta função. Se o valor for deixado em branco ou definido como DEFAULT, insira o formato de texto de acordo com a configuração GUC de estilo de data do PostgreSQL.
valor orafce.nls_date_format para DEFAULT
to_date('19/05/2014 17:23:53+5:30') -> 19/05/2014 17:23:53orafce.nls_date_format='AAAA-MMDD HH24:MI:SS'
to_date('2014-0519 17:23:53+5:30') -> 19/05/2014 17:23:53 to_date(text, text) timestamp - irá digitar o texto de entrada com o formato especificado para timestamp. O GUC orafce.orafce_emit_error_on_date_bug é usado para especificar se um erro é relatado quando o valor da data atinge o bug do Oracle nas datas. Este bug aparece com datas anteriores a 1582-10-05 quando o formato 'J' é usado ( 'J2299159' ) e antes de 1100-03-01 com outros formatos. Um erro é relatado por padrão, para desabilitar esse comportamento, set orafce.orafce_emit_error_on_date_bug to off .
SELECIONE oracle.to_date('112012', 'J');
ERRO: Datas anteriores a 1582-10-05 ('J2299159') não podem ser verificadas devido a um bug no Oracle.
SELECT oracle.to_date('1003-03-15', 'aaaa-mm-dd');
ERRO: Datas anteriores a 1100-03-01 não podem ser verificadas devido a um bug no Oracle.
SET orafce.oracle_compatibility_date_limit TO off;
SELECIONE oracle.to_date('112012', 'J');
a data
------------------------
4407-07-30 00:00:00 AC
(1 linha)
SELECT oracle.to_date('1003/03/15', 'aaaa/mm/dd');
a data
---------------------
15/03/1003 00:00:00
(1 linha)Este módulo contém implementação do tipo de dados DATE compatível com Oracle "oracle.date" e funções que usam o tipo de dados DATE como oracle.add_months,oracle.last_day(),oracle.next_day(),oracle.months_between() etc.
Exemplo:
definir search_path TO oracle,"$usuário", public, pg_catalog;
criar tabela oracle_date(col1 data);
inserir em valores oracle_date('2014-06-24 12:12:11'::date);
selecione * em oracle_date;
col1
---------------------
24/06/2014 12:12:11
(1 linha)oracle.add_months(timestamp com fuso horário, inteiro) - Retorna data e hora mais n meses
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) - Retorna o último dia do mês com base em um valor de data
oracle.last_day(oracle.date '2005-05-24 11:12:12') -> 2005-05-31 11:12:12
oracle.next_day(timestamp com fuso horário, texto) - Retorna o primeiro dia da semana maior que um valor de data
oracle.next_day(oracle.date '2005-05-24 10:12:12', 'segunda-feira') -> 2005-05-30 10:12:12
oracle.next_day(timestamp com fuso horário, inteiro) - O mesmo que acima. O segundo argumento deve ser 1..7 e interpretado 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(timestamp com fuso horário, timestamp com fuso horário) - Retorna o número de meses entre timestamp1 e timestamp2. Se um mês fracionário for calculado, a função meses_entre calcula a fração com base em um mês de 31 dias.
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) - Retorna timestamp sem fuso horário.
oracle.to_date('16/02/09 04:12:12', 'MM/DD/AA HH24:MI:SS') -> 16/02/2009 04:12:12oracle.to_date(texto) - Retorna oracle.date
oracle.to_date('16/02/09 04:12:12') -> 16/02/2009 04:12:12oracle.sysdate() - Retorna o carimbo de data/hora da instrução no fuso horário do servidor (orafce.timezone)
oracle.sysdate() -> 09/12/2015 17:47:56
oracle.dbtimezone - Retorna o fuso horário do servidor - emulado via orafce.timezone
oracle.dbtimezone() -> GMT
oracle.sessiontimezone() - Retorna o fuso horário da sessão - fuso horário atual do PostgreSQL
oracle.sessiontimezone() -> Europa/Praga
oracle.sys_extract_utc(timestamp with timezone) - Retorna timestamp no fuso horário utc
oracle.sys_extract_utc(current_timestamp)
oracle.sys_extract_utc(oracle.date) - Retorna carimbo de data/hora no fuso horário UTC, quando o fuso horário não é especificado, o fuso horário da sessão (PostgreSQL atual) é usado
oracle.sys_extract_utc(oracle.date '2005-05-24 11:21:12', 1) -> 2005-05-24 09:21:12
oracle.to_char(timestamp) - Retorna carimbo de data/hora em nls_date_format.
orafce.nls_date_format='AA-Segunda-feira 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-Segunda-feira HH24:MI:SS'
oracle.to_char(oracle.to_date('21052014 12:13:44+05:30','DDMMAAAA HH24:MI:SS')) -> 14-21 de maio 12:13:44 oracle.+(oracle.date,smallint) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::smallint -> 11/07/2014 10:08:55oracle.+(oracle.date,integer) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::inteiro -> 11/07/2014 10:08:55oracle.+(oracle.date,bigint) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::bigint -> 11/07/2014 10:08:55oracle.+(oracle.date,numeric) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') + 9::numérico -> 11/07/2014 10:08:55oracle.-(oracle.date,smallint) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::smallint -> 23/06/2014 10:08:55oracle.-(oracle.date,integer) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::inteiro -> 23/06/2014 10:08:55oracle.-(oracle.date,bigint) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::bigint -> 23/06/2014 10:08:55oracle.-(oracle.date,numeric) - Retorna oracle.date
oracle.to_date('02/07/2014 10:08:55','AAAA-MM-DD HH:MI:SS') - 9::numérico -> 23/06/2014 10:08:55oracle.-(oracle.date,oracle.date) - Retorna precisão dupla
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.048785Você precisa definir search_path TO oracle,"$user", public, pg_catalog porque funções como oracle.add_months,oracle.last_day,oracle.next_day,oracle.months_between são instaladas lado a lado com pg_catalog.add_months,pg_catalog.last_day, pg_catalog.next_day,pg_catalog.meses_entre.
O PostgreSQL não precisa da tabela 'dual' do Oracle, mas como é intensamente utilizado pelos usuários do Oracle, foi adicionado ao orafce. Esta tabela está no esquema oracle . Normalmente você deseja permitir acesso não qualificado - então você deve adicionar este esquema à configuração search_path (como search_path = 'oracle, pg_catalog, "$user", public' in postgresql.conf ).
PostgreSQL envia informações ao cliente via RAISE NOTICE. Oracle usa dbms_output.put_line(). Isso funciona de maneira diferente de RAISE NOTICE. O Oracle tem uma fila de sessão, put_line() adiciona uma linha à fila e a função get_line() lê da fila. Se o sinalizador 'serveroutput' estiver definido, o cliente em todas as instruções SQL lê a fila. Você pode usar:
selecione dbms_output.enable();
selecione dbms_output.put_line('first_line');
selecione dbms_output.put_line('next_line');
selecione * em dbms_output.get_lines(0);ou
selecione dbms_output.enable();
selecione dbms_output.serveroutput('t');
selecione dbms_output.put_line('first_line');Este pacote contém as seguintes funções: enable(), desabilitar(), serveroutput(), put(), put_line(), new_line(), get_line(), get_lines(). A fila de pacotes é implementada na memória local da sessão.
Este pacote permite que programas PL/pgSQL leiam e gravem em qualquer arquivo acessível no servidor. Cada sessão pode abrir no máximo dez arquivos e o tamanho máximo da linha é 32K. Este pacote contém as seguintes funções:
utl_file.fclose(arquivo utl_file.file_type) - fecha arquivo
utl_file.fclose_all() - fecha todos os arquivos
utl_file.fcopy(src_location, src_filename, dest_location, dest_filename[, start_line][, end_line]) - copia o arquivo de texto
utl_file.fflush(file utl_file.file_type) - libera todos os dados dos buffers
utl_file.fgetattr(local, nome do arquivo) - obtém atributos do arquivo
utl_file.fopen(texto de localização, texto do nome do arquivo, texto do modo_do_arquivo [, maxlinesize int] [, nome da codificação]) utl_file.file_type - abrir arquivo
utl_file.fremove(local, nome do arquivo) - remove o arquivo
utl_file.frename(local, nome do arquivo, dest_dir, dest_file[, overwrite]) - renomear arquivo
utl_file.get_line(file utl_file.file_type) texto - lê uma linha do arquivo
utl_file.get_nextline(file utl_file.file_type) texto - lê uma linha do arquivo ou retorna NULL
utl_file.is_open(file utl_file.file_type) bool - retorna verdadeiro, se o arquivo for aberto
utl_file.new_line(file utl_file.file_type [,rows int]) - coloca alguns novos caracteres de linha no arquivo
utl_file.put(file utl_file.file_type, buffer text) - coloca o buffer no arquivo
utl_file.put_line(file utl_file.file_type, buffer text) - coloca linha no arquivo
utl_file.putf(arquivo utl_file.file_type, buffer de formato [,arg1 text][,arg2 text][..][,arg5 text]) - coloca o texto formatado no arquivo
utl_file.tmpdir() - obtém o caminho do diretório temporário
Como o PostgreSQL não suporta chamada por referência, algumas funções são um pouco diferentes: fclose e get_line.
declare f utl_file.file_type;
começar
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
<<ler>>
laço
começar
aumentar o aviso '%', utl_file.get_line(f);
exceção
quando no_data_found então
sair da leitura;
fim;
ciclo final;
f := ffechar(f);
fim;ou segundo (com função específica do PostgreSQL get_nextline)
declarar
f utl_file.file_type;
texto de linha;
começar
f := utl_file.fopen('/tmp', 'sample.txt', 'r');
laço
linha:= utl_file.get_nextline(f);
sair quando a linha for NULL;
aumentar aviso '%', linha;
exceção
quando outros então
utl_file.fclose_all();
fim;Antes de usar o pacote você deve definir a tabela utl_file.utl_file_dir. Ele contém todos os diretórios permitidos sem símbolo de final ('/' ou ''). Na plataforma WinNT, os caminhos devem terminar sempre com o símbolo ''.
As entradas do diretório podem ser nomeadas (segunda coluna na tabela utl_file.utl_file_dir ). O parâmetro location pode ser o nome do diretório ou o caminho do dicionário. A localização é primeiro interpretada e verificada como um nome de diretório. Se não for encontrado (na 2ª coluna), o local será interpretado e verificado como um caminho.
As funções do pacote utl_file (esquema no Postgres) requerem acesso à tabela utl_file.utl_file_dir. Este fato pode ser usado para controlar quais usuários podem ou não utilizar essas funções. A configuração padrão é LER para PÚBLICO. INSERT, UPDATE só podem ser feitos por usuários privilegiados (superusuário). Portanto, usuários sem privilégios podem usar funções deste pacote, mas não podem alterar a lista de diretórios seguros (conteúdo da tabela utl_file.utl_file_dir). O conteúdo desta tabela é visível para PUBLIC (ou deve estar visível para usuários que utilizam funções deste pacote).
Esta é a implementação da API da Oracle do pacote DBMS_SQL
Não garante compatibilidade total, mas deve diminuir o trabalho necessário para uma migração bem-sucedida.
Atenção: A arquitetura do PostgreSQL é diferente da arquitetura do Oracle. PL/pgSQL é executado no mesmo contexto do mecanismo SQL. Então não há razão para usar os padrões da Oracle, como coleta em massa e iteração sobre coleção no Postgres, para obter um bom desempenho. Este código foi projetado para reduzir o trabalho relacionado à portabilidade de alguns aplicativos do Oracle para o Postgres e pode funcionar bem. Mas não haverá nenhuma vantagem de desempenho em relação à construção de instruções PL/pgSQL. A emulação da API da Oracle possui sobrecarga de memória e CPU, que pode ser significativa em dados maiores.
Esta extensão implementa um subconjunto da interface dbms_sql do Oracle. O objetivo desta extensão não é a compatibilidade com Oracle, ela foi projetada para reduzir alguns trabalhos relacionados à migração de aplicativos Oracle para Postgres. Algumas funcionalidades básicas de DML em massa são suportadas:
fazer $$
declarar
c int;
não[];
bvarchar[];
ca numérico[];
começar
c:=dbms_sql.open_cursor();
chame dbms_sql.parse(c, 'inserir em valores foo(:a, :b, :c)');
uma := MATRIZ[1, 2, 3, 4, 5];
b := ARRAY['Ahoj', 'Nazdar', 'Bazar'];
ca:=MATRIZ[3,14, 2,22, 3,8, 4];
ligue dbms_sql.bind_array(c, 'a', a, 2, 3);
ligue dbms_sql.bind_array(c, 'b', b, 3, 4);
ligue dbms_sql.bind_array(c, 'c', ca);
levantar aviso 'linhas inseridas% d', dbms_sql.execute(c);
fim;
$$;
fazer $$
declarar
c int;
não[];
bvarchar[];
ca numérico[];
começar
c:=dbms_sql.open_cursor();
chame dbms_sql.parse(c, 'select i, ''Ahoj'' || i, i + 0,003 de generate_series(1, 35) g(i)');
chame dbms_sql.define_array(c, 1, a, 10, 1);
chame dbms_sql.define_array(c, 2, b, 10, 1);
chame dbms_sql.define_array(c, 3, ca, 10, 1);
execute dbms_sql.execute(c);
enquanto dbms_sql.fetch_rows(c) > 0
laço
chame dbms_sql.column_value(c, 1, a);
chame dbms_sql.column_value(c, 2, b);
chame dbms_sql.column_value(c, 3, ca);
aumentar o aviso 'a = %', a;
aumentar o aviso 'b = %', b;
aumentar o aviso 'c =%', ca;
ciclo final;
chame dbms_sql.close_cursor(c);
fim;
$$; Existe a função dbms_sql.describe_columns_f , que é como o procedimento dbms_sql.describe_columns . Atenção, os IDs dos tipos estão relacionados ao sistema de tipos PostgreSQL. Os valores não são convertidos para números da Oracle
fazer $$
declarar
c int;
registro;
ddbms_sql.desc_rec;
começar
c:=dbms_sql.open_cursor();
chame dbms_sql.parse(c, 'selecione * de pg_class');
r := dbms_sql.describe_columns(c);
aumentar o aviso '%', r.col_cnt;
foreach d na matriz r.desc_t
laço
aumentar o aviso '% %', d.col_name, d.col_type::regtype;
laço final;
chame dbms_sql.close_cursor(c);
fim;
$$;
fazer $$
declarar
c int;
n int;
ddbms_sql.desc_rec;
da dbms_sql.desc_rec[];
começar
c:=dbms_sql.open_cursor();
chame dbms_sql.parse(c, 'selecione * de pg_class');
chame dbms_sql.describe_columns(c, n, da);
aumentar o aviso '%', n;
foreach d na matriz da
laço
aumentar o aviso '% %', d.col_name, d.col_type::regtype;
laço final;
chame dbms_sql.close_cursor(c);
fim;
$$;Este pacote é uma emulação do pacote Oracle dbms_pipe. Ele fornece comunicação entre sessões. Você pode enviar e ler qualquer mensagem com ou sem espera; listar pipes ativos; definir um tubo como privado ou público; e use pipes explícitos ou implícitos.
O número máximo de tubos é 50.
A memória compartilhada é usada para enviar mensagens.
Segue um exemplo:
- Sessão A
selecione dbms_pipe.create_pipe('my_pipe',10,true); -- criação explícita de pipe
selecione dbms_pipe.pack_message('neco je jinak');
selecione dbms_pipe.pack_message('qualquer outra coisa');
selecione dbms_pipe.send_message('my_pipe',20,0); - altere o limite e envie sem esperar
selecione * em dbms_pipe.db_pipes; -- lista de pipes atuais
- Sessão B
selecione dbms_pipe.receive_message('my_pipe',1); -- espere no máximo 1 segundo pela mensagem
selecione dbms_pipe.next_item_type(); --> 11, texto
selecione dbms_pipe.unpack_message_text();
selecione dbms_pipe.next_item_type(); --> 11, texto
selecione dbms_pipe.unpack_message_text();
selecione dbms_pipe.next_item_type(); --> 0, sem mais itens
selecione dbms_pipe.remove_pipe('meu_pipe');Existem algumas diferenças em comparação com o Oracle, no entanto:
o limite para pipes não está em bytes, mas em elementos no pipe
você pode enviar mensagem sem esperar
você pode enviar mensagens vazias
next_item_type conhece TIMESTAMP (tipo 13)
PostgreSQL não conhece o tipo RAW, use bytea
Outro meio de comunicação entre processos.
- Sessão A
selecione dbms_alert.register('boo');
selecione * em dbms_alert.waitany(10);
- Sessão B
selecione dbms_alert.register('boo');
selecione * em dbms_alert.waitany(10);
- Sessão C
selecione dbms_alert.signal('boo','Bom dia');Este módulo contém algumas funções para trabalhar com dias úteis do pacote PLVdate. Documentação detalhada pode ser encontrada na biblioteca PLVision. Este pacote é multicultural, mas as configurações padrão são apenas para países europeus (ver código fonte).
Você deve definir seus próprios dias não úteis (máximo 50 dias) e feriados (máximo 30 dias). Feriado é qualquer dia não útil, que é igual todos os anos. Por exemplo, dia de Natal nos países ocidentais.
plvdate.add_bizdays(day date, days int) date - Obtenha a data criada adicionando <n> dias úteis a uma data
plvdate.nearest_bizday(day date) date - Obtenha a data comercial mais próxima de uma determinada data, definida pelo usuário
plvdate.next_bizday(day date) date - Obtenha a próxima data comercial de uma determinada data, definida pelo usuário
plvdate.bizdays_between(day1 date, day2 date) int - Obtenha o número de dias úteis entre duas datas
plvdate.prev_bizday(day date) date - Obtenha a data comercial anterior de uma determinada data
plvdate_isbizday(date) bool – Chame esta função para determinar se uma data é um dia útil
plvdate.set_nonbizday(dow varchar) - Definir dia da semana como dia não comercial
plvdate.unset_nonbizday(dow varchar) - Dia da semana não definido como dia não comercial
plvdate.set_nonbizday(day date) - Definir dia como dia não comercial
plvdate.unset_nonbizday(day date) - Dia não definido como dia não comercial
plvdate.set_nonbizday (dia, data, repetição bool) - Defina o dia como dia não comercial, se 'repetir' for verdadeiro, então o dia não é comercial todos os anos
plvdate.unset_nonbizday(dia data, repetição bool) - Dia não definido como dia não comercial, se 'repetir' for verdadeiro, então o dia não é comercial todos os anos
plvdate.use_easter() - Domingo de Páscoa e segunda-feira de Páscoa serão feriados
plvdate.unuse_easter();
plvdate.use_easter(useit booleano);
plvdate.using_easter() bool - Se usarmos a Páscoa, então retorna verdadeiro
plvdate.use_great_friday() - Sexta-feira Santa de Páscoa será feriado
plvdate.unuse_easter();
plvdate.use_easter(useit booleano);
plvdate.using_easter() bool - Se usarmos a Páscoa na Sexta-feira Santa como feriado, então retorna verdadeiro
plvdate.include_start() - Inclui a data de início no cálculo bizdays_between
plvdate.noinclude_start();
plvdate.include_start(incluir booleano);
plvdate.incluindo_start() bool;
plvdate.default_holidays(varchar) - carrega configurações padrão. Você pode usar as seguintes configurações: Tcheco, Alemão, Áustria, Polônia, Eslováquia, Rússia, GB e EUA neste momento.
configuração contém apenas feriados comuns para todas as regiões. Você pode adicionar seu próprio feriado regional com plvdate.set_nonbizday(nonbizday, true)
Exemplo:
postgres=# selecione plvdate.default_holidays('czech');
feriados_padrão
-----------------
(1 linha)
postgres=# selecione to_char(data_atual, 'dia'),
plvdate.next_bizday(data_atual),
to_char(plvdate.next_bizday(data_atual),'dia');
to_char | próximo_dia_biz | para_char
----------+-------------+-----------
sábado | 13/03/2006 | segunda-feira
(1 linha)Mudança para um ambiente não europeu:
selecione plvdate.unset_nonbizday('sábado');
selecione plvdate.unset_nonbizday('domingo');
selecione plvdate.set_nonbizday('sexta-feira');
selecione plvdate.set_nonbizday('2006-05-19', verdadeiro);
selecione plvdate.unuse_easter(); Este pacote contém algumas funções úteis de strings e caracteres. Cada função suporta deslocamentos positivos e negativos — ou seja, deslocamento do final da string. Por exemplo:
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 funções:
plvstr.normalize(str text) - Normalizar string - Substituir caracteres brancos por espaço, substituir espaços por espaço
plvstr.is_prefix(str text, prefix text, cs bool) - Retorna verdadeiro, se o prefixo for o prefixo de str
plvstr.is_prefix(str text, prefix text) - Retorna verdadeiro, se o prefixo for o prefixo de str
plvstr.is_prefix(str int, prefix int) - Retorna verdadeiro, se o prefixo for o prefixo de str
plvstr.is_prefix(str bigint, prefix bigint) - Retorna verdadeiro, se o prefixo for o prefixo de str
plvstr.substr(str text, start int, len int) - Retorna a substring iniciada em start_in até o final
plvstr.substr(str text, start int) - Retorna a substring iniciada em start_in até o final
plvstr.instr(str text, patt text, start int, nth int) - Padrão de pesquisa em string
plvstr.instr(str text, patt text, start int) - Padrão de pesquisa em string
plvstr.instr(str text, patt text) - Padrão de pesquisa em string
plvstr.lpart(str text, div text, start int, nth int, all_if_notfound bool) - Chame esta função para retornar a parte esquerda de uma string
plvstr.lpart(str text, div text, start int, nth int) - Chame esta função para retornar a parte esquerda de uma string
plvstr.lpart(str text, div text, start int) - Chame esta função para retornar a parte esquerda de uma string
plvstr.lpart(str text, div text) - Chame esta função para retornar a parte esquerda de uma string
plvstr.rpart(str text, div text, start int, nth int, all_if_notfound bool) - Chame esta função para retornar a parte direita de uma string
plvstr.rpart(str text, div text, start int, nth int) - Chame esta função para retornar a parte direita de uma string
plvstr.rpart(str text, div text, start int) - Chame esta função para retornar a parte direita de uma string
plvstr.rpart(str text, div text) - Chame esta função para retornar a parte direita de uma string
plvstr.lstrip(str text, substr text, num int) - Chame esta função para remover caracteres do início
plvstr.lstrip(str text, substr text) - Chame esta função para remover caracteres do início
plvstr.rstrip(str text, substr text, num int) - Chame esta função para remover caracteres do final
plvstr.rstrip(str text, substr text) - Chame esta função para remover caracteres do final
plvstr.rvrs(str text, start int, _end int) - String reversa ou parte da string
plvstr.rvrs(str text, start int) - String reversa ou parte da string
plvstr.rvrs(str text) - String reversa ou parte da string
plvstr.left(str text, n int) - Retorna os primeiros num_in caracteres. Você pode usar num_in negativo
plvstr.right(str text, n int) - Retorna os últimos num_in caracteres. Você pode usar num_ni negativo
plvstr.swap(str text, replace text, start int, length int) - Substitua uma substring em uma string por uma string especificada
plvstr.swap(str text, replace text) - Substitua uma substring em uma string por uma string especificada
plvstr.betwn(str text, start int, _end int, inclusive bool) - Encontre a substring entre os locais inicial e final
plvstr.betwn(str text, start text, _end text, startnth int, endnth int, inclusive bool, gotoend bool) - Encontre a substring entre os locais inicial e final
plvstr.betwn(str text, start text, _end text) - Encontre a substring entre os locais inicial e final
plvstr.betwn(str text, start text, _end text, startnth int, endnth int) - Encontre a substring entre os locais inicial e final
plvchr.nth(str text, n int) - Chame esta função para retornar o enésimo caractere em uma string
plvchr.first(str text) - Chame esta função para retornar o primeiro caractere em uma string
plvchr.last(str text) - Chame esta função para retornar o último caractere de uma string
plvchr.is_blank(c int) - Está em branco
plvchr.is_blank(c text) - Está em branco
plvchr.is_digit(c int) - É um dígito
plvchr.is_digit(c text) - É um dígito
plvchr.is_quote(c int) - É citação
plvchr.is_quote(c text) - É citação
plvchr.is_other(c int) - É outro
plvchr.is_other(c text) - É outro
plvchr.is_letter(c int) - É carta
plvchr.is_letter(c text) - É carta
plvchr.char_name(c text) - Retorna o nome do caractere para o código ascii como um VARCHAR.
plvchr.quoted1(str text) - Texto citado entre '''
plvchr.quoted2(str text) - Texto citado entre '"'
plvchr.stripped(str text, char_in text) - Remove uma string de todas as instâncias dos caracteres especificados
O pacote PLVsubst executa substituições de string com base em uma palavra-chave de substituição.
plvsubst.string(template_in text, vals_in text[]) - Verifica uma string em busca de todas as instâncias da palavra-chave de substituição e a substitui pelo próximo valor na lista de valores de substituição
plvsubst.string(template_in texto, vals_in texto[], subst_in texto)
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) - Define a palavra-chave de substituição para o padrão '%s'
plvsubst.subst() - Recupera palavra-chave de substituição
Exemplos:
select plvsubst.string('Meu nome é %s %s.', ARRAY['Pavel','Stěhule']);
corda
--------------------------
Meu nome é Pavel Stěhule.
(1 linha)
select plvsubst.string('Meu nome é %s %s.', 'Pavel,Stěhule');
corda
--------------------------
Meu nome é Pavel Stěhule.
(1 linha)
select plvsubst.string('Meu nome é $$ $$.', 'Pavel|Stěhule','|','$$');
corda
--------------------------
Meu nome é Pavel Stěhule.
(1 linha)dms_utility.format_call_stack() — retorna uma string formatada com o conteúdo da pilha de chamadas
postgres=# selecione foo2();
foo2
---------------------------------
----- Pilha de chamadas -----
objeto de linha
nome da instrução numérica
1 função de retorno foo
1 função de retorno foo1
1 função de retorno foo2
(1 linha)Este pacote não é compatível com o PLVlex original.
postgres=# selecione * de
plvlex.tokens('select * from abc join d ON x=y', true, true);
posição | ficha | código | aula | separador | moda
----+--------+------+---------+-----------+------
0 | selecione | 527 | PALAVRA-CHAVE | |
7 | * | 42 | OUTROS | | auto
9 | de | 377 | PALAVRA-CHAVE | |
25 | abc | | IDENT | |
20 | junte-se | 418 | PALAVRA-CHAVE | |
25 | e | | IDENT | |
27 | em | 473 | PALAVRA-CHAVE | |
30 | x | | IDENT | |
31 | = | 61 | OUTROS | | auto
32 | você | | IDENT | |
(10 linhas)Atenção: Os códigos das palavras-chave podem ser alterados entre versões do PostgreSQL! o plvlex.tokens(str text, skip_spaces bool, qualificado_names bool) - Retorna tabela de elementos lexicais em str.
Este pacote protege a entrada do usuário contra injeção de SQL.
dbms_assert.enquote_literal(varchar) varchar - Adicione aspas iniciais e finais, verifique se todas as aspas simples estão emparelhadas com aspas simples adjacentes.
dbms_assert.enquote_name(varchar [, boolean]) varchar - Coloque o nome entre aspas duplas. O segundo parâmetro opcional garante a redução do nome. Atenção - No Oracle o segundo parâmetro é capitalizar!
dbms_assert.noop(varchar) varchar - Retorna valor sem qualquer verificação.
dbms_assert.qualified_sql_name(varchar) varchar - Esta função verifica se a string de entrada é um nome SQL qualificado.
dbms_assert.schema_name(varchar) varchar – A função verifica se a string de entrada é um nome de esquema existente.
dbms_assert.simple_sql_name(varchar) varchar -Esta função verifica se a string de entrada é um nome SQL simples.
dbms_assert.object_name(varchar) varchar - Verifica se a string de entrada é um identificador SQL qualificado de um objeto SQL existente.
Esta unidade contém algumas funções assert.
plunit.assert_true(bool [, varchar]) - Afirma que a condição é verdadeira.
plunit.assert_false(bool [, varchar]) - Afirma que a condição é falsa.
plunit.assert_null(anyelement [, varchar]) - Afirma que o real é nulo.
plunit.assert_not_null(anyelement [, varchar]) - Afirma que o real não é nulo.
plunit.assert_equals(anyelement, anyelement [, double Precision] [, varchar]) - Afirma que esperado e real são iguais.
plunit.assert_not_equals(anyelement, anyelement [, double Precision] [, varchar]) - Afirma que esperado e real são iguais.
plunit.fail([varchar]) - Fail pode ser usado para fazer com que um procedimento de teste falhe imediatamente usando a mensagem fornecida.
dbms_random.initialize(int) - Inicializa o pacote com um valor inicial.
dbms_random.normal() - Retorna números aleatórios em uma distribuição normal padrão.
dbms_random.random() - Retorna um número aleatório de -2^31 .. 2^31.
dbms_random.seed(int)
dbms_random.seed(text) - Redefinir o valor inicial.
dbms_random.string(opt text(1), len int) - Cria uma string aleatória
dbms_random.terminate() - Encerrar pacote (não fazer nada na página)
dbms_random.value() - Retorna um número aleatório de [0,0 - 1,0)
dbms_random.value(baixa precisão dupla, alta precisão dupla) - Retorna um número aleatório de [baixa - alta)
Este módulo contém implementação de funções: concat, nvl, nvl2, lnnvl, decode, maior, mínimo, bitand, nanvl, sinh, cosh, tanh, oracle.substr e oracle.mod.
oracle.substr(str text, start int, len int) - substring compatível com Oracle
oracle.substr(str text, start int) - substring compatível com Oracle
oracle.substr(str numérico, início numérico) - substring compatível com Oracle
oracle.substr(str numérico, início numérico, len numérico) - substring compatível com Oracle
oracle.substr(str varchar, start numeric) - substring compatível com Oracle
oracle.substr(str varchar, start numeric,len numeric) - substring compatível com Oracle
oracle.lpad(string, comprimento [, preenchimento]) - lpad compatível com Oracle
oracle.rpad(string, comprimento [, preenchimento]) - rpad compatível com Oracle
oracle.ltrim(string text [, caracteres text]) - ltrim compatível com Oracle
oracle.rtrim(string text [, caracteres text]) - rtrim compatível com Oracle
oracle.btrim(string text [, caracteres text]) - btrim compatível com Oracle
oracle.length(string char) - Comprimento compatível com Oracle
oracle.listagg(str text [, separator text]) - agrega valores para listar
oracle.wm_concat(str text) - agrega valores à lista separada por vírgulas
oracle.median(float4) - calcula uma mediana
oracle.median(float8) - calcula uma mediana
oracle.to_number(text) - converte uma string em um número
oracle.to_number(numeric) - converte uma string em um número
oracle.to_number(numeric,numeric) - converte uma string em um número
public.to_multi_byte(text) - Converte todos os caracteres de byte único em seus caracteres multibyte correspondentes
public.to_single_byte(text) - Converte todos os caracteres multibyte em seus caracteres de byte único correspondentes
oracle.greatest(anyelement, anyelement[]) - Maior compatibilidade com Oracle, retorna NULL na entrada NULL
oracle.least(anyelement, anyelement[]) - Menos compatibilidade com Oracle, retorna NULL na entrada NULL
oracle.mod(int, int) - Mod de compatibilidade Oracle, se o segundo parâmetro for zero, ele retorna o primeiro parâmetro
oracle.remainder(int, int) - retorna o resto do número dividido por outro número
Oracle.remaainder (numérico, numérico) - Retorna o restante do número dividido por outro número
oracle.sys_guid () - retorna bytea - 16 bytes do Global Uniq ID
Você pode precisar definir o Search_Path como 'Oracle, PG_CATALOG, "$ User", Public' porque Oracle.substr, oracle.lpad, oracle.rpad, oracle.ltrim, oracle.rtrim, oracle.btrim, oracle.length são instalados -by-side with pg_catalog.substr, pg_catalog.lpad, pg_catalog.rpad, pg_catalog.ltrim, pg_catalog.rtrim, pg_catalog.btrim, pg_catalog.length, respectivamente.
Funções Oracle.Decode, Oracle.Greatest e Oracle.least devem sempre ser prefixadas pelo nome do esquema, mesmo que o Oracle seja antes do PG_CATALOG no Search_Path porque essas funções são implementadas dentro do PostgreSql Parser e analisador. Sem o nome do esquema, as funções internas sempre serão usadas.
Observe que, no caso de LPAD e RPAD, os parâmetros e o preenchimento podem ser de tipos de char, varchar, texto, varchar2 ou nvarchar2 (observe que os dois últimos são tipos fornecidos pelo ORAFCE). O caractere de preenchimento padrão é um espaço de meia largura. Da mesma forma, para LTRIM, RTRIM e BTRIM.
Observe que o Oracle.Length tem uma limitação de que funciona apenas em unidades de caracteres, porque o tipo PostGresql Char suporta apenas a semântica do personagem.
O Oracle.substr com três argumentos pode retornar resultados diferentes (string null ou vazia) em dependência para definir ORAFCE.USING_SUBSTRING_ZERO_WIDTH_IN_SUBSTRIABLE (Oracle, Warning_oracle, Orafce, Warning_ORAFCE). Esse resultado diferente é retornado apenas quando o terceiro argumento (substring_length) é zero. O padrão é Warning_oracle, isso significa levantar aviso e retornar nulo.
Esta função retorna ID exclusiva global. Ele chama funções especificadas da extensão "UUID-OSSP" e, em seguida, essa função deve ser instalada antes que o SYS_GUID da função seja usado. Por padrão, essa função usa a função uuid_gererate_v1, mas function uuid_geneate_v1mc, uuid_geneate_v4 também pode ser usado (definindo o orafce.sys_guid_source). Oracle.sys_guid também pode usar o Builin gen_random_uuid func. Nesse caso, a extensão "UUID-OSSP" não é necessária.
O VARCHAR2 da ORAFCE implementa partes da especificação do banco de dados Oracle sobre VARCHAR2:
Unidade do tipo modificador = 'bytes' (para a semântica do personagem, consulte Nvarchar2)
Ao contrário do PostGresql Varchar, o elenco implícito para Varchar2 não trunca os espaços brancos sobre o comprimento máximo declarado
Para esses tipos, é possível usar o nulo seguro || Operador, quando você habilita ORAFCE.VARCHAR2_NULL_SAFE_CONCAT para TRUE. O comportamento é muito semelhante ao Oracle.
ATENÇÃO: - Quando o resultado é a string vazia, o resultado é nulo. Este comportamento é desativado por padrão.
ATENÇÃO: - Existe uma possível incompatibilidade entre 3,7 e ORAFCE mais antigo lançamentos. Uma função do operador agora está marcada como estável (era imutável antes). Não é possível criar índices funcionais sobre expressões estáveis ou voláteis.
- NULL SAFE CONCAT (desativado por padrão) Selecione NULL || 'Olá' :: varchar2 || NULO; Definir orafce.varchar2_null_safe_concat como true; Selecione NULL || 'Olá' :: varchar2 || NULO;
Observe que o PostgreSQL não permite especificar dinamicamente como interpretamos strings VARCHAR. Sempre os interpreta como seqüências de caracteres ', conforme determinado pela codificação do banco de dados. Portanto, não podemos suportar a semântica de byte e caracteres para um determinado tipo VARCHAR no mesmo banco de dados. Optamos por implementar a semântica de byte, pois isso é padrão no Oracle. Para a semântica do personagem, consulte o Nvarchar2 que, por padrão, sempre implementa a semântica do personagem.
Por favor, tenha cuidado ao usar o tipo acima para armazenar strings que consistem em caracteres codificados multibyte, nos quais cada caractere pode ser composto por um número arbitrário de bytes.
Nvarchar2 implementa o seguinte:
Unidade do tipo modifier = 'caracteres' (usando o conjunto de caracteres/codificação do banco de dados)
Use esse tipo se a semântica do caractere for preferida.
Observe que, diferentemente do Oracle, o VARCHAR2 e o Nvarchar2 da ORAFCE não impõem o limite de 4000 bytes no tamanho "declarado". De fato, é o mesmo que o PostgreSQL Varchar, que é de cerca de 10 MB (embora Varchar possa teoricamente armazenar valores de tamanho de até 1 GB)
Algumas funções de string baseadas em bytes a serem usadas com strings VARCHAR2
substrb (varchar2, int [, int]) - extraia uma substring de comprimento especificado (em bytes) começando em uma determinada posição de byte (contando de um); Se o terceiro argumento não for especificado, o comprimento até o final da string é considerado
STRPOSB (VARCHAR2, VARCHAR2) - Retorna a localização da substring especificada em uma determinada string (contando de uma)
LengthB (Varchar2) - Retorna o comprimento (em bytes) de uma determinada string
O Oracle não faz diferenças entre a string nula e vazia (quando um valor é usado como texto). Para string nula e nula pós -gres, são valores diferentes. Para simplificar, é bom garantir (no banco de dados do Postgres) usar apenas nulos (e não use strings vazios) ou use apenas strings vazios (e não use nulos) para colunas do tipo texto. Ambas as variantes têm algumas vantagens e desvantagens.
Isso pode ser enunciado com funções de gatilho:
oracle.replace_empty_strings (['on' | 'true' | 'aviso' | 'erro'])) oracle.replace_null_strings (['on' | 'true' | 'aviso' | 'erro'])
O argumento opcional da string é usado como indicador, portanto essas funções devem aumentar o aviso (possivelmente erro) quando a linha foi alterada dentro dessas funções.
Criar teste de tabela (serial da identificação, nome Varchar, sobrenome Varchar);
Crie Trigger Test_trg
Antes de inserir ou atualizar
No teste
Para cada linha
Executar procedimento oracle.replace_empty_strings ();
Inserir no teste (nome, sobrenome) valores ('', 'stehule');
- O nome será substituído 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
melhor documentação
Melhor sortimento em dbms_pipe (via _send e _recv funções)
alterar estruturas de memória compartilhada por tabelas temporárias: apenas os bloqueios estão em shmem, (bitmaps), dados no tmp tbl
Este módulo é liberado sob licença BSD.
O projeto foi fundado em 2008 por Pavel Stehule <[email protected]>.
Outros colaboradores:
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 Nennciarini (Mnencia)
Vinayak Pokale
Gavin Sherry (SWM)
Pavel Stehule (Okbob)
Rahila Syed (Rahila)
