All perguntas(dba)

O Microsoft SQL Server tem o que considero uma função notavelmente sensata, try_cast()que retorna a nullse a conversão não for bem-sucedida, em vez de gerar um erro.

Isso torna possível usar uma CASEexpressão ou um coalescepara recorrer. Por exemplo:

SELECT coalesce(try_cast(data as int),0);

A questão é, o PostgreSQL tem algo semelhante?

A pergunta é feita para preencher algumas lacunas no meu conhecimento, mas também há o princípio geral de que alguns preferem uma reação menos dramática a alguns erros do usuário. Retornar a nullé mais fácil de se fazer em SQL do que um erro. Por exemplo SELECT * FROM data WHERE try_cast(value) IS NOT NULL;. Na minha experiência, os erros do usuário às vezes são melhor tratados se houver um plano B.

Eu tenho uma tabela com uma coluna varchar. Está permitindo Trademark(™), copyright(©) e outros caracteres Unicode, conforme mostrado abaixo.

Create table VarcharUnicodeCheck
(
col1 varchar(100)
)

insert into VarcharUnicodeCheck (col1) values ('MyCompany')
insert into VarcharUnicodeCheck (col1) values ('MyCompany™')
insert into VarcharUnicodeCheck (col1) values ('MyCompany░')
insert into VarcharUnicodeCheck (col1) values ('MyCompanyï')
insert into VarcharUnicodeCheck (col1) values ('MyCompany')

select * from VarcharUnicodeCheck

Mas a definição de varchar diz que permite dados de string não unicode. Mas os símbolos Trademark(™) e Registered(®) são caracteres Unicode . A definição contradiz a propriedade do tipo de dados varchar? Eu li alguns links como o primeiro e o segundo . Mas ainda não consegui entender por que ele permite string unicode quando a definição diz que permite apenas valores de string não unicode.

Eu tenho uma consulta que é muito mais rápida com select top 100e muito mais lenta sem top 100. O número de registros retornados é 0. Você poderia explicar a diferença nos planos de consulta ou compartilhar links onde essa diferença explicada?

A consulta sem toptexto:

SELECT --TOP 100
*
FROM InventTrans
     JOIN
     InventDim
     ON InventDim.DATAAREAID = 'dat' AND 
        InventDim.INVENTDIMID = InventTrans.INVENTDIMID
WHERE InventTrans.DATAAREAID = 'dat' AND 
      InventTrans.ITEMID = '027743' AND 
      InventDim.INVENTLOCATIONID = 'КзРЦ Алмат' AND 
      InventDim.ECC_BUSINESSUNITID = 'Казахстан';

O plano de consulta para o acima (sem top):

https://pastebin.com/cbtJpxFf

As estatísticas IO e TIME (sem top):

SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

 SQL Server Execution Times:
   CPU time = 0 ms,  elapsed time = 0 ms.
SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

(0 row(s) affected)
Table 'INVENTDIM'. Scan count 0, logical reads 988297, physical reads 0, read-ahead reads 1, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'INVENTTRANS'. Scan count 1, logical reads 1234560, physical reads 0, read-ahead reads 14299, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

(1 row(s) affected)

 SQL Server Execution Times:
   CPU time = 6256 ms,  elapsed time = 13348 ms.
SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

 SQL Server Execution Times:
   CPU time = 0 ms,  elapsed time = 0 ms.

Os índices usados ​​(sem top):

1. INVENTTRANS.I_177TRANSIDIDX
   4 KEYS:
 - DATAAREAID
 - INVENTTRANSID
 - INVENTDIMID
 - RECID
2. INVENTTRANS.I_177ITEMIDX
   3 KEYS:
   - DATAAREAID
   - ITEMID
   - DATEPHYSICAL 
3. INVENTDIM.I_698DIMIDIDX
   2 KEYS:
   - DATAAREAID
   - INVENTDIMID

A consulta com top:

SELECT TOP 100
*
FROM InventTrans
     JOIN
     InventDim
     ON InventDim.DATAAREAID = 'dat' AND 
        InventDim.INVENTDIMID = InventTrans.INVENTDIMID
WHERE InventTrans.DATAAREAID = 'dat' AND 
      InventTrans.ITEMID = '027743' AND 
      InventDim.INVENTLOCATIONID = 'КзРЦ Алмат' AND 
      InventDim.ECC_BUSINESSUNITID = 'Казахстан';

O plano de consulta (com TOP):

https://pastebin.com/0dyu6QZd

As estatísticas de IO e TIME da consulta (com TOP):

SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

 SQL Server Execution Times:
   CPU time = 0 ms,  elapsed time = 0 ms.
SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

(0 row(s) affected)
Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'INVENTTRANS'. Scan count 15385, logical reads 82542, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table 'INVENTDIM'. Scan count 1, logical reads 62704, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

(1 row(s) affected)

 SQL Server Execution Times:
   CPU time = 265 ms,  elapsed time = 257 ms.
SQL Server parse and compile time: 
   CPU time = 0 ms, elapsed time = 0 ms.

 SQL Server Execution Times:
   CPU time = 0 ms,  elapsed time = 0 ms.

Os índices usados ​​(com TOP):

 1. INVENTTRANS.I_177TRANSIDIDX
     4 KEYS:
     - DATAAREAID
     - INVENTTRANSID
     - INVENTDIMID
     - RECID
 2. INVENTTRANS.I_177DIMIDIDX
    3 KEYS:
    - DATAAREAID
    - INVENTDIMID
    - ITEMID
 3. INVENTDIM.I_698DIMIDIDX
    2 KEYS:
    - DATAAREAID
    - INVENTDIMID
 4. INVENTDIM.I_698ECC_BUSUNITLOCIDX
    3 KEYS
    - DATAAREAID
    - ECC_BUSINESSUNITID
    - INVENTLOCATIONID

Apreciará profundamente qualquer ajuda sobre o tema!

Estou tentando retornar vários registros usando o tipo de dados RECORD, existe uma maneira de anexar a RECORD e adicionar/anexar um novo valor a cada iteração a este RECORD.

isto é, eu quero anexar para recque recse torne um conjunto de linhas quando o loop terminar, que eu possa apenas RETURN no final da minha função. Atualmente, estou fazendo isso -

SELECT temp_table.col1, temp_table.col2, temp_table.col3
      INTO rec
      FROM temp_table
      WHERE temp_table.col3 = false;

meu código completo está aqui:

CREATE OR REPLACE FUNCTION validation()
  RETURNS RECORD AS $$
DECLARE
        rec RECORD;
        temp_row RECORD;
BEGIN

  CREATE TEMPORARY TABLE temp_table (col1 TEXT, col2 INTEGER, col3 BOOLEAN) ON COMMIT DROP;

  FOR temp_row IN SELECT * FROM staging.validation
  LOOP

    RAISE NOTICE 'sql: %', temp_row.sql;

    EXECUTE format('INSERT INTO temp_table %s', temp_row.sql);

    IF (SELECT DISTINCT temp_table.col3 FROM temp_table WHERE temp_table.col3 = false)=false THEN
      RAISE NOTICE 'there is a false value';

      SELECT temp_table.col1, temp_table.col2, temp_table.col3
      INTO rec
      FROM temp_table
      WHERE temp_table.col3 = false;
    END IF;


  END LOOP;
  RETURN rec;
END; $$
LANGUAGE plpgsql;

Saída de corrente apósSELECT validation();

validation
(crea_ddf,8095,f)

Saída Desejada

validation
(crea_ddf,8095,f)
(some_source_system,some_count,f)
(some_other_source_system,some_count,f)
(.....)

SQL Server 2012 e 2016 Padrão:

Se eu colocar if-elselógica em um procedimento armazenado para executar uma das duas ramificações de código, dependendo do valor de um parâmetro, o mecanismo armazena em cache a versão mais recente?

E se na execução seguinte, o valor do parâmetro mudar, ele irá recompilar e refazer o cache do procedimento armazenado , já que uma ramificação diferente do código deve ser executada? (Esta consulta é bastante cara para compilar.)

Não estou claro sobre o verdadeiro significado nas definições para funções IMUTÁVEIS, VOLÁTEIS e ESTÁVEIS.

Eu li a documentação, especificamente as definições de cada um.

IMMUTABLE indica que a função não pode modificar o banco de dados e sempre retorna o mesmo resultado quando recebe os mesmos valores de argumento ; ou seja, ele não faz pesquisas de banco de dados ou usa informações não presentes diretamente em sua lista de argumentos. Se esta opção for fornecida, qualquer chamada da função com argumentos constantes pode ser imediatamente substituída pelo valor da função.

STABLE indica que a função não pode modificar o banco de dados e que, em uma única varredura de tabela, ela retornará consistentemente o mesmo resultado para os mesmos valores de argumento , mas que seu resultado pode ser alterado nas instruções SQL. Esta é a seleção apropriada para funções cujos resultados dependem de pesquisas de banco de dados, variáveis ​​de parâmetro (como o fuso horário atual), etc. A família de funções current_timestamp se qualifica como estável, pois seus valores não mudam em uma transação.

VOLATILE indica que o valor da função pode ser alterado mesmo em uma única varredura de tabela, portanto, nenhuma otimização pode ser feita. Relativamente poucas funções de banco de dados são voláteis nesse sentido; alguns exemplos são random(), currval(), timeofday(). Mas observe que qualquer função que tenha efeitos colaterais deve ser classificada como volátil, mesmo que seu resultado seja bastante previsível, para evitar que as chamadas sejam otimizadas; um exemplo é setval().

Minha confusão vem com a condição para IMMUTABLE e STABLE que a função ALWAYS ou CONSISTENTLY retorna o mesmo resultado com os mesmos argumentos.

A definição IMMUTABLE afirma que a função não faz pesquisas de banco de dados ou usa informações não presentes diretamente em sua lista de argumentos. Então, para mim, isso significa que essas funções são usadas para manipular dados fornecidos pelo cliente e não devem ter instruções SELECT... embora isso soe um pouco estranho para mim.

Com STABLE, a definição é semelhante, pois diz que deve retornar consistentemente o mesmo resultado. Então, para mim, isso significa que toda vez que a função é chamada com os mesmos argumentos, ela deve retornar os mesmos resultados (mesmas linhas exatas, todas as vezes).

Então, para mim... isso significa que qualquer função que execute um SELECT em uma tabela ou tabelas que possam ser atualizadas, deve ser apenas volátil.

Mas, novamente... isso não soa bem para mim.

Trazendo isso de volta ao meu caso de uso, estou escrevendo funções que executam instruções SELECT com vários JOINs em tabelas que são constantemente adicionadas, portanto, espera-se que as chamadas de função retornem resultados diferentes cada vez que são chamadas, mesmo com os mesmos argumentos .

Então, isso significa que minhas funções devem ser VOLÁTEIS? Mesmo que a documentação indique relativamente poucas funções de banco de dados são voláteis nesse sentido ?

Obrigada!

Eu estava experimentando o efeito de dar ao SQL Server uma pequena quantidade de memória que pensei que fosse recuperar.

Configurei o SQL Server para usar 200MB de memória agora ele não quer iniciar, fiz algumas pesquisas na internet e fui aconselhado a iniciar o SQL Server em modo monousuário. no entanto, recebo o erro

Falha no login do usuário A. Motivo: O servidor está no modo de usuário único. Apenas um administrador pode se conectar neste momento (Microsoft SQL Server, Erro: 18461)

Eu parei o SQL Server Agent.

Uma operação "ALTER INDEX ALL REBUILD" no SQL Server 2012 falhou porque o log de transações ficou sem espaço. Os índices nunca foram reorganizados ou reconstruídos, então a fragmentação é superior a 80% em quase todos eles.

O banco de dados usa o modelo de recuperação simples. Presumi que, após cada operação de índice executada pela forma "ALL" do comando, os dados do log de transações seriam liberados antes da próxima reconstrução do índice. É assim que realmente funciona ou as recompilações de índice são registradas como se fossem parte de uma única transação?

Em outras palavras, eu poderia reduzir o crescimento do log de transações escrevendo um script para executar cada reconstrução individualmente? Existem outros fatores a serem considerados?

Houve uma pergunta neste fórum sobre a module_endunidade de duração do Evento Estendido, que eu respondi. Detalhes aqui .

É sempre em microssegundos para todos os eventos?

Estou começando agora com o Postgres. Lendo este documento me deparei com esta consulta:

SELECT title, ts_rank_cd(textsearch, query) AS rank
FROM apod, to_tsquery('neutrino|(dark & matter)') query
WHERE query @@ textsearch
ORDER BY rank DESC
LIMIT 10;

Eu posso entender tudo nesta consulta, exceto isso: FROM apod, ....

O que isso ,significa? Estou acostumado a junções, mas não a várias FROMinstruções separadas por uma vírgula.

Procurei na net sem sucesso. Depois de olhar e pensar, me parece que está declarando uma variável chamada query para poder usá-la várias vezes. Mas se isso for verdade, o que isso tem a ver FROM?