Shaul Behr's questions

Verificando nossos logs de produção de ontem, descobrimos um período de cerca de 5 minutos em que um monte de consultas realmente simples estavam expirando. Investigações adicionais nos logs do servidor mostraram um grande aumento na atividade do disco, o que me levou à conclusão de que um CHECKPOINT automático estava sendo executado no banco de dados naquele momento.

Isso é algo que eu realmente não quero que aconteça durante o horário de pico. Então eu estava pensando em agendar um CHECKPOINT diário todos os dias fora do horário de pico.

Essa é uma boa ideia? Péssima ideia? Perda de tempo? Se não isso, então o quê?

Eu tenho um usuário ls_readonlyque deveria ter db_datareaderprivilégios em vários bancos de dados. Achei que tinha configurado direitinho:

Mas quando eu me conecto ao servidor como ls_readonlye tento abrir o db no Object Explorer, recebo um erro:

O banco de dados wtest não está acessível. (Explorador de Objetos)

Eu abro uma janela de consulta mastere tento executar:

use wtest

Isso responde com:

Msg 916, Level 14, State 1, Line 1
The server principal "ls_readonly" is not able to access the database "wtest" under the current security context.

o que estou perdendo?

ATUALIZAÇÃO: aqui está uma pista. Se eu excluir ls_readonlycomo usuário do contexto de segurança do banco de dados, vou para o usuário no contexto de segurança do servidor e em "Mapeamento do usuário" concedo acesso ao banco de dados e ele começa a funcionar.

Pode ser que o banco de dados tenha sido originalmente restaurado de um servidor diferente, que também tenha um ls_readonlyusuário. Eu acho então que a identificação do usuário não é baseada no nome de usuário?

Estou montando um sistema SaaS, onde planejamos dar a cada cliente seu próprio banco de dados. O sistema já está configurado para que possamos expandir facilmente para servidores adicionais se a carga se tornar muito grande; esperamos ter milhares, ou mesmo dezenas de milhares de clientes.

Perguntas

• Existe alguma limitação prática no número de micro-bancos de dados que você pode/deve ter em um SQL Server?
• Isso pode afetar o desempenho do servidor?
• É melhor ter 10.000 bancos de dados de 100 MB cada ou um banco de dados de 1 TB?

Informação adicional

Quando digo "microbancos de dados", não quero dizer "micro"; Quero dizer apenas que estamos visando milhares de clientes, de modo que cada banco de dados individual seria apenas um milésimo ou menos do armazenamento total de dados. Na realidade, cada banco de dados teria cerca de 100 MB, dependendo de quanto uso ele recebe.

A principal razão para usar 10.000 bancos de dados é a escalabilidade. O fato é que a V1 do sistema tem um banco de dados e tivemos alguns momentos desconfortáveis ​​quando o banco de dados estava sobrecarregado.

Estava sobrecarregando CPU, memória, E/S - todos os itens acima. Apesar de termos corrigido esses problemas, eles nos fizeram perceber que em algum momento, mesmo com a melhor indexação do mundo, se formos tão bem-sucedidos quanto esperamos, simplesmente não podemos colocar todos os nossos dados em um grande honkin ' base de dados. Portanto, para a V2, estamos fragmentando, para que possamos dividir a carga entre vários servidores de banco de dados.

Passei o último ano desenvolvendo essa solução fragmentada. É uma licença por servidor, mas de qualquer forma isso é resolvido, pois estamos usando VMs no Azure. A razão pela qual a questão surge agora é porque anteriormente estávamos oferecendo apenas para grandes instituições e montando cada uma por nós mesmos. Nossa próxima ordem de negócios é um modelo de autoatendimento em que qualquer pessoa com um navegador pode se inscrever e criar seu próprio banco de dados. Seus bancos de dados serão muito menores e muito mais numerosos do que as grandes instituições.

Tentamos os Pools Elásticos do Banco de Dados SQL do Azure . O desempenho foi muito decepcionante, então voltamos para as VMs normais.

(Relacionado a esta pergunta )

Se eu quiser ver se existem consultas de longa duração em execução no meu banco de dados, qual é a maneira mais fácil de verificar? (Espero que a resposta seja alguma consulta master..sysprocesses?)

Muitas vezes descobri que, quando estou tendo problemas de desempenho em meu banco de dados MSSQL, posso resolvê-los executando sp_UpdateStats. Aprendi isso porque essa é sempre a primeira linha de defesa do suporte técnico, logo após: "Seu computador está ligado?"

Meu entendimento é que o SQL Server deve manter as estatísticas automaticamente; Eu não deveria precisar cuidar dele. Então eu gostaria de entender: que circunstâncias podem levar as estatísticas a ficarem tão desatualizadas que eu precise atualizá-las manualmente?

Eu tenho uma função definida pelo usuário:

create function ut_FooFunc(@fooID bigint, @anotherParam tinyint)
returns @tbl Table (Field1 int, Field2 varchar(100))
as
begin
  -- blah blah
end

Agora eu quero juntar isso em outra tabela, assim:

select f.ID, f.Desc, u.Field1, u.Field2
from Foo f 
join ut_FooFunc(f.ID, 1) u -- doesn't work
where f.SomeCriterion = 1

Em outras palavras, para todos os Fooregistros onde SomeCriterioné 1, quero ver o Foo IDand Desc, juntamente com os valores de Field1e Field2que são retornados ut_FooFuncpara uma entrada de Foo.ID.

Qual é a sintaxe para fazer isso?

Eu tenho um procedimento armazenado:

create proc sp_MyProc(@calcType tinyint) as
begin
    -- some stuff collating data into #MyTempTable

    if (@calcType = 1) -- sum
        select A, B, C, CalcField = sum(Amount) 
        from #MyTempTable t 
        join AnotherTable a on t.Field1 = a.Field1;
        group by A, B, C
    else if (@calcType = 2) -- average
        select A, B, C, CalcField = avg(Amount) 
        from #MyTempTable t 
        join AnotherTable a on t.Field1 = a.Field1;
        group by A, B, C
    else if (@calcType = 3) -- some other fancy formula
        select A, B, C, CalcField = sum(case when t.Type = 1 then 1 else 0 end) * t.Factor 
        from #MyTempTable t 
        join AnotherTable a on t.Field1 = a.Field1;
        group by A, B, C
    -- plus a whole bunch of other, similar cases
    else    
        select A, B, C, CalcField = 0.0
        from #MyTempTable t 
        join AnotherTable a on t.Field1 = a.Field1;
        group by A, B, C
end

Agora, todos esses casos diferentes para valores diferentes de @calcType parecem estar desperdiçando muito espaço e me fazendo copiar e colar tudo, o que sempre me causa arrepios na espinha.

Existe alguma maneira de declarar uma função para CalcField, semelhante à notação lambda em C#, para tornar meu código mais compacto e sustentável? Eu gostaria de fazer algo assim:

declare @func FUNCTION(@t #MyTempTable) as real -- i.e. input is of type #MyTempTable and output is of type real

if (@calcType = 1) -- sum
    set @func = sum(@t.Amount)
else if (@calcType = 2) -- average
    set @func = avg(@t.Amount)
else if (@calcType = 3) -- some other fancy formula
    set @func = sum(case when @t.Type = 1 then 1 else 0 end) * @t.Factor 
-- plus a whole bunch of other, similar cases
else    
    set @func = 0;

select A, B, C, CalcField = @func(t) 
from #MyTempTable t 
join AnotherTable a on t.Field1 = a.Field1;
group by A, B, C

Obviamente, a sintaxe aqui não funciona, mas há algo que alcançará o que eu quero?

Estrutura da tabela:

Foo             FooChild                Bar
---             --------                ---
ID              ID                      ID
Date            FooID                   Date
GroupID         UserID                  UserID
Notes           Amount                  GroupID
                                        IsComplete

• Footem um índice único em Date+GroupID
• FooChildtem um FK para Foo e um índice exclusivo em FooID+ UserID, que incluiAmount
• Bartem um índice exclusivo em ++ Date, que incluiUserIDGroupIDIsComplete

Agora preciso criar um relatório mostrando a soma de todos os valores de FooChild junto com a contagem de barras completas para qualquer intervalo de datas. Os usuários também querem poder ver as estatísticas por grupo ou por usuário. Este parece ser um ótimo lugar para escrever uma visão:

create view vFooBar as
select f.Date, f.GroupID, fc.UserID, fc.Amount, b.IsComplete
from Foo f join FooChild fc on fc.FooID = f.ID
left join Bar b on f.Date = b.Date and f.GroupID = b.GroupID and fc.UserID = b.UserID
union
select b.Date, b.GroupID, b.UserID, x.Amount, b.IsComplete
from Bar b left join 
    (select f.Date, f.GroupID, fc.UserID, fc.Amount
    from Foo f join FooChild fc on fc.FooID = f.ID) x
on x.Date = b.Date and x.GroupID = b.GroupID and x.UserID = b.UserID

( É por isso que escrevi a visão dessa maneira.)

Agora posso facilmente escrever consultas como esta:

select UserID, sum(Amount) FooAmount, sum(cast(IsCompleted as int)) CompletedBars
from vFooBar
where Date between @fromDate and @toDate
group by UserID

Mas há um obstáculo aqui. Assim que o intervalo de datas começa a ficar relativamente grande, o plano de execução fica todo em forma de pêra. Ele usa o índice de data em Foo, mas em vez de usar o FooIDíndice em FooChild, ele faz uma varredura de índice clusterizado e, em seguida, uma correspondência de hash FooIDpara se juntar aos resultados de Foo. E faz isso duas vezes no plano geral; Eu estou supondo uma vez para cada agregado. E isso realmente dói.

Entendo que usar o índice que criei FooChildpode não ser eficiente, pois os valores de FooIDpara uma determinada data podem ser discretos, embora normalmente sejam inseridos aproximadamente na mesma ordem.

Eu poderia desnormalizar e adicionar Datee GroupIDà tabela FooChild, indexar essas colunas e tenho certeza de que isso melhoraria muito o desempenho. Mas simplesmente não parece certo.

Alguma outra ideia?

Eu tenho duas tabelas, vamos chamá-las de TableA e TableB.

TableA               TableB
------               ------
ID                   ID
Date                 Date
Foo                  Bar

Ambas as tabelas possuem um índice em seu campo de data. Agora, quero criar uma exibição que tenha uma junção externa completa entre as duas tabelas no campo Data, para me mostrar o Foovalor dessa data (se houver) junto com o valor Bardessa data.

create view vFooBar as
select isnull(a.Date, b.Date) Date, a.Foo, b.Bar
from TableA a
full outer join TableB b on a.Date = b.Date

Então eu executo uma consulta:

select * from vFooBar where Date = '20141201'

Isso funciona ... mas a união a.Datee b.Dateengana o compilador para não usar os índices, e recebo um plano de execução horrível envolvendo varreduras de tabela.

Como posso criar essa exibição de forma que a consulta ainda use meus índices?

Estou investigando os benefícios de atualizar do MS SQL 2012 para 2014. Um dos grandes pontos de venda do SQL 2014 são as tabelas com otimização de memória, que aparentemente tornam as consultas super rápidas.

Descobri que existem algumas limitações em tabelas com otimização de memória, como:

• Nenhum (max)campo dimensionado
• Máximo ~1 KB por linha
• Nenhum timestampcampo
• Nenhuma coluna computada
• Sem UNIQUErestrições

Todos eles se qualificam como incômodos, mas se eu realmente quiser contorná-los para obter os benefícios de desempenho, posso fazer um plano.

O verdadeiro problema é o fato de que você não pode executar uma ALTER TABLEinstrução e precisa passar por essa ladainha toda vez que adicionar um campo à INCLUDElista de um índice. Além disso, parece que você precisa excluir os usuários do sistema para fazer alterações de esquema nas tabelas MO no banco de dados ativo.

Acho isso totalmente ultrajante, na medida em que realmente não consigo acreditar que a Microsoft possa ter investido tanto capital de desenvolvimento nesse recurso e deixado sua manutenção tão impraticável. Isso me leva à conclusão de que devo ter entendido errado; Devo ter entendido mal algo sobre tabelas com otimização de memória que me levou a acreditar que é muito mais difícil mantê-las do que realmente é.

Então, o que eu entendi errado? Você já usou tabelas MO? Existe algum tipo de interruptor ou processo secreto que os torna práticos de usar e manter?

Eu tenho um banco de dados SQL ao qual adicionei recentemente dados do Filestream. Agora temos um backup/restauração diário em um servidor de controle de qualidade e, desde que adicionei os dados do Filestream, isso começou a falhar. Então, modifiquei a instrução "restore" para incluir um "with move":

RESTORE DATABASE MyDb 
FROM DISK = 'c:\somepath\mydb.bak'
WITH RECOVERY, REPLACE,
MOVE 'MyDb' TO 'f:\sql\MyDb.mdf',
MOVE 'MyDb_Log' TO 'f:\sql\MyBb_log.ldf',
MOVE 'MyDb_Filestream' TO 'f:\sql\MyDb_FS', NOUNLOAD, STATS = 10;

Mas isso está falhando com o seguinte erro:

O arquivo 'MyDb_Filestream' não pode ser restaurado para 'f:\sql\MyDb_FS'. Use WITH MOVE para identificar um local válido para o arquivo.

Pesquisei no Google para encontrar uma solução para isso. Esta resposta diz que você precisa de 3 instruções RESTORE DATABASE separadas, mas não especifica o que são. A resposta aceita aqui indica que você precisa copiar toda a pasta Filestream manualmente, o que acho muito difícil de acreditar. E, de qualquer forma, não deixa claro qual é o processo.

Alguém pode me explicar, em instruções passo a passo à prova de idiotas, como exatamente se deve fazer backup de um banco de dados contendo um fluxo de arquivos, copiá-lo para outro servidor e restaurá-lo lá?

Obrigado!

Eu tenho uma consulta que foi gerada pelo código C#/Linq-To-Entities. Tal como acontece com este tipo de consulta, parece muito feio e duvido que ajude a incluí-lo aqui. Mas eu o executei por meio de um criador de perfil de consulta e descobri que 50,5% do tempo de processamento está acontecendo em uma etapa "Nested Loops (Inner Join)", que está juntando uma busca de índice clusterizado em a2_AssessmentQuestion(0,3%) e uma varredura de índice clusterizado em mesma tabela (13,1%).

Confesso que não entendi bem o que essa "junção de loops aninhados" está fazendo, mas por que a consulta estaria fazendo uma varredura na tabela logo após fazer uma busca de índice, quando os campos que ela está procurando estão disponíveis diretamente por outro índice em exatamente os campos obrigatórios? E sim, eu corri update statistics a2_AssessmentQuestion, sem efeito.

Não sendo um especialista em entender o plano de consulta, agradeceria se você pudesse me estimular para obter respostas para perguntas relevantes; Talvez eu simplesmente não saiba o suficiente para fornecer a você informações úteis suficientes.

Obrigado!

EDIT: FWIW, aqui está a consulta:

SELECT 
[Project6].[ID] AS [ID], 
[Project6].[ID2] AS [ID1], 
[Project6].[ID1] AS [ID2], 
[Project6].[ID3] AS [ID3], 
[Project6].[ID5] AS [ID4], 
[Project6].[ID7] AS [ID5], 
[Project6].[ID6] AS [ID6], 
[Project6].[ID8] AS [ID7], 
[Project6].[ID9] AS [ID8], 
[Project6].[ID11] AS [ID9], 
[Project6].[ID10] AS [ID10], 
[Project6].[ID12] AS [ID11], 
[Project6].[ID13] AS [ID12], 
[Project6].[Number] AS [Number], 
[Project6].[ScholarAssessmentID] AS [ScholarAssessmentID], 
[Project6].[C1] AS [C1], 
[Project6].[GradingStyle] AS [GradingStyle], 
[Project6].[PartID] AS [PartID], 
[Project6].[C2] AS [C2], 
[Project6].[ID4] AS [ID13], 
[Project6].[Description] AS [Description], 
[Project6].[Version] AS [Version], 
[Project6].[DifficultyLevel] AS [DifficultyLevel], 
[Project6].[AssessmentQuestionID] AS [AssessmentQuestionID], 
[Project6].[GradingDueDate] AS [GradingDueDate], 
[Project6].[C3] AS [C3], 
[Project6].[AssessmentFormat] AS [AssessmentFormat], 
[Project6].[C4] AS [C4], 
[Project6].[Structure] AS [Structure], 
[Project6].[Title] AS [Title], 
[Project6].[C5] AS [C5], 
[Project6].[AssessmentFormat1] AS [AssessmentFormat1], 
[Project6].[C6] AS [C6], 
[Project6].[Label] AS [Label]
FROM ( SELECT 
    [Extent1].[ID] AS [ID], 
    [Extent1].[ScholarAssessmentID] AS [ScholarAssessmentID], 
    [Extent1].[AssessmentQuestionID] AS [AssessmentQuestionID], 
    [Join1].[ID1] AS [ID1], 
    [Join1].[ID2] AS [ID2], 
    [Extent4].[ID] AS [ID3], 
    [Extent4].[PartID] AS [PartID], 
    [Extent4].[Number] AS [Number], 
    [Extent4].[DifficultyLevel] AS [DifficultyLevel], 
    [Extent4].[Structure] AS [Structure], 
    [Extent4].[GradingStyle] AS [GradingStyle], 
    [Extent5].[ID] AS [ID4], 
    [Extent5].[Description] AS [Description], 
    [Extent5].[Version] AS [Version], 
    [Extent6].[ID] AS [ID5], 
    [Extent6].[GradingDueDate] AS [GradingDueDate], 
    [Extent6].[Title] AS [Title], 
    [Join6].[ID3] AS [ID6], 
    [Join6].[ID4] AS [ID7], 
    [Extent9].[ID] AS [ID8], 
    [Extent10].[ID] AS [ID9], 
    [Extent10].[AssessmentFormat] AS [AssessmentFormat], 
    [Join10].[ID5] AS [ID10], 
    [Join10].[ID6] AS [ID11], 
    [Extent13].[ID] AS [ID12], 
    [Extent14].[ID] AS [ID13], 
    [Extent14].[AssessmentFormat] AS [AssessmentFormat1], 
     CAST( [Extent4].[Points] AS bigint) AS [C1], 
     CAST( [Extent1].[PointsAwarded] AS decimal(19,0)) AS [C2], 
     CAST( [Extent6].[DueDate] AS datetime2) AS [C3], 
     CAST( [Extent4].[Number] AS bigint) AS [C4], 
    [Join14].[Label] AS [Label], 
    CASE WHEN ([Extent4].[RubricWeight] IS NOT NULL) THEN  CAST( [Extent4].[RubricWeight] AS int) ELSE 0 END AS [C5], 
    CASE WHEN ([Join14].[ScholarAssessmentAnswerID] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C6]
    FROM            [dbo].[a2_ScholarAssessmentAnswer] AS [Extent1]
    INNER JOIN  (SELECT [Extent2].[ID] AS [ID1], [Extent2].[AssessmentID] AS [AssessmentID], [Extent3].[ID] AS [ID2]
        FROM  [dbo].[a2_ScholarAssessment] AS [Extent2]
        LEFT OUTER JOIN [dbo].[a2_ScholarFNPAssessment] AS [Extent3] ON [Extent2].[ID] = [Extent3].[ID] ) AS [Join1] ON [Extent1].[ScholarAssessmentID] = [Join1].[ID1]
    INNER JOIN [dbo].[a2_AssessmentQuestion] AS [Extent4] ON [Extent1].[AssessmentQuestionID] = [Extent4].[ID]
    LEFT OUTER JOIN [dbo].[a2_AssessmentQuestionType] AS [Extent5] ON [Extent4].[QuestionTypeID] = [Extent5].[ID]
    INNER JOIN [dbo].[a2_AssessmentPart] AS [Extent6] ON [Extent4].[PartID] = [Extent6].[ID]
    INNER JOIN  (SELECT [Extent7].[ID] AS [ID3], [Extent7].[AssessmentID] AS [AssessmentID], [Extent8].[ID] AS [ID4]
        FROM  [dbo].[a2_ScholarAssessment] AS [Extent7]
        LEFT OUTER JOIN [dbo].[a2_ScholarFNPAssessment] AS [Extent8] ON [Extent7].[ID] = [Extent8].[ID] ) AS [Join6] ON [Extent1].[ScholarAssessmentID] = [Join6].[ID3]
    INNER JOIN [dbo].[a2_Assessment] AS [Extent9] ON [Join6].[AssessmentID] = [Extent9].[ID]
    LEFT OUTER JOIN [dbo].[a2_AssessmentType] AS [Extent10] ON [Extent9].[AssessmentTypeID] = [Extent10].[ID]
    INNER JOIN  (SELECT [Extent11].[ID] AS [ID5], [Extent11].[AssessmentID] AS [AssessmentID], [Extent12].[ID] AS [ID6]
        FROM  [dbo].[a2_ScholarAssessment] AS [Extent11]
        LEFT OUTER JOIN [dbo].[a2_ScholarFNPAssessment] AS [Extent12] ON [Extent11].[ID] = [Extent12].[ID] ) AS [Join10] ON [Extent1].[ScholarAssessmentID] = [Join10].[ID5]
    INNER JOIN [dbo].[a2_Assessment] AS [Extent13] ON [Join10].[AssessmentID] = [Extent13].[ID]
    LEFT OUTER JOIN [dbo].[a2_AssessmentType] AS [Extent14] ON [Extent13].[AssessmentTypeID] = [Extent14].[ID]
    LEFT OUTER JOIN  (SELECT [Extent15].[ScholarAssessmentAnswerID] AS [ScholarAssessmentAnswerID], [Extent16].[Label] AS [Label]
        FROM  [dbo].[a2_ScholarAssessmentAnswerSelection] AS [Extent15]
        INNER JOIN [dbo].[a2_AssessmentAnswers] AS [Extent16] ON [Extent15].[AssessmentAnswerID] = [Extent16].[ID] ) AS [Join14] ON [Extent1].[ID] = [Join14].[ScholarAssessmentAnswerID]
    WHERE (1538 = [Join1].[AssessmentID]) AND ( NOT EXISTS (SELECT 
        1 AS [C1]
        FROM ( SELECT 
            [Extent18].[ID] AS [ID]
            FROM  [dbo].[a2_AssessmentQuestion] AS [Extent17]
            INNER JOIN [dbo].[a2_AssessmentQuestion] AS [Extent18] ON [Extent17].[PartID] = [Extent18].[PartID]
            WHERE [Extent1].[AssessmentQuestionID] = [Extent17].[ID]
        )  AS [Project1]
        WHERE ( NOT EXISTS (SELECT 
            1 AS [C1]
            FROM [dbo].[a2_ScholarAssessmentAnswer] AS [Extent19]
            WHERE ([Extent1].[ScholarAssessmentID] = [Extent19].[ScholarAssessmentID]) AND ([Extent19].[AssessmentQuestionID] = [Project1].[ID])
        )) OR (CASE WHEN ( EXISTS (SELECT 
            1 AS [C1]
            FROM [dbo].[a2_ScholarAssessmentAnswer] AS [Extent20]
            WHERE ([Extent1].[ScholarAssessmentID] = [Extent20].[ScholarAssessmentID]) AND ([Extent20].[AssessmentQuestionID] = [Project1].[ID])
        )) THEN cast(1 as bit) WHEN ( NOT EXISTS (SELECT 
            1 AS [C1]
            FROM [dbo].[a2_ScholarAssessmentAnswer] AS [Extent21]
            WHERE ([Extent1].[ScholarAssessmentID] = [Extent21].[ScholarAssessmentID]) AND ([Extent21].[AssessmentQuestionID] = [Project1].[ID])
        )) THEN cast(0 as bit) END IS NULL)
    ))
)  AS [Project6]
ORDER BY [Project6].[ID] ASC, [Project6].[ID2] ASC, [Project6].[ID1] ASC, [Project6].[ID3] ASC, [Project6].[ID5] ASC, [Project6].[ID7] ASC, [Project6].[ID6] ASC, [Project6].[ID8] ASC, [Project6].[ID9] ASC, [Project6].[ID11] ASC, [Project6].[ID10] ASC, [Project6].[ID12] ASC, [Project6].[ID13] ASC, [Project6].[ID4] ASC, [Project6].[C6] ASC

Tentei incluir o plano de execução, mas ultrapassei o limite de 30.000 caracteres.

O mais louco é que estou fornecendo AssessmentID = 1538, que é a informação de limitação mais útil na consulta, mas o plano de execução está ignorando esse fato e verificando quase todas as outras tabelas unidas, apenas filtrando por AssessmentID tipo de como uma reflexão tardia...

Tenho uma tabela Foocom os seguintes campos:

ID bigint not null identity(1,1),
SerializedValue nvarchar(max),
LongValue as TRY_CAST(SerializedValue as bigint)

Agora quero criar um índice em LongValue, para que eu possa pesquisar facilmente valores serializados que representam números.

create nonclustered index IX_Foo on Foo(LongValue);

Que cospe o seguinte erro para mim:

String ou dados binários seriam truncados.

Sim, existem dados em SerializedValue. Mas o que, por favor, pode ser truncado ao criar um índice em um campo computado?

Recebi um arquivo de exportação de bomba de dados DMP para importar para minha instância Oracle local. Eu tentei executar esta linha de comando:

impdp full=Y diretório=DATA_PUMP_DIR dumpfile=MyDumpFile.dmp logfile=import.log

Eu recebo os erros:

ORA-31655: nenhum objeto de dados ou metadados selecionado para o trabalho

ORA-39154: Objetos de esquemas externos foram removidos da importação

E nenhum dado é importado.

Pelo que pesquisei no Google, uma possível causa disso é que preciso especificar remap_schama. Mas não tenho ideia de qual é o nome do esquema no arquivo dmp. Alguma maneira fácil de descobrir?

EDIT: Não encontrei uma solução para esta questão, mas encontrei uma solução alternativa ... Rastreei o cara que fez o DMP e consegui o nome do esquema dele. Especificado remap_schemade acordo com sua definição, e Hey Presto!

Eu tenho um requisito comercial para ter um campo FK na TableAreferência TableB. Se houver um valor em TableBID, ele deve ser único, mas não é obrigatório, portanto pode haver vários registros com valores nulos.

É possível, de alguma forma, impor esse tipo de exclusividade no nível do banco de dados, usando um índice ou uma restrição?

Tenho duas máquinas, cada uma com uma instância padrão do SQL Server 2008 instalada; cada um exibindo um comportamento diferente.

• No PC1, quando executo sqlcmd -Lc, não vejo o PC1 na lista de servidores SQL na rede local quando o SQL Browser Service não está em execução. Quando inicio o serviço do navegador SQL, PC1 aparece na lista.
• No PC2, quando executo sqlcmd -Lc, vejo o PC2 na lista, independentemente de o SQL Browser Service estar ou não em execução. Se o SQL Browser Service estiver em execução, também vejo PC2\SQLEXPRESS.

Por que a instância SQL padrão do PC1 não aparece na lista de SQL Servers?

Eu tenho um problema intermitente com um pacote de instalação de software que instala nosso produto (escrito usando InstallShield/InstallScript). Durante o processo de instalação, reiniciamos o SQL Browser Service. Na maioria das vezes isso funciona bem. Mas, ocasionalmente - e não descobri como reproduzir isso de forma previsível - o serviço falha ao reiniciar e descubro em meu gerenciador de "Serviços" que o status do serviço está definido como "Desativado".

Alguma ideia do que estaria causando a desativação do serviço e como evitar que isso aconteça?

Tenho uma tabela grande (dezenas a centenas de milhões de registros) que dividimos por motivos de desempenho em tabelas ativas e de arquivo, usando um mapeamento de campo direto e executando um processo de arquivo todas as noites.

Em vários lugares do nosso código, precisamos executar consultas que combinam as tabelas ativas e arquivadas, quase invariavelmente filtradas por um ou mais campos (nos quais obviamente colocamos índices em ambas as tabelas). Por conveniência, faria sentido ter uma visão como esta:

create view vMyTable_Combined as
select * from MyTable_Active
union all
select * from MyTable_Archive

Mas se eu executar uma consulta como

select * from vMyTable_Combined where IndexedField = @val

ele fará a união em tudo , desde Active e Store antes de filtrar por @val, o que prejudicará o desempenho.

Existe alguma maneira inteligente de fazer com que as duas subconsultas da união visualizem cada filtro @valantes de criarem a união?

Ou talvez haja alguma outra abordagem que você sugeriria para alcançar o que estou procurando, ou seja, uma maneira fácil e eficiente de obter o conjunto de registros da união, filtrado pelo campo indexado?

EDIT: aqui está o plano de execução (e você pode ver os nomes reais das tabelas aqui):

Curiosamente, a tabela ativa está realmente usando o índice correto (além de uma pesquisa RID?), mas a tabela de arquivo está fazendo uma varredura na tabela!

Estou mantendo o código de outra pessoa. Há um procedimento armazenado que é executado uma vez por dia ou semana (dependendo da configuração), que migra vários registros de uma tabela ativa para um arquivo. Mas não é um verdadeiro arquivo, pois existem vários processos ativos que incluem a tabela de arquivos em consultas SQL, devidamente indexada para o efeito.

Agora a história dessa história é que a mesa de arquivamento foi crescendo e crescendo, e o SP de arquivamento começou a demorar muito. Então, Alguém decidiu que seria uma boa ideia no início do SP descartar todos os índices na tabela de arquivo e recriá-los no final. Claro, recriá-los também leva eras, mas sem dúvida não tanto quanto inserir os novos registros com os índices no lugar.

Esta situação grita para mim: " ISSO É PECADO! " Parece errado, errado, errado brincar com índices em tempo de execução. Tenho certeza de que não é uma situação incomum, então qual é a maneira "correta" de lidar com uma situação como essa?

Portanto, temos um site de cliente que está reclamando de um desempenho muito lento. Dei uma olhada e é óbvio que o problema é porque Somebody Else (grrrr) projetou uma tabela contendo mais de 20 milhões de registros sem um índice agrupado.

Agora quero criar um índice clusterizado nessa tabela - mas em meu ambiente de teste, meu create indexcomando está em execução há uma hora e ainda não foi concluído. O site do cliente é um chão de fábrica que funciona 24 horas por dia, 7 dias por semana e não pode perder uma hora de inatividade enquanto crio um índice.

Existe algum método com menos força bruta para criar o índice que terminará o trabalho rapidamente ou o fará de alguma maneira inteligente que não acabará totalmente com o desempenho do servidor enquanto estiver ocupado?

Estamos usando o SQL Server Enterprise Edition.