All perguntas(dba)

Temos um banco de dados SQL que é um banco de dados secundário ou devo dizer uma réplica secundária em um AlwaysOn Availabiltity Group. Como resultado, o banco de dados é sempre um banco de dados somente leitura e, portanto, não posso executar o procedimento armazenado abaixo porque o procedimento armazenado tenta criar uma nova tabela... basicamente, recebo a mensagem de erro:

Failed to update database xxxxxx because the database is read-only.

Foi sugerido que uma solução alternativa seria modificar o procedimento para SELECT ... INTO uma tabela em um banco de dados diferente (que não seja somente leitura/não faça parte de um AlwaysOn Availability Group) que esteja no mesmo servidor. Por exemplo:

INTO SomeOtherDatabase.' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + '

Alguém pode dar uma olhada no meu código e ajudar a modificá-lo?

Eu tentei o seguinte:

INTO tempdb.dbo.@DeltaTable' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + '

O procedimento acima não funcionou.

O procedimento completo é o seguinte:

CREATE PROCEDURE dbo.GenerateDeltaTable
    @Domain VARCHAR(100),
    @TableName VARCHAR(100),
    @DeltaTable VARCHAR(100)
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE @sql NVARCHAR(MAX);

    -- Construct dynamic SQL for dropping and creating the target table
    SET @sql = '
    IF OBJECT_ID(''' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + ''', ''U'') IS NOT NULL
        DROP TABLE ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + ';

    SELECT T.*, 
           LOWER(CONVERT(VARCHAR(64), HASHBYTES(''SHA2_256'', 
           (SELECT T.* FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)), 2)) AS signature 
    INTO ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + '
    FROM ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@TableName) + ' AS T;';

    -- Execute the constructed SQL
    EXEC sp_executesql @sql;
END;

Alguma ideia sobre como criar a tabela do procedimento armazenado para outro banco de dados

Estou me preparando para atualizar os nós de 3.11.17 para 4.1.7. Fiz a atualização com sucesso manualmente com alguns nós de desenvolvimento, mas quero tornar isso mais repetível com o Ansible. Estou executando em servidores Ubuntu, então tenho que lutar com o apt iniciando o serviço automaticamente. Imaginando qual seria o processo mais kosher de fazer essas atualizações sem o apt jogando arquivos padrão para mim e possivelmente bagunçando as coisas. Meus pensamentos são:

1. drenar e parar um nó
2. Modelo nos meus arquivos cassandra.yaml e rack properties necessários
3. Faça a instalação do cassandra 4.1.7
4. Lidar com a inicialização automática do apt cassandra

Isso significa desastre? Meus dados não estão no caminho padrão da configuração que vem do mantenedor do pacote (/var/lib/cassandra), e algumas das minhas variáveis ​​de configuração não estão mais presentes no 4.1, então eu esperaria que o cassandra travasse na inicialização, vendo as variáveis ​​não reconhecidas (que eu encontrei com meus testes de desenvolvimento). O que eu REALMENTE gostaria é de instalar o cassandra e dar uma boa olhada antes de começar, mas não tenho esse luxo. Em vários testes, parar o cassandra imediatamente após uma instalação bem-sucedida não funcionou, o cassandra persistia.

Temos um Banco de Dados SQL secundário que está constantemente sincronizando com o banco de dados primário. No passado, executei um procedimento armazenado no banco de dados secundário (mesmo enquanto ele estava sincronizando) com sucesso.

Por algum motivo, agora estou recebendo a seguinte mensagem de erro quando tento executar o mesmo procedimento armazenado

Failed to update database xxxxxx because the database is read-only.

O procedimento armazenado é o seguinte:

CREATE PROCEDURE dbo.GenerateDeltaTable
    @Domain VARCHAR(100),
    @TableName VARCHAR(100),
    @DeltaTable VARCHAR(100)
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE @sql NVARCHAR(MAX);

    -- Construct dynamic SQL for dropping and creating the target table
    SET @sql = '
    IF OBJECT_ID(''' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + ''', ''U'') IS NOT NULL
        DROP TABLE ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + ';

    SELECT T.*, 
           LOWER(CONVERT(VARCHAR(64), HASHBYTES(''SHA2_256'', 
           (SELECT T.* FOR JSON PATH, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES)), 2)) AS signature 
    INTO ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@DeltaTable) + '
    FROM ' + QUOTENAME(@Domain) + '.' + QUOTENAME(@TableName) + ' AS T;';

    -- Execute the constructed SQL
    EXEC sp_executesql @sql;
END;

Alguém pode me dizer por que estou recebendo o erro de repente?

Ou existe alguma maneira de fazer com que o banco de dados SQL primário force a execução de um procedimento armazenado no banco de dados secundário?

Basicamente, existe uma maneira de superar a situação de somente leitura no banco de dados secundário?

Tenho um banco de dados PostgreSQL 16 configurado com a seguinte configuração:

-- DB Version: 16
-- OS Type: linux
-- DB Type: oltp
-- Total Memory (RAM): 64 GB
-- CPUs num: 32
-- Connections num: 200
-- Data Storage: ssd

show effective_cache_size; --48 GB
show effective_io_concurrency; --200
show huge_pages; --try
show maintenance_work_mem; --4GB
show max_connections; --200
show max_parallel_maintenance_workers; --4
show max_parallel_workers; --32
show max_parallel_workers_per_gather; --4
show max_wal_size; --8GB
show max_worker_processes; --32
show min_wal_size; --2GB
show parallel_setup_cost; --0.1
show random_page_cost; --1.1
show shared_buffers; --16GB
show wal_buffers; --16MB
show work_mem; --256MB

Estou executando uma CREATE TABLEconsulta com múltiplas junções. Às vezes, a consulta é executada em paralelo, mas outras vezes não. Quero garantir que a consulta seja executada em paralelo ou, pelo menos, aumentar as chances de ela ser executada em paralelo para aquela sessão de transação específica. Também é bom se os trabalhadores paralelos atribuídos forem menos do que o normal, porque sem trabalhadores paralelos a consulta é muito lenta.

A configuração abaixo funcionou melhor para mim por algum tempo, mas causou um erro semelhante a este problema .

ALTER SYSTEM SET maintenance_work_mem = '8GB';
ALTER SYSTEM SET work_mem = '2GB';
ALTER SYSTEM SET effective_io_concurrency = '400';
ALTER SYSTEM SET max_parallel_workers_per_gather = '16';
ALTER SYSTEM SET wal_buffers = '1GB';

Estou anexando um plano de consulta selecionado para referência: plano de consulta .

Quero maximizar a utilização da CPU (atualmente menos de 10%) e a utilização da RAM (atualmente menos de 30%).

Estou ciente de que force_parallel_modefoi descontinuado. Como posso obter execução paralela consistente para minhas consultas no PostgreSQL?

Como posso acelerar esta consulta abaixo? Tenho uma tabela ~grande com url_meta90 milhões de registros, 38 GB de dados, 6 GB de índice

O ID exclusivo principal de cada linha é url_hash(um md5 truncado para 16 caracteres)

Então criei um grande índice de texto completo chamado url_meta_index, contendo estas colunas:

• título_url
• url_descrição
• palavras-chave url
• url_paragrafos

A tabela também contém uma coluna indexada chamadaurl_total_links_in

1. Se eu selecionar apenas as URLs com muitos links, o processo será muito rápido e, o mais importante, há apenas 240 linhas com mais de 1.000 links:

SELECT * FROM url_meta WHERE url_total_links_in > 1000
240 rows in set (0.01 sec)

2. Mas se eu pesquisar no índice de texto grande DEPOIS da mesma consulta (selecionando as mesmas linhas acima) , isso demora uma eternidade:

    mysql> 
    SELECT  *
    FROM  url_meta
    WHERE  url_total_links_in > 1000
      AND  match(url_title, url_description, url_keywords, url_paragraphs)
        against('computer store' IN BOOLEAN MODE)
    LIMIT  500;
   
    10 rows in set (4 min 4.94 sec)
   

Eu esperava match againstque a segunda parte olhasse apenas os 240 registros que encontrou por url_total_links_in > 1000, não é assim que funciona ? Pelo longo tempo de consulta, acho que ele olha todos os 90 milhões de registros.

Por PHP, posso selecionar as 240 linhas na primeira consulta e, em seguida, fazer um loop sobre essas poucas linhas para "comparar" com o texto mostrado na segunda consulta. Mas como posso fazer isso pelo MySQL?

Ajudaria se eu ... incluísse o id de linha exclusivo ( url_hash) no índice de texto multicoluna grande url_meta_index? Ou ajuda se eu adicionar a coluna url_total_links_inao mesmo índice de texto multicoluna url_meta_index? Algum outro operador MySQL que ajudaria neste caso? Ou alguma variável MySQL que seria relevante neste caso?

Edição posterior, incluindo mais detalhes:

DESCRIBE url_meta;
+--------------------+--------------+------+-----+---------+-------+
| Field              | Type         | Null | Key | Default | Extra |
+--------------------+--------------+------+-----+---------+-------+
| url_hash           | char(16)     | NO   | PRI | NULL    |       |
| url_sharding       | char(2)      | YES  | MUL | NULL    |       |
| url                | varchar(512) | NO   |     | NULL    |       |
| url_title          | varchar(128) | YES  | MUL | NULL    |       |
| url_description    | text         | YES  |     | NULL    |       |
| url_keywords       | varchar(128) | YES  |     | NULL    |       |
| url_paragraphs     | mediumtext   | YES  |     | NULL    |       |
| url_total_links_in | smallint     | NO   | MUL | 0       |       |
| url_meta_date      | int          | NO   |     | 0       |       |
| url_misc           | tinyint      | YES  |     | NULL    |       |
+--------------------+--------------+------+-----+---------+-------+

EXPLAIN ANALYZE SELECT * FROM url_meta WHERE url_total_links_in > 1000 AND match(url_title, url_description, url_keywords, url_paragraphs) against('computer store' IN BOOLEAN MODE) LIMIT 500;
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| EXPLAIN                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| -> Limit: 500 row(s)  (cost=0.40 rows=0.05) (actual time=2582.991..21198.806 rows=10 loops=1)
    -> Filter: ((url_meta.url_total_links_in > 1000) and (match url_meta.url_title,url_meta.url_description,url_meta.url_keywords,url_meta.url_paragraphs against ('computer store' in boolean mode)))  (cost=0.40 rows=0.05) (actual time=2582.991..21198.800 rows=10 loops=1)
        -> Full-text index search on url_meta using url_meta_index (url_title='computer store')  (cost=0.40 rows=1) (actual time=312.284..21096.609 rows=1247864 loops=1)
 |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (23.36 sec)

SHOW INDEX FROM url_meta;
+----------+------------+--------------------+--------------+--------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| Table    | Non_unique | Key_name           | Seq_in_index | Column_name        | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment | Visible | Expression |
+----------+------------+--------------------+--------------+--------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
| url_meta |          0 | PRIMARY            |            1 | url_hash           | A         |    81358144 |     NULL |   NULL |      | BTREE      |         |               | YES     | NULL       |
| url_meta |          1 | url_total_links_in |            1 | url_total_links_in | A         |        2790 |     NULL |   NULL |      | BTREE      |         |               | YES     | NULL       |
| url_meta |          1 | url_sharding       |            1 | url_sharding       | A         |        1590 |     NULL |   NULL | YES  | BTREE      |         |               | YES     | NULL       |
| url_meta |          1 | url_meta_index     |            1 | url_title          | NULL      |    81358147 |     NULL |   NULL | YES  | FULLTEXT   |         |               | YES     | NULL       |
| url_meta |          1 | url_meta_index     |            2 | url_description    | NULL      |    81358147 |     NULL |   NULL | YES  | FULLTEXT   |         |               | YES     | NULL       |
| url_meta |          1 | url_meta_index     |            3 | url_keywords       | NULL      |    81358147 |     NULL |   NULL | YES  | FULLTEXT   |         |               | YES     | NULL       |
| url_meta |          1 | url_meta_index     |            4 | url_paragraphs     | NULL      |    81358147 |     NULL |   NULL | YES  | FULLTEXT   |         |               | YES     | NULL       |
+----------+------------+--------------------+--------------+--------------------+-----------+-------------+----------+--------+------+------------+---------+---------------+---------+------------+
7 rows in set (0.00 sec)

Eu sei que esse numericé um tipo de dado "exato", que representa números com a maior precisão possível para que não haja erros de ponto flutuante, como nos tipos de dados floatou real.

Mas e quanto a numeric(p,s)? Ele deve aproximar um número por causa da escala fixa, mas ele tem imprecisões de ponto flutuante ou é “seguro”? Não consegui encontrar nenhuma informação sobre ele. Talvez seja óbvio, mas eu gostaria de entender melhor esse aspecto.

Estou tentando conceder a permissão [CONNECT ANY DATABASE] a uma conta SQL específica em várias instâncias. No entanto, um servidor está executando o SQL Server 2012 e essa permissão não foi introduzida até 2014.

Tenho procurado maneiras adicionais de lidar com esse erro específico graciosamente para que o restante do script que concede permissões adicionais seja executado. Atualmente, o script lança um erro de finalização do analisador?.

Aqui está a seção do código com o problema:

IF NOT EXISTS 
(
    SELECT *
    FROM sys.server_permissions AS perm 
        INNER JOIN sys.server_principals AS prin 
            ON perm.grantee_principal_id = prin.principal_id
    WHERE perm.permission_name = 'CONNECT ANY DATABASE' 
    AND prin.name = '<ServerPrincipal>'
)
BEGIN
    GRANT CONNECT ANY DATABASE TO [<ServerPrincipal>];
END;

O erro é: " Sintaxe incorreta perto de 'CONNECT'. "

Tentei o seguinte, mas não funcionou.

1. Usando um bloco TRY-CATCH
2. Adicionando lógica adicional à condição IF

AND ( SERVERPROPERTY('servername') <> '<2012ServerName>' )

Finalmente encontrei uma solução viável, mas queria aprender sobre outras maneiras pelas quais as pessoas resolveram um problema semelhante.

IF NOT EXISTS 
(
    SELECT *
    FROM sys.server_permissions AS perm 
        INNER JOIN sys.server_principals AS prin 
            ON perm.grantee_principal_id = prin.principal_id
    WHERE perm.permission_name = 'CONNECT ANY DATABASE' 
    AND prin.name = '<ServerPrincipal>'
)
AND ( SERVERPROPERTY('servername') <> '<2012ServerName>' )
BEGIN
    DECLARE @String NVARCHAR(150)
    SET @String = 'GRANT CONNECT ANY DATABASE TO [<ServerPrincipal>];';
    EXEC sp_executesql @Command = @String;
END

Estamos implementando o MaxScale como um proxy de banco de dados entre nosso aplicativo e o banco de dados hospedado no AWS Aurora MySQL.

Configurei o MaxScale e verifiquei que todos os servidores podem se conectar e, quando me conecto do servidor de aplicativo ao ponto de extremidade do proxy via CLI, tudo funciona:

mysql -h proxy.end.point -u admin -p

Isso funciona muito bem como esperado e abre uma conexão. Posso chamar use db_name;e alterar bancos de dados sem problemas, por exemplo:

Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 76
Server version: 8.0.32 Source distribution

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]> use db_name;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
MySQL [db_name]>

No entanto, o que é super bizarro é que quando especifico o db_namecomo um argumento cli, recebo um erro de permissão:

 mysql -h proxy.end.point -u admin -p db_name

ERROR 1044 (42000): Access denied for user 'admin'@'ip.of.data.base' to database 'db_name'

Não tenho certeza se isso é um problema com o adminusuário mysql ou se é alguma nuance com o MaxScale, mas estava curioso para saber se alguém tem alguma informação.

Para referência, estou usando um maxscaleusuário como proxy e ele tem as seguintes permissões:

GRANT SHOW DATABASES ON *.* TO `maxscale`@`%`
GRANT SELECT ON `mysql`.* TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`columns_priv` TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`db` TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`procs_priv` TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`proxies_priv` TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`tables_priv` TO `maxscale`@`%`
GRANT SELECT ON `mysql`.`user` TO `maxscale`@`%`

Aqui está o conteúdo do meu /etc/maxscale.cnfarquivo:

[maxscale]
threads=auto
debug=enable-statement-logging

[db_writer]
type=server
address=rds-writer-endpoint.rds.amazonaws.com
port=3306

[db_reader]
type=server
address=rds-reader-endpoint.rds.amazonaws.com
port=3306

[Read-Write-Service]
type=service
router=readwritesplit
servers=db_writer,db_reader
user=maxscale
password=maxscale_password

[Read-Write-Listener]
type=listener
service=Read-Write-Service
protocol=MariaDBClient
port=3306

Eu instalei a versão maxscale 24.02.4.

Qualquer ajuda é bem-vinda. Obrigado!

Notei que há dois SQL Servers instalados na mesma máquina, que são 2014 e 2019; no entanto, quando entro no SSMS e digito select @@version, ele mostra 2014, e o nome da instância é exibido como servername\sqlexpress.

Gostaria de saber como posso encontrar o nome da instância do SQL 2019.

Eu me esforcei muito para tentar entender o processo de pg_dump e pg_restore, mas há algumas coisas importantes que ainda não entendi. Meu objetivo é copiar um esquema de um banco de dados de produção com muitas funções para minha replicação local, onde preciso usar apenas um usuário administrador do postgres.

Eu despejo myschema com esta sintaxe

pg_dump -h "pgprod" -p "5432" -d prod_db -U "myuser" -Fc  -C --verbose --schema "myschema" -f .\test.backup

Restaurar

pg_restore -U postgres -h localhost -p 5432 -d localdb -C -v --no-acl --role=postgres test.backup

Mas não consigo descobrir como ignorar qualquer forma de funções que existisse no prod_db. Também tentei o sinalizador –no-owner com o mesmo resultado. Estou completamente preso nesta etapa, pois não entendo por que isso está acontecendo. Executando postgres 16

pg_restore: error: could not execute query: ERROR:  role "user1" does not exist
Command was: ALTER TABLE public."mytable" OWNER TO user1;