All perguntas(dba)

Estou usando o modo de linha de comando de consulta (gquery) do gStore . Primeiro criei um banco de dados de exemplo usando bin/gbuild -db test_db -f test_db.nt, onde test_db.nt contém apenas uma linha de texto <a> <b> <c>:. Em seguida, criei dois arquivos no diretório raiz do gStore para atualização e consulta ao banco de dados, chamados test_insert.rq e test_query.rq, respectivamente. O conteúdo desses arquivos é o seguinte:

• test_insert.rq:

  INSERT DATA {<a1> <b1> <c1> .}
  

• test_query.rq:

  SELECT * WHERE {?x <b1> <c1> .}
  

Depois de iniciar uma sessão de consulta de linha de comando por bin/gquery -db test_db, executo a inserção:

> sparql test_insert.rq

Então, na mesma sessão, executo a consulta:

> sparql test_query.rq

Isso retorna <a1>como resultado para ?x, o que está correto. No entanto, se eu sair do processo gquery por Ctrl + C, reiniciá-lo com o mesmo comando e executar a consulta novamente, nenhum resultado será retornado.

Como os resultados estão corretos na mesma sessão, presumo que não seja um bug de atualização. Há alguma etapa adicional que devo executar para garantir que as atualizações feitas no modo de linha de comando do gquery sejam preservadas após as reinicializações?

Eu tenho uma tabela de vídeos com uma coluna e ide estou tentando escrever uma consulta que retornará uma lista de reprodução de vídeos distintos com duração total superior a .skill_leveldurationX

select _id, duration, running_total
from (select *, sum(duration) over (order by RANDOM()) as running_total
      from videos
      where skill_level in ('beginner', 'superbeginner') AND watched IS NULL
     )
where running_total <= 7200;

Isso funciona e retorna o seguinte:

5e4d11fbaac87f3820954c45|305|305
64e51ad279223a9ad03525c2|930|1235
5e4d1204aac87f3820954c64|627|1862
5e4d1212aac87f3820954c95|367|2229
641e05c2d7c1512d278dc51a|361|2590
5e4d1200aac87f3820954c57|444|3034
649aa7089776ba12d8de28d5|329|3363
5e4d123eaac87f3820954d2c|573|3936
5e4d1216aac87f3820954ca1|399|4335
5e4d120daac87f3820954c84|315|4650
5e4d11dfaac87f3820954be1|510|5160
64f7036d3d578af923ba2afc|326|5486
5e4d11fcaac87f3820954c47|437|5923
5fa51afc27a912152cc51c33|1062|6985

Mas, idealmente, quero retornar registros suficientes para exceder, Xmas apenas um. 6375274c1cff4a7e31b04a0dabaixo nos coloca 7200.

5e4d11fbaac87f3820954c45|305|305
64e51ad279223a9ad03525c2|930|1235
5e4d1204aac87f3820954c64|627|1862
5e4d1212aac87f3820954c95|367|2229
641e05c2d7c1512d278dc51a|361|2590
5e4d1200aac87f3820954c57|444|3034
649aa7089776ba12d8de28d5|329|3363
5e4d123eaac87f3820954d2c|573|3936
5e4d1216aac87f3820954ca1|399|4335
5e4d120daac87f3820954c84|315|4650
5e4d11dfaac87f3820954be1|510|5160
64f7036d3d578af923ba2afc|326|5486
5e4d11fcaac87f3820954c47|437|5923
5fa51afc27a912152cc51c33|1062|6985
6375274c1cff4a7e31b04a0d|1138|8123

É possível escrever uma consulta para conseguir isso no sqlite?

Digamos que eu tenha uma tabela chamada usersque contém informações básicas do usuário, como e-mail e senha, e também tenho uma tabela chamada clients.

Um cliente é um tipo de usuário, portanto terá um campo que conterá o id do usuário correspondente da tabela users, um campo como user_id.

Agora digamos que existem tabelas específicas do cliente e então haverá a necessidade de armazenar o id do cliente, assim:

Tabela de usuários:

Tabela de clientes:

Tabela de cursos:

Agora o que eu realmente não sei é qual ID devo salvar na tabela Cursos.

Devo salvar a client_idtabela de clientes ou devo salvar o ID do usuário da tabela de usuários como ID do cliente.

Eu realmente não sei porque cliente é um tipo de usuário e só um cliente pode comprar um curso, nem todos os tipos de usuários, por outro lado, um cliente não existe sem um usuário o que é realmente confuso é que se eu usar o ID do usuário em vez do ID do cliente, então o campo deve ser chamado de "user_id"? Mas então seria genérico, pois apenas clientes podem fazer um curso.

Então, qual é a melhor abordagem:

1 - Nomeie o campo client_ide adicione o id do cliente da tabela de clientes e depois obtenha o usuário relacionado a esse cliente (estou inclinado a este).

2 - Nomeie o campo client_ide armazene o id do usuário na tabela de usuários e obtenha o cliente associado (Isso é um pouco mais confuso, mas pode fazer sentido hierarquicamente falando, já que não há cliente sem usuário).

3 - Nomeie o campo user_ide armazene o id do usuário da tabela de usuários (essa abordagem realmente quebra a semântica na minha opinião, pois user_idpoderia ser qualquer usuário, mas somente o usuário do tipo cliente poderia ter um curso).

-----------------------------ATUALIZAR-------------------- -----

Então acho que minha pergunta não ficou clara, então vou esclarecer.

O que eu quero saber é se existe alguma prática recomendada neste tópico porque a maneira como armazeno e recupero dados impactaria diretamente a maneira como recupero dados no aplicativo devido aos relacionamentos.

Agora, em um cenário real onde tenho 3 tabelas: table users, table clientse table courses.

A tabela clientscontém apenas os campos que não caberiam na userstabela considerando que terei mais tipos de usuários que estarão em outras tabelas também, como administradorso que também é um tipo de usuário.

Agora, considerando que um cliente não existiria sem um usuário e considerando que apenas os clientes podem fazer compras para comprar um curso por exemplo, qual id devo armazenar na client_idtabela courses, o id da tabela clientsou o id da tabela users.

Por exemplo, apenas clientes podem comprar produtos, mas um cliente ( clientstabela) pertence a um usuário ( userstabela). Na tabela, digamos purchased_productsque contém um campo chamado client_id, devo ter o id do cliente da tabela clientsou o id do usuário da tabela users?

Ambos fazem sentido para mim e eu seria capaz de recuperar os dados independentemente do que eu realmente queira saber é o que faz mais sentido aqui:

1 - Se eu armazenasse o id da tabela clientsem courses.client_id, recuperaria o usuário assim: $client->usero que hierarquicamente não faz sentido já que um usuário vem antes de um cliente e não o contrário mas pelo menos seria o id da tabela clientarmazenado em courses.client_id.

2 - Se eu armazenar o id da tabela usersem courses.client_id, recuperaria os dados de uma forma que fizesse mais sentido, como $user->client but I fell like the name of the field should not be cursos.client_id but rathercursos.user_id` mas também seria ruim porque nem todos os usuários podem comprar um curso, então pode parecer enganoso .

No primeiro exemplo $clientcontém todas as informações relacionadas à tabela clientse $client->user would access all information related to the tableusers` desse cliente.

No segundo exemplo $usercontém todas as informações relacionadas à tabela userse $user->client would access all information related to the tableclients` desse usuário.

Novamente, é mais uma questão semântica para tornar as coisas mais organizadas.

Boa tarde a todos,

Eu tenho dois registros de dados iguais ou mais na tabela MySql. Como posso contar os mesmos dados como um e zero se tiver apenas um dado com base no par de status do sinalizador. Abaixo está um exemplo de dados:

GLOBAL_ID        FLAG_STATUS    
VTSA-C-B002      IN
VTSA-C-B002      OUT
VTSA-C-B003      IN
VTSA-C-B031      IN
VTSA-C-B031      OUT
VTSA-C-B031      OUT
VTSA-C-B002      OUT
VTSA-C-B005      OUT
ABCD-D-B004      IN
ABCD-D-B001      IN
ABCD-D-B003      IN
ABCD-D-B001      OUT
ABCD-D-B003      OUT
ABCD-D-B005      IN

Então o resultado que eu queria contar é parecido com aqui

Global ID        Count
VTSA-C-B002      1 (Because have a Pair Flag Status ("IN" AND "OUT")
VTSA-C-B003      0 (Because Dont have a Pair Flag Status ("IN" AND "OUT")
VTSA-C-B031      1
VTSA-C-B005      0
ABCD-D-B004      0
ABCD-D-B001      1
ABCD-D-B003      1
ABCD-D-B005      0

então o resultado final para resumir a contagem assim,

Global_ID ALias      SUM of counting
VTSA                 2
ABCD                 2

Eu tentei esta consulta abaixo, mas o resultado que procuro

SELECT global_id,
       mandays 
FROM ( SELECT COUNT(DISTINCT b.global_id) AS mandays,
              CASE WHEN b.global_id like "%ABCD%" THEN 'ABCD' ELSE 'VTSA' END AS global_id 
       FROM she_cii.tb_gate_log b 
       WHERE b.global_id REGEXP 'VTSA|ABCD' 
       AND date(b.received_date)="2024-02-03" 
       AND flag_status IN("IN","OUT") 
       group by SUBSTRING(b.global_id FROM POSITION('-' in b.global_id)+1 FOR 5)
      ) x

o resultado dessa consulta é assim

global_id   mandays
VTSA        36 (counting all distint global id record)
ABCD        45 (counting all distint global id record)

Obrigado, lembraças.

No SQL Server, desejo restringir todos os usuários (exceto alguns usuários específicos) a enviar um email com anexo.

Por exemplo, alguém importa dados para um arquivo Excel e os envia por correio usando o sp_send_dbmailprocedimento.

Podemos restringir o uso deste procedimento?

Ou existe alguma outra maneira de fazer isso?

Existem alguns usuários que têm permissão de administrador de sistema, quero restringi-los também.

Se não for possível, pelo menos quero receber uma notificação quando alguém enviar um email com anexo.

O gatilho ou procedimento pode funcionar, mas não consegui nenhum resultado.

O QUE EU TENHO

Tenho duas tabelas com a mesma estrutura. Podemos dizer que uma é a tabela principal, enquanto a outra é uma tabela lateral , o que significa que cada linha rastreia uma edição para uma linha correspondente da tabela principal. Para combinar a edição com a linha original, obviamente uso algumas teclas.

O QUE EU QUERO FAZER

Preciso de uma consulta que retorne um conjunto de resultados onde as linhas de edição substituam as originais.

Por exemplo, tenho esta linha na tabela lateral :

que corresponde, pelo ID da pessoa e pela data que são KEYs , à linha destacada na tabela principal (abaixo)

A consulta deve retornar um conjunto de quatro tuplas onde a linha 96368é substituída pelos valores da linha de edição.

Que tipo de abordagem você sugere? No início levei em consideração um UNION, pois as duas tabelas compartilham a mesma estrutura, mas não sei como fazer as edições para mascarar as linhas originais.

Tenho uma cópia pública do banco de dados Stack Overflow aqui no AWS Aurora Postgres 15.5:

• Servidor: query.smartpostgres.com
• Nome de usuário: somente leitura
• Senha: 511e0479-4d35-49ab-98b1-c3a9d69796f4

A tabela de usuários possui este índice:

create index users_length_displayname on users(length(displayname));

Mas quando executo uma destas consultas:

select * from users where length(displayname) > 35;
select length(displayname) from users where length(displayname) > 35;

Eles não usam o índice funcional, como evidenciado pelos seus planos de consulta :

Então, por quê?

Normalmente quando o banco de dados está online eu uso a seguinte consulta e obtenho quanto espaço há livre dentro de cada arquivo:

            SELECT CONVERT (decimal(12,2)  , 
                           (CONVERT(decimal(12,2), size)/128)/1024.00) 
                          - CONVERT(decimal(12,2),
                            ROUND(fileproperty(a.name,'SpaceUsed')/128.000,2)/1024.00)  as [FREESPACE GB],
                   * 
              FROM sys.database_files a WITH(NOLOCK)

você precisa estar no banco de dados que deseja consultar.

No entanto, como você pode fazer isso quando o banco de dados está offline?

Eu não encontrei uma maneira.

Eu estava tentando isso, mas não deu certo:

select object_name,counter_name,instance_name,cntr_value,
case cntr_type 
    when 65792 then 'Absolute Meaning' 
    when 65536 then 'Absolute Meaning' 
    when 272696576 then 'Per Second counter and is Cumulative in Nature'
    when 1073874176 then 'Bulk Counter. To get correct value, this value needs to be divided by Base Counter value'
    when 537003264 then 'Bulk Counter. To get correct value, this value needs to be divided by Base Counter value' 
    else 'I don"t know'   
end as counter_comments
from sys.dm_os_performance_counters with(nolock)
where cntr_type not in (1073939712)
and counter_name in ('Data File(s) Size (KB)                                                                                                          ',
                     'Database pages                                                                                                                  ')

Existe uma maneira de descobrir espaço livre dentro de arquivos de bancos de dados offline?

Estou tentando entender o failover do banco de dados (principalmente no SQL Server) e qual tratamento é necessário do lado do aplicativo para ter tempo de inatividade zero (sem falhas) para lidar com o failover do banco de dados?

Supondo que os DBAs tenham feito a melhor configuração para servidores SQL (nós primários e alguns nós secundários com replicação). Agora, se um dos nós falhar (ou qualquer nó for desativado para manutenção programada),

1. O que acontece com as consultas em andamento no SQL Server? Eles falham ou são transferidos para outro nó?
2. O driver jdbc do SQL Server conectado ao banco de dados apresenta alguma falha? Ele tentará novamente automaticamente nesses casos?

Alguma ideia sobre essas questões básicas?

Em "SQL Server 2019" no Windows 2019:

1. Abri o Microsoft SQL Server Management Studio.
2. Entrei no servidor de banco de dados.
3. Cliquei em "SQL Server Agent" e cliquei em "Logs de erros" e cliquei duas vezes em "Atual".
4. O programa Log File Viewer é exibido. No site certo vejo muitos erros, mas erros antigos não são mais importantes. Como limpar/excluir esses erros para remover a desordem?