All perguntas(dba)

Ao fazer login como um usuário específico do SQL Server, não consegui visualizar todos os bancos de dados na árvore do SSMS Explorer. Originalmente, pensei que fosse um problema de conta de usuário do SQL Server. Examinei a definição de Login, a definição de Usuário, comparei a linha Usuário nos vários bancos de dados em questão. Tudo combina.

Posteriormente, ficou evidente para mim que o problema está no SSMS, ou talvez em alguma tabela subjacente que o SSMS usa para renderizar sua árvore do Explorer. Porque os bancos de dados estão de fato disponíveis para este usuário. (Esse usuário está na função db_owner dos bancos de dados em questão e, na verdade, possui vários esquemas nesses bancos de dados. Esse usuário não pode ser eliminado desses bancos de dados.)

Então, aqui está o que vejo ao fazer login como o usuário em questão. A árvore do SSMS Explorer mostra apenas os bancos de dados master e rater8 . Existem dois outros bancos de dados neste servidor, mas estes não são mostrados na árvore do Explorer. No entanto, quando vou para uma janela de consulta e desço o seletor de banco de dados, vejo todos os quatro bancos de dados conforme esperado.

Quando faço login com essa mesma conta do SQL Server usando o Azure Data Studio, vejo todos os quatro bancos de dados conforme esperado.

Alguma ideia de por que o SQL Server está tendo problemas para renderizar os outros dois bancos de dados para esta conta de usuário específica? O problema depende da conta. Quando faço logon via SSMS usando várias contas diferentes, consigo ver todos os quatro bancos de dados na árvore do SSMS Explorer, conforme esperado. Aqui está uma captura de tela do que vejo quando faço login usando uma conta diferente:

Alguma ideia do que está causando o colapso na árvore do SSMS Explorer para uma conta específica do SQL Server? Obrigada pelo Conselho!

Sou muito novo em coisas de banco de dados.
Estou usando o Supabase para criar um aplicativo onde acompanho o número de curtidas em determinados itens ('cliques'). Quero filtrar os itens pela data em que as curtidas foram adicionadas ou por determinadas categorias dos itens. Até agora tenho uma função que posso chamar de javascript como:

const { data, error } = await supabase.rpc('rpc_test', { "json_params": {
  "categories": '{"fruits", "test"}',
  "start_date": "2024-04-16 00:22:35.837547+00",
} })

Que deve retornar todos os itens que possuem uma categoria correspondente à matriz que passei e o número de cliques que foram criados desde start_datee antes e end_datese fornecidos, ou zero se nenhum clique tiver sido criado nessa janela de tempo. E quase funciona, mas continuo encontrando erros que não sei como consertar.

As tabelas importantes em meu banco de dados são:

Unid:

Cliques:

Categorias:

Categorias de itens:

Minha consulta de função atualmente se parece com isto:

create
or replace function public.rpc_test (json_params json default null) returns table (
  id bigint,
  created_at timestamp with time zone,
  name text,
  clicks bigint,
  categories_arr text[]
) as $$
BEGIN
  RETURN QUERY
    select
      items.id,
      items.created_at,
      items.name,
      click_counts.clicks,
      item_id_to_cat_array.categories_arr
    from
      items
      LEFT JOIN (
          SELECT item_categories.item_id AS itemid, array_agg(categories.name) AS categories_arr
          FROM   item_categories
          JOIN   categories ON categories.id = item_categories.category_id
          GROUP  BY item_categories.item_id
      ) item_id_to_cat_array ON items.id = item_id_to_cat_array.itemid
      LEFT JOIN (
          SELECT item_id as click_item_id, count(c.id) AS clicks
          FROM clicks as c
          WHERE (json_params->>'start_date' IS NULL OR c.created_at >= (json_params->>'start_date')::date)
          AND (json_params->>'end_date' IS NULL OR c.created_at <= (json_params->>'end_date')::date)
          GROUP BY c.item_id
      ) click_counts ON click_item_id = items.id
    where
        json_params->>'categories' IS NULL OR 
        (json_params->>'categories')::text[] && item_id_to_cat_array.categories_arr;
END;
$$ language plpgsql;

O único problema com isso é que categories_arrnunca há dados.

Em vários pontos, tive iterações disso que funcionaram para coletar as informações que desejo, mas sem a filtragem implementada. Tentei fazer coisas com GROUP BY e HAVING e não tenho certeza de para onde ir.

Como posso obter mais informações sobre o que está acontecendo na minha consulta?
Gostaria de ver o categories_arrque está acontecendo em cada etapa do processo, mas não sei como registrar essas informações.

Eu tenho um grupo de disponibilidade do SQL Server 2019 de dois nós com um banco de dados que possui CDC habilitado para várias tabelas. O CDC é usado para rastrear transações que não foram capturadas para população em um data warehouse.

O Grupo de Disponibilidade é configurado com failover de várias sub-redes, com secundários legíveis.

O aplicativo replica as transações capturadas via CDC usando sp_repltrans para obter uma lista de transações, que então lê por meio da função não documentada fn_dump_dblog. Depois que uma transação for capturada e integrada ao data warehouse, o aplicativo marcará a transação como replicada por meio de sp_repldone . Nós o configuramos para ApplicationIntent=ReadOnlyconectar-se automaticamente ao nó secundário legível do Grupo de Disponibilidade.

O processo de captura/integração parece estar funcionando bem e se recupera bem durante um failover do Grupo de Disponibilidade, alternando automaticamente para o outro nó conforme necessário para manter uma conexão com um secundário legível. As transações estão sendo capturadas no data warehouse.

Depois que as transações são replicadas no data warehouse, o aplicativo é executado sp_repldoneno secundário, o que parece ter sido bem-sucedido, mas a transação nunca é marcada como replicada no primário, fazendo com que o log de transações seja relatado REPLICATIONna log_reuse_wait_desccoluna de sys.databases.

O aplicativo chama sp_repldoneassim:

EXEC sys.sp_repldone
        @xactid = NULL
      , @xact_seqno = NULL
      , @numtrans= 0
      , @time= 0
      , @reset= 1;

O acima foi capturado por meio de Extended Events sp_statement_completed. A sessão de captura de Eventos Estendidos também está configurada para capturar eventos de erro e nenhum está sendo relatado.

Se eu executar manualmente sp_repltranspara obter uma lista de transações não replicadas e, em seguida, executar sp_repldoneessa lista no secundário, parece ter êxito sem problemas, mas o primário ainda acredita que as transações não foram replicadas. ou seja, a execução sp_repltransno primário ainda mostra transações aguardando replicação.

Não vejo nada nos documentos de sp_repldone indicando que ele pode ou não ser executado a partir de um secundário legível; na verdade, eu acho que retornaria um erro se não pudesse marcar as transações como replicadas, mas talvez haja um bug na implementação. É certo que esta configuração provavelmente não é tão comum. Se configurarmos o processo de captura/integração para anexar ao nó primário, removendo ApplicationIntent=ReadOnly, a execução sp_repldoneno primário funcionará corretamente e todas as transações serão marcadas como replicadas, permitindo a reutilização do log de transações.

Há algo que precisa ser alterado para que isso funcione no secundário legível?

Relatei o comportamento por meio do site de Feedback do Azure aqui .

Estou tentando extrair algumas estatísticas de um banco de dados Postgres e fiz esta consulta:

SELECT
  city,
  job_count,
  TO_CHAR(job_count * 100 / SUM(job_count) OVER (), '90D00%') AS job_share
FROM (
  SELECT
    localities.name as city,
    COUNT(*) AS job_count
  FROM jobads
  JOIN localities ON jobads.locality_uuid = localities.uuid
  WHERE jobads.external = true
  GROUP BY localities.name
  ORDER BY job_count DESC
) AS job_count_table;

Aqui está o resultado que ele retorna:

         city          | job_count | job_share
-----------------------+-----------+-----------
 City #1               |      1300 |  13.00%
 City #2               |       700 |   7.00%
 City #3               |       400 |   4.00%
 ...
 City #1200            |         1 |   0.01%
(1200 rows)

Ele retorna centenas de linhas e a maioria delas tem uma contagem de empregos muito baixa. Eu gostaria de mesclar todas as linhas com job_countmenos de 100 em uma única linha, para que a saída fosse parecida com esta:

         city          | job_count | job_share
-----------------------+-----------+-----------
 City #1               |      1300 |  13.00%
 City #2               |       700 |   7.00%
 City #3               |       400 |   4.00%
 Other cities          |      2000 |  20.00%
(4 rows)

Alguma ideia de como posso fazer isso?

Suponha que eu tenha um esquema como o seguinte:

-- Many rows
CREATE TABLE t1(i INTEGER PRIMARY KEY, c1 INTEGER, c2 INTEGER);

-- t1's rows with c1 even
CREATE VIEW t1_filtered(i, c1, c2) AS
  SELECT i, c1, c2 FROM t1 WHERE c1 % 2 == 0;
-- The real WHERE clause is slightly more complex.

Suponha que essa tabela t1contenha alguns milhões de linhas:

INSERT INTO t1(i, c1, c2)
  SELECT value, random(), random() FROM generate_series(1, 5000000);

Suponha que eu queira obter o índice da linha t1que tem o par mais alto c1e a contagem de linhas com par c1que também tem par c2:

SELECT
  (SELECT i FROM t1_filtered ORDER BY c1 DESC LIMIT 1),
  (SELECT count(*) FROM t1_filtered WHERE c2 % 2 == 0);

A cláusula real ORDER BYé muito mais complexa, mas isto é suficiente para ilustrar o meu problema.

Parece-me que isso deveria ser possível com apenas uma varredura t1, mas EXPLAIN QUERY PLANdiz que esta consulta verifica t1duas vezes:

QUERY PLAN
|--SCAN CONSTANT ROW
|--SCALAR SUBQUERY 1
|  |--SCAN t1
|  `--USE TEMP B-TREE FOR ORDER BY
`--SCALAR SUBQUERY 2
   `--SCAN t1

Se eu unir as duas subconsultas em vez de escrevê-las como colunas de resultados, o plano de consulta será diferente, mas ainda terá duas varreduras de t1:

QUERY PLAN
|--CO-ROUTINE (subquery-1)
|  |--SCAN t1
|  `--USE TEMP B-TREE FOR ORDER BY
|--MATERIALIZE (subquery-2)
|  `--SCAN t1
|--SCAN (subquery-1)
`--SCAN (subquery-2)

Imperativamente, eu esperaria que esta consulta fosse algo como este pseudocódigo:

var top_row = {i: NULL, c1: 0};
var count = 0;
for each {i, c1, c2} in t1:
  if c1 % 2 == 0:
    if c1 > top_row.c1:
      top_row = {i, c1};
    if c2 % 2 == 0:
      count = count + 1;
return {top_row.i, count};

Como posso fazer com que o planejador de consultas veja que isso precisa apenas de uma verificação?

Atualização, 09/05/2024: tentei a consulta proposta por Charlieface . De acordo com EXPLAIN QUERY PLAN, isso faz com que o planejador de consultas use apenas uma varredura de t1...

QUERY PLAN
|--CO-ROUTINE t
|  |--CO-ROUTINE (subquery-4)
|  |  |--SCAN t1
|  |  `--USE TEMP B-TREE FOR ORDER BY
|  `--SCAN (subquery-4)
`--SCAN t

... mas é executado significativamente mais lentamente do que minha SELECT (...), (...)consulta original: testando ambas as consultas no SQLite REPL com .timer on, descobri que (para minha tabela de exemplo t1com 5 milhões de linhas de dados aleatórios) minha consulta original tem um tempo médio de execução de 2,22 segundos com desvio padrão amostral de 0,03 s e esta consulta proposta tem média de 5,57 s com st. dev. 0,23 seg.

Algo que minha intuição imperativa não me sugeriu, mas que o estudo dos planos de consulta "USE TEMP B-TREE FOR ORDER BY" sugeriu foi adicionar um índice em t1(c1). Isso realmente acelera minha consulta original, fazendo com que a média seja de 1,09 s com st. dev. 0,02 seg. No entanto, para minha surpresa, o índice aparentemente faz com que a consulta de Charlieface demore muito mais ou possivelmente até mesmo a torna ininterrupta - interrompi-a depois de esperar 108 segundos e interrompi-a depois de tentar novamente por 32 s, e então o fiz. não tente novamente.

A consulta de Charlieface responde literalmente à minha pergunta, reduzindo o número de varreduras t1para um, mas seu baixo desempenho prático em relação à minha consulta original me faz relutante em aceitá-la como resposta. Espero que isso não seja "mover demais as traves da baliza". Eu marquei isso como query-performance, então o desempenho fez parte da minha pergunta desde o início.

Atualização, 09/05/2024 nº 2: Com CREATE INDEX t1_c1 ON t1(c1), o plano de consulta para minha consulta original tornou-se

QUERY PLAN
|--SCAN CONSTANT ROW
|--SCALAR SUBQUERY 1
|  `--SCAN t1 USING COVERING INDEX t1_c1
`--SCALAR SUBQUERY 2
   `--SCAN t1

e o plano de consulta para a consulta de Charlieface tornou-se

QUERY PLAN
|--CO-ROUTINE t
|  |--CO-ROUTINE (subquery-4)
|  |  `--SCAN t1 USING INDEX t1_c1
|  `--SCAN (subquery-4)
`--SCAN t

Com CREATE INDEX index_per_comment660077_339327 ON t1 (c1 DESC) WHERE (c1 % 2 = 0)o comentário do Charlieface (SQLite não suporta INCLUDE), os planos de consulta tornam-se, respectivamente,

QUERY PLAN
|--SCAN CONSTANT ROW
|--SCALAR SUBQUERY 1
|  `--SCAN t1 USING COVERING INDEX index_per_comment660077_339327
`--SCALAR SUBQUERY 2
   `--SCAN t1 USING INDEX index_per_comment660077_339327

QUERY PLAN
|--CO-ROUTINE t
|  |--CO-ROUTINE (subquery-4)
|  |  `--SCAN t1 USING INDEX index_per_comment660077_339327
|  `--SCAN (subquery-4)
`--SCAN t

Mirar

Eu trabalho com a ferramenta complementar KingswaySoft SSIS "Premium Lookup", mas acho que a mesma pergunta pode surgir com a ferramenta integrada SSIS "Lookup".

Tento combinar um par de colunas duplas "first_name1" e "name1" e "first_name2" e "name2" e ambos os lados 1 e 2 às vezes têm valores NULL.

Se uma das colunas de pesquisa for NULL, toda a linha será passada para a saída "incomparável". A ferramenta Premium Lookup tem a seguinte aparência em um DFT: A entrada é passada para 32 linhas sem correspondência, pois um dos dois lados tem um valor NULL ou porque há um valor NULL em alguma outra coluna correspondente:

Meu objetivo é continuar combinando as colunas quando um NULL em uma delas for encontrado, para que a pesquisa continue e tente combinar as outras colunas também, enquanto a correspondência NULL deve ser:

• ou 0% de correspondência
• ou NULL e não é considerado a pontuação média.

Ambos seriam bons, pois tenho mais algumas colunas que geralmente combinam bem.

Peço um máximo de 5 correspondências e descarto qualquer correspondência da saída que tenha o mesmo ID da entrada primária, pois desejo encontrar apenas as entradas duplas. Portanto, devem ser mostrados até 5 "próximos vizinhos" para qualquer entrada que possa ter duplicatas nos dados mestre:

Por exemplo, se o primeiro nome não for conhecido em ambos os lados e até mesmo no campo de entrada primário, eu ainda gostaria de obter uma correspondência nas outras colunas, como "aniversário" ou "sexo".

O que eu tentei até agora

Já tentei substituir todos os valores NULL por uma string vazia para evitar NULL. No entanto, a pesquisa par difusa deve corresponder a pelo menos 1 por cento, e 1% não pode ser alcançado se você tentar comparar algo com uma string vazia, pois é 0%.

Lenda:

• Alemão/Inglês: Vorname = primeiro_nome, Nachname = nome, Geburtsdatum = aniversário, Geschlecht = sexo
• Pesquisa: lado 1: [1], lado 2: [2]
• Lado primário: [0] (desejo combinar as duas colunas de pesquisa com a mesma coluna primária duas vezes para copiar a coluna Nachname_Vergleich para uma segunda coluna Nachname_Vergleich2 e fazer o mesmo com a coluna Vorname)

A caixa de seleção "Tratar String Vazia como NULL" trava a Pesquisa Premium em qualquer entrada

Também tentei contornar isso definindo essas strings vazias ''como NULL novamente pela própria ferramenta, mas essa configuração trava a pesquisa de qualquer entrada, seja NULL ou não, testada também durante algumas outras tarefas. Portanto, há um bug ou não entendo a configuração, mas pego essa caixa de seleção:

Configurações avançadas de comparação - v22.1 (22.1.0.30606) -> "Tratar string vazia como NULL"

Sempre que você o executa com uma caixa de seleção marcada, ele falha com três erros:

[Premium_Lookup_trying_to_match_NULLs [74]] Erro: Ocorreu um erro com a seguinte mensagem de erro: "System.NullReferenceException: referência de objeto não definida para uma instância de um objeto. (SSIS Productivity Pack, v22.1.0.30606 - DtsDebugHost, v13.0.4495. 10)".

[Premium_Lookup_trying_to_match_NULLs [74]] Erro: Premium_Lookup_trying_to_match_NULLs não conseguiu processar os dados.

[SSIS.Pipeline] Erro: Código de erro SSIS DTS_E_PROCESSINPUTFAILED. O método ProcessInput no componente "Premium_Lookup_trying_to_match_NULLs" (74) falhou com o código de erro 0xC02090F9 ao processar a entrada "Lookup Table Input" (79). O componente identificado retornou um erro do método ProcessInput. O erro é específico do componente, mas é fatal e fará com que a tarefa Data Flow pare de ser executada. Pode haver mensagens de erro postadas antes disso com mais informações sobre a falha.

E mesmo que funcionasse, não ajudaria, pois apenas substituiria as strings vazias por um NULL, o que provavelmente passaria as linhas para a saída sem correspondência novamente como era no início, para que nada fosse ganho com a substituição de NULL:s com strings vazias no início.

Gambiarra

Portanto, não obtenho nenhuma correspondência da ferramenta "Pesquisa Premium" enquanto a pesquisa funciona assim que defino a correspondência das duas colunas como "ignorar".

Minha solução alternativa é substituir o lado 1 pelo lado 2 se o lado 1 for NULL e, em seguida, ele for executado como deveria, mas isso também diminui uma chance de correspondência se ambos os lados estiverem preenchidos, e eu quero obter as duas pontuações correspondentes se as duas colunas estão preenchidas.

Portanto, a solução alternativa é apenas a segunda melhor maneira, já que desejo que a pesquisa simplesmente ignore NULL:s ou dê a eles 0 pontos de pontuação, já que a média dos pontos de pontuação ausentes é a média do conjunto de correspondências encontrado.

Pergunta

Para uma pesquisa que tem dois lados em relação a uma entrada primária que tem apenas um lado, quero combinar ambos os lados da pesquisa por conta própria com a entrada primária. Não quero apenas substituir o lado de pesquisa 1 pelo lado de pesquisa 2 se houver um NULL. Como posso fazer isso e ainda pular NULL:s ou dar a eles 0 pontos de pontuação em vez de perder as linhas para a saída incomparável, como parece acontecer aqui?

Estou projetando um banco de dados para E-comercial. Portanto, o Cliente tem muitos endereços e também 1 endereço também possui muitos clientes, então eu tenho outra tabela CustomerAddress (relação muitos para muitos). Aqui detalhe:

1. Cliente:

   • ID do cliente (PK)
   • Nome
   • Data de nascimento

2. EndereçoNota:

   • EndereçoNotaID (PK)
   • AddressID (FK) (tem relacionamento com a tabela de cidades, então não vou mencionar isso aqui)

3. Endereço do cliente :

   • ID do cliente (PK)

   • EndereçoNotaID (PK)

   • PhoneNumber (O número de telefone aqui indica quem será chamado no momento da entrega naquele endereço)

Meu problema é que quero que 1 cliente tenha vários endereços, mas tenha 1 único endereço padrão. Então estou pensando em adicionar mais uma coluna IsDefault (bool) na tabela CustomerAddress. Mais tarde, me sinto errado porque ainda é permitido que o cliente tenha dois endereços diferentes e ambos definam o endereço padrão. Acredito que a validação em nível de aplicativo pode lidar com isso, mas quero restrições de banco de dados. Existe alguma maneira de projetar essas restrições. Sou apenas iniciante, então agradeço qualquer instrução.

Como automatizar uma atualização em uma tabela, após uma alteração em outra tabela?

Diga (veja abaixo) eu tenho uma mesa countriese uma mesa cities. Como fazer com que, ao adicionar uma cidade na tabela cities, a totalcoluna seja atualizada automaticamente (incrementada para a cidade correspondente) na tabela countries?

Tipo de :

BEGIN; INSERT INTO cities VALUES ('Tokyo', 'Japan'); UPDATE countries SET total=1 WHERE name='Japan'; COMMIT;

, mas automático, faça um countries.the_city.total++ao adicionarcities.the_city .

Países:

postgres=# SELECT * FROM countries;
 name  | total 
-------+-------
 USA   |     0
 Japan |     0
(2 rows)

Cidades:

postgres=# SELECT * FROM cities;
 name | country                                                                                                                                                          
------+---------                                                                                                                                                         
(0 rows)    

Comandos:

CREATE DATABASE geo;
\c geo;
CREATE TABLE countries (
    name VARCHAR(15) PRIMARY KEY,
    total int
);
CREATE TABLE cities (
    name VARCHAR(15),
    country VARCHAR(15),
    FOREIGN KEY (country) REFERENCES countries(name)
);

Contexto:

SQL padrão ou Postgres v16

Tentei implantar a implantação do MySQL com Kubernetes, tendo três réplicas que acessam o mesmo armazenamento (PVC). Aqui está a configuração

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  labels:
    type: local
spec:
  persistentVolumeReclaimPolicy: Retain
  capacity:
    storage: 1Gi
  accessModes:
  - ReadWriteMany
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Gi
---
apiVersion: v1
kind: Service
metadata:
  name: mysql-service
spec:
  type: NodePort
  ports:
  - protocol: TCP
    port: 3307
    targetPort: 3306
    nodePort: 30091
  selector:
    app: mysql
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:latest
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: pwd
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-storage
        persistentVolumeClaim:
          claimName: mysql-pvc

Ao aplicar este arquivo de configuração kubectl apply -f file_name.yaml, você pode criar três pods, que acessam o mesmo armazenamento para os bancos de dados. Ao verificar o status dos pods kubectl get pods, você pode ver que apenas um pod está em execução e os outros estão em CrashLoopestado. O que está acontecendo é que, ao criar mais de uma instância para utilizar um armazenamento comum, apenas uma instância poderá adquirir o bloqueio do ibdata1arquivo. É por isso que apenas um pod fica íntegro e outros no CrashLoop. (você pode ver isso usando kubectl logs pod-name). O que eu quero é,

1. Posso liberar o bloqueio do ibdataarquivo e usar o armazenamento para todos os pods? (geralmente não é possível, devido a problemas de consistência)
2. Caso contrário, como posso criar a ideia proposta? (acessando um único armazenamento/volume usando várias instâncias de pod)?
3. Você sugeriria outras ideias para conseguir acessar um único armazenamento usando várias instâncias de pod?

Suas respostas e ajuda são bem-vindas.

Instalei o MariaDB 11.2.2 no Windows para brincar um pouco com o novo sistema de banco de dados e agora minha confusão. Parâmetros de início do my.ini:

slow_query_log = ON
long_query_time = 0
log_slow_verbosity = ALL

A consulta select information_schema.system_variables.variable_name, information_schema.system_variables.default_value from information_schema.system_variables WHERE variable_name LIKE 'log_slow%'fornece:

LOG_SLOW_QUERY = OFF
LOG_SLOW_QUERY_TIME = 10.000000

A consulta SHOW GLOBAL VARIABLESfornece:

log_slow_query= ON
log_slow_query_time = 0

Existe um log de consulta lenta e o log está funcional.

Achei que as variáveis ​​​​globais do sistema deveriam ter o mesmo valor, independentemente da forma como são consultadas. Pesquisar na documentação do MariaDB não ajuda a entendê-lo. Você poderia, por favor, me empurrar na direção certa?

Obrigado!