Uma equipe está criando um protótipo de armazenamento em Redis para testar operações com pares chave-valor. O objetivo é registrar informações sobre clientes, em que cada chave identifica um cliente e cada valor armazena o respectivo nome. Durante os testes iniciais, foi definido o seguinte conjunto de pares:

CHAVE	VALOR
cliente:1	"Cliente Um"
cliente:2	"Cliente Dois"
cliente:3	"Cliente Três"

O analista precisa registrar cada uma dessas entradas no Redis em um conjunto de comandos adequados para criação de chaves do tipo string. Considerando esse cenário, o conjunto de comandos que cria as chaves e valores apresentados é

 

SET cliente:1 "Cliente Um"
SET cliente:2 "Cliente Dois"
SET cliente:3 "Cliente Três"

LPUSH cliente:1 "Cliente Um"
LPUSH cliente:2 "Cliente Dois"
LPUSH cliente:3 "Cliente Três"

INSERT cliente:1 "Cliente Um"
INSERT cliente:2 "Cliente Dois"
INSERT cliente:3 "Cliente Três"

HSET cliente:1 nome "Cliente Um"
HSET cliente:2 nome "Cliente Dois"
HSET cliente:3 nome "Cliente Três"

CREATE cliente:1 "Cliente Um"
cliente:2 "Cliente Dois"
cliente:3 "Cliente Três"

Uma equipe de TI precisa realizar as três tarefas abaixo em um servidor Linux Ubuntu, instalado e funcionando em condições ideais.

1. Atualizar a lista de pacotes disponíveis no sistema.
2. Instalar o pacote htop para monitorar processos em tempo real.
3. Verificar o status do serviço Apache que fornece relatórios de tráfego.

Com a devida permissão e privilégios, o comando que executa essas três atividades é

apt upgrade && apt install htop && systemctl -status apache

apt-get update && apt-get install htop && systemctl status apache2

apt-get upgrade && apt-install htop && service apache2 --status

apt-update && apt-get install htop && systemctl status httpd

apt-get update && apt-install htop && service httpd status

Uma equipe de desenvolvimento mantém em um banco de dados MongoDB a coleção clientes, utilizada para segmentar campanhas de marketing. Para testes, a coleção foi carregada com os seguintes documentos:

{
    _id: 1,
    nome: "Nome Um",
    cidade: "São Paulo",
    plano: "premium",
    ativo: true
}
{
    _id: 2,
    nome: "Nome Dois",
    cidade: "São Paulo",
    plano: "basic",
    ativo: true
}
{
    _id: 3,
    nome: "Nome Três",
    cidade: "Campinas",
    plano: "premium",
    ativo: false
}

Um agente precisa criar um comando que retorne exatamente clientes com cidade "São Paulo", plano "premium" e ativo true. Considerando a coleção clientes, o comando que realiza a busca com o resultado esperado é

db.clientes.locate({
  plano: "premium",
  ativo: true
})

db.clientes.find({
  ativo: true
})

db.clientes.find({
  cidade: "São Paulo",
  plano: "premium"
})

db.clientes.find({
  cidade: "São Paulo",
  plano: "premium",
  ativo: true
})

db.clientes.locate({
  cidade: "São Paulo",
  plano: "premium",
  ativo: true
})

Uma empresa que administra frota de veículos passou a utilizar o MySQL 8 para registrar alterações em seus cadastros. A equipe de desenvolvimento definiu que toda atualização de dados na tabela veiculo deve gerar um registro em uma tabela de auditoria, permitindo rastrear modificações realizadas por usuários do sistema.

A modelagem simplificada para esse controle está organizada da seguinte forma:

Tabela veiculo
---------------------------------------------------
id_veiculo        INT             PK
placa             VARCHAR(10)
status            VARCHAR(20)
data_atualizacao  DATETIME

Tabela auditoria_veiculo
---------------------------------------------------
id_auditoria      INT             PK AUTO_INCREMENT
id_veiculo        INT
placa_anterior    VARCHAR(10)
placa_nova        VARCHAR(10)
usuario           VARCHAR(100)
data_evento       DATETIME
tipo_evento       VARCHAR(20)

A equipe criou a trigger abaixo, que será executada no MySQL 8, e registra cada atualização na tabela veiculo, gravando na tabela auditoria_veiculo o identificador do veículo, a placa antes da alteração, a nova placa, o usuário corrente, a data e o tipo de evento ('UPD').

DELIMITER $$
CREATE TRIGGER tr_veiculo_update_audit
__I__

FOR EACH ROW
BEGIN
        INSERT INTO auditoria_veiculo
            (id_veiculo, placa_anterior, placa_nova, usuario, data_evento, tipo_evento)
        VALUES
            __II__
    END$$
DELIMITER ;

As lacunas I e II devem ser, correta e respectivamente, preenchidas com

Uma empresa de transporte urbano está migrando seu sistema de gestão de frota para PostgreSQL e deseja analisar as marcas de veículos cadastradas em seu catálogo que ainda não possuem veículos efetivamente alocados na frota. O modelo lógico implementado está organizado em três tabelas relacionadas por chaves estrangeiras, conforme a estrutura a seguir:

Tabela marca
-----------------------------------
id_marca        INTEGER   PK
nome_marca      TEXT

Tabela modelo
-----------------------------------
id_modelo       INTEGER   PK
id_marca        INTEGER   FK -> marca(id_marca)
nome_modelo     TEXT

Tabela veiculo
-----------------------------------
id_veiculo      INTEGER   PK
id_modelo       INTEGER   FK -> modelo(id_modelo)
placa           TEXT
ano_fabricacao  INTEGER

A equipe de agentes de TI precisa montar uma consulta em SQL, compatível com o PostgreSQL, que utilize o conceito de junção para listar as marcas cujos veículos não aparecem na tabela veiculo, ou seja, marcas que ainda não possuem veículos na frota, listando apenas o nome da marca. Considerando essa modelagem, o comando adequado é:

 

SELECT DISTINCT ma.nome_marca
FROM marca   AS ma
INNER JOIN modelo  AS mo ON mo.id_marca   = ma.id_marca
LEFT JOIN veiculo AS ve ON ve.id_modelo = mo.id_modelo
WHERE mo.id_modelo IS NULL;

SELECT DISTINCT ma.nome_marca
FROM marca   AS ma
LEFT JOIN modelo  AS mo ON mo.id_marca   = ma.id_marca
LEFT JOIN veiculo AS ve ON ve.id_modelo = mo.id_modelo
WHERE ve.id_veiculo IS NULL;

SELECT DISTINCT ma.nome_marca
FROM marca   AS ma
JOIN modelo  AS mo ON mo.id_marca   = ma.id_marca
JOIN veiculo AS ve ON ve.id_modelo = mo.id_modelo;

SELECT DISTINCT ma.nome_marca
FROM somemarca AS ma
LEFT JOIN modelo  AS mo ON mo.id_marca   = ma.id_marca
LEFT JOIN veiculo AS ve ON ve.id_modelo = mo.id_modelo
WHERE ve.id_veiculo IS NULL;

SELECT DISTINCT ma.nome_marca
FROM veiculo AS ve
RIGHT JOIN modelo AS mo ON mo.id_modelo = ve.id_modelo
RIGHT JOIN marca  AS ma ON ma.id_marca  = mo.id_marca
WHERE ve.id_veiculo IS NOT NULL;

Uma empresa de transporte intermunicipal utiliza o MS SQL Server para gerenciar sua frota e a escala de motoristas. O modelo de dados relevante para o controle operacional está organizado em três tabelas com a seguinte estrutura analítica:
 

Tabela VEICULOS
------------------------------ ----------- ------------
id_veiculo                     NOT NULL    INT
renavam                                    VARCHAR(20)
marca                                      VARCHAR(50)
modelo                                     VARCHAR(50)
ano_fabricacao                             INT
ano_modelo                                 INT

Tabela MOTORISTAS
------------------------------ ----------- ------------
id_motorista                   NOT NULL    INT
cpf                            UNIQUE      CHAR(11)
nome                                       VARCHAR(100)
cnh                                        VARCHAR(20)
data_nascimento                            DATE

Tabela OPERACAO
------------------------------ ----------- ------------
linha                                      VARCHAR(20)
data                                       DATE
id_veiculo                                 INT
id_motorista                               INT

A gerência solicitou um relatório que apresente todos os CPFs dos motoristas que não operaram no ano de 2024, ou seja, que não foram associados a nenhuma linha na tabela OPERACAO em qualquer data de 2024. Nesse contexto, o comando T-SQL adequado para a consulta compatível com o MS SQL Server é

SELECT m.cpf,
FROM motoristas AS m
WHERE EXISTS (
    SELECT 1
    FROM operacao AS o
    WHERE o.id_motorista = m.id_motorista
    AND YEAR(o.data) <> 2024
);

SELECT m.cpf,
FROM motoristas AS m
WHERE m.id_motorista NOT IN (
    SELECT o.id_motorista
    FROM operacao AS o
);

SELECT m.cpf
FROM MOTORISTAS AS m
LEFT JOIN OPERACAO AS o
    ON m.id_motorista = o.id_motorista
    AND YEAR(o.data) = 2024
WHERE o.id_motorista IS NULL;

SELECT m.cpf
FROM motoristas AS m
WHERE EXISTS (
    SELECT 1
    FROM operacao AS o
    WHERE o.id_motorista = m.id_motorista
    AND YEAR(o.data) = 2024
);

SELECT m.cpf,
FROM motoristas AS m
LEFT JOIN operacao AS o
    ON o.id_motorista = m.id_motorista
WHERE o.id_motorista IS NULL
    AND YEAR(o.data) = 2024;

Uma equipe de agentes de TI revisa o banco de dados de um órgão público e identifica a tabela Atendimentos. Nela, dados do atendimento, do cidadão e do serviço aparecem condensados em uma única tabela, gerando repetição constante de informações. Um recorte simplificado da estrutura original é apresentado a seguir. 

Tabela Atendimentos

atendimento_id	data	cidadao_nome	cidadao_cpf	cidadao_telefone	servico_tipo
101	05/08/2024	Ana Pereira	123.456.789-00	(11) 90000-0001	Carteira
102	06/08/2024	Ana Pereira	123.456.789-00	(11) 90000-0001	Agendamento
103	06/08/2024	Carlos Silva	987.654.321-99	(11) 98888-1234	Carteira

Após avaliar redundâncias, dependências parciais e anomalias, a equipe reorganiza o modelo em duas entidades:

Tabela Cidadao

atendimento_id	data	servico_tipo	cidadao_id
101	05/08/2024	Carteira	1
102	06/08/2024	Agendamento	1
103	06/08/2024	Carteira	2

 

Tabela Atendimento

atendimento_id	data	servico_tipo	cidadao_id
101	05/08/2024	Carteira	1
102	06/08/2024	Agendamento	1
103	06/08/2024	Carteira	2

As informações apresentadas acima caracterizam uma reorganização fundamentada em cardinalidade

 

Um Agente, no terminal Linux Ubuntu, aberto e funcionando em condições ideais, executou em sequência os comandos journalctl _PID=1005 e journalctl _UID=1005 que constavam na documentação para análise de logs. A partir desses comandos, está correto afirmar que

Uma Agência de Regulação precisa implementar roteamento entre VLANs em um ambiente corporativo com três VLANS (VLAN 10- ADM, VLAN 20-TI, VLAN 30- RH). Um Agente de Fiscalização verificou que a Agência possui em sua infraestrutura um switch gerenciável camada 3 ligada a um roteador de borda. Diante desse cenário e considerando as melhores práticas de desempenho e eficiência, deve-se optar por

Ao analisar a documentação de endereçamento IP de uma agência, um agente identificou que determinados serviços utilizam endereços IPs especiais para funções específicas. Considerando a estrutura e o propósito de diferentes tipos de endereços IPv4 e IPv6 definidos, concluiu-se que