Johnny Bones's questions

Tenho tabelas com milhões (possivelmente bilhões) de linhas, então realmente preciso ser eficiente com a consulta.

Nesta consulta, estou unindo várias tabelas. O segmento em questão é:

LEFT JOIN 
    dbo.GCSOCTPS dbo_GCSOCTPS ON (GC_TBMED.MED_CLASS_NUM = dbo_GCSOCTPS.CLASS_NUM) 
                              AND (GC_TBMED.MED_SOC_NUM = dbo_GCSOCTPS.SOC_NUM)
                              AND (GC_TBMED.MED_EFF_DATE = dbo_GCSOCTPS.EFF_DATE)
                              AND (GC_TBMED.MED_CANC_DATE = dbo_GCSOCTPS.CANC_DATE)) 

GC_TBMEDtem datas no DATEformato, dbo_GCSOCTPStem datas no DATETIMEformato. Infelizmente, devido à forma como nossa empresa usa dados, não posso alterar isso.

Qual seria a maneira mais eficiente de comparar essas colunas? CAST? CONVERT? Já vi pessoas convertendo para o formato de texto e comparando dessa forma. Espero que alguém possa me orientar com base em sua experiência com conjuntos de dados muito grandes.

Se eu executar este bloco de código, obtenho um valor para HDHPQ:

SELECT TOP 200 
    HDHPQ,
    SOC_NUM, 
    EFF_DATE,
    CLASS_NUM,
    CANC_DATE
FROM
    dbo.GCSOCTPS
WHERE
    SOC_NUM = '25521'
    AND CLASS_NUM = '37'
    AND CANC_DATE IS NULL;

Isto é retornado:

HDHPQ    SOC_NUM    EFF_DATE                  CLASS_NUM    CANC_DATE 
N         25521    2025-01-01 00:00:00.000      37         NULL

Se eu executar esse bloco de código, também receberei dados retornados:

SELECT TOP 200 
    MED_SOC_NUM,
    MED_EFF_DATE,
    MED_CLASS_NUM,
    MED_CANC_DATE
FROM
    [dbo].[AS_tblTBMED] GC_TBMED
WHERE 
    GC_TBMED.MED_SOC_NUM = '25521'
    AND GC_TBMED.MED_CLASS_NUM = '37'
    AND GC_TBMED.MED_CANC_DATE IS NULL;

Isso é retornado:

MED_SOC_NUM    MED_EFF_DATE    MED_CLASS_NUM    MED_CANC_DATE
25521        2025-01-01        37                NULL

Cada um deles retorna uma linha. Preciso juntá-los para obter todos os dados da segunda consulta e o valor de HDHPQ da primeira consulta.

Então eu executo esta consulta:

SELECT DISTINCT TOP 200 
    dbo_GCSOCTPS.HDHPQ,
    dbo_GCSOCTPS.SOC_NUM, 
    dbo_GCSOCTPS.EFF_DATE,
    dbo_GCSOCTPS.CLASS_NUM,
    dbo_GCSOCTPS.CANC_DATE,
    GC_TBMED.MED_SOC_NUM,
    GC_TBMED.MED_EFF_DATE,
    GC_TBMED.MED_CLASS_NUM,
    GC_TBMED.MED_CANC_DATE
FROM
    [dbo].[AS_tblTBMED] GC_TBMED
LEFT JOIN 
    dbo.GCSOCTPS dbo_GCSOCTPS ON (GC_TBMED.MED_CLASS_NUM = dbo_GCSOCTPS.CLASS_NUM) 
                              AND (GC_TBMED.MED_SOC_NUM = dbo_GCSOCTPS.SOC_NUM)
                              AND (GC_TBMED.MED_EFF_DATE = CAST(dbo_GCSOCTPS.EFF_DATE as DATE))
                              AND (GC_TBMED.MED_CANC_DATE = CAST(dbo_GCSOCTPS.CANC_DATE as DATE)) 
WHERE
    GC_TBMED.MED_SOC_NUM = '25521'
    AND GC_TBMED.MED_CLASS_NUM = '37'
    AND GC_TBMED.MED_CANC_DATE IS NULL
    AND dbo_GCSOCTPS.EFF_DATE >= '2025-01-01';

E um conjunto de registros vazio é retornado. Se eu comentar as duas datas na junção, obtenho dados. Portanto, presumo que os campos de data não estejam sendo equalizados corretamente, já que são iguais e, portanto, eu deveria obter dados se eles fossem incluídos na consulta.

Tenho uma consulta no SQL Server que tenta encontrar combinações duplicadas de colunas. Parece algo assim:

SELECT SOC_NUM, CLS_NUM, CAT_NUM, QERROR, Sum(1) as CNT
FROM dbo.AS_Data_Disjoint_RPTS (nolock)
WHERE ReportName='NBN_Errors' AND QERROR IS NOT NULL
GROUP BY SOC_NUM, CLS_NUM, CAT_NUM, QERROR
ORDER BY SOC_NUM, CLS_NUM, CAT_NUM

Ele produz um conjunto de dados como este:

SOC_NUM         CLS_NUM      CAT_NUM        QERROR              CNT
25113              25         TX9AW          NBN_ID_ERROR       4
25113              25         WI913          NBN_ID_ERROR       4
25113              26         TX9AW          NBN_ID_ERROR       4
25113              26         WI913          NBN_ID_ERROR       4
25113              27         TX9AW          NBN_ID_ERROR       4
25113              27         WI913          NBN_ID_ERROR       4
25257               9         TX9AW          NBN_ID_ERROR       5
25257               9         TX9AW          No Error           1
25257              10         TX9AW          NBN_ID_ERROR       5
25257              10         TX9AW          No Error           1
25257              11         TX9AW          NBN_ID_ERROR       5
25257              11         TX9AW          No Error           1
25257              12         TX9AW          NBN_ID_ERROR       5
25257              12         TX9AW          No Error           1

Como você pode ver pelos agrupamentos, SOC NUM 25113 e CLS NUM 25 não têm IDs NTWRK em comum e seriam ignorados:

SOC_NUM         CLS_NUM      CAT_NUM        QERROR              CNT
25113              25         TX9AW          NBN_ID_ERROR       4
25113              25         WI913          NBN_ID_ERROR       4

Entretanto, SOC NUM 25257, CLS NUM 9 tem registros para NTWRK ID TX9AW que são No Error e NBN ID ERROR:

SOC_NUM         CLS_NUM      CAT_NUM        QERROR              CNT
25257               9         TX9AW          NBN_ID_ERROR       5
25257               9         TX9AW          No Error           1

Preciso criar uma consulta PIVOT que se pareça com esta:

SOC_NUM    CLS_NUM        CAT_NUM       Error 1                   Error 2
25113        25            TX9AW        NBN ID ERROR              NULL
25113        25            WI913        NBN ID ERROR              NULL
25257         9            TX9AW        NBN ID ERROR              No Error

Teria todas as combinações SOC_NUM/CLS_NUM/CAT_NUM, não apenas as três acima. Simplifiquei o conjunto de dados esperado para restrições de tempo/espaço.

O objetivo disso é comparar os resultados com um grande conjunto de dados e sinalizar todos os registros onde há 2 erros para qualquer combinação SOC_NUM/CLS_NUM/CAT_NUM. Imaginei que se eu pegasse os resultados desse PIVOT, eu poderia filtrar por quaisquer registros onde ERROR 2 não fosse NULL e eu teria todas as combinações que eu precisava encontrar.

Alguém pode me ajudar a construir a consulta PIVOT necessária para concluir esta tarefa? Não tenho NENHUMA compreensão da construção PIVOT, simplesmente não consigo entender isso.

Tenho o seguinte código que deve avisar ao usuário que uma pergunta foi enviada e, em seguida, atualizar a página:

protected void ButtonSubmitQuestionClick(object sender, EventArgs e)
{
    -- A whole bunch of code that does stuff --

    //close window
    ScriptManager.RegisterStartupScript(Page, Page.GetType(), "alert", "alert('Your question has been submitted!');window.close();", true);
    Response.Redirect("~/QA_QuestionIntake.aspx");
}

O problema é que o pop-up nunca aparece, presumivelmente porque a página atualiza imediatamente. Como posso fazer o código pausar no alerta até que o usuário pressione um botão?

Estou tentando limpar/redefinir todos os controles de caixa de texto e dropdown em uma página, depois que um usuário seleciona o botão "Enviar". Gostaria de fazer isso programaticamente, então se outros controles forem adicionados/removidos depois, ainda funcionará.

Eu tenho isso, parte do qual peguei emprestado de outra resposta semelhante no SO:

protected void ResetAllControls()
{
    foreach (Control c in this.Controls)
    {
        if (c is TextBox)
        {
            TextBox tb = (TextBox)c;
            if (tb != null)
            {
                tb.Text = string.Empty;
            }
        }

        if (c is DropDownList)
        {
            DropDownList ddl = (DropDownList)c;
            ddl.SelectedIndex = -1;
        }
    }
}

c resolve para System.Web.UI.LiteralControl, e nunca resolve para Textbox ou DropDownList, então não redefine nada na página. Alguém pode me dizer o que estou esquecendo?