Observe a inserção dos registros pelo seguinte script SQL.

INSERT INTO Parte (ParteID, idade)

VALUES (1 ,17);

INSERT INTO Parte (ParteID, idade)

VALUES (2 ,16);

INSERT INTO Processo (processoID, data_audiencia,

valor_causa)

VALUES (1 ,'2025-02-05',1000);

INSERT INTO Processo (processoID, data_audiencia,

valor_causa)

VALUES (2 ,'2025-10-05',2000);

INSERT INTO ProcessoParte (processoID, parteid)

VALUES (1 ,1);

INSERT INTO ProcessoParte (processoID, parteid)

VALUES (2 ,2);

No PostgreSQL, para consultar os Processos (Processos) que envolvem partes menores que 18 anos, por ordem de maior Valor de Causa (valor_causa), cuja Audiência (data_audiencia) está agendada para os próximos 30 dias, deve-se executar o comando SQL:

Observe a transação SQL a seguir.

BEGIN;
INSERT INTO Parte (ParteID, NomeParte)
    VALUES (1, 'Mariana Souza');
SAVEPOINT insercao;
INSERT INTO Parte (ParteID, NomeParte)
    VALUES (2, 'Joca Silva');
SAVEPOINT insercao;
INSERT INTO Parte (ParteID, NomeParte)
    VALUES (3, 'Luiz Almeida');
ROLLBACK TO SAVEPOINT insercao;
RELEASE SAVEPOINT insercao;
ROLLBACK TO SAVEPOINT insercao;
SELECT * FROM Parte;
COMMIT;

No PostgreSQL, após a execução da transação SQL, o(s) registro(s) da tabela Parte é(são):

O analista Paulo precisa analisar e descobrir padrões nas relações entre as diversas entidades nos processos judiciais do MPU, como promotores, juízes, autores, réus, secretários e advogados. Para isso, Paulo vai utilizar um banco de dados NoSQL para armazenar essa rede social judiciária que chamou de SocialJud. Para implementar o SocialJud, Paulo deve usar um banco de dados:

Observe os registros incluídos na tabela Processo pelo seguinte script SQL:

INSERT INTO Processo (processoID, descricao)
    VALUES (1, 'Tributário');
INSERT INTO Processo (processoID, descricao)
    VALUES (2, 'Divórcio');
INSERT INTO Processo (processoID, descricao)
    VALUES (3, 'Trabalhista');
SELECT * FROM PROCESSO;

Para consultar apenas os Processos (Processo) que possuem o termo “trabalhista” no campo descrição (descricao), deve-se complementar a consulta com a cláusula where e a seguinte condição:

O administrador de banco de dados Pedro criou o papel dadosadm para cadastrar os funcionários do MPU que desempenham a função de Administrador de Dados usando o seguinte comando SQL no PostgreSQL:

CREATE ROLE dadosadm WITH LOGIN PASSWORD 'admin';

Para que o papel dadosadm possa alterar a estrutura, bem como adicionar e remover linhas e colunas da tabela processo com controle total, Pedro deve usar o seguinte comando SQL:

Observe o modelo de dados, que utiliza a Notação Crow's Foot (Pé de Galinha), onde PK representa a Chave Primária:

Após a normalização, no PostgreSQL, para implementar o modelo de dados físico com as integridades referenciais, deve-se executar o seguinte script SQL:

CREATE TABLE Processo (
    ProcessoID SERIAL PRIMARY KEY,
    NomeProcesso VARCHAR(100));
CREATE TABLE Parte (
    ParteID SERIAL PRIMARY KEY,
    NomeParte VARCHAR(100));
CREATE TABLE ProcessoParte (
    ProcessoID INTEGER REFERENCES Processo(ProcessoID),
    ParteID INTEGER REFERENCES Parte(ParteID),
    PRIMARY KEY (ProcessoID, ParteID));

CREATE TABLE Processo (
    ProcessoID SERIAL UNIQUE,
    NomeProcesso VARCHAR(100) );
CREATE TABLE Parte (
    ParteID SERIAL UNIQUE,
    NomeParte VARCHAR(100) );
CREATE TABLE ProcessoParte (
    ProcessoID SERIAL UNIQUE,
    ParteID SERIAL UNIQUE );

CREATE TABLE Processo (
    ProcessoID SERIAL NOT NULL,
    NomeProcesso VARCHAR(100) );
CREATE TABLE Parte (
    ParteID SERIAL NOT NULL,
    NomeParte VARCHAR(100) );
CREATE TABLE ProcessoParte (
    UNIQUE (ProcessoID, ParteID));

CREATE TABLE ProcessoParte (
    ProcessoID FOREIGN KEY,
    ParteID FOREIGN KEY,
    NomeParte VARCHAR(100),
    NomeProcesso VARCHAR(100) );

CREATE TABLE ProcessoParte (
    FOREIGN KEY(ProcessoID NOT NULL, ParteID NOT NULL),
    NomeParte VARCHAR(100),
    NomeProcesso VARCHAR(100) );

No processo de realizar análises nos dados armazenados em um banco de dados relacional, o perito Charles está implementando diversas consultas SQL. Ele precisa acessar o resultado dessas consultas diversas vezes, como se fosse uma tabela, em um ciclo de refinamento analítico contínuo. Em um banco de dados relacional, para criar uma tabela virtual que represente o resultado de uma consulta SQL, Charles deve implementar um(a):

O analista João está analisando os dados de diversas fontes, carregando-os em um banco de dados relacional. Durante as cargas, diversas tabelas foram criadas, e agora João precisa fazer uma limpeza no seu banco de dados. Para remover uma tabela do banco de dados, João deve utilizar o comando:

Observe o resultado da execução dos seguintes comandos do MongoDB Shell.

> use MPU2025
> switched to db MPU2025
> db.getCollectionNames();
< [ 'Processos' ]
> db["Processos"].find();
< {
    _id: '676850ada9ec96543d3001c2',
    processo_numero: '0001',
    situacao: 'Ativo',
    partes: {
      autor: ['Maria'],
      reu: [
        'Pedro',
        'Ivo'
      ]
    }
  },
  {
    _id: '67685117a9ec96543d3001c5',
    processo_numero: '0002',
    partes: {
      autor: ['Maria'],
      reu: ['Joana']
    }
  },

Para listar apenas os processos que possuem dois réus, deve-se executar o comando:

João está aprendendo banco de dados orientado a documento. Para começar, João buscou a correspondência com a sua área de conhecimento, que é a álgebra relacional e o banco de dados relacional.

Em seu estudo, João identificou que uma relação (relation) da álgebra relacional corresponde, no MySQL e no MongoDB, respectivamente, a: