All perguntas(dba)

Por que as restrições são aplicadas no banco de dados? Não será mais flexível colocá-lo no código?

Estou lendo um livro para iniciantes sobre como implementar bancos de dados, então estou perguntando isso como iniciante. Digamos que eu tenha projetado um banco de dados, incluindo este modelo de entidade:

 entity type    |   sub-types
----------------+--------------------------------------------
   Person       |   Employee, Student,       ...
   Student      |   Graduate, Undergraduate, ...
   Employee     |   Teacher,  Administrator, ...

Restrições atuais:

1. A pessoa cadastrada no sistema só pode ser Aluno ou Funcionário.
2. A entidade de pessoa requer a exclusividade do número social, que presumimos que cada pessoa possui apenas um único número (também conhecido como uma chave primária boa o suficiente ). (veja #1)

Depois resolvemos tirar o número 1: Se um dia a faculdade decidir que o Teacher(o Employeesubtipo) também pode ser Student, fazendo cursos nas horas vagas, fica muito mais difícil mudar o desenho do banco de dados que pode ter milhares, milhões, bilhões, zilhões de entradas em vez de apenas mudar a lógica do código: apenas a parte que não permitia que uma pessoa fosse cadastrada como aluno e funcionário.

(É muito improvável, mas não consigo pensar em mais nada agora.Aparentemente é possível).

Por que nos preocupamos com as regras de negócios no design do banco de dados e não no código?

# 1: Uma nota 7 anos depois, um exemplo da vida real:
eu vi um governo onde, por engano, os SSNs emitidos foram duplicados: várias pessoas, mesmo SSN. Aqueles que projetaram o banco de dados original definitivamente cometeram o erro de não aplicar essa restrição de exclusividade no banco de dados. (e mais tarde um bug no aplicativo original? vários aplicativos usando o banco de dados compartilhado e não concordando onde colocar, verificar e aplicar a restrição? ...).
Esse bug continuará a residir no sistema e em todo o sistema desenvolvido, após o qual dependerá do banco de dados do sistema original por muitos e muitos anos. Lendo as respostas aqui, aprendi a aplicar todas as restrições, o máximo possível, sabiamente (não cegamente) no banco de dados para representar o mundo físico real da melhor maneira possível.

Os dados recuperados do Microsoft SQL Server são compactados? Se isso for controlado pela string de conexão, existe alguma maneira simples de saber se algum aplicativo específico está usando?

Estou examinando as ferramentas de análise e o volume de dados pode levar minutos para ser transmitido pela nossa rede. Estou me perguntando se devo esperar um aumento de desempenho se extrairmos dados de um armazenamento de dados compactados no mesmo servidor remoto.

Já que estamos no assunto, estou curioso: os dados são transmitidos em binário ou ASCII? Por exemplo, se o valor 12345for consultado de uma INTcoluna, ele é transmitido como os cinco bytes 0x31, 0x32, 0x33, 0x34, 0x35; os dois bytes necessários para o valor; ou quatro bytes conforme necessário para a coluna?

Para ser claro, entendo que existem opções em relação ao armazenamento de dados com compactação e backup. Estou perguntando sobre como os dados são transmitidos.

MSDN " Missing Join Predicate Event Class " diz que " indica que uma consulta está sendo executada sem nenhum predicado de junção ".

Mas infelizmente não parece ser tão fácil assim.

Por exemplo, situação muito simples:

create table #temp1(i int);
create table #temp2(i int);
Select * from #temp1, #temp2 option (recompile);

Não há dados nas tabelas, também não há aviso, embora obviamente não tenha predicado de junção.

Se eu der uma olhada na documentação do SQL Server 2005 (o mesmo link, apenas outra versão do servidor), há uma frase extra: " Este evento é produzido apenas se ambos os lados da junção retornarem mais de uma linha. " perfeito sentido na situação anterior. Não há dados, então ambos os lados retornam 0 linhas e nenhum aviso. Insira linhas, receba um aviso. OK legal.

Mas para a próxima situação confusa, insiro os mesmos valores nas duas tabelas:

Insert into #temp1 (i) values (1)
Insert into #temp1 (i) values (1)
Insert into #temp2 (i) values (1)
Insert into #temp2 (i) values (1)

E eu recebo:

-- no warning:
Select * from #temp1 t1 
    inner join #temp2 t2 on t1.i = t2.i 
option (recompile)
-- has warning:
Select * from #temp1 t1 
    inner join (select 1 i union all select 1) t2 on t1.i = t2.i 
option (recompile)

Porque isto é assim?

Nota : alguns scripts que usei para detectar essas consultas ruins no meu servidor.

1. claro, plano de execução de procedimentos

2. usou o rastreamento de servidor padrão para encontrar avisos

   Declare @trace nvarchar(500);
   Select @trace = cast(value as nvarchar(500))
   From sys.fn_trace_getinfo(Null)
   Where traceid = 1 and property = 2;
   
   Select t.StartTime, te.name, *
   From sys.fn_trace_gettable(@trace, 1) t
       Inner join sys.trace_events te on t.EventClass = te.trace_event_id
       where EventClass = 80
   order by t.StartTime desc
   

3. cache do plano de execução, para encontrar esses planos com avisos (como este)

   WITH XMLNAMESPACES (default 'http://schemas.microsoft.com/sqlserver/2004/07/showplan')
   SELECT
       Cast('<?SQL ' + st.text + ' ?>' as xml) sql_text,
       pl.query_plan,
       ps.execution_count,
       ps.last_execution_time,
       ps.last_elapsed_time,
       ps.last_logical_reads,
       ps.last_logical_writes
   FROM sys.dm_exec_query_stats ps with (NOLOCK)
       Cross Apply sys.dm_exec_sql_text(ps.sql_handle) st
       Cross Apply sys.dm_exec_query_plan(ps.plan_handle) pl
   WHERE pl.query_plan.value('(//Warnings/@NoJoinPredicate)[1]', 'bit') = 1
   Order By last_execution_time desc
   OPTION (RECOMPILE);
   

Eu tenho replicação em execução no Percona Server 5.5 seguindo este guia e me pergunto se devo adicionar read-only=1ao meu escravo my.cnfpara torná-lo somente leitura?

O guia configura a replicação para a tabela mysql para que os usuários sejam replicados, mas estou usando principalmente o escravo para obter mysqldumps e, em caso de emergência, reconfigurá-lo para ser mestre, então não acredito que precisamos (ou deveríamos) ativar a gravação em constantemente?

Vejo referências frequentes a WITHconsultas (expressões de tabela comuns ou CTEs) atuando como uma cerca de otimização, onde o servidor não tem permissão para inserir filtros nas consultas CTE, extrair expressões comuns do CTE etc. para ser um comportamento exigido pelos padrões SQL.

Os CTEs são definitivamente uma cerca de otimização no PostgreSQL ... mas isso é exigido pelo padrão ou, na verdade, apenas detalhes de implementação?

Por exemplo, essas postagens da lista de discussão afirmam ou sugerem que é padrão:

• http://www.digipedia.pl/usenet/thread/11566/101385/

Depois de mencioná-lo em um comentário , perguntaram-me onde está especificado - e depois de dar uma olhada no único rascunho do SQL: 2008 ao qual tenho acesso, não estou tendo muita sorte em encontrá-lo.

Ainda não estudei intensivamente o padrão, então espero uma sugestão de alguém que o tenha feito: a delimitação de otimização de CTEs no PostgreSQL é realmente exigida pelo padrão? E se sim, onde está especificado? Ou as declarações na lista de discussão da Pg estão erradas?

Veja também a cerca de otimização de CTE de thread na lista de tarefas? .

Dada a string:

'Eu acho que o PostgreSQL é bacana'

Eu gostaria de operar nas palavras individuais encontradas dentro dessa string. Essencialmente, tenho um separado do qual posso obter detalhes da palavra e gostaria de ingressar em uma matriz não aninhada dessa string neste dicionário.

Até agora eu tenho:

select word, meaning, partofspeech
from unnest(string_to_array('I think that PostgreSQL is nifty',' ')) as word
from table t
join dictionary d
on t.word = d.wordname;

Isso cumpre os fundamentos do que eu esperava fazer, mas não preserva a ordem original das palavras.

Questão relacionada:
PostgreSQL unnest() com número de elemento

Criei uma tabela testtabledentro do banco de dados testbaseque tem a seguinte estrutura:

product_no (int, not null)
product_name (varchar(30), not null)
price (money, null)
expire_date (date, null)
expire_time (time(7), null)

que usei o Microsoft SQL Server 2008 Management Studio.

Eu criei um procedimento armazenado testtable_pricesmallerda seguinte forma

use testbase
go
create procedure testtable_pricesmaller
    @pricelimit money
as
select * from testtable where price = @pricelimit;
go

e são capazes de visualizar os procedimentos armazenados no Object ExplorerMicrosoft SQL Server Management Studio. (Está listado na seguinte estrutura em árvore do Object Explorer)

Databases
    + testbase
        + Tables
            + dbo.testtable
        + Programmability
            + Stored Procedures
                + dbo.testtable_pricesmaller

Acho muito estranho quando recebo o seguinte erro:

Could not find the stored procedure 'dbo.testtable_pricesmaller'.

quando executo a seguinte instrução SQL:

execute dbo.testtable_pricesmaller 50

O que pode estar faltando?

Atualmente, estou trabalhando em um banco de dados MySQL onde estamos vendo um grande número de invalidações do cache de consulta, principalmente por causa do alto número de instruções INSERT, DELETE e UPDATE que estão sendo executadas em muitas das tabelas.

O que estou tentando determinar é se há ou não algum benefício em permitir que o cache de consulta seja usado para instruções SELECT que estão sendo executadas nessas tabelas. Como eles são invalidados tão rapidamente, parece-me que a melhor coisa seria apenas usar SQL_NO_CACHE nas instruções SELECT com essas tabelas.

A sobrecarga de invalidação frequente vale a pena?

Editar: A pedido do usuário @RolandoMySQLDBA abaixo, aqui estão as informações sobre MyISAM e INNODB.

InnoDBGenericName

• Tamanho dos dados: 177,414 GB
• Tamanho do índice: 114,792 GB
• Tamanho da tabela: 292,205 GB

MyISAMGenericName

• Tamanho dos dados: 379,762 GB
• Tamanho do índice: 80,681 GB
• Tamanho da tabela: 460,443 GB

Informação adicional:

• Versão: 5.0.85
• query_cache_limit: 1048576
• query_cache_min_res_unit: 4096
• query_cache_size: 104857600
• query_cache_type: ON
• query_cache_wlock_invalidate: OFF
• innodb_buffer_pool_size: 8841592832
• 24 GB de RAM

Eu tenho mensagens de depuração em funções. Essas mensagens são levantadas como

RAISE NOTICE 'Value of id : %', id;

Eu configurei meu arquivo de log com\o messages.txt

Então eu faço o que eu preciso fazer com\i process.sql

E quando a execução é encerrada, \o.

O problema é que não tenho as mensagens geradas por avisos em messages.txt. As mensagens são exibidas na tela, mas eu quero que elas sejam escritas em messages.txt

Como eu poderia fazer isso?

Tentei usar RAISE LOG...e as mensagens são escritas em arquivo de log... Não é o que eu quero.

Eu tenho um trabalho com

plsql -f /path/to/process.sql > messages.txt 2>&1

mas gostaria de saber como poderia usar \i e \o no cliente plsql tendo as mensagens no arquivo especificado em \o

Meu cliente, no cygwin é o psql (PostgreSQL) 8.2.11 e a versão do servidor é 9.0.7

Eu tenho o seguinte procedimento (SQL Server 2008 R2):

create procedure usp_SaveCompanyUserData
    @companyId bigint,
    @userId bigint,
    @dataTable tt_CoUserdata readonly
as
begin

    set nocount, xact_abort on;

    merge CompanyUser with (holdlock) as r
    using (
        select 
            @companyId as CompanyId, 
            @userId as UserId, 
            MyKey, 
            MyValue
        from @dataTable) as newData
    on r.CompanyId = newData.CompanyId
        and r.UserId = newData.UserId
        and r.MyKey = newData.MyKey
    when not matched then
        insert (CompanyId, UserId, MyKey, MyValue) values
        (@companyId, @userId, newData.MyKey, newData.MyValue);

end;

CompanyId, UserId, MyKey formam a chave composta para a tabela de destino. CompanyId é uma chave estrangeira para uma tabela pai. Além disso, há um índice não clusterizado em CompanyId asc, UserId asc.

Ele é chamado de muitos threads diferentes e estou constantemente obtendo impasses entre diferentes processos que chamam essa mesma instrução. Meu entendimento era que o "with (holdlock)" era necessário para evitar erros de condição de corrida de inserção/atualização.

Presumo que dois threads diferentes estão bloqueando linhas (ou páginas) em ordens diferentes quando estão validando as restrições e, portanto, estão em um impasse.

Será esta uma suposição correta?

Qual é a melhor maneira de resolver essa situação (ou seja, sem impasses, impacto mínimo no desempenho multithread)?

(Se você visualizar a imagem em uma nova guia, ela é legível. Desculpe pelo tamanho pequeno.)

• Há no máximo 28 linhas no @datatable.
• Rastreei o código e não consigo ver em nenhum lugar onde iniciamos uma transação aqui.
• A chave estrangeira está configurada para cascatear apenas na exclusão e não houve exclusões da tabela pai.