All perguntas(dba)

Este é o SQL Server 2008 R2 SP2. Eu tenho 2 mesas. Ambos são idênticos (dados e indexação), exceto que a primeira tabela tem uma coluna VALUE como nvarchar(max)e a segunda tem a mesma coluna que nvarchar(800). Esta coluna está incluída em um índice não clusterizado. Também criei um índice clusterizado em ambas as tabelas. Eu também reconstruí os índices. O comprimento máximo da string nesta coluna é 650.

Se eu executar a mesma consulta em ambas, a nvarchar(800)tabela será consistentemente mais rápida, muitas vezes duas vezes mais rápida. Claro que parece que está derrotando o propósito de "varchar". A tabela contém mais de 800.000 linhas. A consulta deve examinar cerca de 110.000 linhas (que é o que o plano estima).

De acordo com as estatísticas io, não há leituras de lob, então tudo parece estar em ordem. Os planos de execução são os mesmos, exceto que há uma pequena diferença na porcentagem de custo entre as duas tabelas e o tamanho estimado da linha é maior com nvarchar(max)(91 bytes vs 63 bytes). O número de leituras também é praticamente o mesmo.

Por que a diferença?

===== Esquema ====

 CREATE TABLE [dbo].[table1](
        [ID] [bigint] IDENTITY(1,1) NOT NULL,
        [ProductID] [bigint] NOT NULL,
        [ProductSkeletonID] [bigint] NOT NULL,
        [Value] [nvarchar](max) NOT NULL,
        [IsKeywordSearchable] [bit] NULL,
        [ValueInteger] [bigint] NULL,
        [ValueDecimal] [decimal](18, 2) NULL,
        [ValueDate] [datetime] NULL,
        [TypeOfData] [nvarchar](20) NOT NULL,
     CONSTRAINT [PK_table1] PRIMARY KEY CLUSTERED 
    (
        [ID] ASC
    )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

    CREATE NONCLUSTERED INDEX [IX_table1_productskeletonid] ON [dbo].[table1] 
    (
        [ProductSkeletonID] ASC
    )
    INCLUDE ( [ProductID],
    [Value]) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]

    CREATE TABLE [dbo].[table2](
        [ID] [bigint] IDENTITY(1,1) NOT NULL,
        [ProductID] [bigint] NOT NULL,
        [ProductSkeletonID] [bigint] NOT NULL,
        [Value] [nvarchar](800) NOT NULL,
        [IsKeywordSearchable] [bit] NULL,
        [ValueInteger] [bigint] NULL,
        [ValueDecimal] [decimal](18, 2) NULL,
        [ValueDate] [datetime] NULL,
        [TypeOfData] [nvarchar](20) NOT NULL,
     CONSTRAINT [PK_table2] PRIMARY KEY CLUSTERED 
    (
        [ID] ASC
    )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    ) ON [PRIMARY]

    CREATE NONCLUSTERED INDEX [IX_table2_productskeletonid] ON [dbo].[table2] 
    (
        [ProductSkeletonID] ASC
    )
    INCLUDE ( [ProductID],
    [Value]) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]


CREATE TABLE [dbo].[table_results](
    [SearchID] [bigint] NOT NULL,
    [RowNbr] [int] NOT NULL,
    [ProductID] [bigint] NOT NULL,
    [PermissionList] [varchar](250) NULL,
    [SearchWeight] [int] NULL,
 CONSTRAINT [PK_table_results] PRIMARY KEY NONCLUSTERED 
(
    [SearchID] ASC,
    [RowNbr] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

CREATE NONCLUSTERED INDEX [IX_table_results_SearchID] ON [dbo].[cart_product_searches_results] 
(
    [SearchID] ASC
)
INCLUDE ( [ProductID]) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]

======= Tabela1 consulta ====

    SELECT cppev.ProductSkeletonID, cppev.Value, COUNT(*) AS Value FROM table1 cppev
    JOIN search_results cpsr ON cppev.ProductID = cpsr.ProductID AND cpsr.SearchID = 227568 
    WHERE cppev.ProductSkeletonID in (3191, 3160, 3158, 3201)
    GROUP BY cppev.ProductSkeletonID, cppev.Value

    Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
    Table 'table1'. Scan count 4, logical reads 582, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
    Table 'table_results'. Scan count 1, logical reads 82, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

    SQL Server Execution Times:
       CPU time = 1373 ms,  elapsed time = 1576 ms.

 |--Compute Scalar(DEFINE:([Expr1005]=CONVERT_IMPLICIT(int,[Expr1008],0)))
       |--Stream Aggregate(GROUP BY:([cppev].[Value], [cppev].[ProductSkeletonID]) DEFINE:([Expr1008]=Count(*)))
            |--Sort(ORDER BY:([cppev].[Value] ASC, [cppev].[ProductSkeletonID] ASC))
                 |--Hash Match(Inner Join, HASH:([cpsr].[ProductID])=([cppev].[ProductID]), RESIDUAL:([dbo].[table1].[ProductID] as [cppev].[ProductID]=[dbo].[table_results].[ProductID] as [cpsr].[ProductID]))
                      |--Index Seek(OBJECT:([dbo].[table_results].[IX_table_results_SearchID] AS [cpsr]), SEEK:([cpsr].[SearchID]=(227568)) ORDERED FORWARD)
                      |--Index Seek(OBJECT:([dbo].[table1].[IX_table1_productskeletonid] AS [cppev]), SEEK:([cppev].[ProductSkeletonID]=(3158) OR [cppev].[ProductSkeletonID]=(3160) OR [cppev].[ProductSkeletonID]=(3191) OR [cppev].[ProductSkeletonID]=(3201)) ORDERED FORWARD)

======= Tabela2 consulta ====

    SELECT cppev.ProductSkeletonID, cppev.Value, COUNT(*) AS Value FROM table2 cppev
    JOIN table_results cpsr ON cppev.ProductID = cpsr.ProductID AND cpsr.SearchID = 227568 
    WHERE cppev.ProductSkeletonID in (3191, 3160, 3158, 3201)
    GROUP BY cppev.ProductSkeletonID, cppev.Value

    Table 'Worktable'. Scan count 0, logical reads 0, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
    Table 'table2'. Scan count 4, logical reads 584, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
    Table 'table_results'. Scan count 1, logical reads 82, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

    SQL Server Execution Times:
       CPU time = 484 ms,  elapsed time = 796 ms.

  |--Compute Scalar(DEFINE:([Expr1005]=CONVERT_IMPLICIT(int,[Expr1008],0)))
       |--Stream Aggregate(GROUP BY:([cppev].[Value], [cppev].[ProductSkeletonID]) DEFINE:([Expr1008]=Count(*)))
            |--Sort(ORDER BY:([cppev].[Value] ASC, [cppev].[ProductSkeletonID] ASC))
                 |--Hash Match(Inner Join, HASH:([cpsr].[ProductID])=([cppev].[ProductID]), RESIDUAL:([auctori_core_v40_D].[dbo].[table2].[ProductID] as [cppev].[ProductID]= [dbo].[table2].[ProductID] as [cpsr].[ProductID]))
                      |--Index Seek(OBJECT:([dbo].[table_results].[IX_table_results_SearchID] AS [cpsr]), SEEK:([cpsr].[SearchID]=(227568)) ORDERED FORWARD)
                      |--Index Seek(OBJECT:([dbo].[table2].[IX_table2_productskeletonid] AS [cppev]), SEEK:([cppev].[ProductSkeletonID]=(3158) OR [cppev].[ProductSkeletonID]=(3160) OR [cppev].[ProductSkeletonID]=(3191) OR [cppev].[ProductSkeletonID]=(3201)) ORDERED FORWARD)

Introdução:

Banco de dados PostgreSQL com várias centenas de funções armazenadas, incluindo obsoletas, não usadas etc.

Problema

Preciso descobrir todas as funções armazenadas que tenham alguma relação com a tabela X - pois quero alterar a estrutura da tabela. Alguns deles podem não ser usados, então não posso fazer isso apenas olhando o código.

A solução que tenho no ATM está executando a saída do psql \df+e do grepping, mas eu prefiro uma solução mais parecida com o banco de dados, ou seja, usando o esquema de informações. Esta será definitivamente uma tarefa repetitiva e eu gostaria de tê-la agradável e limpa.

Alguma sugestão?

Não consigo encontrar documentação que descreva os formatos válidos de um nome de esquema PostgreSQL. Eu sei que um nome de esquema não pode:

• comece com um número
• ter espaços
• começar compg_

O que mais? Onde devo procurar?

No DB2, tenho uma tabela contendo grandes dados binários. Agora limpei toda a tabela e executei runstats, reorg, runstats, mas a quantidade de espaço em disco ocupado não muda. Oque pode estar errado aqui?

A tabela reside em seu próprio tablespace que criei da seguinte forma:

CREATE BUFFERPOOL "MY_BP" SIZE 250 AUTOMATIC PAGESIZE 4096;
CREATE LARGE TABLESPACE MY_TBS IN DATABASE PARTITION GROUP IBMDEFAULTGROUP PAGESIZE 4096 MANAGED BY AUTOMATIC STORAGE EXTENTSIZE 64 PREFETCHSIZE 64 BUFFERPOOL MY_BP OVERHEAD 10.500000 TRANSFERRATE 0.140000 FILE SYSTEM CACHING;

Eu apaguei/reorganizei da seguinte forma:

DELETE FROM MY_TBL
RUNSTATS ON TABLE MY_TBL WITH DISTRIBUTION AND DETAILED INDEXES ALL
REORG TABLE MY_TBL
RUNSTATS ON TABLE MY_TABLE WITH DISTRIBUTION AND DETAILED INDEXES ALL
ALTER TABLESPACE MY_TBS REDUCE

A tabela MY_TBL ocupava 2,5 GB antes de tudo isso e depois de deletar/reordenar usa apenas 3 MB a menos.

FWIW: Estou executando o DB2/NT v9.5.2.

Estou atrás de alguma confirmação dessa ideia para consertar um banco de dados com desempenho ruim ou uma sugestão melhor, se alguém tiver uma. Sempre aberto a melhores sugestões.

Eu tenho um banco de dados muito grande (mais de 20 milhões de registros crescendo cerca de 1/2 milhão por dia) que está usando GUID como PK.

Um descuido da minha parte, mas o PK está agrupado no servidor SQL e está causando problemas de desempenho.

O motivo de um guid - esse banco de dados é parcialmente sincronizado com 150 outros bancos de dados, portanto, o PK precisava ser exclusivo. A sincronização não é gerenciada pelo SQL Server, mas há um processo personalizado criado que mantém os dados sincronizados para os requisitos do sistema - tudo com base nesse GUID.

Cada um dos 150 bancos de dados remotos não armazena os dados completos armazenados no banco de dados SQL central. eles armazenam apenas um subconjunto dos dados de que realmente precisam, e os dados exigidos não são exclusivos deles (10 dos 150 bancos de dados podem ter alguns dos mesmos registros de bancos de dados de outros sites, por exemplo - eles compartilham). Além disso - os dados são realmente gerados nos sites remotos - não no ponto central - daí a necessidade dos GUIDs.

O banco de dados central é usado não apenas para manter tudo sincronizado, mas as consultas de mais de 3.000 usuários serão executadas nesse banco de dados fragmentado muito grande. Isso já é um grande problema nos testes iniciais.

Felizmente, ainda não estamos ativos - então posso fazer alterações e colocar as coisas offline, se necessário, o que é pelo menos alguma coisa.

O desempenho dos bancos de dados remotos não é um problema - os subconjuntos de dados são muito pequenos e o banco de dados geralmente nunca fica acima de 1 GB de tamanho total. Os registros são alimentados de volta ao sistema principal regularmente e removidos dos BDs menores quando não são mais necessários.

O desempenho do banco de dados central, que é o guardião de todos os registros, é lamentável - devido a um GUID agrupado como chave primária para tantos registros. A fragmentação do índice está fora dos gráficos.

Então - meus pensamentos para corrigir o problema de desempenho é criar uma nova coluna - Unsigned BIGINT IDENTITY (1,1) e, em seguida, alterar o Clustered PK da coluna BIGINT da tabela.

Eu criaria um índice exclusivo não clusterizado no campo GUID, que era a chave primária.

Os 150 bancos de dados remotos menores não precisam saber sobre o novo PK no banco de dados Central SQL Server - ele será usado exclusivamente para organizar os dados no banco de dados e interromper o mau desempenho e a fragmentação.

Isso funcionaria e melhoraria o desempenho do banco de dados SQL central e evitaria o futuro inferno da fragmentação do índice (até certo ponto, é claro)? ou eu perdi algo muito importante aqui que vai pular e me morder e causar ainda mais dor?

Existe uma diferença de desempenho entre essas duas consultas de exemplo?

Consulta 1:

select count(*)
from   table1 a
join   table2 b
on     b.key_col=a.key_col
where  b.tag = 'Y'

Consulta 2;

select count(*)
from   table1 a
join   table2 b
on     b.key_col=a.key_col
   and b.tag = 'Y'

Observe que a única diferença é a colocação da condição suplementar; o primeiro usa uma WHEREcláusula e o segundo adiciona a condição à ONcláusula.

Quando executo essas consultas em meu sistema Teradata, os planos de explicação são idênticos e a etapa JOIN mostra a condição adicional em cada caso. No entanto, nesta questão do SO em relação ao MySQL, uma das respostas sugeriu que o segundo estilo é preferido porque WHEREo processamento ocorre após as junções serem feitas.

Existe uma regra geral a seguir ao codificar consultas como esta? Acho que deve depender da plataforma, pois obviamente não faz diferença no meu banco de dados, mas talvez seja apenas um recurso do Teradata. E se for dependente da plataforma, gostaria muito de obter algumas referências de documentação; Eu realmente não sei o que procurar.

Anteriormente criei um usuário:

SQL>create user suhail identified by password
SQL>User created.
SQL>Grant create session,create table to suhail;
SQL>Grant Succeeded.

mas quando eu entro como suhaile tento criar um tablerecebo um erro dizendo ORA-01950: no privileges on tablespace 'SYSTEM'. Que erro é? Por que ocorre?

SQL> connect suhail
Enter password:
Connected.
SQL> create table suhail_table(name char(10));
create table suhail_table(name char(10))
*
ERROR at line 1:
ORA-01950: no privileges on tablespace 'SYSTEM'

Estou usando o Oracle Database 11g Express Edition Release 11.2.0.2.0

Estamos usando o SQL Server 2012 com um identificador exclusivo e notamos que ao fazer seleções com caracteres adicionais adicionados ao final (portanto, não 36 caracteres), ele ainda retorna uma correspondência para um UUID.

Por exemplo:

select * from some_table where uuid = '7DA26ECB-D599-4469-91D4-F9136EC0B4E8' 

retorna a linha com uuid 7DA26ECB-D599-4469-91D4-F9136EC0B4E8.

Mas se você executar:

select * from some_table where uuid = '7DA26ECB-D599-4469-91D4-F9136EC0B4E8EXTRACHARS'

ele também retorna a linha com o uuid 7DA26ECB-D599-4469-91D4-F9136EC0B4E8.

O SQL Server parece ignorar todos os caracteres além de 36 ao fazer suas seleções. Isso é um bug/recurso ou algo que pode ser configurado?

Não é um problema enorme, pois temos validação no front-end para o comprimento, mas não parece um comportamento correto para mim.

Eu uso um software que faz um grande banco de dados PostgreSQL (há uma tabela com um milhão de linhas) e os desenvolvedores dizem que eu deveria VACUUMe ANALYZEperiodicamente. Mas o padrão do banco de dados PostgreSQL está autovacuumativado.

Devo aspirar/analisar? Quais são os benefícios? Qual é a diferença entre vácuo automático e manual

Por exemplo, no Pgadmin3, eu tenho isso:

Eu tenho uma tabela grande (~ 50 milhões de linhas) estou tentando inserir em massa no SQL Server e recebo o erro:

Não foi possível alocar espaço para o objeto 'myDB' no banco de dados 'I 3 Stroke' porque o grupo de arquivos 'PRIMARY' está cheio. Crie espaço em disco excluindo arquivos desnecessários, descartando objetos no grupo de arquivos, adicionando arquivos adicionais ao grupo de arquivos ou definindo o crescimento automático para arquivos existentes no grupo de arquivos.

Há outra tabela no banco de dados com cerca de 25 milhões de linhas. Esse banco de dados será usado apenas em uma única máquina e será projetado para extrair dados que já existem e, sob nenhuma circunstância, crescerá além de seu tamanho atual.

Para uma situação como essa, qual é a melhor maneira de resolver isso para que o SQL Server não reclame? A solução será importante para que esse banco de dados não seja exposto a vários usuários?