Em um sistema Java EE 8 de gestão de transporte público, o serviço ViagemService é usado por vários recursos JAX-RS para registrar e consultar viagens de ônibus e metrô. Ele injeta um EntityManager JPA e cada chamada deve rodar em uma transação independente (por exemplo, ao registrar a validação de um bilhete). A equipe quer evitar EJB e usar apenas CDI + JTA. A configuração mais coerente com esse objetivo é

Um agente de fiscalização de transporte está avaliando práticas de arquitetura para sistemas cloud-native que precisam garantir escalabilidade e resiliência em ambientes de nuvem. Nesse contexto, a configuração mais adequada é:

Uma equipe de uma agência reguladora de transporte está modernizando o sistema de gestão da frota de ônibus para uma arquitetura baseada em microsserviços implantados em Docker containers, em Java. Cada microsserviço, como rastreamento de posição, cálculo de previsão de chegada e análise de demanda por ponto, deve poder ser iniciado, parado e escalado de forma independente, sem impactos nos demais componentes. A partir dessas mudanças, optou-se por

Considere, por hipótese, que uma equipe técnica está migrando serviços críticos, como roteamento dinâmico, monitoramento de frota e emissão de bilhetes, para um ambiente conteinerizado. Durante a revisão do projeto, surgiu a dúvida sobre como o Kubernetes coordena a execução de containers que precisam manter alta disponibilidade para lidar com picos de demanda em horários de rush. Um técnico com experiência no uso de Docker e Kubernetes, explicou que o mecanismo utilizado para garantir essa resiliência é o

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 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