CRUD significa Create, Read, Update, Delete (Criar, Ler, Atualizar e Excluir), um conjunto comum de operações que são realizadas em dados em um banco de dados ou em uma aplicação.

O que é CRUD

CRUD é a abreviação que se refere às quatro operações básicas em uma aplicação de software, não importa se a aplicação é um aplicativo móvel, uma aplicação web ou um software desktop.

As quatro operações são: Criar, Ler, Atualizar e Deletar, do Inglês: Create, Read, Update and Delete.

Em resumo, a operação de Criar é semelhante à inserção de um novo registro em um banco de dados, a operação de Ler é a recuperação de um registro do banco de dados, a operação de Atualizar é a atualização dos valores de um registro e a operação de Deletar é a ação de remover um registro inteiro do banco de dados. Podemos dizer que em um banco de dados, as operações CRUD se mapeiam a comandos SQL como SELECT, INSERT, UPDATE e DELETE.

As operações CRUD também podem ser aplicadas a funções de nível superior de uma aplicação, como soft deletes onde os dados não são realmente excluídos, mas marcados como excluídos via um status no banco de dados. Ou mesmo uma operação de LISTA que usa a operação de Ler para ler e listar o conjunto de dados resultantes. Eu gosto de chamar o conjunto acrescido de lista de CRUD-L: Criar, Ler, Atualizar, Deletar, Listar.

Aqui está uma tabela que lista as operações CRUD equivalentes aos métodos SQL e HTTP:

CRUDSQLHTTP
CreateINSERTPOST
ReadSELECTGET
UpdateUPDATEPUT/PATCH
DeleteDELETEDELETE
  • A operação Create corresponde a uma declaração SQL INSERT e a um método HTTP POST.
  • A operação Read corresponde a uma declaração SQL SELECT e a um método HTTP GET.
  • A operação Update corresponde a uma declaração SQL UPDATE e a um método HTTP PUT/PATCH.
  • A operação Delete corresponde a uma declaração SQL DELETE e a um método HTTP DELETE.

Esquema para Catálogo de Livros

Para nos ajudar a compreender os conceitos neste post, consideremos uma aplicação simples que gerencia uma coleção de livros. Os campos do livro seriam: título, autor do livro, data de publicação, em que idioma e seu tipo.

Vamos ver exemplos de esquemas para um “catálogo de livros”:

Aqui está um exemplo de um esquema SQL para uma tabela “book”:

CREATE TABLE book (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    published_at DATE NOT NULL,
    author VARCHAR(255) NOT NULL,
    language VARCHAR(255) NOT NULL,
    type ENUM('Novel', 'Essay', 'Poetry') NOT NULL
);

Isto cria uma tabela no banco de dados, chamada “book”, com as seguintes colunas:

  • id: uma chave-primária autoincremental
  • title: uma string não nula de 255 caracteres
  • published_at: uma data não nula
  • author: uma string não nula de 255 caracteres
  • language: uma string não nula de 255 caracteres
  • type: um enumerador para os valores: ‘Novel’, ‘Essay’, ‘Poetry’

Aqui um exemplo de um esquema JSON para “book” com um recurso de uma API REST:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer"
    },
    "title": {
      "type": "string"
    },
    "published_at": {
      "type": "string",
      "format": "date"
    },
    "author": {
      "type": "string"
    },
    "language": {
      "type": "string"
    },
    "type": {
      "type": "string"
    }
  },
  "required": [
    "title",
    "published_at",
    "author",
    "language",
    "type"
  ]
}

This defines a JSON schema with the following properties:

  • id: integer
  • title: string
  • published_at: data no formato de string
  • author: string
  • language: string
  • type: string

Sendo que todos os campos são obrigatórios.

Este esquema será utilizado em todos os nossos exemplos desta lição.

A operação CREATE no CRUD

A operação Create no CRUD é usada para inserir novos dados em um banco de dados ou armazenar dados de uma aplicação.

Imaginemos que estamos desenvolvendo o recurso criar livros nesta aplicação, considerando os esquemas apresentados, aqui está um exemplo de uma operação Create em algumas linguagens e stacks: NodeJS, PHP, Laravel, SQL.

Em Node.js, usar a tabela “book” seria um endpoint de API RESTful que aceita uma requisição POST com um payload JSON representando um novo livro:

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const mysql = require('mysql');

app.use(bodyParser.json());

// Connect to the database
const connection = mysql.createConnection({
  host: 'hostname',
  user: 'username',
  password: 'password',
  database: 'database'
});

connection.connect(function(err) {
  if (err) throw err;
  console.log('Connected to database');
});

app.post('/books', function (req, res) {
  var newBook = req.body;
  // Validate and sanitize newBook here
  const sql = "INSERT INTO book (title, published_at, author, language, type) VALUES (?, ?, ?, ?, ?)";
  const values = [newBook.title, newBook.published_at, newBook.author, newBook.language, newBook.type];
  
  // Insert newBook into database
  connection.query(sql, values, function (err, result) {
    if (err) throw err;
    res.status(201).json({message: "Book created successfully"});
  });
}); 

Neste exemplo, usamos a biblioteca mysql para conectar a um banco de dados e então usamos o método de SQL para realizar a operação INSERT. O middleware bodyParser é usado para analisar os dados JSON de entrada, que é usado como o objeto newBook na query SQL.

Este pendpoint escuta por uma requisição POST na rota /books. Ele recupera os dados do novo livro a partir do corpo da requisição, valida e saneia (sanitiza) os dados, e então os insere no banco de dados. O ponto final então envia uma resposta JSON com um código de status “201 Created” e uma mensagem indicando que o livro foi criado com sucesso.

Um exemplo de SQL com uma instrução Create usando a tabela “book” seria:

INSERT INTO book (title, published_at, author, language, type) VALUES ('The Great Gatsby', '2022-01-01', 'F. Scott Fitzgerald', 'English', 'Novel');

Esta instrução iria inserir um novo livro na tabela com o título “The Great Gatsby”, publicado em “2022-01-01”, escrito por “F. Scott Fitzgerald”, na língua “English”, do tipo “Novel”.

Um exemplo da operação Create em PHP usando ADODB para a tabela “book” seria:

<?php
require('adodb/adodb.inc.php');

$dsn = "mysql://username:password@localhost/myDB";
$db = ADONewConnection($dsn);

$title = $_POST["title"];
$published_at = $_POST["published_at"];
$author = $_POST["author"];
$language = $_POST["language"];
$type = $_POST["type"];

$query = "INSERT INTO book (title, published_at, author, language, type) VALUES ('$title', '$published_at', '$author', '$language', '$type')";
$db->Execute($query);

echo "New book created successfully";
?>

Este script manipula uma submissão de formulário, cria uma nova conexão com o banco de dados usando o método ADONewConnection() e passa a string DSN, em seguida, cria a consulta e a executa usando o método Execute(), que insere os dados na tabela livro do banco de dados.

Em Laravel, a operação Create pode ser implementada usando o Eloquent, ORM (Mapeamento Objeto-Relacional) do Laravel. Aqui está um exemplo de um método de controlador que cria um novo livro e o salva no banco de dados usando a tabela de livros:

public function store(Request $request)
{
    $book = new Book;
    $book->title = $request->title;
    $book->published_at = $request->published_at;
    $book->author = $request->author;
    $book->language = $request->language;
    $book->type = $request->type;
    $book->save();

    return redirect()->route('books.index')->with('success', 'Book created successfully');
}

Então, para inserir o novo livro, nesta aplicação, seria necessário uma chamada do cliente, provavelmente no formato REST, usando cliente de API REST como o Postman, ou a partir da interface da aplicação. Um cliente poderia criar um novo livro enviando uma requisição POST com um payload JSON representando o novo livro:

{
    "title": "The Great Gatsby",
    "published_at": "2022-01-01",
    "author": "F. Scott Fitzgerald",
    "language": "English",
    "type": "Novel"
}

Aqui está um exemplo de como usar curl para enviar uma requisição POST para o endpoint “/books” e criar um novo livro:

curl -X POST -H "Content-Type: application/json" -d '{
    "title": "The Great Gatsby",
    "published_at": "2022-01-01",
    "author": "F. Scott Fitzgerald",
    "language": "English",
    "type": "Novel"
}' http://localhost:3000/books

Este comando envia uma requisição POST para o endereço do endpoint em "http://localhost:3000/books" com um payload JSON representando um novo livro.

  • A opção -X especifica o método de solicitação (neste caso, POST)
  • A opção -H define o cabeçalho “Content-Type” como “application/json” para indicar que o corpo da solicitação está no formato JSON
  • A opção -d define o corpo da solicitação como o payload JSON representando o novo livro

Você deve receber uma resposta do ponto final semelhante a isto:

{
  "message": "Book created successfully"
}

Isto significa que o livro foi criado com sucesso.

A operação READ no CRUD

A operação READ, também conhecida como operação Retrieve (recuperar ou ler), é usada para recuperar dados de um banco de dados ou outro sistema de armazenamento de dados.

No contexto de um banco de dados relacional, isso normalmente corresponde a uma instrução SQL SELECT. O objetivo da instrução SELECT é recuperar dados de uma ou mais tabelas no banco de dados, com base em certas condições ou critérios.

No contexto de uma API RESTful, a operação READ é normalmente executada usando o método HTTP GET, que é usado para recuperar uma representação de um recurso.

Em resumo, a operação READ é usada para recuperar dados de um banco de dados ou outro sistema de armazenamento de dados e normalmente é executada usando uma instrução SQL SELECT em um banco de dados relacional e um método HTTP GET em uma API RESTful.

Em uma aplicação poderia ser o recurso LIST que mostra os últimos registros inseridos, em nossos exemplos seriam os últimos livros criados. Ou o resultado de uma pesquisa ou ainda a funcionalidade de mostrar os detalhes de um registro em uma página HTML.

Aqui estão exemplos de operação READ para recuperar todos os registros do banco de dados:

Uma operação SQL READ usando a tabela “book”:

SELECT * FROM book

Um exemplo de operação READ em Node.js usando a tabela “book”:

app.get('/books', function (req, res) {
  var bookId = req.params.id;
  // Validate and sanitize bookId here
  // Retrieve book from database using bookId
  var book = null;
  // Code to execute a SQL SELECT statement to retrieve the book with id = bookId  
  const books = database.query("SELECT * FROM book", function (err, result, fields) {
    if (err) throw err;
    res.status(200).json(result);
  });
}); 

Este endpoint escuta uma solicitação GET para a rota "/books", recupera todos os livros do banco de dados e os envia de volta como uma resposta JSON. Observe que retrieveBooksFromDB() deve ser implementado pelo desenvolvedor.

Aqui está um exemplo de uma operação READ em PHP usando a tabela “book” e ADODB:

<?php
require('adodb/adodb.inc.php');

$dsn = "mysql://username:password@localhost/myDB";
$db = ADONewConnection($dsn);

$query = "SELECT * FROM book";
$books = $db->getAll($query);

foreach($books as $book)
{
    echo $book['title'] . "<br>";
}

?>

Este script cria uma nova conexão com o banco de dados usando o método ADONewConnection() e passa a string DSN, então ele cria a query e a executa usando o método GetAll(), que recupera todos os livros da tabela “book” do banco de dados e percorrer os resultados.

Aqui está um exemplo de uma operação READ no Laravel usando a tabela “book”:

public function index()
{
    $books = Book::all();
    return view('books.index', ['books' => $books]);
}

Este método controller recupera todos os livros da tabela “book” usando o método all() do Eloquent ORM, e então passa o resultado para a view ‘books.index’.

É claro que não devemos recuperar todos os registros do banco de dados em todas as situações. Este é apenas um exemplo simples. Se quisermos mostrar apenas um registro, ou recuperar apenas um registro, podemos usar o valor id para fazer isso, devemos fazer algo como os exemplos a seguir, recebendo o valor a ser pesquisado.

Veja alguns exemplos de operação READ baseada em um valor id fornecido:

Um exemplo de uma operação SQL READ usando a tabela “book” para recuperar um livro por seu id, neste exemplo usando um valor direto:

Esta instrução recupera a linha da tabela “book” onde o id é 1.

    SELECT * FROM book WHERE id = 1

Aqui está um exemplo de uma operação READ em Node.js usando a tabela “book” para recuperar um livro por seu id, o id deve ser enviado com a solicitação de endpoint da API:

app.get('/books/:id', function (req, res) {
  var bookId = req.params.id;
  // Validate and sanitize bookId here
  // Retrieve book from database using bookId
  var book = null;
  // Code to execute a SQL SELECT statement to retrieve the book with id = bookId  
  connection.query('SELECT * FROM books WHERE id = ?', [bookId], function (error, results, fields) {
    if (error) throw error;
    book = results[0];
    connection.end();
  });
  
  // Return the retrieved book
  res.status(200).json(book);
}); 

Este terminal escuta uma solicitação GET para a rota "/books/:id", recupera o livro com o id passado no parâmetro do banco de dados e o envia de volta como uma resposta JSON.

Um exemplo de operação READ em PHP usando a tabela “book” e ADODB para recuperar um livro pelo seu id:

<?php
require('adodb/adodb.inc.php');

$dsn = "mysql://username:password@localhost/myDB";
$db = ADONewConnection($dsn);

$book_id = $_GET["id"];
$query = "SELECT * FROM book WHERE id = ".$book_id;
$book = $db->getRow($query);

echo $book['title'] . "<br>";

?>

Este script após a conexão com o banco de dados, cria a consulta usando o id passado pela variável $_GET, então a executa usando o método GetRow(), que recupera o livro baseado no valor do seu id.

Um exemplo de uma operação READ no Laravel usando a tabela “book” para recuperar um livro pelo seu id:

public function show($id)
{
    $book = Book::find($id);
    return view('books.show', ['book' => $book]);
}

Este método controlador recupera um livro por seu id da tabela “book” usando o método find() do Eloquent ORM, e então passa o resultado para a view books.show.

Aqui está um exemplo de como você pode usar o curl para enviar uma solicitação GET para o endpoint /books/3 e recuperar um livro com id 3:

curl http://localhost:3000/books/3

Este comando envia uma solicitação GET para o endpoint http://localhost:3000/books/3 e recupera o livro com id 3.

Você deve obter uma resposta do terminal semelhante a esta:

{
  "id": 3,
  "title": "The Catcher in the Rye",
  "published_at": "2021-01-01",
  "author": "J.D. Salinger",
  "language": "English",
  "type": "Novel"
}

A operação UPDATE no CRUD

A operação UPDATE é usada para modificar ou atualizar dados existentes em um banco de dados ou outro sistema de armazenamento de dados.

No contexto de um banco de dados relacional, a operação UPDATE é executada usando uma instrução SQL UPDATE. A sintaxe de uma instrução SQL UPDATE é a seguinte:

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE some_column = some_value;

Esta instrução atualiza os dados na tabela especificada definindo os valores de uma ou mais colunas para novos valores, com base em certas condições ou critérios especificados na cláusula WHERE. Por exemplo, usando nosso cenário de tabela “livro”, a seguinte instrução SQL atualiza o nome do autor de um livro em que o id é 3:

UPDATE book
SET author = 'J.D. Salinger'
WHERE id = 3;

No contexto de uma API RESTful, a operação UPDATE é normalmente executada usando o método HTTP PUT ou PATCH.

  • O método PUT é usado para substituir um recurso em sua totalidade
  • O método PATCH é usado para fazer atualizações parciais em um recurso.

Por exemplo, a seguinte requisição PUT deve ser realizada pelo servidor para atualizar todo o registro “book” que possui o id = 3:

PUT /books/1
Content-Type: application/json
{
    "title": "The Catcher in the Rye",
    "published_at": "2021-01-01",
    "author": "J.D. Salinger",
    "language": "English",
    "type": "Novel"
}

Alguns exemplos de operação UPDATE considerando a alteração de todo o registro, mesmo que apenas um campo seja modificado, a web deve configurar todos os valores do registro:

Uma operação SQL UPDATE usando a tabela “livro” para atualizar o livro com id = 3:

UPDATE book
SET title = 'The Catcher in the Rye 2.0', published_at = '2022-01-01', author = 'J.D. Salinger', language = 'English', type = 'Novel'
WHERE id = 3;

Esta instrução atualiza todos os campos do livro com id = 3.

Uma operação UPDATE no Node.js usando a tabela “book” para atualizar o livro com id = 3:

app.put('/books/:id', function (req, res) {
  var bookId = req.params.id;
  var updatedBook = req.body;
  // Validate and sanitize updatedBook here
  // Update book with id = bookId in database
  // For example using an SQL query:
  connection.query("UPDATE book SET title = ?, published_at = ?, author = ?, language = ?, type = ? WHERE id = ?", [updatedBook.title, updatedBook.published_at, updatedBook.author, updatedBook.language, updatedBook.type, bookId], function (error, results, fields) {
    if (error) {
      res.status(500).json({message: "Error updating book"});
    } else {
      res.status(200).json({message: "Book updated successfully"});
    }
  });
});

Este terminal escuta uma solicitação PUT para a rota "/books/:id", atualiza o livro com o id passado no parâmetro da solicitação com os dados do corpo da solicitação no banco de dados e envia de volta uma resposta JSON indicando que o livro foi atualizado com sucesso.

Exemplo de operação UPDATE em PHP utilizando a tabela “livro” e ADODB para atualizar o livro com id = 3, considerando que os valores são enviados por requisição:

<?php
require('adodb/adodb.inc.php');

$dsn = "mysql://username:password@localhost/myDB";
$db = ADONewConnection($dsn);

$book_id = $_POST["id"];
$title = $_POST["title"];
$published_at = $_POST["published_at"];
$author = $_POST["author"];
$language = $_POST["language"];
$type = $_POST["type"];
$query = "UPDATE book SET title = '$title', published_at = '$published_at', author = '$author', language = '$language', type = '$type' WHERE id = ".$book_id;
$db->execute($query);

echo "Book updated successfully";

?>

Este script cria a consulta usando o id passado pela variável $_POST e os valores de title, published_at, author, language e type, então ele a executa usando o método Execute().

Um exemplo de operação UPDATE no Laravel usando a tabela “book” para atualizar o book com id = 3:

public function update(Request $request, $id)
{
    $book = Book::find($id);
    $book->title = $request->title;
    $book->published_at = $request->published_at;
    $book->author = $request->author;
    $book->language = $request->language;
    $book->type = $request->type;
    $book->save();

    return redirect()->route('books.index')->with('success', 'Book updated successfully');
}

Este método controlador recupera um livro por seu id da tabela “book” usando o método find() do Eloquent ORM, atualiza todos os seus campos com os valores passados pela requisição e salva as alterações usando o método save() método. Desta forma o registro lido é atualizado pelos novos valores.

O método redireciona o usuário de volta para a exibição de índice com uma mensagem de sucesso.

Aqui está um exemplo de como você pode usar o curl para enviar uma solicitação PUT para o endpoint /books/3 e atualizar o livro com id 3 com todos os campos:

curl -X PUT -H "Content-Type: application/json" -d '{"title": "The Catcher in the Rye 2.0", "published_at": "2022-01-01", "author": "J.D. Salinger", "language": "English", "type": "Novel"}' http://localhost:3000/books/3

Este comando envia uma solicitação PUT para o terminal http://localhost:3000/books/3 e atualiza o livro com id 3 com os dados que são enviados no corpo da solicitação.

Você deve obter uma resposta do terminal semelhante a esta:

{
  "message": "Book updated successfully"
}

A operação DELETE no CRUD

A operação DELETE é uma das quatro operações CRUD (Criar, Ler, Atualizar, Excluir) básicas no desenvolvimento de software. Ele é usado para excluir ou remover dados existentes de um banco de dados ou outro sistema de armazenamento de dados.

No contexto de um banco de dados relacional, a operação DELETE é executada usando uma instrução SQL DELETE. A sintaxe de uma instrução SQL DELETE é a seguinte:

DELETE FROM table_name
WHERE some_column = some_value;

Esta instrução exclui as linhas na tabela especificada que correspondem às condições ou critérios especificados na cláusula WHERE. Por exemplo, a instrução SQL a seguir exclui o livro em que o id é 3:

DELETE FROM book
WHERE id = 3;

No contexto de uma API RESTful, a operação DELETE normalmente é executada usando o método HTTP DELETE. Por exemplo, a seguinte solicitação DELETE exclui o livro com id 3:

DELETE /books/1

Vejamos alguns exemplos da operação DELETE:

Aqui está um exemplo de uma operação SQL DELETE usando a tabela “livro” para excluir o livro com id = 3:

DELETE FROM book
WHERE id = 3;

Esta instrução exclui o livro com id = 3 da tabela “livro”.

Aqui está um exemplo de uma operação DELETE no Node.js usando a tabela “book” para excluir o livro com id = 3:

app.delete('/books/:id', function (req, res) {
  var bookId = req.params.id;
  // Validate bookId here
  // Delete the book with the specified id from the database
  var sql = "DELETE FROM book WHERE id = ?";
  connection.query(sql, [bookId], function (error, result) {
    if (error) {
      res.status(500).json({message: "Error deleting book"});
    } else {
      res.status(200).json({message: "Book deleted successfully"});
    }
  });
});

Este endpoint escuta uma solicitação DELETE para a rota “/books/:id”, exclui o livro com o id passado no parâmetro da solicitação e envia de volta uma resposta JSON indicando que o livro foi excluído com sucesso.

Segue um exemplo de operação DELETE em PHP utilizando a tabela “livro” e ADODB para deletar o livro com id = 3 e os valores passados por requisição:

<?php
require('adodb/adodb.inc.php');

$dsn = "mysql://username:password@localhost/myDB";
$db = ADONewConnection($dsn);

$book_id = $_POST["id"];
$query = "DELETE FROM book WHERE id = ".$book_id;
$db->execute($query);

echo "Book deleted successfully";

?>

Este script cria a consulta usando o id passado pela variável $_POST, então a executa usando o método Execute().

E aqui está um exemplo de operação DELETE no Laravel usando a tabela “book” para deletar o book com id = 3, usando os valores passados por requisição:

public function destroy($id)
{
    $book = Book::find($id);
    $book->delete();

    return redirect()->route('books.index')->with('success','Book deleted successfully');
}

Este método controlador recupera um livro por seu id da tabela “book” usando o método find() do Eloquent ORM e exclui o registro usando o método delete(). O método redireciona o usuário de volta para a exibição de índice com uma mensagem de sucesso.

Conclusões

De maneira geral, o CRUD é um conjunto de operações simples e poderoso amplamente utilizado na engenharia de software, sendo considerado uma boa prática porque ajuda a simplificar e padronizar a forma como os dados são armazenados e acessados, tornando o processo de desenvolvimento mais eficiente, sustentável e escalável.