Estou criando um script de um banco de dados bastante simples para que eu possa simplesmente passar um script para outra pessoa para um aplicativo usar. Estou curioso para saber onde as melhores práticas/comunidade se posicionam sobre isso: quando você deve criar suas restrições de chave primária/estrangeira? Você deve fazer isso enquanto está criando as tabelas por causa da continuidade, ou deve fazê-lo depois que as tabelas forem criadas, pois será mais fácil criar scripts dessa maneira, pois você pode criar as tabelas na ordem que desejar? Existem falhas fatais em potencial no caminho com qualquer um dos padrões?
Estou começando a aprender um pouco sobre como analisar planos de execução e tornar as consultas mais eficientes
Considere estas duas consultas básicas
select distinct pat_id, drug_class, drug_name from rx
select pat_id, drug_class, drug_name from rx
e seus planos de execução
índice usado:
CREATE CLUSTERED INDEX [ix_overlap] ON [dbo].[rx]
(
[pat_id] ASC,
[fill_date] ASC,
[script_end_date] ASC,
[drug_name] ASC
)
Embora a primeira consulta supostamente tenha o custo mais alto por uma margem de 4:1, ela é executada mais rapidamente que a segunda. Por que um distinto simples adicionado à consulta adicionará o operador de correspondência de hash (o que suponho ser sempre ruim, correções são bem-vindas)? E por que ela tem o custo de consulta mais alto em relação à segunda consulta se for executada mais rapidamente?
Se eu tiver duas tabelas com restrições, tipos de dados e chaves primárias idênticos, existe uma maneira de 'importar' o índice de uma tabela para outra se estiverem no mesmo servidor, mas em bancos de dados separados?
Sou novo no mundo do banco de dados e recentemente comecei a trabalhar com um grande banco de dados com várias tabelas principalmente com texto varchar e inteiros. As duas maiores tabelas são de aproximadamente 50 milhões e 25 milhões de linhas. O banco de dados contém cerca de 350.000 números de identificação para pessoas e muitas vezes preciso recuperar informações sobre todos os indivíduos que envolvem junções para ambas as minhas tabelas muito grandes (elas são um para muitos relacionamentos). Essas consultas também são de natureza temporal e envolvem obetweenoperador para determinar eventos que acontecem sem um determinado período de tempo. Geralmente, leva de 10 a 15 minutos para que algumas dessas consultas sejam executadas (ainda estou aprendendo e tento novos índices para ver se consigo melhorar o desempenho. Depois de ficar sem memória RAM executando uma consulta específica, meu computador congelou e eu tive que reiniciar. Mesmo depois de reiniciar, não consegui desanexar, descartar conexões e excluir meus arquivos de log para excluir meu banco de dados (que estava no modo de recuperação).
Inicializei no modo de segurança para excluir os arquivos mdf e ldf e vi que meu arquivo de log tinha o dobro do tamanho do arquivo de dados. Se eu precisar executar consultas rotineiramente que retornarão informações temporais agregadas em tabelas do tamanho especificado acima, há algo que eu possa fazer para evitar o inchaço do log? Além disso, sei que o SQL Server consome recursos para o almoço, mas que tipo de especificações um computador precisa ter para executar uma consulta como a seguinte com os tamanhos de tabela listados acima? (demora uma hora na minha máquina local)
EDIT: este banco de dados é estático por natureza e não terá nada adicionado a ele. também está indisponível apenas para um usuário, eu. Não tenho certeza de que tipo de recuperação teve, não tenho esse PC na minha frente no momento.
consulta:
--my real database field names are not this generic
;with x
as
( --the first CTE finds the number of different classes a person qualified for and lists a number for a given date
select rx.pat_id
,c.cal_date
,COUNT(distinct rx.class) as distinctClass
from rx,Calendar as c
where c.cal_date between rx.fill_date and rx.script_end_date
group by rx.pat_id,c.cal_date
),y
as
( --the second CTE gives interval number to the date so the max and min date values can be grouped by grp_nbr to give a time span
select x.pat_id
,x.cal_date
,c2.id-ROW_NUMBER() over(partition by x.pat_id,x.distinctClass
order by x.cal_date) as grp_nbr
,x.distinctClass
from x
inner join Calendar as c2
on c2.cal_date=x.cal_date
)
--this groups the max and min dates with a particular grp_nbr and the number of different classes a person qualifies for
select y.pat_id,min(cal_date),max(cal_date),MIN(distinctClass)
from y
group by y.pat_id,grp_nbr
order by MIN(distinctClass) desc
Eu tenho uma tabela grande (~ 50 milhões de linhas) estou tentando inserir em massa no SQL Server e recebo o erro:
Não foi possível alocar espaço para o objeto 'myDB' no banco de dados 'I 3 Stroke' porque o grupo de arquivos 'PRIMARY' está cheio. Crie espaço em disco excluindo arquivos desnecessários, descartando objetos no grupo de arquivos, adicionando arquivos adicionais ao grupo de arquivos ou definindo o crescimento automático para arquivos existentes no grupo de arquivos.
Há outra tabela no banco de dados com cerca de 25 milhões de linhas. Esse banco de dados será usado apenas em uma única máquina e será projetado para extrair dados que já existem e, sob nenhuma circunstância, crescerá além de seu tamanho atual.
Para uma situação como essa, qual é a melhor maneira de resolver isso para que o SQL Server não reclame? A solução será importante para que esse banco de dados não seja exposto a vários usuários?