Quanto desempenho eu perco aumentando o número de viagens para o SQL Server?

Question

Eu tenho um aplicativo da web onde o banco de dados do servidor da Web e do SQL Server 2008 se senta em caixas diferentes no mesmo farm de servidores.

Se eu fizer um procedimento armazenado monolítico e quebrá-lo em vários processos armazenados menores, tornando o código cliente responsável por chamadas para vários procedimentos armazenados em vez de apenas um, e eu vou notar um desempenho significativo meu aplicativo da web?

---

.

informações adicionais:

Eu tenho um procedimento armazenado com várias centenas de linhas de código contendo lógica de decisão, instruções de atualização e, finalmente, uma instrução SELECT que retorna um conjunto de dados para o cliente.

Eu preciso inserir uma funcionalidade no código do cliente (nesse sentido, o código do cliente é o servidor da Web ASP que está chamando o servidor de banco de dados) que chama uma DLL de componente. No entanto, o procedimento armazenado está atualizando um conjunto de registros e retornando os dados udpated na mesma chamada, e meu código idealmente precisa ser chamado após As instruções de lógica de decisão e atualização são chamadas, mas antes < / em> Os dados são retornados ao cliente.

Para obter essa funcionalidade para funcionar, provavelmente vou ter que dividir o PROC armazenado existente em pelo menos duas partes: um protetor armazenado que atualiza o banco de dados e outro que recupera dados do banco de dados. Eu iria inserir meu novo código entre essas chamadas do PROP armazenado.

Quando eu olho para este problema, não posso deixar de pensar que, a partir de um ponto de vista de manutenção de código, seria muito melhor isolar Tudo da minha atualização e selecione declarações em finas Procs armazenados e deixe a lógica de negócios para o código do cliente. Dessa forma, sempre que precisar inserir funcionalidade ou lógica de decisão no meu código de cliente, tudo que eu preciso fazer é alterar o código do cliente em vez de modificar um enorme proc.

Embora o uso de procs armazenados fino possa ser melhor a partir de um ponto de vista de manutenção de código, quanta dor de desempenho eu experimentarei aumentando o número de viagens para o banco de dados? O resultado líquido para os dados é o mesmo, mas estou tocando no banco de dados com mais frequência. Como essa abordagem afeta o desempenho quando o aplicativo é dimensionado para lidar com a demanda?

Eu não sou um para colocar a otimização de desempenho acima de tudo mais, especialmente quando afeta a manutenção de código, mas eu não quero me atirar no pé e criar dores de cabeça quando o aplicativo da Web tiver que escalar.

Answer 1

Em geral, como regra geral, você deve fazer redondas para o SQL Server no mínimo.

O "hit" no servidor é muito caro, é realmente mais caro de se desviar a mesma operação em 3 partes, em seguida, fazendo 1 hit e tudo mais no servidor.

Em relação à manutenção, você pode chamar 1 PROP armazenado do cliente, tendo que o PROC ligue para outro 2 PROP.

Eu tinha um aplicativo com a lógica de pesquisa extrema, é isso que eu fiz para implementá-lo.

alguns resultados de benchmarking ... Eu tive um cliente um pouco de volta que tinha servidores caindo e desmoronando, quando nós verificamos o problema, muitas rodas para o SQL Server, quando minimizá-lo, os servidores voltaram ao normal.

Answer 2

Isso afetará.Usamos um servidor Weblogic em que toda a lógica de negócios está no AppServer conectado a um banco de dados DB / 2.Nós usamos principalmente grãos de entidade em nosso projeto e para a maioria das chamadas de serviço comercial faz várias viagens para o banco de dados sem efeitos colaterais visíveis.(Nós ajustamos algumas consultas para ser multi-table quando necessário).

Isso realmente depende do seu aplicativo.Você precisará de referência.

Answer 3

Um servidor SQL bem configurado em um bom hardware pode processar muitos milhares de transações por segundo.

Na verdade, quebrando um grande procedimento armazenado pode ser benéfico, porque você só pode ter um plano de consulta em cache por lote.Quebrar em vários lotes significa que cada um deles obterá seu próprio plano de consulta.

Você definitivamente deve errar do lado da manutenção de código, mas a referência para ter certeza.

Dado que a paisagem do plano de consulta vai quiser, você deve estar preparado para atualizar seus índices, talvez criando diferentes índices de cobertura.

Answer 4

Em essência, esta questão está intimamente relacionada ao acoplamento apertado vs. solto.

No início: você sempre pode levar o procedimento armazenado monolítico e quebrar em vários processos armazenados menores, que são chamados por um procedimento armazenado , fazendo o código do cliente apenas responsável apenas por chamarum procedimento armazenado.

A menos que o cliente faça alguma coisa (alterar os dados ou fornecer status ao usuário), provavelmente não recomendaria mover várias chamadas para o cliente, já que você seria mais firmemente acoplando o cliente à ordem de operações para o procedimento armazenado semum aumento significativo de desempenho.

De qualquer forma, eu iria revezar e ajustar de lá.