class Cliente {
  public constructor(private _id: number, private _name: string) {}

  get clientes(): number {
    return this._id;
  }

  // outros comportamentos do cliente
}

class ClienteService {
  public execute(path: string) {
    if (path === "sincronizarImagens") {
      // lógica para sincronizar as imagens do cliente
    }

    if (path === "sincronizarReport") {
      // lógica para sincronizar os relatórios do cliente
    }

    if (path === "sincronizarLogs") {
      // lógica para sincronizar os logs do cliente
    }
  }
}

Iniciando solução

Podemos pensar em excluir essa lógica de ifs, e uma forma de fazer isso é com o Handler Map.

A primeira parte é definir um tipo onde teremos uma chave e o tipo de parâmetros da função de callback. Perceba que, nesse ponto, podemos usar qualquer string como tipo da chave, e nos parâmetros estamos esperando o ID e não vamos retornar nada.

type HandlerMap = {
  [key: string]: (id: number) => void;
};

Agora precisamos de uma função para resolver nossa callback conforme o parâmetro que passarmos, mas o detalhe é que não vamos passar parâmetro nenhum, te mostro já.

class ClientService {
    private resolverHandlerMapByName(): HandlerMap {
        return {
            sincronizarImagens:(id: number) => this.searchImages(id),
            sincronizarReport(id: number) => this.sincronizarReport(id),
            sincronizarLogs(id: number) => this.sincronizarLogs(id),
        }
    }

    sincronizarImagens(id: number): void {
        // lógica para sincronizar as imagens do cliente
    }

    sincronizarReport(id: number): void {
        // lógica para sincronizar os relatórios do cliente
    }

    sincronizarLogs(id: number): void {
        // lógica para sincronizar os logs do cliente
    }
}

Conforme o exemplo acima, resolvemos nossa execução de forma transparente, sem a necessidade de verificações estranhas.

Como usar?

class ClientService {

    execute(path: string) {

        const id = 123;

        const handler = this.resolverHandlerMapByName()[path]

        handler(id);

    }

    private resolverHandlerMapByName(): HandlerMap {
        return {
            sincronizarImagens:(id: number) => this.searchImages(id),
            sincronizarReport(id: number) => this.sincronizarReport(id),
            sincronizarLogs(id: number) => this.sincronizarLogs(id),
        }
    }

    sincronizarImagens(id: number): void {
        // lógica para sincronizar as imagens do cliente
    }

    sincronizarReport(id: number): void {
        // lógica para sincronizar os relatórios do cliente
    }

    sincronizarLogs(id: number): void {
        // lógica para sincronizar os logs do cliente
    }
}

Dessa forma conseguimos resolver nossa chamada com HandlerMap de forma transparente, há outras formas de resolver isso também, mas essa é uma forma que deixa as coisas bem legíveis.

Qual a utilidade de um vetor não ordenado?

Um vetor não ordenado tem a utilidade de guardar agrupamentos de dados que, como o nome já diz, não necessitam estritamente de uma ordem. Vetores sempre terão um limite, e esse é o diferencial para uma lista. Em um vetor não ordenado, pode-se guardar um grupo de objetos ou primitivos temporários. Vetores não ordenados são uma boa escolha na hora de lidar com poucos dados fixos.

Implementação em Python

import numpy as np

'''
Vetor não ordenado de inteiros, não permite inserção de valores duplicados
Operações:
    inserir
    imprimir
    excluir
    pesquisar
'''


class VetorNaoOrdenado:
    def __init__(self, capacidade_vetor):
        self.capacidade_vetor = capacidade_vetor
        self.ultima_posicao = -1
        self.valores = np.empty(self.capacidade_vetor, dtype=int)

    def insere_no_vetor(self, valor):
        self.ultima_posicao += 1
        self.valores[self.ultima_posicao] = valor

    def insere(self, valor):
        if self.ultima_posicao == self.capacidade_vetor - 1:
            print('A capacidade foi atingida')
        else:
            if self.ultima_posicao == -1:
                self.insere_no_vetor(valor)
            else:
                for i in range(self.ultima_posicao + 1):
                    if self.valores[i] == valor:
                        print(f'Não é permitido inserir {valor} já existe no vetor')
                        return
                self.insere_no_vetor(valor)

    def pesquisa_linear(self, valor):
        for i in range(self.ultima_posicao + 1):
            if self.valores[i] == valor:
                return i
        return -1

    def excluir(self, valor):
        if self.ultima_posicao == -1:
            return -1
        indice_pesquisado = self.pesquisa_linear(valor)
        for i in range(indice_pesquisado, self.ultima_posicao):
            self.valores[i] = self.valores[i + 1]
        self.ultima_posicao -= 1

    def imprime_valores(self):
        if self.ultima_posicao == -1:
            print('O vetor está vazio')
        else:
            for i in range(self.ultima_posicao + 1):
                print(i, '-->', '[', self.valores[i], ']')


if __name__ == '__main__':
    vetor = VetorNaoOrdenado(5)
    vetor.insere(1)
    vetor.insere(8)
    vetor.insere(7)
    vetor.insere(6)
    vetor.insere(5)
    vetor.excluir(7)
    vetor.imprime_valores()

    print('Posicao', vetor.pesquisa_linear(19))

Implementação em Typescript

export class VetorNaoOrdenado {
  private ultimaPosicao: number;
  private vetor: number[];

  constructor(private capacidade: number) {
    this.ultimaPosicao = -1;
    this.vetor = [];
  }

  valorNaoEncontrado(value: number): boolean {
    return this.procurar(value) === -1;
  }

  inserir(value: number) {
    if (this.ultimaPosicao == this.capacidade - 1) {
      return -1;
    }
    if (this.valorNaoEncontrado(value)) {
      this.ultimaPosicao += 1;
      this.vetor[this.ultimaPosicao] = value;
    } else {
      return -1;
    }
  }

  remover(value: number) {
    const foundIndex = this.procurar(value);
    if (!this.vetor[foundIndex]) {
      return -1;
    }

    for (let i = 0; i < this.capacidade - 1; i++) {
      if (this.vetor[i] == value) {
        for (let j = i; j < this.capacidade - 1; j++) {
          this.vetor[j] = this.vetor[j + 1];
        }
      }
    }
    this.ultimaPosicao -= 1;
  }

  procurar(value: number): number {
    let result = -1;
    for (let i = 0; i < this.capacidade - 1; i++) {
      if (this.vetor[i] === value) {
        result = i;
      }
    }
    return result;
  }

  imprimir() {
    for (let i = 0; i < this.capacidade - 1; i++) {
      if (!this.vetor[i]) continue;
      console.log(`[Posição: ${i}] -> Valor: ${this.vetor[i]}`);
    }
  }
}

const lista = new VetorNaoOrdenado(5);

lista.inserir(1);
lista.inserir(3);
lista.inserir(2);
lista.inserir(10);

lista.remover(1);

lista.imprimir();

Como subir o Kafka com Debezium localmente?

services:
  mysql-kafka:
    image: mysql:5.7
    environment:
      - MYSQL_DATABASE=kafka-test
      - MYSQL_ROOT_PASSWORD=root
    ports:
      - 3306:3306
    volumes:
      - .data/mysql:/var/lib/mysql
    networks:
      - kafka-test-network

  connect:
    image: debezium/connect:latest
    depends_on:
      - kafka
      - mysql-kafka
    environment:
      - BOOTSTRAP_SERVERS=kafka:9092
      - GROUP_ID=1
      - CONFIG_STORAGE_TOPIC=my_connect_configs
      - OFFSET_STORAGE_TOPIC=my_connect_offsets
      - STATUS_STORAGE_TOPIC=my_connect_statuses
    ports:
      - 8083:8083
      - 5005:5005
    networks:
      - kafka-test-network

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    networks:
      - kafka-test-network
    deploy:
      resources:
        limits:
          cpus: "0.8"
          memory: 800M
        reservations:
          memory: 100M

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
      - "9094:9094"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_NUM_PARTITIONS: 1
      KAFKA_DEFAULT_REPLICATION_FACTOR: 1
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_INTER_BROKER_LISTENER_NAME: INTERNAL
      KAFKA_LISTENERS: INTERNAL://:9092,OUTSIDE://:9094
      KAFKA_ADVERTISED_LISTENERS: INTERNAL://kafka:9092,OUTSIDE://localhost:9094
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INTERNAL:PLAINTEXT,OUTSIDE:PLAINTEXT
    networks:
      - kafka-test-network
    deploy:
      resources:
        limits:
          cpus: "0.8"
          memory: 800M
        reservations:
          memory: 100M

networks:
  kafka-test-network:
    driver: bridge
    name: kafka-test-network

A primeira imagem que precisamos é do próprio MySQL. Nele, vamos criar um banco para posteriormente listar os logs.

Em seguida, iniciamos a imagem do Debezium e adicionamos as dependências do Kafka e do Zookeeper.

Obs.: Este docker-compose é apenas um exemplo. O recomendado é usar um arquivo .env para adicionar os parâmetros e configurações de nossas imagens.

Rodando o projeto

$ docker compose up

A partir desse momento, se tudo der certo, teremos toda a nossa infraestrutura rodando localmente para testarmos.

Para ver o estado dos containers ativos, você pode executar:

docker ps

Se tudo ocorreu bem, vamos ver uma saída dos containers ativos

Montando script SQL

Vamos criar uma tabela no banco para posteriormente inserirmos dados e ler como tópicos de criação no Debezium.

use `kafka-test`;
drop table if exists users;
CREATE table users(
    id int not null auto_increment,
    name varchar(50) not null,
    age int default null,
    surname varchar(40) default null,
    primary key (id)
);

Definindo primeiro connector

O Debezium possui sua própria API REST e diversos plugins. O que vamos precisar para ele começar a ler as alterações dessa tabela é:

curl --location 'localhost:8083/connectors' \
--header 'Content-Type: application/json' \
--data '{
    "name": "database-connector",
    "config": {
        "connector.class": "io.debezium.connector.mysql.MySqlConnector",
        "tasks.max": "1",
        "database.hostname": "mysql-kafka",
        "database.port": "3306",
        "database.user": "root",
        "database.password": "root",
        "database.server.id": "184054",
        "topic.prefix": "connector",
        "database.include.list": "kafka-test.users",
        "schema.history.internal.kafka.bootstrap.servers": "kafka:9092",
        "schema.history.internal.kafka.topic": "schema-changes.inventory"
    }
}'

Nesse ponto perceba que adicionamos como connector o prefixo de nossos tópicos gerados pelo debezium, outro ponto é que apontamos todas as configurações de conexão com banco e kafka diretamente pela rede interna que criamos no nosso docker-compose.

Inserindo dados

Agora que temos nosso plugin ativo, podemos adicionar dados no banco. Esses dados vão produzir tópicos que vamos poder consumir e posteriormente gerar eventos ou mesmo trabalhar com streams.

INSERT INTO users (name, age, surname) VALUES
('Alice', 25, 'Smith'),
('Bob', 30, 'Johnson'),
('Charlie', 35, 'Williams'),
('David', 40, 'Jones'),
('Emma', 22, 'Brown'),
('Frank', 28, 'Davis'),
('Grace', 33, 'Miller'),
('Henry', 45, 'Wilson'),
('Isabella', 27, 'Moore'),
('Jack', 32, 'Taylor'),
('Kate', 29, 'Anderson'),
('Liam', 38, 'Thomas'),
('Mia', 26, 'Jackson'),
('Noah', 31, 'White'),
('Olivia', 34, 'Harris'),
('Patrick', 37, 'Clark'),
('Quinn', 41, 'Allen'),
('Riley', 36, 'Scott'),
('Sophia', 39, 'Adams'),
('Thomas', 42, 'Lee'),
('Uma', 23, 'Parker'),
('Vincent', 44, 'Robinson'),
('Willow', 43, 'Nelson'),
('Xander', 24, 'Evans'),
('Yasmine', 21, 'Murphy'),
('Zoe', 46, 'Carter'),
('Aaron', 20, 'Baker'),
('Bella', 47, 'Wright'),
('Caleb', 19, 'Garcia'),
('Diana', 48, 'King'),
('Ethan', 50, 'Hall'),
('Fiona', 49, 'Adams'),
('Gabriel', 51, 'Mitchell'),
('Hannah', 52, 'Thompson'),
('Ian', 53, 'Green'),
('Julia', 54, 'Phillips'),
('Kevin', 55, 'Cook'),
('Laura', 56, 'Rivera'),
('Michael', 57, 'Perez'),
('Nora', 58, 'Torres'),
('Oscar', 59, 'Hill'),
('Penelope', 60, 'Young'),
('Quentin', 61, 'Gonzalez'),
('Rachel', 62, 'Hughes'),
('Samuel', 63, 'Turner'),
('Tiffany', 64, 'Parker'),
('Ulysses', 65, 'Ward'),
('Victoria', 66, 'Foster'),
('Walter', 67, 'Stewart'),
('Xavier', 68, 'Wells'),
('Yolanda', 69, 'Bennett'),
('Zachary', 70, 'Gray'),
('Arthur', 71, 'Sullivan'),
('Beatrice', 72, 'Cole'),
('Christopher', 73, 'Morris'),
('Danielle', 74, 'Gutierrez'),
('Edward', 75, 'Perry'),
('Felicity', 76, 'Barnes'),
('George', 77, 'Knight'),
('Holly', 78, 'Bryant'),
('Ivan', 79, 'Reed'),
('Jessica', 80, 'Banks'),
('Kenneth', 81, 'Lopez'),
('Lily', 82, 'Harrison'),
('Matthew', 83, 'Gomez'),
('Natalie', 84, 'Fisher'),
('Oliver', 85, 'Murray'),
('Patricia', 86, 'Marshall'),
('Quincy', 87, 'Dean'),
('Rebecca', 88, 'Gilbert'),
('Simon', 89, 'Wagner'),
('Tara', 90, 'Dunn'),
('Ursula', 91, 'Mcdonald'),
('Victor', 92, 'Pierce'),
('Wendy', 93, 'Gordon'),
('Xena', 94, 'Holmes'),
('Yvonne', 95, 'Henry'),
('Zelda', 96, 'Hunt'),
('Andrew', 97, 'Rose'),
('Barbara', 98, 'Owens'),
('Carl', 99, 'Hudson'),
('Daisy', 100, 'Bishop');

E assim concluímos o processo de configuração do Kafka com Debezium, estabelecendo uma estrutura local para monitoramento de operações em bancos de dados legados. Com este ambiente configurado, podemos gerar eventos a partir das alterações realizadas nas tabelas do banco de dados, facilitando a integração e o processamento de dados em tempo real. Se precisar de mais alguma informação ou tiver alguma dúvida, estou à disposição para ajudar!

enum ClientType
{
    PF,
    PJ,
    FORNECEDOR,
}
class MensagensService {

    public async void EnviarMensagens(Cliente cliente) {

        if (ClienteHelper.TypeCliente(cliente) == ClientType.PF) {
            // lógica para executar o envio da mensagem para cliente pessoa fisica
        }

        if (ClienteHelper.TypeCliente(cliente) == ClientType.PJ) {
            // lógica para executar o envio da mensagem para cliente PJ
        }

        if (ClienteHelper.TypeCliente(cliente) == ClientType.FORNECEDOR) {
            // lógica para executar o envio da mensagem para cliente fornecedor
        }

    }
}

O código acima é muito ruim. Com o passar do tempo, ele se torna ineficiente e confuso. Cada tipo de cliente tem estratégias diferentes para o envio de mensagens, e essas, neste momento, não importam muito. O que importa é que isso tem que ser tratado de forma separada. Existem outras formas de resolver isso, mas hoje estamos falando do strategy.

Solução

Uma boa solução seria uma classe que consegue navegar entre cada estratégia, e aqui vamos definir que cada estratégia se trata de cada tipo de envio de mensagem. Vamos chamar essa classe de contexto.

Também precisamos de uma rota (interface) entre a classe de contexto e as estratégias.

interface Strategy {
    void Execute();
}

class EnvioMensagemPF : Strategy {
    public void Execute() {
        // lógica para executar o envio da mensagem para cliente pessoa fisica
    }
}

class EnvioMensagemPJ : Strategy {
    public void Execute() {
        // lógica para executar o envio da mensagem para cliente PJ
    }
}

class EnvioMensagemFornecedor : Strategy {
    public void Execute() {
        // lógica para executar o envio da mensagem para cliente FORNECEDOR
    }
}

class Context {
    private Strategy Strategy {get; set;}

     public Context(Strategy strategy) {
        Strategy = strategy;
     }

    public void Execute() {
        Console.WriteLine("executando strategy");
        Strategy.Execute();
    }

    public void SetStrategy(Strategy strategy) {
        Strategy = strategy;
    }
}

A partir de agora, ficou bem mais tranquilo adicionar lógica e comportamento de forma separada para cada método Execute de cada tipo de envio.

Factory

Vamos definir uma factory para não precisar lidar com esses ifs de forma excessiva.

class EnvioMensagemFactory
{
    private readonly Dictionary<ClientType, IStrategy> _strategies;

    public EnvioMensagemFactory()
    {
        _strategies = new Dictionary<ClientType, IStrategy>
        {
            { ClientType.PF, new EnvioMensagemPF() },
            { ClientType.PJ, new EnvioMensagemPJ() },
            { ClientType.FORNECEDOR, new EnvioMensagemFornecedor() }
        };
    }

    public IEnvioMensagemStrategy GetStrategy(ClientType tipoCliente)
    {
        if (_strategies.TryGetValue(tipoCliente, out var strategy))
            return strategy;

        throw new Exception("Tipo de cliente não suportado");
    }
}

Executando strategy

class MensagensService
{
    private readonly EnvioMensagemFactory _factory;

    public MensagensService()
    {
        _factory = new EnvioMensagemFactory();
    }

    public async Task EnviarMensagens(Cliente cliente)
    {
        var tipoCliente = ClienteHelper.TypeCliente(cliente);
        var strategy = _factory.GetStrategy(tipoCliente);

        await strategy.EnviarMensagem(cliente);
    }
}

Gostou do resultado? Esse tipo de implementação melhora muito a leitura e a manutenibilidade do código.

Olá, talvez o ecossistema spring seja o mais completo da atualidade, esse ecossistema cada vez vem melhorando e refinando, temos um mundo de empresas que o utilizam e quando falamos de microserviços spring é fantástico.

Por onde podemos começar a utilização do spring, bem antigamente era bem complicado para configurar o spring como aplicação para se trabalhar com web, eu mesmo sofri um pouco com xml na epoca da faculdade rsrsrs, mas o pessoal do spring teve uma ideia muito boa, visto que a maioria das aplicações tem a mesma configuração, por que não utilizar configuração por convenção? o spring boot ajuda nisso, com seus componentes pré configurados ficou muito fácil sair utilizando todo poder que o ecosistema spring nos dá.

instalando plugin vs-code

Se você já tem uma IDE configurada pode pular essa parte, agora se está começando poderá instalar esses plugins no vs-code https://marketplace.visualstudio.com/items?itemName=Pivotal.vscode-boot-dev-pack A partir de agora você está apto a rodar projetos spring no vs-code, não tem mistério, se preferir utilizar o https://spring.io/tools ou https://www.jetbrains.com/pt-br/idea/ fique a vontade pois são ótimas escolhas também.

Start project

Hoje temos o https://start.spring.io/ e vale muito a pena conhecer, esse site tem a capacidade de gerar projetos para a plataforma spring.

Mas vamos seguir o caminho de pegar um projeto pré configurado, onde podemos apenas escrever a entidade, controller e repositorio, mas se você pensou, eu não sei o que é isso, fica tranquilo que no caminho você vai aprender.

Link para o repositorio pré configurado: https://github.com/andremartds/spring_boot_pre_configurado

Estrutura do projeto

Se você já entende dos pakages do java, esse entendimento vai ser tranquilo, basicamente temos: main: pasta principal do projeto java: sendo nosso contexto da aplicação java com/andremartds/cadastro: contexto do nosso endpoint

Logo dentro de cadastro temos, controllers, exceptionHandler, model, repository, services e nosso ponto de entrada da aplicação que no caso é esse arquivo App.java

Perceba o quanto é simples esse arquivo, ele apenas chama a classe do SpringApplication e nossa aplicação será inicializada, não vamos entrar em detalhes mais profundos nesse ponto, precisamos subir nossa api o mais rápido possível.

Entidade ou Model

No java assim como em outras linguágens podemos ter representações de tabelas do banco de dados em nossa aplicação, e isso facilita o dia dia, imagine que pra acessar seu banco de dados sempre tivesse que escrever querys na mão, quão verboso sua api seria, é claro que as vezes é necessário, sem mais delongas vamos a nossa entidade de pessoa.

Nada demais, aqui estamos mapeando nossa entidade com seus atributos, vamos passar por cada um deles

codigo

O código anotamos com a anotação @Id e @GeneratedValue(strategy = GenerationType.IDENTITY) resumindo essas anotação farão com que seja criado o codigo no banco de dados, esse código será auto incrementável, ou seja, 1, 2, 3...

nome

Para o nome temos logo acima do mesmo, @NotNull essa anotação faz a uma validação onde não poderá ser um campo indefinido, sem valor ou nulo. Temos também o @size(min=3, max=50) com isso só pode ter o mínimo de caracteres de 3 a 50

Endereco

Aqui temos uma pequena curiosidade, no caso estamos utilizando o @Embedded estamos instruindo o código a aceitar esse embedável, que estamos tratando em outra classe.

Nessa classe anotamos a mesma com @Embeddable ou seja ela poderá ser embedada por um @Embedded pegou a ideia? Dessa forma estamos colocando na mesma tabela do banco de dados, porém estamos trabalhando com responsabilidades separadas no codigo.

ativo

Por último temos o ativo que se trata de um boleano, não tem mistérios.

Repository

Logo a baixo da pasta model temos a pasta Repository, e uma das maiores vantágens de se trabalhar com o padrão repository é o fato de podermos extender todo os métodos do SpringDataJpa, você pode pensar, que vantágem tem isso? com o SpringDataJpa você passa a ter super poderes e é muito provável que ele resolva a maioria de suas chamadas ao banco de dados.

Tão simples quanto isso, basta criar a interface extender JpaRepository Passando Pessoa e o tipo de seu Id, no caso Long.

ExceptionHandler

não vou me alongar muito na explicação do exceptionHandler, vamos resumir em uma frase. Responsável por capturar as exceções e tratá-las, deixando mais limpo, service ou controller.

Na verdade não precisava nesse primeiro momento trabalharmos com esse tipo de captura de exception, vou deixar o código mais como exemplo mesmo, hehe.

Controller

Controller ou Resource é onde vamos trabalhar com toda a camada dos dados que entram para o nosso endpoint, nesse caso que entram por '/pessoas'

De cara vemos algumas coisas interessantes, a primeira é como o spring trabalha para dizer que esse arquivo é um controller, então adicionamos a anotação @RestController e logo abaixo temos a @RequestMapping("/pessoas") que é responsável por adicionar a URI de entrada para esse endpoint

Autowired

Utilizamos essa anotação para injetarmos algo no contexto do spring, e nesse caso estamos injetando aquele repository que terá todos os métodos para utilizarmos e também estamos injetando o service de pessoas que já vamos detalhar.

Todos Usuarios

Esse método tem a reponsabilidade de retornar todos os usuários, nesse caso estamos utilizando os artificios do nosso repository para trazer tudo, e já estamos jogando isso para uma lista de pessoas.

Buscar Por Código

Esse metodo tem a finalidade de trazer uma pessoa por seu código, perceba que adicionamos o @GetMapping("/{codigo}") e dessa forma vamos estar prontos para pegar uma variável com o @PathVariable que no caso foi o proprio codigo, depois utilizamos os recursos adicionados no java 8 para fazer o map com uma lambda, trazendo todos os registros se ok e se não nada foi encontrado.

Adicionando Pessoa

Esse método vamos adicionar uma pessoa no nosso banco de dados, perceba que nos argumentos da função estamos passando @valid essa anotação fará com que aquelas validações que colocamos dentro da entidade sejam verificadas, no final retornamos o ResponsyEntity passando o Status http como create e o body que foi a própria pessoa salva.

Remover Pessoa

Esse método tem por finalidade remover a pessoa selecionada, pegamos o codigo só que agora com o @deleteMapping("/{codigo}") e vamos dar a resposta com o httpStatus no content assim, não irá retornar nada do que foi removido, que é o correto, já que o registro não existe mais.

Atualizar Pessoa e Atualizar pessoa parcialmente

Para atualizar uma pessoa também é muito simples, só que nesse caso vamos utilzar o service, que no dia a dia é bem mais comun, afinal não dá pra deixar regras de negócio na camada do controller, então passamos para nosso service no método atualiza pessoa o codigo e a pessoa que veio na requisição put.

No caso da atualização de pessoa, estamos fazendo o trabalho duro no service, estamos seguindo o mesmo comportamento anterior dos outros métodos só que no service retornando para o controller, imagine se sua aplicação tivesse várias validações para atualizar uma pessoa, não seria justo nem bonito deixar o código no controller.

Por fim temos a atualização com o patch, atualizar com esse verbo significa que será uma atualização parcial, isso é sempre bom quando possível afinal estamos poupando recursos, no caso desse método trabalhamos com o mesmo comportamento, recebemos o id em @patchMapping("/{codigo}/ativo") só que a diferença é que estamos enviando no body, true ou false, dessa forma setamos apenas esse valor para a entidade.

A importação dos arquivos do postman estão zipados dentro do projeto.

obrigado pela leitura.

Muitas pessoas tem dificuldades para iniciar com docker, mas na verdade se elas tem domínio das ferramentas que já trabalham no seu dia dia, docker vai ser mais um detalhe, bom acho que todos já estão cansados de saber quão bom é trabalhar com docker e quão flexível isso pode se tornar, alem do mais é amplamente utilizado em muitas empresas e acaba se tornando indispensável para o currículo de um desenvolvedor, então deixemos de lado a introdução e vamos direto aos pontos.

Comandos úteis para seu dia dia

Rodando

// quer trazer uma imagem para sua máquina e já sair rodando? esse é o comando
docker run ubuntu

// faz o download de uma imagem mas não excuta
docker pull nome_usuario/nome_image

Containers

// listando todos os containers que estiverem ativos
docker ps

// listando todos os ids dos containers, ativos
docker ps -q

// listando todos os ids dos containers, ativos
docker ps -aq

// iniciando um container
docker start name_container

// para todos os containers ativos de uma só vez
docker stop $(docker ps -aq)

// rodando um container atrelado ao seu terminal
docker run -it name_image

// para parar um container
docker stop (name or id)

// removendo um container de forma forçada
docker rm (id or name) -f

// removendo todos os containers parados
docker container prune

// rodando um container com uma porta e nome e de forma desatrelada ao terminal
docker run -d -p 80:8080 --name server nginx:latest

// parando um container e removendo e o removendo
docker-compose down --rmi all

// acessando seu container
docker exec -it name-container sh

Imagens

//lista todas as imagens
docker image ls

//lista todas as imagens
docker image

// remove todas as imagens
docker rmi $(docker images -q)

// remove uma imagem
docker rmi name_image

// limpando tudo
docker system prune

Network

// Adicionando rede
docker network create --driver bridge local

// removendo todas as redes
docker network prune

Outros

// Copiando excema de uma base mysql
docker exec container_mysql_name /usr/bin/mysqldump -u root --password=root schema > backup.sql

// Rodando um postgresql sem dockerfile
docker run --name postgres11 -e POSTGRES_PASSWORD=docker -p 5432:5432 -d postgres:11

// rodando um mongo sem dockerfile
docker run --name mongo -p 27017:27017 -d -t mongo

// rodando um mysql sem dockerfile
docker run --detach --name=mysql8 -p 3306:3306  --env="MYSQL_ROOT_PASSWORD=docker" mysql:8.0.22

Docker Register

Imagine o cenário, precisamos configurar uma imagem pessoal para subir em um container em determinado servidor, com o doker hub podemos facilmente ter images pessoais privadas(plano não gratuito no docker hub), assim podemos usa-las quando e onde quisermos, grandes datacenter como, gcp, amazon e azure também vão ter seus próprios registers, basta termos nosso register privado lá e conseguiremos ter nossas imagens privadas para subir em nosso servdor remoto.

Binds e mounts/volumes

Muitas vezes removemos os containers após o uso.

É muito comum usar o container e apagá-lo após o uso, dessa forma os dados desses container são perdidos e nesse ponto que os volumes ou mounts permitem salvar dados fora de um container.

Volumes são usados para os dados não serem removidos ao paramos nosso container, trata-se de um mapeamento entre seu host (computador de trabalho) e container, na maioria dos projetos que trabalhamos em ambiente de dev costumamos fazer um apontamento entre nossa maquina e algum container.

docker run -d --name nginx -v ~/ti/testdocker/html:/usr/share/nginx/html -p 8080:80 nginx

No exemplo acima apontamos um volume de nossa maquina local por meio da tag -v para dentro da pasta do nginx, dessa forma se perdemos nossa imagem o conteúdo está salvo em nosso host.

A forma mais atual de se trabalhar com volumes é utilizando mounts, um exemplo de diferença entre volumes e mouts é que volumes criam pastas em nosso host mesmo que essas não existam, mounts não.

docker run -d --name nginx --mount type=bind, source=/Users/andremartds/ti/testdocker/html,target=/usr/share/nginx/html -p 8080:80 nginx

docker run -d --name nginx --mount type=bind, source="$(pwd)",target=/usr/share/nginx/html -p 8080:80 nginx

Caso você utilize $(pwd) isso vai conseguir pegar o diretório absoluto de onde você está no momento.

Volumes

Pode ser que precisemos ter um volume centralizado em nosso host e queremos apontar esses dados para um ou mais containers, nesse caso tudo que for criado em um container será apontado para os outros que compartilham desse type.

requer estar na mesma rede*

// comandos
docker volume

// criando nosso volume
docker volume create myvolume

// lista todos os volumes existentes
docker volume ls

// removendo um volume
docker volume prune (hash volume)

// inspecionando um volume
docker volume inspect myvolume

Criando e utilizando volumes

// cria um volume
docker volume create myvolue

// rodando uma imagem e atrelando nosso novo volume com -v
docker run -d -p 8082:80 --name nginx24 -v myvolume:/app nginx
// ou
docker run -d -p 8080:80 --name nginx1 --mount type=volume,source=myvolume,target=/app nginx
//e
docker run -d -p 8081:80 --name nginx2 --mount type=volume,source=myvolume,target=/app nginx

Acessando e alterando arquivos de um container

 //lista os diretorios da pasta root do container
docker exec nginx ls

 // acessa o container com nosso bash local
docker exec nginx -it bash

Agora que acessamos nosso container vamos alterar o arquivo index do nginx, caminho: cd /usr/share/nginx/html

sudo nano index.html

Perceba o conceito images, elas são IMUTÁVEIS ou seja, caso nosso container seja removido ao reutilzarmos a imagem que temos em nossa máquina a mesma virá sem as alterações que acabamos de fazer

Dicas adicionais

caso você esteja trabalhando no linux ou mac você poderá adicionar em seu .bashrc ou zshrc alguns atalhos para executar seus comandos

alias d="docker"
alias dcu="docker-compose up"
alias dd="docker-compose up -d"

agora é só sair utilizando as abreviações na hora de rodar seus comandos docker.

O Banco de dados MYSQL tem por característica salvar dados em arquivos dentro do host atual ou remoto e criar tratativas para esses dados. Para trabalhar com os dados utilizamos estrutura em tabelas que ficam dentro de banco de dados nomeados.

Databases == schemas

Em banco de dados MYSQL temos as Databases e Schemas, na verdade são sinônimos e podemos pensar neles como agrupadores de tabelas. Por exemplo: a aplicação do comércio do João tem uma base de dados específica que nada mais é do que tabelas relacionadas entre si utilizando um corpo de trabalho, lugar ou schemas.

Qual a finalidade do sql? Facilitar a manipulação dos dados podendo interagir de forma produtiva. Existem querys sql, funções, triggers e entre outros que vão tratar dados para facilitar a vida de quem lida com esses dados de forma a ser mais fácil inserir, excluir ou atualizar com base nas regras do negócio.

Como criar uma base de dados?

CREATE DATABASE padaria_joao;

Para criar uma base de dados podemos passar o comando CREATE DATABASE, e definimos o nome de nossa base de dados, nesse caso criamos uma base de dados padaraia_joao

Composição de uma tabela

No exemplo da imagem acima temos uma tabela produtos com as características:

columns(colunas),

indexes(índices),

Foreign Keys(Chaves Estrangeiras),

Triggers (Gatilhos).

As colunas são os campos a serem preenchidos com seus respectivos dados, como exemplos podemos pensar em: id, nome e preco , os índices geralmente se tratam de nossa chave primária que em muitas vezes são incrementais ou seja, ao ser inserido um dado o proprio MYSQL faz gerêncimento, os indices também podem ser índices não clusterizados onde podemos trabalhar para melhorar as consultas em uma tabela muito acessada.

Chaves estrangeiras são índices relacionados ao mundo exterior ou seja, as outras tabelas dentro de sua base de dados.

Os gatilhos geralmente são comportamentos que queremos que nossa tabela faça se determinada ocorrência acontecer antes ou depois de uma execução. Por exemplo, temos uma tabela cliente e temos uma tabela mensalidades, sempre que um cliente é inserido podemos criar um gatilho para ser disparado e iniciar a mensalidade com zero dentro da tabela mensalidade, sem uma linha de código no backend da aplicação.

Corpo de uma tabela

Você pode imaginar uma tabela como uma planilha do excel ou libre office, onde temos as colunas e em suas linhas tendo os valores, veja o exemplo abaixo.

-------------------------------------------
id| nome                   | idade   |
-------------------------------------------
1 | André Martins          | 150     |
2 | Bia Martins            | 11      |

as colunas são id, nome e idade. os valores são os dados embaixo de cada titulo de coluna.

Sessão de comandos

Criação de um tabela

create table estudo_mysql.teste(
    id int not null auto_increment,
    nome varchar(90) not null,
    primary key (`id`));

No exemplo acima criamos uma tabela com o nome teste que está dentro da base de dados estudo_mysql e tem os campos id e nome, sendo que o id é auto incrementável, não podendo ser nulo e o nome é do tipo varchar suportando até 90 caracteres, também definimos a chave primária sendo o id.

Como criar um relacionamento entre duas tabelas

Acredito que poucas pessoas façam esse tipo de operação sem a ajuda de uma interface gráfica, mas de qualquer forma irei deixar o registro de como fazer.

CREATE TABLE `testes`.`produtos` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `nome` VARCHAR(45) NULL,
  `id_categoria` INT NOT NULL,
  PRIMARY KEY (`id`),
  INDEX `fk_categoria_idx` (`id_categoria` ASC) VISIBLE,
  CONSTRAINT `fk_categoria`
    FOREIGN KEY (`id_categoria`)
    REFERENCES `testes`.`categorias` (`id`)
    ON DELETE CASCADE
    ON UPDATE NO ACTION);

No exemplo acima iremos destacar que criamos um INDEX com o nome fk_categoria_idx que tem uma referência para a coluna id_categoria, declaramos que ela é visivel, também declaramos a CONSTRAINT (limitação em tradução literal) que é chamada de fk_categoria, por fim nossa FOREING_KEY que de fato é onde iremos posteriormente atribuir os resultados. Sempre que fizermos um delete de uma categoria por termos colocado ON DELETE CASCASE na tabela de produtos o MYSQL irá excluir todos os produtos relacionados a uma categoria, assim não existirão dados mortos em nosso banco, já no update não colocamos nenhuma ação para ser feita.

Adicionando colunas a uma tabela Para adicionar uma coluna em MYSQL precisamos alterar uma tabela existente, vamos utilizar a tabela de produtos adicionando a coluna preco.

ALTER TABLE produtos ADD COLUMN preco decimal(10,2) default 0.0;

Utilizamos no exemplo o ALTER TABLE passando o nome da tabela e adicionando uma coluna preco, note que aplicamos o default com o valor 0.0, nesse caso todos os registros que já existam terão o valor padrão 0.0 e como não definimos essa coluna como NOT NULL quando não inserido nada o valor padrão será 0.0

Modificando tipo de dado de uma coluna existente

Para modificar um tipo de uma coluna existente vamos aplicar na tabela produtos, alterando o valor preco para uma string que suporta 45 caracteres.

ALTER TABLE produtos modify COLUMN preco varchar(45) default 'novo_valor';

O que já existe na tabela não será alterado, porém toda inserção nova que não tiver valores irá atribuir o novo valor padrão 'novo_valor'

Adicionando em uma tabela

inserção única

insert into produtos (nome, preco, descricao) values ('Testes de primeira inserção', 100.00, 'descricao do produto');

inserção em massa

INSERT INTO tabela(campo1, campo2) values ("valor 1", 1), ("valor 2", 2), ("valor 3", 3);

Pra inserir em uma tabela precisamos passar o comando insert into o nome da tabela, seus campos e após isso os values(valores) que vem precedido da palavra reservada values, note que é preciso respeitar cada tipo de valor que será inserido em sua ordem, no caso da tabela de produtos temos nome sendo varchar, preco sendo decimal (10,2) e temos a descrição sendo text.

caso queira estudar mais sobre tipos de dados para mysql segue um link da documentação oficial

https://dev.mysql.com/doc/refman/8.0/en/data-types.html

Seleção de dados de uma tabela

Para trabalhar com recuperação de dados temos muitas formas a partir do select, veja alguns exemplos abaixo:

SELECT * FROM pessoa;

Esse comando seleciona todos os campos da tabela pessoa.

SELECT * FROM pessoa WHERE id=1;

Esse comando seleciona todos os campos de uma pessoa selecionada a partir de uma id passado, perceba que a palavra reservada where é onde passamos esse valor.

select * from produtos where preco <= 100;

Podemos selecionar todos os produtos desde que (where) o preco for menor ou igual a 100

select * from produtos order by preco [desc || asc]

Agora imagine que você gostaria de trazer todos os produtos com preços por ordem ascendente ou descendente, podemos fazer isso com o order by passando a coluna que queremos.

Apelidos em colunas de tabelas

Utilizamos apelidos em colunas para apresentar de uma forma diferente

SELECT nome as `Nome do Produto`, preco as `Preço do produto` from produtos;

dessa forma alteramos a apresentação das colunas de uma tabela.

Seleção IN

Podemos ter a necessidade de trazer vários produtos com ids passados mas ao mesmo tempo deixar de fora outros, vejamos um exemplo:

SELECT * FROM produtos WHERE id IN (1, 2, 3);

Muitas vezes queremos trazer dados de tabelas relacionadas e montamos geralmente a partir de joins, mas podemos utilizar a cláusula IN para performar melhor em consultas que frequentemente acontecem.

Exemplo: tabela produto e tabela categoria sendo que um produto tem um relacionamento de n-1 com categoria (n produtos podem estar na mesma categoria), ou seja uma categoria pode ter vários produtos.

tabela de produto campos:id, nome, preco, id_categoria(sendo fk)

tabela de categoria campos:id, nome, descricao

select * from produtos where id_categoria in(
    select id from categorias where nome like 'frutas'
);

Dessa forma percebemos que podemos trazer todos os produtos que estão em uma determinada categoria que selecionamos a partir de um nome.

select * from produtos where id_categoria in(
    select id from categorias where id=2
);

Agora trazemos todos os produtos que estão na categoria de id 2

select * from produtos where id_categoria in(
    select id from categorias where id in(1, 2)
);

Agora trazemos todos os produtos que estão na categoria 1 e 2

select * from produtos where valor > 10 and id_categoria in(
    select id from categorias where id in(1, 3, 5)
);

Agora trazemos todos os produtos com valor maior que 10 e que estão na categoria de id 1, 3 ou 5 perceba o nivel de granularidade que podemos ter em nossas consultas, isso é PODEROSO.

select nome, preco from produtos p where id_categoria IN(
   select id from categorias where (nome='frutas' OR nome='verduras') and p.preco >= 15
);

Nesse exemplo estamos selecionando nome e preco de produtos desde que o id esteja contido no select mais abaixo, onde definimos que a seleção será a partir de nome de uma categoria igual a frutas ou nome igual a verduras, perceba que passamos um apelido para nossa tabela produtos onde utilizamos o mesmo na consulta interna e adicionamos mais uma condição, essa últimas condição poderia ser no primeiro select sem problemas também.

Seleção AND

Podemos utilizar juntamente com o where o and ou or para operar logicamente, veja o exemplo.

# AND
select * from produtos where preco > 100 and preco < 112;
# OR
select * from produtos where (valor > 20 ou valor < 30);

No exemplo acima selecionamos na primeira linha de execução todos os produtos que o preço é maior que 100 e menor que 112 e na segunda linha de execução selecionamos todos os produtos que o valor é maior que 10 ou menor que 30

Seleção Like

SELECT nome FROM produtos WHERE nome LIKE'm%';

No exemplo acima selecionamos um nome de uma tabela chamada produtos desde que nome comece com m e tenha qualquer sequencia de caractéres

SELECT nome FROM produtos WHERE nome NOT LIKE'm%';

Agora é o inverso, onde não temos a letra m sendo a primeira traremos os outros resultados.

SELECT NOME from produtos WHERE NOME like '_a%';

Selecionamos todos os produtos desde que contenham a segunda letra sendo a seguido de qualquer outro caractere

SELECT nome FROM produtos WHERE nome NOT LIKE '_a%';

Selecionamos todos os produtos desde que não contenham a segunda letra sendo a seguido de qualquer outro caractere

Selecionando tipos distintos em uma coluna Caso queira verificar quais são os tipos diferentes em determinada coluna você poderá utilizar o distinct para trazer apeanas os valores diferentes.

por exemplo: em uma determinada tabela chamada produto temos a coluna nome, e nessa coluna temos diversos valores diferentes mas queremos trazer apenas o valores distintos uns dos outros, então podemos fazer o comando:

    SELECT distinct(nome) from produtos;

Como resultado será retornado todos os nomes de produtos que se tem valores diferentes.

Seleção com Regexp Podemos utilizar expressões regulares para selecionar dados em uma tabela, alguns exemplos abaixo.

SELECT nome from testes.produtos where nome regexp '^[cp]';

No exemplo acima, utilizamos o caractere especial ^ fora dos colchetes para dizer que qualquer nome que comece com a letra c ou p será retornado nessa consulta.

select nome from testes.produtos where nome regexp '^[^cp]';

Nesse outro exemplo fizemos o NOT, quando colocamos ^ dentro do colchete estamos trazendo uma negação para a consulta, nesse caso seria descrito: selecione nome de produtos desde que não comece com c ou p

select nome from produtos where nome regexp '[a]$';

Com a utilização do caractere $ no final de uma expressão estamos dizendo que queremos selecionar todos os nomes que terminem com a, caso estivesse com o ^a seria um NOT.

Seleção com group by A clausula group by tem por finalidade como o nome já diz retornar dados agrupados por, um exemplo seria: digamos que temos uma tabela de endereço e nessa tabela temos usuarios de varios estados e temos também vários usuários que moram no mesmo Estado, com essa cláusula fica facil saber quantos usuários tem em cada estado.

Na tabela endereco temos as colunas, estado, nome_usuario e endereco

select estado, count(estado) from endereco group by estado;

Descrevendo o comando: selecione estado contando todos os estados e agrupando por estado, dessa forma como SP tem varias pessoas ele vai agrupar nessa linha o resultado para sp, se RJ tiver varios usuarios ele também vai agrupar esses usuarios em uma linha especifica.

Having o where do group by Quando queremos filtros em cima de dados agrupados podemos utilizar a cláusula having.

select estado count(estado) from estado group by estado having count(estado)=1;

dessa forma podemos construir filtros em cima do que foi agrupado em nossa consulta. ainda poderíamos ser mais específicos trazendo um where logo após o from estado por exemplo

select estado count(estado) from estado where nome='sp' or nome='rj' group by estado having count(estado) > 10;

Inner join

Um dos assuntos que as pessoas ficam mais confusas é a utilização de inner join, Para illustrar imagine que você tenha uma tabela chamada alunos e outra tabela chamada cursos, para saber quais cursos tem alunos e quais alunos estão presentes em cursos podemos utilizar o artifício do inner join.

Na imagem acima podemos ver que a seleção a partir de inner join trará todas as intersecções entre alunos e cursos que está destacado com a seta vermelha, onde se vê as setas verdes são o outer join que em tradução literal é exterior, onde podemos perceber que ficando intuitivo, inner join para dados esperados outer join para dados exteriores.

Exemplo: digamos que nós temos uma tabela produtos e uma tabela categorias, onde cada produto pode estar com um relacionamento para uma categoria.

select p.nome, p.valor, c.nome, c.descricao
from produtos p
inner join categorias c
on p.categoria_id=c.id

No exemplo acima fizemos uma seleção de nome e valor da tabela produtos e nome e descrição de categorias, se tratando do inner join ele vai trazer todos os produtos que tem uma categoria inserida.

Observações, c e p são alias para suas respectivas tabelas.

Ainda falando do exemplo acima podemos fazer filtros nos resultados obtidos, por exemplo:

select p.nome, p.valor, c.nome, c.descricao
from produtos p
inner join categorias c
on p.categoria_id=c.id
where c.nome='comida'

com filtros tão específicos fica fácil fazer seleções em tabelas relacionadas.

left join

Na imagem acima podemos ver o exemplo de um left join, no caso sendo selecionado o left join para alunos e cursos do lado right, o que será retornado nesse tipo de seleção é tudo do lado left e tudo do inner(meio ou intercecção), nada do right será retornado, imagine que na tabela estamos trazendo duas colunas nome_aluno e nome_curso, nesse caso ele vai trazer todos os alunos mesmo que não tenham nenhuma associação com algum curso alem de trazer todos os alunos que tenham.

exemplo de left join na tabela de produtos e categorias.

select p.nome, p.valor, c.nome, c.descricao
from produtos
left join categorias c
on p.id_categoria=c.id

com o left join podemos trazer todos os produtos que tenham e que não tenham uma categoria relacionada essa é a unica diferença entre o left e o inner

Right join

Na imagem acima podemos ver o exemplo de um right join, no caso sendo selecionado o right join para cursos e alunos do lado left, o que será retornado nesse tipo de seleção é tudo do lado right e tudo do inner(meio ou intercecção), nada do left será retornado, imagine que na tabela estamos trazendo duas colunas nome_aluno e nome_curso, nesse caso ele vai trazer todos os nome_curso mesmo que não tenham nenhuma associação com algum aluno especifico e apenas nome_aluno que tenha associação, alem de trazer todos os cursos que tenham.

exemplo de left join na tabela de produtos e categorias.

select p.nome, p.valor, c.nome, c.descricao
from produtos
right join categorias c
on p.id_categoria=c.id

Em determinada situação podemos querer saber apenas categorias que não tem nenhum produto setado, podemos fazer como abaixo

select c.nome, c.descricao, p.nome, p.valor
from categorias c
left join produtos p
on c.id = p.id_categoria
where p.nome is null;

Selecione nome da categoria, descrição da categoria, nome do produto e valor do produto da tabela categoria, fazendo um left join com produtos, ou seja irá trazer categorias que tem produtos e categorias que não tem produtos, e por fim fazemos uma condição desde que o nome do produto seja null, nesse caso irá trazer apenas as categorais que não tem produtos cadastrados.

com o right join podemos trazer todos as categorias que tenham e que não tenham um produto relacionado essa é a unica diferença entre o right e o inner

Remoção

DROP TABLE tabela;

Comando para deletar uma tabela do banco de dados, um comando muito perigoso.

As vezes temos a necessidade de deletar apenas uma linha de nossa tabela então podemos executar o comando:

DELETE from table_teste where id=5;

Atenção, sempre utilize o where esse é um comando muito perigoso, verifique se você tem um dump de backup de sua base de dados, e sempre se arrisque em ambiente de desenvolvimento nunca em produção.

**Comparações entre valores **

Se você tiver a necessidade de selecionar algum dado de uma tabela que esteja entre dois valores poderá utilizar a clausula between, essa cláusula não é apenas para comparativos entre datas, pode se utilzar outros valores para fazer os comparativos.

Select * from produtos where(data_inicio BETWEEN '2020-12-16' and '2020-12-20' and status = '1');

No exemplo acima filtramos um produto que está entre as datas 16 do 12 e 20 do 12 e que seu status esteja definido igual a 1

select nome as Nome, preco as Preço from produtos as p where(p.preco between 10.00 and 15.00);

Podemos trazer dois preços em algum intervalo de uma tabela, ou seja irá trazer preços que estejam entre 10 e 15 da tabela de produtos

Atualização

UPDATE users set name='novo', idade='23' where(id=1);

UPDATE produtos set nome='maçã é muito boa' where id=1

Para atualizar uma tabela passamos a cláusula update seguida do nome da tabela e apos isso passamos o set para cada coluna que será atualizada, caso não passe alguma coluna ela permanecerá com o valor que já existe, e não custa lembrar para sempre passar a cláusula where para atualizar apenas a tabela selecionada.

Adicionar campos a uma tabela

Caso tenhamos a necessidade de adicionar campos em alguma tabela podemos fazer isso atravéz do alter table, veja o exemplo. ex1

ALTER TABLE produtos ADD preco_de decimal(10,2);

No exemplo acima passamos a cláusula alter table para alterar a tabela de produtos e passamos o add para adicionar um campo que nomeamos de preco_de passando seu tipo como decimal(10,2)

Removendo campo de uma tabelaex1

alter table produtos drop column preco;

No exemplo acima nos alteramos a tabela produtos removendo a coluna preco.

Explanação de recursos no mysql

É possível verificar quanto de recurso uma consulta irá gastar, podemos fazer isso atravéz do explain

explain select * from produtos where nome='maçã é boa';

com base nesse tipo de consulta podemos verificar quanto de recurso será utilizado

Funções de agregação

Podemos utilizar funções de agregação para fazer operações aritiméticas em uma determinada tabela, vamos ver alguns exemplos.

select count(*) from produtos;

Conta todas as linhas de uma tabela

select count(distinct id_categoria) from produtos;

Conta todas as linhas de uma tabela mas sem id_categoria repetidos, ou seja se tiver dois produtos que tem o mesmo id irá contar apenas o primeiro.

select max(preco) from produtos;

Seleciona o maior preço da tabela produto

select min(preco) from produtos;

Seleciona o menor preço da tabela de produtos.

select min(preco) from produtos where (id <= 10 and id >= 5);

Seleciona o menor preço da tabela de produtos desde que o id for menor ou igual a 10 e maior ou igual a 5

select avg(preco) from produtos;

Podemos retornar a media de preços de todos os produtos ao qual passamos a função avg.

select sum(preco) from produtos;
select sum(preco) from produtos where (id>1 and id <5);

Somamos a coluna preço e trazemos a somatória de todos os preços, e no outro select somamos desde que o id for maior que 1 e menor que 5.

Renomear uma tabela

rename table table_teste to test_new_name;

Com esse comando é possivel renomear uma tabela.

Backup/restore de uma base de dados Para se fazer o backup de uma base de dados mysql você precisa do mysqldump que é um utilitário do mysql.

A partir do terminal você poderá seguir com o comando para executar os seu backup.

mysqldump -u root -p meu_banco > /home/SEU_USER/dumps/meu_banco.sql

Para fazer a restauração de um banco de dados você pode utilizar o comando mysql

mysql -u root -p meu_novo_banco < /home/andremartds/dumps/meu_banco.sql

Caso de uma restauração é necessário sempre observar que o novo banco de preferência esteja vazio, caso o banco não exista você pode utilizar comando abaixo.

create database meu_novo_banco;

Funcões Podemos utilizar funcões personalizadas no mysql, vamos colocar alguns exemplos:

CREATE FUNCTION fn_teste(n DECIMAL(10,2), m int)
returns INT deterministic
return n * m;

a função acima é muito simples, ela apenas multiplica um decimal com um inteiro e retorna um inteiro, quando executamos essa função ela será armazenada em nosso banco, podemos utilizar nossa função da seguinte forma.

select fn_teste (10.5,20) as soma;

Funcões com delimitadores

DELIMITER $$
CREATE FUNCTION adiciona_valor(preco DECIMAL(10,2), aumento decimal(10,2)) returns decimal(10,2) deterministic
BEGIN
    RETURN preco + preco * aumento / 100;
END$$
DELIMITER ;

select concat('O total a pagar é = ', adiciona_valor(100, 10), ' reais') as valor;

A funcao acima adiciona uma porcentagem a um valor passado, mas o interessante desse exemplo são os delimitadores e o begin e end, dentro do bloco begin e and podemos ter nossas execuções e dessa forma podemos tratar valores para respostas, o problema é que por padrão o ponto e virgula sempre mata a execução e para resolver essa questão definimos outro delimitador, que pode ser qualquer caractére não reservado do myql.

após executamos a função ela será armazenada em nossa base de dados, e dai pomos executar, nesse caso concatenamos para uma melhor saída para o usuário.

Procedimentos armazenados

No myslq podemos criar procedimentos armazenados, Logo abaixo podemos ver um procedimento que tem por nome verPreco e como parâmetro passamos o id de um produto sendo do tipo int, o selecionamos e concatenamos com uma mensagem para trazer uma mensagem, id e valor com um alias, logo depois definimos a tabela que vamos selecionar e também a partir de que condição(where), nesse caso estamos trazendo pelo id do produto que foi o que passamos por parâmetros.

# criação
create procedure verPreco(id_produto int)
select concat('o preço é do produto identificado pelo id ',p.id, p.valor) as 'Descrição'
from produtos p
where p.id = id_produto;

# vamos chamar nosso procedimento
call verPreco(1);

Obrigado por chegar até aqui!! um abraço!! ;)