All perguntas(dba)

Precisamos criar o valor de hash dos dados nvarchar para fins de comparação. Existem vários algoritmos de hash disponíveis no T-SQL, mas qual é o melhor para escolher neste cenário?

Queremos garantir que o risco de ter um valor de hash duplicado para dois valores nvarchar diferentes seja o mínimo. Com base em minha pesquisa na internet, o MD5 parece o melhor. Isso está certo? O MSDN nos informa (link abaixo) sobre os algoritmos disponíveis, mas nenhuma descrição sobre qual deles para quais condições?

HASHBYTES (Transact-SQL)

Precisamos unir duas tabelas em duas colunas nvarchar(max). Como você pode imaginar, a consulta leva muito tempo para ser executada. Achamos que seria melhor manter o valor de hash de cada dado nvarchar(max) e fazer a junção nos valores de hash em vez dos valores nvarchar(max) que são blobs. A questão é qual algoritmo de hash fornece a exclusividade, para que não corramos o risco de ter um valor de hash para mais de um nvarchar(max).

Pelo que entendi, a consistência no ACID está garantindo a integridade dos dados.

No entanto, a consistência no CAP significa que os dados podem aparecer rapidamente no sistema distribuído.

Isso significa: eles não são o mesmo conceito?

SUB-ÁRVORE DENTRO DE UMA ÁRVORE no MySQL

No meu MYSQL Database COMPANY, tenho uma Table: Employeeassociação recursiva, um funcionário pode ser chefe de outro funcionário. A self relationship of kind (SuperVisor (1)- SuperVisee (∞) ).

Consulta para criar tabela:

CREATE TABLE IF NOT EXISTS `Employee` (
  `SSN` varchar(64) NOT NULL,
  `Name` varchar(64) DEFAULT NULL,
  `Designation` varchar(128) NOT NULL,
  `MSSN` varchar(64) NOT NULL, 
  PRIMARY KEY (`SSN`),
  CONSTRAINT `FK_Manager_Employee`  
              FOREIGN KEY (`MSSN`) REFERENCES Employee(SSN)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Eu inseri um conjunto de tuplas (Query):

INSERT INTO Employee VALUES 
 ("1", "A", "OWNER",  "1"),  

 ("2", "B", "BOSS",   "1"), # Employees under OWNER 
 ("3", "F", "BOSS",   "1"),

 ("4", "C", "BOSS",   "2"), # Employees under B
 ("5", "H", "BOSS",   "2"), 
 ("6", "L", "WORKER", "2"), 
 ("7", "I", "BOSS",   "2"), 
 # Remaining Leaf nodes   
 ("8", "K", "WORKER", "3"), # Employee under F     

 ("9", "J", "WORKER", "7"), # Employee under I     

 ("10","G", "WORKER", "5"), # Employee under H

 ("11","D", "WORKER", "4"), # Employee under C
 ("12","E", "WORKER", "4")  

As linhas inseridas têm o seguinte Tree-Hierarchical-Relationship :

         A     <---ROOT-OWNER
        /|\             
       / A \        
      B     F 
    //| \    \          
   // |  \    K     
  / | |   \                     
 I  L H    C        
/     |   / \ 
J     G  D   E

Eu escrevi uma consulta para encontrar o relacionamento:

SELECT  SUPERVISOR.name AS SuperVisor, 
        GROUP_CONCAT(SUPERVISEE.name  ORDER BY SUPERVISEE.name ) AS SuperVisee, 
        COUNT(*)  
FROM Employee AS SUPERVISOR 
  INNER JOIN Employee SUPERVISEE ON  SUPERVISOR.SSN = SUPERVISEE.MSSN 
GROUP BY SuperVisor;

E a saída é:

+------------+------------+----------+
| SuperVisor | SuperVisee | COUNT(*) |
+------------+------------+----------+
| A          | A,B,F      |        3 |
| B          | C,H,I,L    |        4 |
| C          | D,E        |        2 |
| F          | K          |        1 |
| H          | G          |        1 |
| I          | J          |        1 |
+------------+------------+----------+
6 rows in set (0.00 sec)

[ PERGUNTA ]
Em vez de uma árvore hierárquica completa, preciso SUB-TREEde um ponto (seletivo), por exemplo:
Se Bo argumento de entrada for, a saída deve ser como abaixo ...

+------------+------------+----------+
| SuperVisor | SuperVisee | COUNT(*) |
+------------+------------+----------+
| B          | C,H,I,L    |        4 |
| C          | D,E        |        2 |
| H          | G          |        1 |
| I          | J          |        1 |
+------------+------------+----------+   

Por favor me ajude nisso. Se não for uma consulta, um procedimento armazenado pode ser útil.
Eu tentei, mas todos os esforços foram inúteis!

Eu preciso de uma consulta que pode ser usada em (ou como) uma função e recupera todas as combinações de n valores. E eu preciso de todas as combinações de comprimento k onde k = 1..n.

Entrada e resultado de amostra estendida para que a entrada tenha 3 valores em vez de 2 - no entanto, o número de valores de entrada pode variar de 1 a n.

Exemplo: Entrada: tabela com valores em uma coluna em várias linhas

Value  (nvarchar(500))
------
Ann
John
Mark

Saída#1: tabela com valores concatenados em uma coluna

    Ann
    John
    Mark
    Ann,John
    John,Mark
    Ann,Mark
    Ann,John,Mark

Estou seguindo o guia - http://www.sqlchicken.com/2009/07/how-to-create-a-server-side-trace-with-sql-profiler/ que está funcionando até chegar à Etapa 8

8. Agora para agendar seu script recém-criado. No SSMS, conecte-se ao servidor no qual deseja rastrear. Vá para o SQL Server Agent e expanda-o para ver a pasta Jobs. Clique com o botão direito do mouse na pasta Trabalhos e selecione Novo Trabalho.

não consigo não encontrar SQL Server Agent. Onde posso tornar isso SQL Server Agentvisível? Eu dei ao usuário atual toda a permissão de acesso.

Aprendi sobre normalização recentemente e entendo o quão importante é ao implementar um novo esquema.

Como posso verificar se meu banco de dados é compatível com 2NF ou 3NF?

A revisão manual é uma opção segura, mas estou procurando uma ferramenta automatizada aqui.

Não estou procurando uma ferramenta de apontar e clicar, mas algo que destacaria possíveis otimizações para tornar uma tabela compatível com 3NF. Eu acho que pode usar estatísticas baseadas em bons dados de amostra e/ou análise semântica dos nomes das colunas.

Para fins de solução de problemas, gostaria de poder verificar se um cliente pode se conectar a uma instância do SQL Server, independentemente do aplicativo que possivelmente não pode se conectar ao SQL Server.

Existe uma maneira fácil (ou seja, não ter que instalar software de terceiros) para fazer isso usando as ferramentas padrão do sistema Windows? Talvez usando scripts ou aplicativos de rede?

É possível ao usar o pgadminou plsqlobter um plano de consulta para uma instrução sql executada dentro de uma função definida pelo usuário ( UDF ) usando EXPLAIN. Então, como obtenho o plano de consulta para uma invocação específica de uma UDF? Vejo o UDF abstraído em uma única operação F()no pgadmin.

Já procurei na documentação mas não encontrei nada.

Atualmente, estou retirando as instruções e executando-as manualmente. Mas isso não vai cortá-lo para grandes consultas.

Por exemplo, considere o UDF abaixo. Essa UDF, embora tenha a capacidade de imprimir sua string de consulta, não funcionará com um copiar e colar, pois possui uma tabela temporária criada localmente, que não existe quando você a cola e executa.

CREATE OR REPLACE FUNCTION get_paginated_search_results(
    forum_id_ INTEGER,
    query_    CHARACTER VARYING,
    from_date_ TIMESTAMP WITHOUT TIME ZONE DEFAULT NULL,
    to_date_ TIMESTAMP WITHOUT TIME ZONE DEFAULT NULL,
    in_categories_ INTEGER[] DEFAULT '{}')
RETURNS SETOF post_result_entry AS $$
DECLARE
    join_string CHARACTER VARYING := ' ';
    from_where_date CHARACTER VARYING := ' ';
    to_where_date CHARACTER VARYING := ' ';
    query_string_ CHARACTER VARYING := ' ';
BEGIN
    IF NOT from_date_ IS NULL THEN
        from_where_date := ' AND fp.posted_at > ''' || from_date_ || '''';
    END IF;

    IF NOT to_date_ IS NULL THEN
        to_where_date := ' AND fp.posted_at < ''' || to_date_ || '''';
    END IF;

    CREATE LOCAL TEMP TABLE un_cat(id) ON COMMIT DROP AS (select * from unnest(in_categories_)) ;

    if in_categories_ != '{}' THEN
        join_string := ' INNER JOIN forum_topics ft ON fp.topic_id = ft.id ' ||
        ' INNER JOIN un_cat uc ON uc.id = ft.category_id ' ;
    END IF;

    query_string_ := '
    SELECT index,posted_at,post_text,name,join_date,quotes
    FROM forum_posts fp
    INNER JOIN forum_user fu ON
    fu.forum_id = fp.forum_id AND fu.id = fp.user_id' ||
        join_string
    ||
    'WHERE fu.forum_id = ' || forum_id_ || ' AND
    to_tsvector(''english'',fp.post_text) @@ to_tsquery(''english'','''|| query_||''')' || 
        from_where_date || 
        to_where_date
    ||';';

    RAISE NOTICE '%', query_string_ ;

    RETURN QUERY
    EXECUTE query_string_;
END;
$$ LANGUAGE plpgsql;

Percebi que minha empresa usa um processo ELT (extract-load-transform) em vez de usar um processo ETL (extract-transform-load).
Quais são as diferenças entre as duas abordagens e em quais situações uma seria "melhor" que a outra? Seria ótimo se você pudesse fornecer alguns exemplos.

Eu tenho 170 GB de InnoDBíndice e dados.

Eu tenho que reajustar o tamanho do innodb_buffer_pool para melhor desempenho. O tamanho máximo da tabela do InnoDB (índice + dados) é 28 GB.

Então, qual deve ser o tamanho ideal de innodb_buffer_pool.

ATUALIZAR

vamos migrar nosso banco de dados local para o ec2, então definiremos a RAM de acordo com as estatísticas atuais do innodb, por isso preciso do tamanho do buffer pool para que possamos ter RAM disponível lá.

Arquivo por tabela está habilitado.

Estou usando máquina Linux.