arthur's questions

Tenho acesso a um banco de dados em modo read uncommitted e preciso fazer manutenção em uma tabela em ambiente operativo. Preciso adquirir um cadeado exclusivo em uma mesa, fazer um trabalho e depois liberar o cadeado.

Durante essa manutenção, mesmo as consultas de leitura não devem obter dados não confirmados de volta.

Esta pergunta e resposta parece promissora. Eu faço:

begin transaction;
SELECT TOP (1) 1 FROM a WITH (TABLOCK);

mas então, um SIXbloqueio é adquirido na tabela a. No entanto, isso não bloqueia a tabela de consultas selecionadas. Como posso adquirir Sch-Mo bloqueio na mesa? No máximo consigo o Sch-Scadeado com:

SELECT TOP (1) * FROM a WITH (TABLOCK);

isso ainda não bloqueia consultas selecionadas na tabela.

Usando a seguinte consulta, posso obter o tamanho dos índices de uma tabela:

SELECT
    i.name              AS IndexName,
    SUM(page_count * 8) AS IndexSizeKB
FROM sys.dm_db_index_physical_stats(db_id(), object_id('schema.table'), NULL, NULL, 'DETAILED') AS s
JOIN sys.indexes AS i
ON s.[object_id] = i.[object_id] AND s.index_id = i.index_id
GROUP BY i.name
ORDER BY i.name

Se eu executar sp_spaceused 'schema.table'o tamanho sem índices corresponde à datacoluna?

Alguma maneira de obter o tamanho da tabela sem índices no sql server? ( SELECTa declaração seria boa, pois gostaria de conectar essa consulta a uma consulta maior).

Se eu executar Get size of all tables in database , os tamanhos das tabelas são quase os mesmos dos tamanhos dos índices (sugerindo que algo está errado).

Esta é uma consulta SQL perfeitamente válida e funciona bem (por exemplo) em Microsoft SQL Server 2014:

with t as (select 'a' as attr) select * from t

ele retorna a, certamente pode-se simplificá-lo e descartar a withparte, mas esse não é o ponto, o ponto é descobrir um menor exemplo que ilustre a necessidade/problema. Eu posso empacotar parte dele como um UDF:

CREATE PROCEDURE x(@__employee_id uniqueidentifier)
AS
RETURN (select 'a' as attr);

Como posso empacotar uma consulta que tem withbloco? Meu objetivo é conseguir algo como:

CREATE PROCEDURE x (@__employee_id uniqueidentifier)
AS
RETURN (
    with t as (select 'a' as attr) select * from t
);

porém sql servernão gosta, disparando um erro:

Msg 156, Level 15, State 1, Procedure x, Line 4 [Batch Start Line 0]
Incorrect syntax near the keyword 'with'.

Eu instalei o postgres (versões diferentes na verdade), bem como o pgadmin3 no Windows usando o gerenciador de pacotes:

https://www.openscg.com/bigsql/package-manager/ https://www.openscg.com/bigsql/docs/pgcli/pgcli/

Eu também adicionei os diretórios bin no ambiente de caminho no Windows. Existe alguma maneira de instalar atalhos do programa para o menu Iniciar no Windows?

Contexto: replicação master-slave no Postgres 9.4, slave morreu algumas semanas atrás:

• o escravo copiou um arquivo WAL do mestre,
• disse ao mestre que o arquivo foi copiado,
• o mestre excluiu o arquivo wal,
• o escravo tentou reproduzir o arquivo wal corrompido,
• descobriu que o arquivo está corrompido,
• e desiste de começar.

Enquanto isso, o mestre acumulou mais logs do que o próprio banco de dados.

Como posso dizer ao mestre que a replicação acabou (para reconfigurar a replicação)? Algum comentário geral sobre como proceder com esta situação?

No postgres (9.5) selectsolicita bloqueio exclusivo. Por quê?

play=# \x on
Expanded display is on.
play=#   SELECT * FROM pg_locks pl
  LEFT JOIN pg_stat_activity psa
    ON pl.pid = psa.pid
    where
    pl.mode = 'ExclusiveLock'
;


-[ RECORD 1 ]------+---------------------------------
locktype           | virtualxid
database           |
relation           |
page               |
tuple              |
virtualxid         | 7/16
transactionid      |
classid            |
objid              |
objsubid           |
virtualtransaction | 7/16
pid                | 17376
mode               | ExclusiveLock
granted            | t
fastpath           | t
datid              | 1700431
datname            | play
pid                | 17376
usesysid           | 10
usename            | postgres
application_name   | psql
client_addr        | 127.0.0.1
client_hostname    |
client_port        | 54308
backend_start      | 2018-05-07 15:12:30.682069+02
xact_start         | 2018-05-07 15:12:59.513311+02
query_start        | 2018-05-07 15:12:59.513311+02
state_change       | 2018-05-07 15:12:59.513313+02
wait_event_type    |
wait_event         |
state              | active
backend_xid        |
backend_xmin       | 7152428
query              | SELECT * FROM pg_locks pl       +
                   |   LEFT JOIN pg_stat_activity psa+
                   |     ON pl.pid = psa.pid         +
                   |     where                       +
                   |     pl.mode = 'ExclusiveLock'   +
                   | ;

Estou tentando instalar o SQL Server 2016 no Windows 10 Pro. Na guia Configuração do Servidor, preciso fornecer os nomes das contas, os serviços serão executados como. Independente se eu fornecer contas virtuais ou locais, um erro é gerado e não consigo prosseguir:

Comentários?

Eu tenho um UDF bastante complicado (move-se em torno de um monte de tabelas, bem como cria um monte de novas) onde podem ocorrer várias interrupções. Antes de cada operação, gostaria de registrar a hora em que uma operação ocorre e a própria consulta. A UDF se parece com o seguinte então:

log function_start

log sql1
execute sql1

log sql2
execute sql2

...

log sqlN
execute sqlN

log function_end

Cada declaração de log significa inserir um novo registro na seguinte tabela:

CREATE TABLE backup_logs
(
  id serial NOT NULL,
  t timestamp with time zone default now(),
  sql text,
  CONSTRAINT backup_logs_pkey PRIMARY KEY (id)
)

Em caso de aborto, gostaria sql1, sql2, ... sqlNde ser revertido, mas inserto into backup_logspara persistir. Pergunta: como posso conseguir isso?

Estou usando um banco de dados Postgres para implementar um agendamento de trabalhos para um grande número de computadores/processos. Para encurtar a história, cada trabalho tem seu id, todo o agendamento é implementado com três guias: todos os trabalhos, trabalhos em execução no momento e trabalhos já concluídos.

A principal funcionalidade do agendamento é (1) solicitar um trabalho e (2) informar o banco de dados sobre um trabalho concluído. A solicitação de um trabalho leva qualquer id da lista de trabalhos, que não esteja na tabela em execução e nem na tabela concluída:

insert into piper.jobs_running
select x.fid from ( 
  SELECT fid FROM piper.jobs
  except 
  select fid from piper.jobs_running
  except 
  select fid from piper.jobs_completed
 ) as x limit 1
returning(fid)

A conclusão do trabalho o remove da lista em execução e o insere na lista concluída. Como não é específico da simultaneidade, omito os comandos SQL (leva de dezenas de minutos a algumas horas para concluir um trabalho).

Foi uma surpresa desagradável para mim que dois processos executando exatamente a mesma consulta acima (praticamente solicitando o trabalho ao mesmo tempo) possam obter o mesmo id de trabalho (fid). A única explicação possível que estou apresentando é que o Postgres não é compatível com o ACID. Comentários?

Informações adicionais: Eu configurei as transações para serem serializáveis ​​(em postgresql.conf set default_transaction_isolation = 'serializable' ). Agora o SGBD falha nas transações caso o isolamento não seja cumprido. é possível forçar o Postgres a reiniciá-los automaticamente?

Estou tentando importar dados para o postgres. Os campos de dados são separados por vírgula, as strings podem conter vírgulas, caso em que são escapadas:

Estrutura de dados:

create table v (a varchar);

Arquivo de dados:

bus
'Gat\,\\e\'way_MQB'

Comando de importação (executado no Linux a partir do bash)

cat data.csv | psql -d database -c "copy v (a) from stdin with delimiter ',' escape '\\' CSV header"

Erro:

ERROR:  extra data after last expected column

Eu tenho lutado e google contra esse problema por algumas horas e não entendo o que estou fazendo de errado?

Estou com uma situação completamente curiosa com um dbms postgres. Eu instalei o banco de dados e devido a uma configuração incorreta dos meus scripts de instalação, tornei a função de superusuário um usuário comum. Agora eu tenho uma instalação completamente nova do postgres com apenas o banco de dados de modelo e um único usuário 'postgres' que não pode fazer praticamente nada. Como posso tornar o usuário postgres superusuário novamente?

Tentei reinstalar o servidor no ubuntu 12.04 aptitude reinstall postgresql-9.1, mas a função parece não ser afetada. Muito provavelmente porque a reinstalação não afeta os arquivos onde as funções são gravadas.

Eu tenho várias tabelas, todas contendo atributos aid,bid,cide xiddo tipo integer, outros atributos podem diferir. Para cada tabela (dada) T, gostaria de ordenar as linhas de acordo com a aid,bid,cidcoluna ascendente e atualizada xidcom valores incrementados começando com 0. Qual é a melhor maneira de conseguir isso?

Minha solução atual envolve:

• selecionando mesaT
• abrindo um cursor sobre as tuplas ordenadas de uma tabela
• atribuir o valor de autoincremento axid
• inserindo a tupla em uma tabela temporalT_temp
• excluindo todos os registros deT
• inserindo todos os registros de T_tempdentroT

Como as tabelas têm esquemas diferentes, programei metade do código PL/pgSQLe metade do código com script bash.

Questão 1: Algum comentário sobre como programá-lo em PL/pgSQL puro?

Pergunta 2: Algum comentário sobre como implementar isso de forma mais elegante?

É possível em SQL atingir com elegância o seguinte:

insert into my_table (the_geom) VALUES 
    geomfromwkb('\x010100000058b4b610a73a27408144b7147f194840',4326)),
    geomfromwkb('\x010100000058b4b610a73a27408144b7147f194840',4326)),
    .....

que envolve invocar uma função externa geomfromwkbcom dois parâmetros?

Até agora, tenho uma solução nada elegante. A primeira solução é deste tipo:

insert into mytable (the_geom) select 
    geomfromwkb('\x010100000058b4b610a73a27408144b7147f194840',4326)) union
    geomfromwkb('\x010100000058b4b610a73a27408144b7147f194840',4326)) union
    .....

O segundo usa a instrução prepare:

PREPARE my_insert AS INSERT INTO geom_example (the_geom) 
    VALUES (geomfromwkb($1,4326));
EXECUTE my_insert ('\x010100000058b4b610a73a27408144b7147f194840');
EXECUTE my_insert ('\x010100000058b4b610a73a27408144b7147f194840');
statement: DEALLOCATE my_insert;

Pergunta 1: Existe algo mais elegante do que isso?

Questão 2 : O que o banco de dados faz quando vê um monte de sindicatos?

Questão 3 : a preparação realmente acelera as coisas em comparação com uma inserção de gordura?

Questão 4 : a sequência de bytes é do tipo geometria. É possível pular as verificações de consistência (para garantir que esta é realmente a sequência de bytes de geometria) para acelerar as inserções?

O código proprietário (que não podemos alterar) possui várias funções definidas pelo usuário do tipo:

create or replace function f() returns record as $$ ... $$

que chamamos da seguinte forma (por exemplo):

SELECT status, log FROM f() as (status boolean, log text);

(status boolean, log text)é um tipo de linha da tabela T. É possível converter automaticamente o record(ou setof recordtipo de retorno) no tipo de Tlinha sem listar os atributos? O que procuro é do tipo:

SELECT * FROM f() as T%rowtype

Estou desenvolvendo uma função definida pelo usuário que recebe dois argumentos:

create or replace function gesio(
    events_table_in regclass,  
    events_table_out regclass)
returns void as $$ ... $$

events_table_ine events_table_outtêm exatamente o mesmo esquema.

Explicado de forma simples, eu percorro os registros de events_table_in, manipulo os registros e quero anexar (inserir) os registros manipulados events_table_outda seguinte maneira:

OPEN recCurs FOR execute 
format('SELECT * FROM %s order by session_id, event_time', event_table_in);

LOOP
    FETCH recCurs into rec;
    if not found then
      exit;
    end if;

    -- 1. do something with rec

    -- 2. insert the rec into events_table_out

end loop;

Como posso salvar o recem events_table_out?

No Postgres em uma função definida pelo usuário eu faço

execute format('delete from table where session_id = %L', id);

correu sem executepostgres (pode) retornar (s) o seguinte:

DELETE 0

Existe alguma maneira de obter essa saída na função definida pelo usuário? O que estou procurando é algo como:

execute format('delete from table where session_id = %L', id) into log;