John's questions

Eu sei que esta é uma ideia estúpida, mas estou tendo dificuldade em encontrar uma solução melhor agora. Preciso executar vários procedimentos armazenados em sql diariamente e, em seguida, executar um script powershell para acionar um aplicativo externo para extrair alguns dados do servidor sql

A segunda etapa precisa passar o nome de usuário e a senha como argumentos. Esses dois servidores não fazem parte do mesmo domínio do Windows, portanto, qualquer confiança no nível do usuário não é possível, apenas o envio explícito de um nome de usuário e senha nos scripts do powershell funcionará.

O servidor é SQL Server 2008, e não temos SSIS disponível como opção. O próprio servidor sql é restrito a apenas 3 usuários hoje, portanto, ter a senha em texto simples como uma etapa de comando do powershell em um trabalho de agente não obteria nenhum privilégio de usuário que eles ainda não possuem hoje, mas isso ainda parece como se devesse haver uma maneira melhor que estou perdendo.

Estou procurando o saldo total de todas as contas que tiveram um saldo negativo em um ponto específico no tempo. Eu já tenho o código abaixo e funciona, mas funciona horrivelmente.

A tabela de transações contém 20 milhões de linhas. A consulta abaixo leva cerca de 30 segundos, o que não é ruim, mas há uma segunda parte em que preciso repetir @report_date no primeiro dia de cada mês desde o início do banco de dados, o que aumenta o tempo de execução para aproximadamente 30 minutos.

Isso está no MSSQL2008 e não estou recebendo nenhum aviso de índices ausentes no plano de execução, mas suspeito que meu problema ainda esteja com os índices, então estou intencionalmente deixando-os fora daqui.

CREATE TABLE transactions(
    transaction_id int,
    account_id int,
    department_id int,
    location_id int,
    post_date date,
    amount money
    );

SELECT
    t2.department_id,
    t2.location_id,
    SUM(t2.credit_balances)
FROM
    (
    SELECT
        t1.department_id,
        t1.location_id,
        t1.account_id,
        SUM(t1.amount) as credit_balances
    FROM
        transactions t1
    WHERE
        t1.post_date < @report_date
    GROUP BY
        t1.department_id,
        t1.location_id,
        t1.account_id
    HAVING
        SUM(t1.amount) < 0
    ) t2
GROUP BY
    t2.department_id,
    t2.location_id;

A tabela contém 38 department_id,location_idcombinações distintas e 4,5 milhões de arquivos department_id,location_id,account_id.

Eu tenho duas tabelas no Sql Server 2008 que se parecem com isto:

Transaction_Details:
    Dataset,
    Department,
    Charge_ID,
    Transaction_Type,
    dos_month,
    post_month,
    amount


Charge_Summary
    Dataset,
    Department,
    Charge_ID,
    dos_month,
    Ins1_Category
    

A saída que estou procurando seria mais ou menos assim: Dataset, Department, Ins1_Category, dos_month, Post_Month, Total_Payments, Total_Charges, Previous_Balance -- Definido como valor total para todas as transações correspondentes com um post_month anterior ao mês atual

O SQL que estou usando abaixo fornece a saída esperada, mas há uma busca de índice no plano de execução que ocupa mais de 90% do custo. Isso está em uma operação de datawarehouse, portanto, não há nenhuma outra atividade no servidor além dessa consulta, nenhuma outra leitura ou gravação com que se preocupar. O tempo de execução de aproximadamente 30 minutos é aceitável para o que está sendo usado, mas ainda gostaria de alguns conselhos se houver uma maneira melhor de fazer isso.

SELECT
    t1.Dataset,
    t1.Department,
    c1.Ins1_Category,
    t1.dos_month,
    t1.post_month,
    SUM(case
            when t1.transaction_type = 'payment' THEN t1.amount
            ELSE 0
        END
        ) AS total_payments,
    SUM(case
            when t1.transaction_type = 'adjustment' THEN t1.amount
            ELSE 0
        END
        ) AS total_adjustments,
    SUM(case
            when t1.transaction_type = 'charge' THEN t1.amount
            ELSE 0
        END
        ) AS total_charges,
    (
        SELECT
            SUM(t2.amount)
        FROM
            Transaction_Details t2
        LEFT JOIN
            Charge_Summary c2
        ON
            t2.Dataset = c2.Dataset AND
            t2.Charge_ID = c2.Charge_ID
        WHERE
            t1.Dataset = t2.Dataset AND
            t1.Department = t2.Department AND
            t1.dos_month = t2.dos_month AND
            t1.post_month > t2.post_month AND
            t2.Charge_ID IS NOT NULL AND
            c2.Ins1_Category = c1.Ins1_Category
    ) as previous_balance
FROM
    Transaction_Details t1
LEFT JOIN
    Charge_Summary c1
ON
    t1.Dataset = c1.Dataset AND
    t1.Charge_ID = c1.Charge_ID
WHERE
    t1.Charge_ID is not null
GROUP BY
    t1.Dataset,
    t1.Department,
    c1.Ins1_Category,
    t1.dos_month,
    t1.post_month

Temos um processo ETL noturno que envolve dados de várias fontes diferentes sendo nivelados e carregados em uma tabela completamente desnormalizada no SQL Server 2008 para geração de relatórios. O índice clusterizado na tabela consiste em uma chave composta de quatro colunas.

Devido à origem dos dados, não há realmente nenhuma maneira de carregar os dados na mesma ordem do índice clusterizado. Manter o índice ativo durante o carregamento ou descartá-lo/reconstruí-lo após o carregamento leva mais tempo do que o próprio carregamento sem um índice. Por outro lado, nenhum cluster com índices não clusterizados adequados ainda pode resultar em algumas consultas de relatórios que levam horas para serem processadas.

As únicas coisas em que consigo pensar para acelerar isso seriam particionar e colocar mais hardware no problema. Estou perdendo alguma coisa que ajudaria?

Tenho um data warehouse que passa por uma atualização completa todas as noites, o que pode levar cerca de uma hora para processar 16 milhões de linhas/25 gigas de dados e estamos procurando maneiras de reduzir esse tempo sem usar a abordagem incremental.

O formato básico de nossas consultas é o seguinte, apenas retirei cerca de 20 junções e mais de 30 colunas que também seriam incluídas. As colunas e junções removidas são muito diretas, sem agregação, subconsultas ou outros tipos de cálculo envolvidos. O que resta é a tabela de fatos principal (First_Source_Table) e o ponto de dados mais problemático a ser coletado. Second_Source_Table consiste em muitos registros para cada Account_ID, mas queremos incluir apenas o primeiro registro para cada Account_ID.

Agora minhas restrições. Isso em um ambiente replicado no SQL Server 2008. Infelizmente, não tenho controle sobre as tabelas de origem e, embora possa adicionar novos índices a elas, elas serão perdidas no dia seguinte. Eu tentei calcular uma tabela intermediária de Second_Source_Table antes de fazer a tabela completa, mas como isso precisaria ser recalculado a cada noite, isso não teve um impacto material no tempo de cálculo geral.

O código abaixo funciona, mas se você observar o plano de execução e IO Stats, a lógica associada a Second_Source_Table constitui cerca de 80% de todos os recursos usados, mas alterar esse campo para NULL apenas reduz o tempo de execução pela metade. Também vou apontar novamente que, sendo um ambiente replicado, não há problemas para se preocupar com o bloqueio ou outros usuários gravando nas tabelas em que estamos.

INSERT INTO
    New_Table
SELECT
    First_Source_Table.Account_ID,
    (
        select
            top 1
            Second_Source_Table.Code
        FROM
            Second_Source_Table
        WHERE
            Second_Source_Table.Account_ID = First_Source_Table.Account_ID
        ORDER BY
            Second_Source_Table.ID
    ) as Code
FROM
    First_Source_Table

Estou lidando com uma situação no SQL Server 2008 em que cada cliente é configurado como seu próprio banco de dados, com cada banco de dados tendo estruturas de tabelas idênticas.

Eu tenho uma consulta que seleciona cerca de 20 tabelas diferentes em um banco de dados e insere os registros em um banco de dados de relatórios. O que gostaríamos de fazer é repetir esse processo para cada banco de dados, de modo que todas as informações de relatórios em todos os bancos de dados de clientes estejam contidas em um banco de dados de relatórios consolidado.

A maneira "fácil" seria apenas copiar/colar o código e localizar/substituir todos os nomes do banco de dados para que o script seja executado em todos os clientes. Existe alguma maneira melhor do que isso?

Eu tenho uma visão materializada na Postgres 9.3qual gostaria de atualizar com novas colunas. No entanto, outras exibições materializadas também dependem dessa exibição, e a mensagem de erro indica que não é possível descartar uma exibição quando outros objetos dependem dela.

ERRO: não é possível descartar a visualização materializada last_charges porque outros objetos dependem dela

Também aparece na documentação que a palavra-chave REPLACE não é válida para uma visualização materializada. Existe algum atalho além de descartar todos os objetos dependentes e reconstruir cada um?

Eu tenho uma tabela de cerca de 15 milhões de registros. Sempre que as informações sobre um charge_id específico são alteradas, uma nova linha é adicionada com o timestamp atual e as alterações. Isso resulta em várias linhas com o mesmo charge_id e colunas hierárquicas relacionadas. Isso não é controlado por mim e não pode ser alterado, além disso, gostamos de ter o histórico disponível para consulta.

A exibição abaixo destina-se a identificar a entrada mais recente para cada charge_id e criar uma tabela simples de par de chave-valor para junção. A visualização funciona bem, mas o tempo de execução é horrível. Eu tentei algumas tentativas em um índice para acelerar as coisas, mas cada vez parece que o postgres está ignorando o índice e verificando tudo de qualquer maneira. Também devo observar que a maioria das consultas em que nos unimos a essa exibição serão agregações de tabela completa, agrupadas por 2 a 5 dimensões diferentes na tabela de cobranças.

Minha pergunta especificamente é o que posso fazer para acelerar o tempo de execução nessa exibição específica?

CREATE VIEW current_charge_ids AS 
(
SELECT
    c2.id,
    c2.charge_id,
    t1.last_post_date
FROM
    charges c2
LEFT JOIN
    (
        SELECT
            c1.client,
            c1.practice,
            c1.account_id,
            c1.encounter_id,
            c1.charge_id,
            max(c1.post_date) AS last_post_date
        FROM
            charges c1
        GROUP BY
            c1.client,
            c1.practice,
            c1.account_id,
            c1.encounter_id,
            c1.charge_id
    ) t1
ON
    c2.client = t1.client AND
    c2.practice = t1.practice AND
    c2.account_id = t1.account_id AND
    c2.encounter_id = t1.encounter_id AND
    c2.charge_id = t1.charge_id AND
    c2.post_date = t1.last_post_date
);