db2's questions

Estamos nos estágios iniciais de planejamento de um novo ambiente de banco de dados para nossos aplicativos ERP e CRM (de terceiros). O objetivo é usar Always On Availability Groups para HA, patches contínuos, secundários somente leitura, etc. Queremos usar failover automático, sem que o aplicativo cliente precise estar ciente do HA.

Temos um servidor físico com especificações bastante massivas. Ele estará executando duas instâncias do SQL Server: uma para o aplicativo ERP que requer o SQL Server 2016 e uma para o aplicativo CRM que é mais adequado até 2017 (e isso também nos permite conceder direitos de administrador de sistema ao suporte do fornecedor do aplicativo CRM sem afetar a aplicação ERP).

Também temos uma infraestrutura ESX bastante madura e queremos usar algumas VMs como nós de failover. Eles não serão construídos de forma tão decadente quanto o servidor primário, mas garantiremos um desempenho aceitável para interrupções curtas ou janelas de manutenção no servidor primário.

Meu pensamento inicial era ter duas VMs de failover: uma para a instância do ERP e outra para o CRM. Não parece que um único servidor possa ser membro de vários clusters de failover do Windows, ou seja, não consigo fazer um cluster ERP com a ERP VM e o servidor físico, além de um cluster CRM com a CRM VM e o mesmo servidor físico .

Se, em vez disso, eu construísse um cluster de três nós e controlasse em quais nós cada instância pode ser executada, estaria provocando efeitos colaterais desagradáveis? Meu principal medo é que a votação do quorum possa ficar um pouco estranha se começarmos a adicionar mais servidores de banco de dados ao cluster, e podemos ter uma instância inativa inesperadamente, mesmo que todos os nós que podem hospedar essa instância ainda estejam ativos. Isso é mesmo um risco, e existem maneiras razoáveis ​​de mitigá-lo? Existem complicações possíveis suficientes para que eu use uma única VM mais robusta que possa lidar com as duas instâncias?

tl; dr:

Eu estaria me dando um tiro no pé construindo um cluster de três nós onde a instância 1 só pode ser executada nos servidores A e B e a instância 2 só pode ser executada nos servidores A e C? Devo apenas criar um cluster de dois nós (mais o membro do quorum) e garantir que o servidor B possa lidar com as duas instâncias do SQL Server?

Estou trabalhando na preparação/teste de migração do nosso ERP e outros sistemas auxiliares para um novo servidor de banco de dados. Isso envolverá a restauração de backups de banco de dados do servidor antigo para o novo.

Por conveniência, gostaria de poder usar um script/procedimento armazenado para restaurar um banco de dados simplesmente apontando para um ou mais diretórios contendo os arquivos de backup (combinação de completo, diferencial e log) e, opcionalmente, especificando uma hora STOPAT, ou omitindo-a e restaurando para a hora mais recente possível, considerando os backups presentes. Eu também precisaria especificar novos locais de arquivos (a opção MOVE), explicitamente ou, mais geralmente, "colocar todos os arquivos de dados aqui e todos os arquivos de log aqui". A ferramenta deve examinar todos os arquivos nos diretórios fornecidos e determinar quais precisam ser restaurados para atingir o tempo de destino.

A ferramenta de restauração da GUI no Management Studio pode fazer tudo isso, mas isso obviamente não pode ser incluído em um script. Eu gostaria de poder escrever um script de migração geral que seria conceitualmente semelhante a este:

EXEC master..RestoreDB
    @database='ERPSysDB',
    @source='\\oldserver\Backup\oldserver\ERPSysDB\FULL,\\oldserver\Backup\oldserver\ERPSysDB\DIFF,\\oldserver\Backup\oldserver\ERPSysDB\LOG',
    @datadir='D:\SQLServer\DATA',
    @logdir='L:\SQLServer\DATA';

--Do various cleanup/post processing steps in ERPSysDB here

EXEC master..RestoreDB
    @database='ERPCompanyDB',
    @source='\\oldserver\Backup\oldserver\ERPCompanyDB\FULL,\\oldserver\Backup\oldserver\ERPCompanyDB\DIFF,\\oldserver\Backup\oldserver\ERPCompanyDB\LOG',
    @datadir='D:\SQLServer\DATA',
    @logdir='L:\SQLServer\DATA';

--More post-processing in ERPCompanyDB here

--Now restore a test copy of the database that we don't back up directly on the production server,
--using production database backups instead:
EXEC master..RestoreDB
    @database='ERPCompanyDB',
    @restoreas='ERPCompanyTestDB',
    @source='\\oldserver\Backup\oldserver\ERPCompanyDB\FULL,\\oldserver\Backup\oldserver\ERPCompanyDB\DIFF,\\oldserver\Backup\oldserver\ERPCompanyDB\LOG',
    @stopat='2018-11-01T08:00:00'
    @with='MOVE ''ERPDataFile'' TO ''D:\SQLServer\DATA\ERPCompanyTestDB.mdf'', MOVE ''ERPLogFile'' TO ''L:\SQLServer\DATA\ERPCompanyTestDB.ldf''';

--Additional post-processing, database restores, etc...

Existem ferramentas existentes que fornecem essa funcionalidade? Estou preparado para escrever o meu próprio, mas seria um pedaço de código bastante complexo (particularmente tratamento de erros/exceções), então não quero reinventar a roda. Eu preferiria que isso fosse utilizável no T-SQL, ou seja, não nos cmdlets do PowerShell, mas os procedimentos armazenados CLR seriam bons (e possivelmente a maneira mais fácil/melhor de implementar isso).

Precisamos fazer alguns relatórios sobre valores que geralmente são strings mistas de números e letras que precisam ser classificados 'naturalmente'. Coisas como, por exemplo, "P7B18" ou "P12B3". @As strings serão principalmente sequências de letras e depois números alternados. O número desses segmentos e o comprimento de cada um podem variar, no entanto.

Gostaríamos que as partes numéricas deles fossem classificadas em ordem numérica. Obviamente, se eu manusear esses valores de string diretamente com ORDER BY, então "P12B3" virá antes de "P7B18", já que "P1" é anterior a "P7", mas eu gostaria do contrário, já que "P7" precede naturalmente "P12".

Eu também gostaria de poder fazer comparações de intervalo, por exemplo, @bin < 'P13S6'ou algo assim. Não preciso lidar com ponto flutuante ou números negativos; estes serão estritamente números inteiros não negativos com os quais estamos lidando. Os comprimentos das strings e o número de segmentos podem ser arbitrários, sem limites superiores fixos.

Em nosso caso, o uso de maiúsculas e minúsculas não é importante, embora, se houver uma maneira de fazer isso com reconhecimento de agrupamento, outras pessoas possam achar isso útil. A parte mais feia de tudo isso é que eu gostaria de poder fazer a ordenação e a filtragem de intervalo na WHEREcláusula.

Se eu estivesse fazendo isso em C#, seria uma tarefa bastante simples: faça algumas análises para separar o alfa do numérico, implemente IComparable e basicamente pronto. O SQL Server, é claro, não parece oferecer nenhuma funcionalidade semelhante, pelo menos até onde eu sei.

Alguém conhece algum bom truque para fazer isso funcionar? Existe alguma capacidade pouco divulgada de criar tipos CLR personalizados que implementam IComparable e se comportam conforme o esperado? Também não me oponho a truques de XML estúpidos (consulte também: concatenação de lista) e também tenho funções de wrapper de correspondência/extração/substituição de CLR regex disponíveis no servidor.

EDIT: Como um exemplo um pouco mais detalhado, gostaria que os dados se comportassem assim.

SELECT bin FROM bins ORDER BY bin

bin
--------------------
M7R16L
P8RF6JJ
P16B5
PR7S19
PR7S19L
S2F3
S12F0

isto é, divida as strings em tokens de todas as letras ou todos os números e classifique-os alfabeticamente ou numericamente, respectivamente, com os tokens mais à esquerda sendo o termo de classificação mais significativo. Como mencionei, é fácil no .NET se você implementar IComparable, mas não sei como (ou se) você pode fazer esse tipo de coisa no SQL Server. Certamente não é algo que eu já encontrei em 10 ou mais anos trabalhando com isso.

Estou configurando um FileTable para permitir que os usuários coloquem rapidamente alguns arquivos de relatório em PDF em um banco de dados para pesquisa posterior por meio de um aplicativo de intranet (a ser criado posteriormente). Classificar as permissões necessárias é um pouco desafiador e estou encontrando alguns obstáculos.

Primeiro, confirmei que eu (com privilégios de administrador de sistema) posso adicionar e remover arquivos do compartilhamento sem problemas, portanto, pelo menos, a FileTable é funcional.

Adicionei um usuário final a um grupo do AD, criei um logon do Windows no SQL Server para esse grupo, mapeei-o para um usuário do banco de dados e concedi a esse usuário permissões de seleção, inserção, atualização e exclusão na FileTable. O usuário saiu do computador e fez login novamente para garantir que o grupo ao qual o adicionei esteja no token de autenticação.

Ele pode acessar o compartilhamento de fluxo de arquivos base para a instância ( \\servername\FileStream), mas quando tenta ir mais fundo no diretório específico do banco de dados ( \\servername\FileStream\DatabaseFileStreamDirectoryName), ele recebe um erro de permissão ("Você não tem permissão para acessar..."). A mesma coisa se ele tentar acessar o caminho FileTable diretamente ( \\servername\FileStream\DatabaseFileStreamDirectoryName\PDFReports).

Então, qual é a maneira correta de conceder acesso para que os usuários possam navegar até o subdiretório de compartilhamento para um banco de dados específico, ver os diretórios lá para FileTables e, finalmente, navegar/acessar arquivos dentro das FileTables? Aparentemente, é mais do que apenas um mapeamento de usuário no banco de dados e permissões de seleção/inserção/atualização/exclusão na tabela, e não estou encontrando muita documentação clara sobre isso até agora.

Aqui está o código (ligeiramente anônimo) que usei para configurar isso:

USE master
GO
ALTER DATABASE AppData ADD FILEGROUP FS CONTAINS FILESTREAM
ALTER DATABASE AppData ADD FILE ( NAME = N'FS', FILENAME = N'S:\Filestream\AppData\FS' ) TO FILEGROUP [FS]
ALTER DATABASE AppData SET SINGLE_USER WITH ROLLBACK IMMEDIATE
ALTER DATABASE AppData SET FILESTREAM( DIRECTORY_NAME = N'AppData' ) WITH NO_WAIT
ALTER DATABASE AppData SET MULTI_USER
GO
USE AppData
GO
CREATE TABLE PDFReports AS FileTable WITH (FileTable_Directory = 'PDFReports')

GRANT SELECT, INSERT, UPDATE, DELETE ON PDFReports TO [MyDomain\App Operators]

Para encurtar a história, tenho uma visão chamada vwRelatives que usa recursão CTE para construir árvores genealógicas. Destina-se a ser consultado por uma única pessoa de cada vez.

Isso é executado em cerca de um quarto de segundo:

SELECT * FROM vwRelatives WHERE person_id = 5

Isso (a forma como a consulta é executada no aplicativo) leva mais de 4,5 segundos:

exec sp_executesql N'SELECT * FROM vwRelatives WHERE person_id = @P1',N'@P1 int',5

(Observe que simplifiquei um pouco a consulta. A coisa real tem uma lista de colunas explícita e um ORDER BY, mas a WHEREsemântica é a mesma. Obtenho os mesmos sintomas com qualquer uma das versões.)

Muito provavelmente o SQL Server consegue levar person_id = 5em conta na hora de criar um plano de execução para a primeira query, mas parametrizar isso está fazendo com que toda a view seja executada e depois filtrada por person_id.

Então pensei em criar um guia de plano. E agora tenho dois problemas.

Estes são os passos que estou dando, que parecem não surtir efeito.

Primeiro, execute a consulta 'boa' para colocá-la no cache do plano...

SELECT * FROM vwRelatives WHERE person_id = 5

...em seguida, execute as etapas padrão para transformá-lo em um guia de plano...

--Get the 'good' plan
SET @xml_showplan = (
    SELECT query_plan
    FROM sys.dm_exec_query_stats AS qs 
        CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS st
        CROSS APPLY sys.dm_exec_text_query_plan(qs.plan_handle, DEFAULT, DEFAULT) AS qp
        WHERE st.text LIKE N'SELECT * FROM vwRelatives WHERE person_id = 5'
)

--Apply a plan guide to the meat of the sp_executesql query
EXEC sp_create_plan_guide 
    @name = N'vwRelatives_Test_Plan_Guide', 
    @stmt = N'SELECT * FROM vwRelatives WHERE person_id = @P1', 
    @type = N'SQL',
    @module_or_batch = NULL, 
    @params = N'@P1 int', 
    @hints = @xml_showplan;

Isso é concluído com êxito, mas quando executo a instrução sp_executesql original novamente, ainda leva 4,5 segundos. Tenho o Profiler em execução e os eventos Plan Guide Success e Plan Guide Unsuccessful estão selecionados. Nenhum desses eventos aparece no rastreamento.

O que estou fazendo de errado que está impedindo o SQL Server de ver este guia de plano como uma correspondência para a consulta sp_executesql?

Estou trabalhando na indexação e particionamento de uma única tabela de data warehouse que pesa cerca de 500 GB. A tabela é um heap, tem mais de cem TEXTcolunas e a TEXT_IN_ROWopção está habilitada. Não fui eu que desenhei esta mesa e não tenho capacidade para a alterar num futuro imediato.

Fui encarregado de particioná-lo. Estamos lidando com isso usando uma cópia do banco de dados em um servidor de teste. Ele pode enviar cerca de 2 GB por segundo para as matrizes SSD RAID, portanto, a E/S não é um gargalo significativo e possui 16 núcleos (2 nós NUMA) e 64 GB de RAM.

Minha abordagem é desabilitar todos os índices não clusterizados, criar uma função de partição e esquema de partição (cerca de 12 partições, todas no grupo de PRIMARYarquivos - eles estão usando isso para permitir a manutenção contínua e fornecer mais inserções localizadas para ETL noturno, e não para distribuir I /O), crie um índice clusterizado para a tabela usando esse esquema de partição.

Estou criando o índice clusterizado e particionando a tabela da seguinte forma:

CREATE CLUSTERED INDEX CX_DailyTable ON DailyTable (LoadDate, SeqNumber) 
  WITH (SORT_IN_TEMPDB = ON) ON monthly_on_primary (LoadDate)

Obviamente, está demorando muito (3 horas até este post) e certamente não espero que seja rápido. O que me preocupa um pouco é que o tempdb agora está empurrando quase 1 TB e subindo constantemente, apesar da tabela atual ter cerca de metade desse tamanho. Os documentos do MS que li sugerem que o uso do espaço tempdb deve ser do tamanho da tabela final/índice clusterizado.

http://msdn.microsoft.com/en-us/library/ms188281.aspx

Se SORT_IN_TEMPDB for definido como ON, deve haver espaço livre suficiente em tempdb para armazenar as execuções de classificação e espaço livre suficiente no grupo de arquivos de destino para armazenar a estrutura de índice final. As execuções de classificação contêm as linhas folha do índice.

Suas estimativas estão incorretas? O tempdb está sendo usado para muito mais do que apenas as execuções de classificação? Ou a criação desse índice clusterizado está dobrando de alguma forma o tamanho da tabela? (Parece bastante improvável; é uma tabela bastante ampla e estimo que estamos obtendo de 4 a 8 bytes extras por linha, além de páginas não folha adicionando um índice clusterizado.)

Preciso fazer um pequeno benchmarking do AlwaysOn, com e sem o TDE ativado. Todas as instruções que vejo cobrem a adição de bancos de dados criptografados a um grupo de disponibilidade, mas não vejo menção de habilitar a criptografia para um banco de dados já em um AG.

Posso apenas restaurar o certificado do servidor para todos os nós e habilitar o TDE do primário? Espero não precisar remover o banco de dados do AG, criptografá-lo e reinicializar todos os nós, pois o banco de dados tem cerca de 100 GB. Podemos fazer isso se necessário, mas certamente atrasará um pouco nossos testes.

Atualizar

Acabei de tentar isso em algumas VMs de laboratório. Consegui criar um certificado no primário, restaurá-lo em todos os nós secundários e, em seguida, criar uma chave de criptografia de banco de dados no primário usando este certificado. Tudo o que tive que fazer depois disso foi ALTER DATABASE AdventureWorks SET ENCRYPTION ONno servidor principal e, após um ou dois minutos, sys.dm_database_encryption_keys mostrou o estado_criptografia = 3 em todos os nós.

Então, pergunta de acompanhamento: Existe alguma razão para pensar que não devo usar este procedimento? O SQL Server parece estar satisfeito com os resultados, mas não vi essa abordagem ser discutida em nenhum lugar. Ao lidar com questões de criptografia e alta disponibilidade, não quero deixar as coisas ao acaso.

Tenho um relatório de fatura que estou desenvolvendo para o faturamento de alguns projetos. O tablix principal possui vários grupos, nesta ordem:

• ProjectGroup
• TicketGroup
• NoteGroup
• Detalhes (detalhes de cobrança reais)

Os dados podem acabar se parecendo com algo assim:

project_id  ticket_id   note_id     hours        billing_agreement_id billed_hours
----------- ----------- ----------- ------------ -------------------- ------------
1           1           1           0.50         4                    0.75
1           1           2           0.50         5                    1.00
1           1           3           1.00         7                    1.00
1           1           8           5.00         7                    3.00
1           1           8           5.00         2                    2.00
2           2           4           4.00         1                    4.00
2           2           5           2.00         6                    3.00

Em outras palavras, um tíquete é atribuído a um projeto, notas são inseridas em um tíquete (com um número correspondente de horas trabalhadas) e as horas de notas são cobradas para um ou mais acordos/contratos (se um acordo de bloqueio de tempo estiver esgotado, o restante pode transbordar para outro contrato, por exemplo). Tudo isso está funcionando bem, no que diz respeito ao aplicativo.

Agora estou criando o relatório de fatura e preciso fornecer um total geral de horas trabalhadas no final do relatório. Dê uma olhada na 4ª e 5ª linhas (com note_id = 8). O rodapé do relatório usa Sum(hours), que acaba contando essa nota como 10 horas. Ambos note_ide hoursvêm da linha de notas e devem ser somados de acordo. Incluir hoursna expressão de agrupamento para NoteGroup não tem nenhum efeito no comportamento de Sum, naturalmente.

Existe uma maneira direta de fazer o Reporting Services somar as horas, observando apenas os valores agrupados desse grupo, em vez das linhas de detalhes? Ainda não consigo pensar em nada particularmente elegante. Posso recorrer a acrobacias estranhas de código personalizado, se necessário.

Antes de ir em frente e colocar uma restrição de verificação realmente terrível na tabela Catálogo, gostaria de solicitar algumas ideias melhores primeiro.

Desejo garantir que todas as fontes de dados compartilhadas em nosso servidor de relatório sejam implantadas em "/Data Sources". De vez em quando, recebemos um implantado por engano em algum outro diretório (principalmente se for um relatório atualizado do SSRS 2000, que não permitia especificar um local de implantação de fonte de dados diferente).

Posso colocar uma restrição de verificação feia no Catálogo ( Type != 5 OR ParentID = 'GUID of /Data Sources directory', ou similar) se for necessário, mas se houver uma opção melhor, prefiro usá-la.

Duas perguntas rápidas para quem já tentou isso:

1. O Management Studio 2012 será instalado e executado lado a lado com, digamos, o Management Studio 2008? Lembro-me vagamente de não poder fazer isso em 2008 e 2005.

2. O Management Studio 2012 suporta totalmente a conexão e administração do SQL Server 2008? O Intellisense ainda funciona em versões mais antigas?

Estou executando o SQL Server Management Studio 2008 (10.0.5500.0) e estava tentando editar o modelo integrado "Criar gatilho T-SQL (novo menu)". Abro o Explorador de modelos, clico com o botão direito do mouse no modelo, escolho Editar, modifico e salve.

Mas quando tento usar o modelo clicando com o botão direito do mouse em "Acionadores" abaixo de qualquer tabela e selecionando "Novo Acionador", ele ainda usa o modelo padrão.

No Process Explorer, posso vê-lo acessando este arquivo quando edito o modelo:

C:\Users\username\AppData\Roaming\Microsoft\Microsoft SQL Server\100\Tools\Shell\Templates\Sql\Trigger\Create T-SQL Trigger (New Menu).sql

Quando tento usar o template, ele carrega o script deste caminho:

C:\Program Files\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\SqlWorkbenchProjectItems\Sql\Trigger\Create T-SQL Trigger (New Menu).sql

Existe uma determinada configuração/patch para ajudá-lo a manter os caminhos de arquivo classificados?

Eu tenho um gatilho UPDATE em uma tabela que observa uma coluna específica mudando de um valor específico para qualquer outro valor. Quando isso acontece, ele atualiza alguns dados relacionados em outra tabela por meio de uma única instrução UPDATE.

A primeira coisa que o gatilho faz é verificar se alguma linha atualizada teve o valor desta coluna alterado do valor em questão. Ele simplesmente une INSERTED a DELETED e compara o valor nessa coluna. Se nada se qualificar, ele sai antes do tempo para que a instrução UPDATE não seja executada.

IF NOT EXISTS (
    SELECT TOP 1 i.CUSTNMBR
    FROM INSERTED i
        INNER JOIN DELETED d
            ON i.CUSTNMBR = d.CUSTNMBR
    WHERE d.CUSTCLAS = 'Misc'
        AND i.CUSTCLAS != 'Misc'
)
    RETURN

Nesse caso, CUSTNMBR é a chave primária da tabela subjacente. Se eu fizer uma grande atualização nesta tabela (digamos, mais de 5.000 linhas), essa instrução levará AGES, mesmo que eu não tenha tocado na coluna CUSTCLAS. Posso observá-lo parar nesta instrução por vários minutos no Profiler.

O plano de execução é bizarro. Ele mostra uma varredura inserida com 3.714 execuções e aproximadamente 18,5 milhões de linhas de saída. Isso passa por um filtro na coluna CUSTCLAS. Ele une isso (via loop aninhado) a uma varredura excluída (também filtrada em CUSTCLAS), que é executada apenas uma vez e possui 5.000 linhas de saída.

Que coisa idiota estou fazendo aqui para causar isso? Observe que o gatilho absolutamente deve lidar adequadamente com atualizações de várias linhas.

EDITAR :

Eu também tentei escrever assim (no caso de EXISTS estar fazendo algo desagradável), mas ainda é terrível.

DECLARE @CUSTNMBR varchar(31)
SELECT TOP 1 @CUSTNMBR = i.CUSTNMBR
FROM INSERTED i
    INNER JOIN DELETED d
        ON i.CUSTNMBR = d.CUSTNMBR
WHERE d.CUSTCLAS = 'Misc'
    AND i.CUSTCLAS != 'Misc'

IF @CUSTNMBR IS NULL
    RETURN

Eu tenho um banco de dados do Analysis Services que é usado para relatar atividades de email. Ele conta principalmente as mensagens recebidas e enviadas, para quem são e de onde são, etc.

Tabela de fatos: 11.367.910 linhas
Tabela de dimensões de endereço: 386.015 linhas
Tabela de fatos de endereço: 21.303.290 linhas (usada para grupo de medidas intermediário de muitos para muitos)
Tabela de dimensões de data: 9.132 linhas

É uma estrutura simples, mas contém muitos dados. Os dois grupos de medidas têm 6 partições anuais com vários números de linhas nelas. A coisa toda leva cerca de 30 minutos para processar totalmente.

Mas isso não é problema meu (pelo menos não acho). Aparentemente aleatoriamente, a tarefa de processamento agendada falhará com o erro Unexpected end of file has occurred. The following elements are not closed: root, return, ExecuteResponse, soap:Body, soap:Envelope. Line 3707, position 1.O número da linha pode variar, mas o erro é o mesmo. Eu tentei caçar, mas não consigo encontrar nenhuma informação sobre o que isso indica. Alguém mais se deparou com esse erro?

Eu tenho uma dimensão de data do calendário apoiada por uma tabela física de datas (originalmente criada no SQL Server 2000, portanto, a data e a hora em vez da data):

CREATE TABLE [dbo].[PostDate_Dimension](
    [post_date] [datetime] NOT NULL PRIMARY KEY,
    [day_of_year] [int] NOT NULL,
    [day_of_month] [int] NOT NULL,
    [month_of_year] [int] NOT NULL,
    [post_year]  AS (datepart(year,[post_date])),
    [post_month]  AS (datepart(month,[post_date])),
    [post_day]  AS (datepart(day,[post_date]))
)

A dimensão Post Date tem quatro atributos (com colunas de chave de membro listadas, algumas das quais são calculadas no DSV):

1. Dia (chave de dimensão) - post_date
2. Mês - pós_ano, pós_mês
3. Trimestre - pós_ano, pós_trimestre =DatePart(quarter, "post_date"))
4. Ano - post_year

Não é nada muito chique, obviamente. Também tenho algumas medidas calculadas que usam o ParallelPeriod para calcular os valores acumulados no ano do ano anterior, para comparação rápida lado a lado sem exigir que o usuário escolha uma fatia específica de datas. Basta escolher o ano atual e ele encontrará a data mais recente com vendas e comparará com o mesmo intervalo do ano anterior.

Encontrar a data apropriada no ano anterior normalmente se resume a isso:

ParallelPeriod(
    [Post Date].[Post Date].[Year],
    1,
    Tail(
        NonEmpty(
            Descendants(
                [Post Date].CurrentMember,
                ,
                Leaves
            ),
            Measures.[Total Price]
        ),
        1
    ).Item(0)
)

A chamada Tail é onde encontra a data mais recente abaixo do membro Post Date atualmente selecionado (normalmente o ano atual). Isso funciona bem. Mas se isso retornar 29 de fevereiro, significando que a última venda para uma combinação específica de membros da dimensão ocorreu em 29 de fevereiro, ele passará 29 de fevereiro para a função ParallelPeriod, que subsequentemente retornará nulo. E então a medida YTD do ano anterior também retorna nulo.

Portanto, em poucas palavras: com base nesse esquema específico, existe uma maneira simples de fazer com que o ParallelPeriod se comporte bem para as entradas de 29 de fevereiro? Se retornar apenas em 28 de fevereiro do ano anterior, tudo bem.

EDITAR :

Algumas coisas que tentei:

• Usando esta expressão para ajustar o membro Post Date:
  Iif(MONTH([Post Date].[Post Date].CurrentMember.Member_Caption) = 2 And DAY([Post Date].[Post Date].CurrentMember.Member_Caption) = 29, [Post Date].[Post Date].CurrentMember.PREVMEMBER, [Post Date].[Post Date].CurrentMember)
  Isso funciona, mas o código seria terrível, pois eu teria que substituir all [Post Date].[Post Date].CurrentMemberpor Tail(NonEmpty(Descendants([Post Date].CurrentMember,, Leaves), Measures.[Total Price]), 1).Item(0)).
• Usando Except para remover todas as datas de 29 de fevereiro dos resultados de NonEmpty(Descendants([Post Date].CurrentMember,, Leaves), Measures.[Total Price]). Não consigo descobrir a sintaxe adequada (se houver) para obter um conjunto de todos os 29 de fevereiro da dimensão.
• Criar um assembly .NET com uma função definida pelo usuário que usa um membro como parâmetro e retorna o membro anterior se for 29 de fevereiro. Parece que as classes em Microsoft.AnalysisServices.AdomdServer são extremamente limitadas e nem mesmo permitir esta tarefa básica (nem mesmo recuperar a chave do membro como um valor de data).

Temos uma tabela de clientes (quem não tem?), contendo muitos registros que são, do ponto de vista comercial, duplicados. Consegui criar um pacote SSIS para executar o agrupamento difuso e relatar possíveis duplicatas.

Agora, suponha que eu queira fazer esse tipo de análise no momento em que alguém está entrando em um novo cliente. A ideia seria realizar uma pesquisa difusa no nome do cliente (e possivelmente alguma outra informação básica, como código postal) e mostrar possíveis duplicatas antes de prosseguir para o formulário de criação do cliente.

O problema óbvio aqui é que o agrupamento difuso e os componentes de pesquisa fazem parte do SSIS. Se eu quisesse executá-los sob demanda, teria que fazer algo insano como colocar os termos de pesquisa em uma tabela de preparação, executar o pacote SSIS, aguardar sua conclusão e buscar os resultados de uma tabela de saída. Seria lento, doloroso e teria graves problemas de simultaneidade.

Então, a outra ideia era usar a indexação de texto completo. Ao experimentá-lo, parece que não será adequado. Ele não detecta erros ortográficos sutis de nomes de clientes ou nomes que diferem em "Empresa" x "Corporação" x "Sociedade", ou "Anderson" x "Andersen" e outras variações desse tipo.

Existe algo que permitirá a flexibilidade do agrupamento/correspondência difusa do T-SQL? Posso dizer a uma pesquisa difusa para salvar os tokens, mas parece que ainda teria que reimplementar a maior parte do algoritmo de correspondência para usá-los.

Por alguns motivos, gostaria de receber todos os erros de permissão negada (número 229) por e-mail. A verificação de master.sys.messages mostra que is_event_logged para este erro é 0. Portanto, isso exclui o uso de alertas de erro do SQL Server Agent, que dependem do log de erros do SQL Server (eu testei isso - não recebo nenhum alerta).

Achei que deveria dar uma olhada em mssqlsystemresource e ver a definição de exibição para sys.messages, pensando que talvez pudesse atualizar is_event_logged para a mensagem em questão. Mas esta exibição obtém a mensagem de erro do sistema de OpenRowset(TABLE SYSERRORS), então isso é impossível.

Existe uma maneira razoavelmente simples de receber todos os 229 erros por e-mail imediatamente (ou talvez em 30 segundos) sem prejudicar o desempenho do servidor? Um resfriamento de 60 segundos entre os e-mails provavelmente também seria uma boa ideia.

Tenho uma conta de usuário - vamos chamá-la de 'wordpress' - que preciso permitir o acesso a algumas tabelas de catálogo em outro banco de dados de e-commerce no mesmo servidor. Configurei o usuário com três máscaras de host das quais ele pode se conectar: ​​'localhost', o endereço IP do servidor web e o nome do host do servidor web. Não há problemas.

O usuário 'wordpress' também tem acesso total ao seu próprio banco de dados, concedido através da seção Schema Privileges no MySQL Workbench. Aqui, ele mostra que o host é '%', que é o que eu quero, pois não quero gerenciar três conjuntos duplicados de privilégios para o mesmo usuário. Se eu olhar em mysql.db, vejo esses privilégios, com '%' na coluna Host.

Então agora eu quero conceder permissão SELECT em um punhado de tabelas em outro banco de dados - vamos chamá-lo de 'loja'. Então eu tento isso:

GRANT SELECT ON store.catalog TO 'wordpress'@'%';

E recebo 'Não é possível encontrar nenhuma linha correspondente na tabela de usuários', pelo motivo óbvio de que '%' não é uma máscara de host da qual permiti explicitamente uma conexão para esse usuário específico. Então, qual é a sintaxe adequada para conceder um privilégio de tabela a um usuário de qualquer uma de suas máscaras de host permitidas? Como o MySQL Workbench está se saindo bem para privilégios de esquema? Eu não tenho que inserir linhas manualmente em mysql.tables_priv, tenho?

UPDATE : Para esclarecer, aqui está a aparência das tabelas de usuário/concessão atuais. Eu anonimizei alguns nomes, obviamente. Observe que o host na tabela de privilégios do esquema é '%', mas não há usuários com esse host. Como faço para que o MySQL me permita fazer isso com concessões de objetos de esquema? De preferência sem mexer diretamente no mysql.tables_priv, mas farei isso se for necessário.

mysql> SELECT user, host FROM mysql.user WHERE user = 'wordpress';
+-----------+-----------+
| user      | host      |
+-----------+-----------+
| wordpress | 10.0.0.22 |
| wordpress | webserver |
| wordpress | localhost |
+-----------+-----------+
3 rows in set (0.00 sec)

mysql> SELECT user, host, db, select_priv FROM mysql.db WHERE User = 'wordpress';
+-----------+------+----------------+-------------+
| user      | host | db             | select_priv |
+-----------+------+----------------+-------------+
| wordpress | %    | wordpress      | Y           |
| wordpress | %    | wordpress_test | Y           |
+-----------+------+----------------+-------------+
2 rows in set (0.00 sec)

mysql> SHOW GRANTS FOR 'wordpress'@'localhost';
+---------------------------------------------------------------------------+
| Grants for wordpress@localhost                                            |
+---------------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'wordpress'@'localhost' IDENTIFIED BY PASSWORD '--' |
+---------------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SHOW GRANTS FOR 'wordpress'@'%';
ERROR 1141 (42000): There is no such grant defined for user 'wordpress' on host '%'

O MySQL Workbench está fazendo algo terrivelmente não documentado com privilégios de esquema/objeto? Apenas por diversão, concedi alguns privilégios de tabela para uma das combinações específicas de usuário@host, então atualizei mysql.tables_priv para alterar o host para '%'. Depois de executar FLUSH PRIVILEGES, funcionou perfeitamente. Esquisito.

Suponha que eu queira registrar todas as mensagens de erro do usuário de gravidade 16 (e superior) em uma tabela de banco de dados para permitir alguma solução de problemas retrospectiva do aplicativo (já que a resposta para "Você pode me enviar a mensagem de erro?" é frequentemente "Não, fechei it.") Um rastreamento do lado do servidor será a opção mais eficaz ou haveria uma abordagem ainda melhor?

Tenho um esquema relacionado à folha de pagamento que preciso proteger. Acho que se eu impedir que todos os usuários modifiquem diretamente as tabelas e criar um conjunto de procedimentos para lidar com todas as modificações de dados, estaremos em boa forma. Posso fazer com que os procedimentos lidem com todos os logs de auditoria, envolvam as coisas em transações conforme necessário, etc.

Mas, para fazer isso, preciso negar instruções DML diretas a todos nesse esquema específico - até mesmo a função de servidor sysadmin. Existe alguma maneira simples de fazer isso sem recorrer aos gatilhos INSTEAD OF (que não seriam tão à prova de balas)? Não vejo nenhuma sintaxe como "DENY INSERT, UPDATE, DELETE ON SCHEMA::schemaname TO ALL" e negar permissões para a função "pública" não parece ter o efeito desejado.

Eu sei que a recomendação comum para o volume de dados no SQL Server é usar blocos/faixas de 64 KB, já que o I/O normalmente é feito por extensões inteiras. No entanto, não consigo encontrar nenhuma boa informação sobre a E/S do arquivo de log.

Tenho observado a atividade de E/S no Process Monitor por um tempo e parece que os tamanhos de E/S do arquivo de log variam de 512 bytes a pouco menos de 64 KB. Suponho que isso dependa do tamanho da transação que está sendo registrada, e as grandes são divididas usando várias gravações de ~ 64 KB.

Então, supondo que eu tenha a partição alinhada com as faixas de RAID, seria seguro assumir que blocos/faixas de 64 KB produzirão o melhor desempenho, todas as outras coisas sendo iguais? Eu esperaria que as transações menores, ou seja, aquelas com gravações de 512 bytes, não fossem pesadas o suficiente para que a penalidade de tamanho de bloco grande tivesse um impacto significativo, enquanto as transações muito maiores que gravavam muitos blocos de 64 KB em rápida sucessão teriam ser mais importante para sintonizar.