All perguntas(dba)

Encontrei um impasse que parece mostrar algo que eu pensava ser impossível. Existem dois processos envolvidos no impasse:

1. process8cf948 SPID 63

• Executando um ALTER TABLE na tabela temporária #PB_Cost_Excp_Process_Invoices_Work.

• Possui bloqueio IX na tabela #PB_Cost_Excp_Process_Invoices_Work com ID de objeto 455743580

2. process4cb3708 SPID 72

• Executando em UPDATE na tabela temporária #PB_Cost_Excp_Process_Invoices_Work, que deve ser sua própria cópia exclusiva da tabela.

• Possui bloqueio Sch-M em #PB_Cost_Excp_Process_Invoices_Work com o mesmo objeto ID 455743580 !

Isto é suposto ser impossível. Estou esquecendo de algo? Uma tabela #Temporary realmente foi reutilizada entre esses dois SPIDs?

Isso está no SQL Server 2008 R2 Service Pack 2 com atualização cumulativa 1 (versão 10.50.4260).

O rastreamento de impasse inalterado completo está abaixo. Observe como os dois processos estão operando no mesmo ID de objeto com o mesmo nome de tabela #PB_Cost_Excp_Process_Invoices_Work_SNIP_0000000D8519:

12/14/2012 13:46:03,spid23s,Unknown,waiter id=process8cf948 mode=X requestType=wait
12/14/2012 13:46:03,spid23s,Unknown,waiter-list
12/14/2012 13:46:03,spid23s,Unknown,owner id=process4cb3708 mode=Sch-M
12/14/2012 13:46:03,spid23s,Unknown,owner-list
12/14/2012 13:46:03,spid23s,Unknown,objectlock lockPartition=0 objid=455743580 subresource=FULL dbid=2 objectname=tempdb.dbo.#PB_Cost_Excp_Process_Invoices_Work_________________________________________________________________________________0000000D8519 id=lock371705d00 mode=Sch-M associatedObjectId=455743580
12/14/2012 13:46:03,spid23s,Unknown,waiter id=process4cb3708 mode=Sch-M requestType=wait
12/14/2012 13:46:03,spid23s,Unknown,waiter-list
12/14/2012 13:46:03,spid23s,Unknown,owner id=process8cf948 mode=IX
12/14/2012 13:46:03,spid23s,Unknown,owner-list
12/14/2012 13:46:03,spid23s,Unknown,objectlock lockPartition=3 objid=455743580 subresource=FULL dbid=2 objectname=tempdb.dbo.#PB_Cost_Excp_Process_Invoices_Work_________________________________________________________________________________0000000D8519 id=lock3139b4780 mode=IX associatedObjectId=455743580
12/14/2012 13:46:03,spid23s,Unknown,resource-list
12/14/2012 13:46:03,spid23s,Unknown,Proc [Database Id = 8 Object Id = 1857974987]
12/14/2012 13:46:03,spid23s,Unknown,inputbuf
12/14/2012 13:46:03,spid23s,Unknown,EXEC PB_ProcessExc_Costs_Submit_SP @SiteKey, @PWDate
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.DR_SubmitPaperwork_SP line=174 stmtstart=12912 stmtend=13018 sqlhandle=0x03000800cb72be6e500434018da000000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,EXEC PB_ProcessExc_Costs_Create_SP
    
    -- Clean up work table
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.PB_ProcessExc_Costs_Submit_SP line=138 stmtstart=11890 stmtend=12012 sqlhandle=0x03000800428c1f1950f833018da000000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,UPDATE #PB_Cost_Excp_Process_Invoices_Work
    SET PBCEPrcInv_RtlPkg_Item_Quantity = RtlPkg_Item_Quantity
    FROM #PB_Cost_Excp_Process_Invoices_Work
        INNER JOIN Item_Packages (NOLOCK)
            ON PBCEPrcInv_ItemPkg_Key = ItemPkg_Key
        INNER JOIN Retail_Packages (NOLOCK)
            ON ItemPkg_RtlPkg_Key = RtlPkg_Key
    
    -- Lookup pricebook cost
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.PB_ProcessExc_Costs_Create_SP line=25 stmtstart=2394 stmtend=3050 sqlhandle=0x030008003a082846321f46018da000000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,executionStack
12/14/2012 13:46:03,spid23s,Unknown,process id=process8cf948 taskpriority=0 logused=0 waitresource=OBJECT: 2:455743580:0  waittime=3739 ownerId=707053534 transactionname=UPDATE lasttranstarted=2012-12-14T13:45:59.327 XDES=0x3c4502930 lockMode=X schedulerid=4 kpid=7276 status=suspended spid=72 sbid=0 ecid=0 priority=0 trancount=2 lastbatchstarted=2012-12-14T13:45:58.337 lastbatchcompleted=2012-12-14T13:45:58.337 clientapp=PDI WCF Services - pdidb01-PDIMaster.cfg hostname=PDIWEB01 hostpid=2084 loginname=pdiuser isolationlevel=read committed (2) xactid=707053534 currentdb=8 lockTimeout=4294967295 clientoption1=673316896 clientoption2=128568
12/14/2012 13:46:03,spid23s,Unknown,Proc [Database Id = 8 Object Id = 1857974987]
12/14/2012 13:46:03,spid23s,Unknown,inputbuf
12/14/2012 13:46:03,spid23s,Unknown,EXEC PB_ProcessExc_Costs_Submit_SP @SiteKey, @PWDate
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.DR_SubmitPaperwork_SP line=174 stmtstart=12912 stmtend=13018 sqlhandle=0x03000800cb72be6e500434018da000000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,EXEC dbo.PB_ProcessExc_Costs_CreateInvoiceWorkTable_SP
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.PB_ProcessExc_Costs_Submit_SP line=58 stmtstart=5782 stmtend=5894 sqlhandle=0x03000800428c1f1950f833018da000000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,ALTER TABLE #PB_Cost_Excp_Process_Invoices_Work DROP COLUMN PBCEPrcInv_Filler
12/14/2012 13:46:03,spid23s,Unknown,frame procname=PDICompany_218_01.dbo.PB_ProcessExc_Costs_CreateInvoiceWorkTable_SP line=50 stmtstart=5382 stmtend=5538 sqlhandle=0x0300080025d75a14ffff4701969f00000100000000000000
12/14/2012 13:46:03,spid23s,Unknown,executionStack
12/14/2012 13:46:03,spid23s,Unknown,process id=process4cb3708 taskpriority=0 logused=0 waitresource=OBJECT: 2:455743580:3  waittime=3739 ownerId=707052778 transactionname=ALTER TABLE lasttranstarted=2012-12-14T13:45:58.517 XDES=0x5f48bce80 lockMode=Sch-M schedulerid=6 kpid=7212 status=suspended spid=63 sbid=0 ecid=0 priority=0 trancount=1 lastbatchstarted=2012-12-14T13:45:58.513 lastbatchcompleted=2012-12-14T13:45:58.513 clientapp=PDI WCF Services - pdidb01-PDIMaster.cfg hostname=PDIWEB01 hostpid=2084 loginname=pdiuser isolationlevel=read committed (2) xactid=707052778 currentdb=2 lockTimeout=4294967295 clientoption1=673316896 clientoption2=128568
12/14/2012 13:46:03,spid23s,Unknown,process-list
12/14/2012 13:46:03,spid23s,Unknown,deadlock victim=process4cb3708
12/14/2012 13:46:03,spid23s,Unknown,deadlock-list

ATUALIZAR

A máquina em questão mostra 16 processadores no Gerenciador de Tarefas e no Gerenciador de Dispositivos, portanto, o particionamento de bloqueio está ativado e os dois bloqueios estão em diferentes partições de bloqueio. Não sei se o particionamento de bloqueio é uma causa contribuinte aqui ou não.

Também encontrei esta postagem intrigante no blog CSS SQL Server Engineers .

ATUALIZAÇÃO 2

As tabelas temporárias são descartadas no final de cada procedimento armazenado. Eles são criados com o padrão criar #tabela, modificar esquema, inserir, atualizar, selecionar e, em seguida, descartar. Existem vários pontos de entrada para um procedimento comum que usa essa #tabela temporária, portanto, temos um proc central que configura as colunas necessárias para chamar o proc comum. Caso contrário, teríamos que replicar a mesma definição #table em todos os procs do ponto de entrada.

O processo é chamado frequentemente de vários aplicativos clientes. Alguns dos aplicativos cliente chamam esse processo de vários encadeamentos. Outros executam um de cada vez. Pense em um software de inventário/contabilidade em que o escritório central está processando dados para milhares de lojas em paralelo, enquanto as próprias lojas também executam o mesmo processo. Portanto, se esse é um problema raro quando o particionamento de bloqueio está ativado, não será tão raro em nossos bancos de dados de clientes maiores.

ATUALIZAÇÃO 3 - 2012-12-19

Outro cliente está tendo o mesmo problema no SQL Server 2012 build 11.0.2100. Não vi nenhuma menção a uma correção para esse problema nas descrições de atualização cumulativa. Pesquisando.

ATUALIZAÇÃO 4 - 2013-02-13

A Microsoft lançou a correção para esse bug nas seguintes atualizações:

• Pacote de atualização cumulativa 4 para SQL Server 2008 R2 SP2
• Pacote de atualização cumulativa 2 para SQL Server 2012 SP1

Em continuação a uma pergunta postada por mim em É uma boa ideia mover tabelas de alto volume e altamente acessadas para um banco de dados separado? , estou procurando diferentes técnicas/soluções disponíveis para arquivamento de banco de dados no PostgreSQL.

Poucas soluções que posso pensar são:

1. Particionamento de tabela
2. Espaço de tabela e/ou esquema separado
3. Movendo registros/tabelas arquivados para um disco rígido diferente

Quaisquer outras sugestões/dicas/soluções são muito bem-vindas e apreciadas.

NOTA: Estamos executando o PostgreSQL v9.1.3 no CentOS5.2

Primeiro alguns antecedentes.

O projeto LedgerSMB é um projeto de software de contabilidade financeira de código aberto executado no PostgreSQL. Implementamos uma quantidade muito grande de lógica de negócios em funções definidas pelo usuário, que atuam como a principal ferramenta de mapeamento entre os métodos de objeto do programa e o comportamento do banco de dados. Atualmente, usamos usuários de banco de dados como usuários de autenticação, em parte por opção (isso permite uma lógica de segurança centralizada, para que outras ferramentas possam ser escritas e reutilizar as permissões dadas aos usuários) e em parte por necessidade (depois que bifurcamos do SQL-Ledger, há não havia muitas opções para atualizar a segurança nessa base de código).

Isso nos dá acesso a um número razoável de opções de conexão única às quais o PostgreSQL tem acesso, do LDAP ao Kerberos 5. Podemos até usar o PAM no que diz respeito às senhas. Também nos permite reutilizar permissões ao integrar com outros aplicativos ou permitir outras interfaces de cliente. Para um aplicativo de contabilidade financeira, isso parece uma vitória líquida.

Há custos óbvios envolvidos. Para o aplicativo da web, estamos muito limitados aos tipos de autenticação http que podem ser suportados. DIGEST, por exemplo, está totalmente fora. O BASIC funciona e poderíamos implementar o KRB5 com bastante facilidade (pretendo ter isso suportado e funcionando imediatamente para 1.4). Medidas de autenticação muito fortes não podem ser gerenciadas adequadamente diretamente, embora provavelmente possamos corrigi-las, se necessário (por exemplo, BASIC + certificado SSL do lado do cliente com um cn correspondente ao nome do usuário e uma raiz específica ca).

Ao mesmo tempo, recebemos muitas críticas, principalmente do pessoal do desenvolvimento e, mais ocasionalmente, de dba's que me dizem que o aplicativo deve ser a barreira de segurança, não o banco de dados. Minha opinião ainda é que um perímetro de segurança menor geralmente é melhor, que a reutilização da lógica de negócios e da lógica de segurança andam juntas e que me parece perigoso reutilizar a lógica de negócios sem reutilizar a lógica de segurança no mesmo nível do programa.

Estou perdendo alguma compensação importante aqui? Existem pegadinhas que não estou considerando?

Estou tentando automatizar o processo que executa as alterações no banco de dados SQL Server 2008 R2. O processo que coloquei em prática descarta e recria meus procedimentos e funções armazenados, além de executar scripts para alterar as tabelas/colunas/dados. Infelizmente, um dos scripts requer que uma das funções seja implementada primeiro. Mas não posso executar todas as alterações de proc/função armazenadas primeiro porque depende primeiro das colunas adicionadas dos scripts de alteração de tabelas/colunas/dados.

Eu queria saber se era possível executar procedimentos e funções armazenadas sem o SQL Server validar as colunas usadas na definição da função/SP? Tentei procurar, mas não consegui encontrar uma condição ou comando para habilitar isso.

Tenho monitorado o crescimento de arquivos por meio do coletor de dados no sql server 2008 r2 por duas semanas. O banco de dados está crescendo consistentemente em torno de 35(MB)/dia. O banco de dados ainda não atingiu o tamanho inicial de 2 GB.

O crescimento automático dos arquivos de banco de dados está definido para 5 MB e eu gostaria de tentar uma abordagem diferente, por isso estou procurando sugestões e/ou comentários.

Há uma tarefa de ajuste que é executada toda semana na noite de domingo à 1h30. A tarefa irá:

• Verifique a integridade do banco de dados
• Encolher o arquivo de log - (Isso é bom porque o modo de log é simples)
• Encolher banco de dados
• Reorganizar Índice
• Índice de reconstrução
• Atualizar estatísticas
• Limpar histórico

Gostaria de adicionar mais duas etapas ao plano de ajuste semanal:

1. Aumente o arquivo de banco de dados em 500 MB se o espaço usado atingir um determinado limite ou tamanho total.
2. Aumente o arquivo de log em 250 MB (após a redução) se o espaço usado atingir um determinado limite de tamanho total.

Ao colocar a carga de crescimento em horas off-line, espero ganhar desempenho reduzindo o número de eventos de crescimento automático durante cargas pesadas.

Eu tenho duas perguntas relacionadas a arquivos de crescimento automático.

• O melhor lugar para colocar as etapas de crescimento do arquivo seria antes das etapas atuais ou depois?
• Se eu usar o ALTER DATABASE|MODIFY FILEpara aumentar o arquivo, como posso determinar se SpaceUsedInFile >= (TotalFileSpace-@AllowanceThreshold)?

Estou tentando modelar um módulo de autenticação de usuário para um banco de dados MS SQL Server que será o back-end de um aplicativo Delphi UI. Basicamente, quero ter contas de usuário em que o usuário pertença a apenas um grupo. Um grupo pode ter um número "n" de direitos.

Também quero adicionar o histórico de senhas ao banco de dados, pois o usuário precisará alterar sua senha com base em uma configuração do aplicativo (por exemplo, a cada 90 dias).

Eu também quero registrar um evento para cada vez que um usuário fizer login e logout. Posso estender isso para eventos adicionais no futuro.

Abaixo você encontrará meu primeiro crack nele. Por favor, deixe-me saber quaisquer sugestões para melhorá-lo, pois esta é a primeira vez que faço isso.

Você vê alguma necessidade de atributos adicionais para segurança baseada em função e restrições para as regras de senha/períodos de expiração?

Eu gostaria de usar o código que desenvolvi em C # CLR para ser usado em todos os bancos de dados do sistema, para não precisar definir cada um como confiável e ativar o CLR e manter um monte do mesmo código dentro de cada um .

Existe uma maneira melhor de fazer isso do ponto de vista administrativo e de segurança? As funções CLR são muito básicas, como quebra de string, validação de e-mail, url en/decode, base64 e etc. Gostaria que apenas o esquema dbo em cada banco de dados pudesse acessar as funções.

1. Existe alguma maneira simples de fazer isso?
2. Também não estou claro se a dll CLR está incorporada e se eu mover o banco de dados, ele acompanha ou devo mover a dll também.

Obrigado

Eu tenho um banco de dados Postgresql 8.1. Em uma tabela, há três colunas: first_name, last_name, display_name.

É possível definir o valor padrão de display_nameser first_name + " " + last_name?

Eu estava tentando responder à seguinte pergunta do stackoverflow:

• Qual abordagem de bloqueio do SQL Server 2005/2008 devo usar para processar linhas de tabelas individuais em várias instâncias de aplicativos de servidor?

Depois de postar uma resposta um tanto ingênua, pensei em colocar meu dinheiro onde estava minha boca e realmente testar o cenário que estava sugerindo, para ter certeza de que não estava mandando o OP em uma caça ao ganso selvagem. Bem, acabou sendo muito mais difícil do que eu pensava (não é surpresa para ninguém, tenho certeza).

Aqui está o que eu tentei e pensei:

• Primeiro tentei um TOP 1 UPDATE com um ORDER BY dentro de uma tabela derivada, usando ROWLOCK, READPAST. Isso gerou impasses e também processou itens fora de ordem. Deve ser o mais próximo possível do FIFO, exceto erros que exijam a tentativa de processar a mesma linha mais de uma vez.

• Em seguida, tentei selecionar o próximo QueueID desejado em uma variável, usando várias combinações de READPAST, UPDLOCK, HOLDLOCKe ROWLOCKpara preservar exclusivamente a linha para atualização por essa sessão. Todas as variações que experimentei sofriam dos mesmos problemas de antes, bem como, para certas combinações com READPAST, reclamando:

  Você só pode especificar o bloqueio READPAST nos níveis de isolamento READ COMMITTED ou REPEATABLE READ.

  Isso foi confuso porque foi READ COMMITTED. Já passei por isso antes e é frustrante.

• Desde que comecei a escrever esta pergunta, Remus Rusani postou uma nova resposta para a pergunta. Eu li seu artigo vinculado e vejo que ele está usando leituras destrutivas, já que ele disse em sua resposta que "não é realisticamente possível manter os bloqueios durante as chamadas da web". Depois de ler o que seu artigo diz sobre pontos de acesso e páginas que exigem bloqueio para fazer qualquer atualização ou exclusão, temo que, mesmo que eu fosse capaz de descobrir os bloqueios corretos para fazer o que estou procurando, não seria escalável e poderia não lidar com simultaneidade massiva.

Agora eu não tenho certeza para onde ir. É verdade que manter bloqueios enquanto a linha é processada não pode ser alcançado (mesmo que não suporte tps altos ou simultaneidade massiva)? o que estou perdendo?

Na esperança de que pessoas mais inteligentes do que eu e pessoas mais experientes do que eu possam ajudar, abaixo está o script de teste que eu estava usando. Ele voltou para o método TOP 1 UPDATE, mas deixei o outro método, comentado, caso você queira explorar isso também.

Cole cada um deles em uma sessão separada, execute a sessão 1 e, em seguida, rapidamente todas as outras. Em cerca de 50 segundos, o teste terminará. Veja as mensagens de cada sessão para ver o trabalho que ela fez (ou como falhou). A primeira sessão mostrará um conjunto de linhas com um instantâneo obtido uma vez por segundo, detalhando os bloqueios presentes e os itens da fila sendo processados. Às vezes funciona e outras vezes não funciona de jeito nenhum.

Sessão 1

/* Session 1: Setup and control - Run this session first, then immediately run all other sessions */
IF Object_ID('dbo.Queue', 'U') IS NULL
   CREATE TABLE dbo.Queue (
      QueueID int identity(1,1) NOT NULL,
      StatusID int NOT NULL,
      QueuedDate datetime CONSTRAINT DF_Queue_QueuedDate DEFAULT (GetDate()),
      CONSTRAINT PK_Queue PRIMARY KEY CLUSTERED (QueuedDate, QueueID)
   );

IF Object_ID('dbo.QueueHistory', 'U') IS NULL
   CREATE TABLE dbo.QueueHistory (
      HistoryDate datetime NOT NULL,
      QueueID int NOT NULL
   );

IF Object_ID('dbo.LockHistory', 'U') IS NULL
   CREATE TABLE dbo.LockHistory (
      HistoryDate datetime NOT NULL,
      ResourceType varchar(100),
      RequestMode varchar(100),
      RequestStatus varchar(100),
      ResourceDescription varchar(200),
      ResourceAssociatedEntityID varchar(200)
   );

IF Object_ID('dbo.StartTime', 'U') IS NULL
   CREATE TABLE dbo.StartTime (
      StartTime datetime NOT NULL
   );

SET NOCOUNT ON;

IF (SELECT Count(*) FROM dbo.Queue) < 10000 BEGIN
   TRUNCATE TABLE dbo.Queue;

   WITH A (N) AS (SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1),
   B (N) AS (SELECT 1 FROM A Z, A I, A P),
   C (N) AS (SELECT Row_Number() OVER (ORDER BY (SELECT 1)) FROM B O, B W)
   INSERT dbo.Queue (StatusID, QueuedDate)
   SELECT 1, DateAdd(millisecond, C.N * 3, GetDate() - '00:05:00')
   FROM C
   WHERE C.N <= 10000;
END;

TRUNCATE TABLE dbo.StartTime;
INSERT dbo.StartTime SELECT GetDate() + '00:00:15'; -- or however long it takes you to go run the other sessions
GO
TRUNCATE TABLE dbo.QueueHistory;
SET NOCOUNT ON;

DECLARE
   @Time varchar(8),
   @Now datetime;
SELECT @Time = Convert(varchar(8), StartTime, 114)
FROM dbo.StartTime;
WAITFOR TIME @Time;

DECLARE @i int,
@QueueID int;
SET @i = 1;
WHILE @i <= 33 BEGIN
   SET @Now  = GetDate();
   INSERT dbo.QueueHistory
   SELECT
      @Now,
      QueueID
   FROM
      dbo.Queue Q WITH (NOLOCK)
   WHERE
      Q.StatusID <> 1;

   INSERT dbo.LockHistory
   SELECT
      @Now,
      L.resource_type,
      L.request_mode,
      L.request_status,
      L.resource_description,
      L.resource_associated_entity_id
   FROM
      sys.dm_tran_current_transaction T
      INNER JOIN sys.dm_tran_locks L
         ON L.request_owner_id = T.transaction_id;
   WAITFOR DELAY '00:00:01';
   SET @i = @i + 1;
END;

WITH Cols AS (
   SELECT *, Row_Number() OVER (PARTITION BY HistoryDate ORDER BY QueueID) Col
   FROM dbo.QueueHistory
), P AS (
   SELECT *
   FROM
      Cols
      PIVOT (Max(QueueID) FOR Col IN ([1], [2], [3], [4], [5], [6], [7], [8])) P
)
SELECT L.*, P.[1], P.[2], P.[3], P.[4], P.[5], P.[6], P.[7], P.[8]
FROM
   dbo.LockHistory L
   FULL JOIN P
      ON L.HistoryDate = P.HistoryDate

/* Clean up afterward
DROP TABLE dbo.StartTime;
DROP TABLE dbo.LockHistory;
DROP TABLE dbo.QueueHistory;
DROP TABLE dbo.Queue;
*/

Sessão 2

/* Session 2: Simulate an application instance holding a row locked for a long period, and eventually abandoning it. */
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET NOCOUNT ON;
SET XACT_ABORT ON;

DECLARE
   @QueueID int,
   @Time varchar(8);
SELECT @Time = Convert(varchar(8), StartTime + '0:00:01', 114)
FROM dbo.StartTime;
WAITFOR TIME @Time;
BEGIN TRAN;

--SET @QueueID = (
--   SELECT TOP 1 QueueID
--   FROM dbo.Queue WITH (READPAST, UPDLOCK)
--   WHERE StatusID = 1 -- ready
--   ORDER BY QueuedDate, QueueID
--);

--UPDATE dbo.Queue
--SET StatusID = 2 -- in process
----OUTPUT Inserted.*
--WHERE QueueID = @QueueID;

SET @QueueID = NULL;
UPDATE Q
SET Q.StatusID = 1, @QueueID = Q.QueueID
FROM (
   SELECT TOP 1 *
   FROM dbo.Queue WITH (ROWLOCK, READPAST)
   WHERE StatusID = 1
   ORDER BY QueuedDate, QueueID
) Q

PRINT @QueueID;

WAITFOR DELAY '00:00:20'; -- Release it partway through the test

ROLLBACK TRAN; -- Simulate client disconnecting

Sessão 3

/* Session 3: Run a near-continuous series of "failed" queue processing. */
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET XACT_ABORT ON;
SET NOCOUNT ON;
DECLARE
   @QueueID int,
   @EndDate datetime,
   @NextDate datetime,
   @Time varchar(8);

SELECT
   @EndDate = StartTime + '0:00:33',
   @Time = Convert(varchar(8), StartTime, 114)
FROM dbo.StartTime;

WAITFOR TIME @Time;

WHILE GetDate() < @EndDate BEGIN
   BEGIN TRAN;

   --SET @QueueID = (
   --   SELECT TOP 1 QueueID
   --   FROM dbo.Queue WITH (READPAST, UPDLOCK)
   --   WHERE StatusID = 1 -- ready
   --   ORDER BY QueuedDate, QueueID
   --);

   --UPDATE dbo.Queue
   --SET StatusID = 2 -- in process
   ----OUTPUT Inserted.*
   --WHERE QueueID = @QueueID;

   SET @QueueID = NULL;
   UPDATE Q
   SET Q.StatusID = 1, @QueueID = Q.QueueID
   FROM (
      SELECT TOP 1 *
      FROM dbo.Queue WITH (ROWLOCK, READPAST)
      WHERE StatusID = 1
      ORDER BY QueuedDate, QueueID
   ) Q

   PRINT @QueueID;

   SET @NextDate = GetDate() + '00:00:00.015';
   WHILE GetDate() < @NextDate SET NOCOUNT ON;
   ROLLBACK TRAN;
END

Sessão 4 e superior -- quantas quiser

/* Session 4: "Process" the queue normally, one every second for 30 seconds. */
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET XACT_ABORT ON;
SET NOCOUNT ON;

DECLARE @Time varchar(8);
SELECT @Time = Convert(varchar(8), StartTime, 114)
FROM dbo.StartTime;
WAITFOR TIME @Time;

DECLARE @i int,
@QueueID int;
SET @i = 1;
WHILE @i <= 30 BEGIN
   BEGIN TRAN;

   --SET @QueueID = (
   --   SELECT TOP 1 QueueID
   --   FROM dbo.Queue WITH (READPAST, UPDLOCK)
   --   WHERE StatusID = 1 -- ready
   --   ORDER BY QueuedDate, QueueID
   --);

   --UPDATE dbo.Queue
   --SET StatusID = 2 -- in process
   --WHERE QueueID = @QueueID;

   SET @QueueID = NULL;
   UPDATE Q
   SET Q.StatusID = 1, @QueueID = Q.QueueID
   FROM (
      SELECT TOP 1 *
      FROM dbo.Queue WITH (ROWLOCK, READPAST)
      WHERE StatusID = 1
      ORDER BY QueuedDate, QueueID
   ) Q

   PRINT @QueueID;
   WAITFOR DELAY '00:00:01'
   SET @i = @i + 1;
   DELETE dbo.Queue
   WHERE QueueID = @QueueID;   
   COMMIT TRAN;
END

Tenho um problema que enfrento toda vez que decido construir um cubo e ainda não encontrei uma maneira de superá-lo.

A questão é como permitir que o usuário defina uma gama de coisas automaticamente sem ter a necessidade de codificá-las na dimensão. Vou explicar meu problema em um exemplo.

Tenho uma tabela chamada Clientes :

esses são os dados da tabela:

Desejo exibir os dados em um estilo dinâmico e agrupar o Salário e a Idade em intervalos definidos, como abaixo:

Eu escrevi este script e defini os intervalos:

SELECT [CustId]
      ,[CustName]
      ,[Age]
      ,[Salary]
      ,[SalaryRange] = case
        when cast(salary as float) <= 500 then
            '0 - 500'
        when cast(salary as float) between 501 and 1000 then
            '501 - 1000'
        when cast(salary as float) between 1001 and 2000 then
            '1001 - 2000'
        when cast(salary as float) > 2000 then
            '2001+'
        end,
        [AgeRange] = case
        when cast(age as float) < 15 then
            'below 15'
        when cast(age as float) between 15 and 19 then
            '15 - 19'
        when cast(age as float) between 20 and 29 then
            '20 - 29'               
        when cast(age as float) between 30 and 39 then
            '30 - 39'
        when cast(age as float) >= 40 then
            '40+'
        end
  FROM [Customers]
GO

Meus intervalos são codificados e definidos. Quando copio os dados para o Excel e os visualizo em uma tabela dinâmica, aparece como abaixo:

Meu problema é que quero criar um cubo convertendo a tabela Customers em uma tabela de fatos e criar tabelas de 2 dimensões SalaryDim & AgeDim .

A tabela SalaryDim tem 2 colunas ( SalaryKey,SalaryRange ) e a tabela AgeDim é semelhante ( ageKey,AgeRange ). Minha tabela de fatos do cliente tem:

Customer
[CustId]
[CustName]
[AgeKey] --> foreign Key to AgeDim
[Salarykey] --> foreign Key to SalaryDim

Ainda tenho que definir meus intervalos dentro dessas dimensões. Sempre que conecto um pivô do Excel ao meu cubo, só consigo ver esses intervalos definidos codificados.

Minha pergunta é como definir intervalos dinamicamente da tabela dinâmica diretamente, sem criar as dimensões do intervalo como AgeDim e SalaryDim . Não quero ficar preso apenas aos intervalos definidos na dimensão.

O intervalo definido é '0-25' , '26-30' , '31-50'. Talvez eu queira alterá-lo para '0-20', '21-31' , '32-42' e assim por diante, e os usuários solicitam intervalos diferentes sempre.

Toda vez que eu mudo, tenho que mudar a dimensão. Como posso melhorar esse processo?

Seria ótimo ter uma solução implementada no cubo, para que qualquer ferramenta cliente de BI que se conectasse ao cubo pudesse definir os intervalos, mas não me importaria se houvesse uma boa maneira de usar apenas o Excel.