O que é CRUD - Create, read, update and delete

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:

• 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”:

• SQL
• JSON

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

{
  "$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"
  ]
}

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.

• NodeJs
• SQL
• PHP
• Laravel

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"});
  });
}); 

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

<?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";
?>

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:

• SQL
• NodeJS
• PHP
• Laravel

SELECT * FROM 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);
  });
}); 

<?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>";
}

?>

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

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

• SQL
• NodeJS
• PHP
• Laravel

    SELECT * FROM book WHERE id = 1

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);
}); 

<?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>";

?>

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

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:

• SQL
• NodeJS
• PHP
• Laravel

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;

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"});
    }
  });
});

<?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";

?>

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');
}

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:

• SQL
• NodeJS
• PHP
• Laravel

DELETE FROM book
WHERE 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"});
    }
  });
});

<?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";

?>

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

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

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.