Vídeo Aula, Aplicação simples utlizando JSF+JPA+Hibernate

Mapeamento de entidade ManyToMany

Olá tudo bem ?

Para concluir o post de mapeamento de entidade com hibernate, relacionamento ManyToMany (Muitos para Muitos).

Como exemplo vamos fazer um relacionamento entre Cliente e Produto.
Vários Cliente pode ter vários Produtos e vários Produto pode ter vários Clientes.

Crie um database no banco de dados chamada manytomany.
Crie um projeto Dynamic Web Project chamado MapeamentoManyToMany adicione as lib do hibernate no projeto e configure o arquivo persistence.xml para se comunicar com a database.

persistence.xml

1.1 Crie uma classe chamada Cliente dentro do package br.com.vejajava.entidades

@Entity
@Table(name="cliente")
public class Cliente {

@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private Long codigo;

private String nome;

@ManyToMany
@JoinTable(name = "cliente_produto", joinColumns = {@JoinColumn(name = "cod_cliente")}, 
inverseJoinColumns ={@JoinColumn(name = "cod_produto")})
private List produtos = new ArrayList();

//getters e setters
}

Observe que no mapeamento com a classe produto temos a anotação @JoinTable essa anotação é opcional, caso você não declare ela criará o nome da classe seguida de "_" mais um novo da classe que está sendo mapeada.

Veja que temos também a anotação @JoinColumns e @InverseJoinColumns elas define o quais colunas fazem parte da chave primaria.

1.2 Crie uma classe chamada Produto dentro do package br.com.vejajava.entidades

@Entity
@Table(name = "produto")
public class Produto {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long codigo;

private String descricao;

@Column(scale = 2, precision = 4)
private double preco;

//getters e setters
}

Observe a anotação @Column seguida de scale e precision.
A anotação scale: define a quantidade de casas decimais e anotação.
A anotação precision: define a quantidade de digitos que serão armazenados.

Como estamos mostrando um relacionamento Uniderecional a classe Produto nao terá o mapeamento para a classe Cliente.

1.3 Crie uma classe ManyToMany dentro do package br.com.vejajava.principal

Vamos adicionar alguns produtos e fazer o relacionamento com os clientes.

EntityManagerFactory factory = Persistence.createEntityManagerFactory("MapeamentoManyToMany");
EntityManager manager = factory.createEntityManager();

manager.getTransaction().begin();

Produto p1 = new Produto();
p1.setDescricao("Açucar");
p1.setPreco(1.50);

Produto p2 = new Produto();
p2.setDescricao("Macarrão Favorita");
p2.setPreco(1.50);

Cliente c1 = new Cliente();
c1.setNome("Maria");
c1.getProdutos().add(p1);
c1.getProdutos().add(p2);

Cliente c2 = new Cliente();
c2.setNome("José");
c2.getProdutos().add(p2);

manager.persist(p1);
manager.persist(p2);
manager.persist(c1);
manager.persist(c2);

manager.getTransaction().commit();

manager.close();
factory.close();

Verifique no banco de dados que foi criado três tabelas
Cliente: Temos dois cliente cadastrado.
Produto: Temos dois produtos cadastro
Cliente_Produto: Aonde o codigo do cliente se referencia ao codigo do produto, observe que no cliente Maria adicionamos dois produtos por isso na tabela ele faz o relacionamentos para os dois produtos cadastrado.

mysql> select * from cliente;
+--------+-------+
| codigo | nome |
+--------+-------+
| 1 | Maria |
| 2 | José |
+--------+-------+

mysql> select * from produto;
+--------+--------------------+-------+
| codigo | descricao | preco |
+--------+--------------------+-------+
| 1 | Açucar | 1.5 |
| 2 | Macarrão Favorita | 1.5 |
+--------+--------------------+-------+

mysql> select * from cliente_produto;
+-------------+-------------+
| cod_cliente | cod_produto |
+-------------+-------------+
| 1 | 1 |
| 1 | 2 |
| 2 | 2 |
+-------------+-------------+


Obrigado pela visita = D

Mapeamento de Herança com Hibernate

Olá tudo bem ?

Nesse post irei falar sobre Mapeamento de Herança com Hibernate.

As três estratégia que pode ser feita para realizar o mapeamento de herança:

1.1 SINGLE TABLE
1.2 JOINED
1.3 TABLE PER CLASS

Antes de começar a apresentar cada um, irei mostrar qual exemplo iremos fazer para testar cada estratégia.

Vamos fazer um exemplo com Pessoa, Professor e Aluno.
Pessoa será a super classe seguidas das sub classe Professor e Aluno.

1.1 Single Table: Essa estratégia é a mais utilizada e possibilita um maior desempenho para realizar consultas no banco de dados.

Pessoa.java

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public abstract class Pessoa {
 
 @Id
 @GeneratedValue
 private Long codigo;
 
 @Column(name="nome")
 private String nome;
        
          //getters e setters
}

Professor.java

@Entity
public class Professor extends Pessoa {

 private String disciplina;
 
 @Column(name="carga_horaria")
 private int cargaHoraria;

          //getters e setters
}

Aluno.java

@Entity
public class Aluno extends Pessoa{
 
 private String turma;

         //getters e setters
}

Todas as classe tem anotação @Entity para que seja criada as tabelas no banco de dados. Como estamos usando a estratégia SINGLE_TABLE só será criada uma única tabela com todos os campos de todas as classes que extends da classe Pessoa.
A classe Pessoa foi criada como classe abstract para que ela não possa ser instanciada, porque não faz sentido instanciar uma classe do tipo Pessoa, sendo que não temos um tipo Pessoa definido.
Ex: O mesmo seria um exemplo de uma super Classe Animal aonde é seguida por suas sub classe Cachorro, Gato etc.. Não faz sentido instanciar uma classe do tipo animal, que tipo de animal é esse?

Observe a anotação @Inheritance seguida por (strategy = InheritanceType.SINGLE_TABLE) essa anotação serve para definir o tipo Single_Table.

Faça o teste:

public class Principal {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Herança");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Professor professor1 = new Professor();
  professor1.setNome("Rafael Braga");
  professor1.setDisciplina("Programação para Internet");
  professor1.setCargaHoraria(20);
  
  Aluno aluno1 = new Aluno();
  aluno1.setNome("Jardel");
  aluno1.setTurma("ADS");
  
  manager.persist(professor1);
  manager.persist(aluno1);
  
  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Verifique no banco de dados a tabela criada e seus valores.

Veja que foi criado uma coluna do tipo DTYPE, ela é utilizada para identificar qual tipo de objeto se refere a qual classe.

Desvantagem: A desvantagem desse tipo de estratégia é que consumo de espaço desnecessário na tabela.
Quando cadastramos o Professor veja que o campo turma da classe Aluno também está na tabela e não tem nenhum valor. Ou seja ele está ocupando espaço e não vai ser utilizado.
O mesmo acontece quando cadastramos Aluno, os campos da classe Professor também aparece na tabela ocupando espaço e não vai ser utilizado.

1.2 JOINED: Essa estratégia ela cria um tabela para cada classe que extends da classe principal.
No nosso exemplo será criado as tabelas da classe Pessoa, Professor e Aluno.

@Entity
@Inheritance(strategy = InheritanceType.JOINED)

Desvantagem: As consultas para esse tipo de estratégia são lentas, será necessário utilizar operação de join, para pegar os dados cadastrado nas tabelas.
Informações sobre consultas utilizando Join, Inner Join, Left Join no link clique aqui

1.3 TABLE PER CLASS: Essa estratégia uma tabela para as classes concreta é criada.

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)

Modifique também o tipo de valor gerado que está sendo utilizado na tabela Pessoa.

@Id
@GeneratedValue(strategy = GenerationType.TABLE)
private Long codigo;
 

Desvantagem: Não existe informações de uma tabela para outra. Veja que temos agora a anotação @GeneratedValue(strategy = GenerationType.TABLE) não podemos mais utilizar geração automática de chave primária.


Obrigado pela visita =D

Duvidas, Críticas e Sugestões, só comentar ;)

Mapeamento de entidade com Hibernate

Olá tudo bem ?

Nesse post vou falar sobre mapeamento de entidades com hibernate.

Primeiramente crie um projeto Dynamic Web Project na IDE, adicione os jar do hibernate, tambem nao esqueça de adicionar o jar do banco de dados.

Configure o arquivo persistence.xml, para adicionar ao seu projeto (alt + enter) em cima do projeto > Project Facets > marque a opção JPA > Aplly > OK.

Crie uma database mapeamento

persistence.xml

Verifique o usuario e a senha do seu banco se corresponde com a mesma utilizada.

1.1 OneToOne
1.2 OneToMany
1.3 ManyToOne
1.4 ManyToMany

Vamos começar com relacionamento OneToOne (Um para Um).

1.1 OneToOne

No relacionamento OneTone (Um para Um), irei fazer como exemplo um relacionamento entre País e Presidente se "em caixa" perfeitamente nessa condição, aonde um País pode ter apenas um Presidente e um Presidente só pode administrar um País.

1.1.1 Vamos criar uma classe chamada País dentro do package br.com.vejajava.entidades

@Entity
@Table(name="pais")
public class Pais {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 private String capital;
 
 @OneToOne
 private Presidente presidente;
 
 
 @Column(name="lingua_oficial")
 private String linguaOficial;
 
 private String populacao;

         // getters e setters
}

Podemos ver que na nossa classe País temos a anotação @OneToOne isso faz com que o relacionamento entre Pais e Presidente aconteça no banco de dados.
Observe que o tipo de dado que é feita no relacionamento com Presidente é do tipo Presidente e não um tipo primitivo.

1.1.2 Vamos criar uma classe chamada Presidente dentro do package br.com.vejajava.entidades

@Entity
@Table(name="presidente")
public class Presidente {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 @OneToOne
 private Pais pais;

         // getters e setters

Observe que temos o mesmo tipo referenciado na classe Presidente, com anotação @OneToOne isso faz com que o relacionamento entre Pais e Presidente aconteça no banco de dados.

Temos que definir qual classe mandará no relacionamento.

Para resolver esse problema temos um elemento chamado mappedBy que é um relacionamento bidirecional, significa que tanto na classe Pais como na classe Presidente podemos carregar-lás.
Lembrando que toda a classe que faz um relacionamento e tenha essa função (mappedBy) ela nao mandará no relacionamento.

O relacionamento na classe Presidente ficará assim:

@OneToOne(mappedBy= "presidente")
private Pais pais;

No exemplo feito teria a foreing key presidente_id na tabela Pais, para modificar o nome desse campo existe uma anotação chamada @JoinColumn.

Ex:

@JoinColumn(name="pres_id")

1.1.3 Vamos criar uma classe chamada TesteOneToOne dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteOneToOne {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Presidente presidente = new Presidente();
  presidente.setNome("Dilma R");
  
  Pais pais = new Pais();
  pais.setNome("Brasil");
  pais.setCapital("Brasília");
  pais.setLinguaOficial("Português");
  pais.setPopulacao(193.946886);
  
  pais.setPresidente(presidente);
  
  manager.persist(pais);
  manager.persist(presidente);
  
  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Podemos observa que criamos uma instancia de Presidente e Pais e passamos os valores para eles.
Observe que pais.setPresidente(presidente) ele pega o valor passado quando criamos um novo Presidente.
Nao podemos fazer o mesmo para Presidente pois quem manda no relacionamento é classe País.

Observe que temos que persistir os dois objetos

manager.persist(pais);
manager.persist(presidente);

Com o elemento (Cascade = CascadeType.PERSIST) na classe Pais so bastaria persist o objeto do tipo Pais.

Veja como ficaria o elemento Cascade.

@OneToOne(cascade = CascadeType.PERSIST)
private Presidente presidente;

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from pais;
+----+-----------+----------------+--------+------------+---------------+
| id | capital | lingua_oficial | nome | populacao | presidente_id |
+----+-----------+----------------+--------+------------+---------------+
| 1 | Brasília | Português | Brasil | 193.946886 | 1 |
+----+-----------+----------------+--------+------------+---------------+
mysql> select * from presidente;
+----+---------+
| id | nome |
+----+---------+
| 1 | Dilma R |
+----+---------+

1.2 OneToMany

No relacionamento OneToMany(Um para Muitos), irei fazer como exemplo um relacionamento entre Escola e Aluno se "em caixa" perfeitamente nessa condição, aonde uma Escola pode ter vários Alunos.

1.2.1 Vamos criar uma classe chamada Escola dentro do package br.com.vejajava.entidades

@Entity
@Table(name="escola")
public class Escola {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;

        @OneToMany(cascade = CascadeType.PERSIST)
 private Collection alunos = new ArrayList();
 
       //getters e setters
}

Observe que na classe Escola só temos 2 atributos, coloquei apenas esses dois pra entender melhor o relacionamento.
Temos uma Coleção de Alunos seguido da anotação @OneToMany, (Um para Muitos) aonde uma Escola pode ter varios alunos, temos também o elemento cascade = CascadeType.PERSIST faz com que quando o objeto escola for persistido ele automaticamente persist todos os campos que está fazendo o relacionamento entre escola e aluno. Esse relacionamento so pode ser carregado na classe Escola pois nao é um relacionamento bidirecional, para que seja um relacionamento bidirecional seria necessário adicionar o mappedyBy no relacionamento @OneToMany.

1.2.2 Vamos criar uma classe chamada Aluno dentro do package br.com.vejajava.entidades

Nessa classe vamos aprofundar mais um pouco e entender a anotação @Embedded

@Entity
@Table(name="aluno")
public class Aluno {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 @Embedded
 private Endereco endereco;
         
         //getters e setters
}

Observe que na classe Aluno temos a anotação @Embedded essa anotação faz com que eu possa criar uma classe com as informações do endereço do aluno, sem a necessidade de criar outra tabela. Ela pega todos os atributos da classe endereco que será criada e coloca dentro da propria tabela aluno, essa é uma maneira muito interessante para organização do seu sistema.
Criando uma classe para colocar todas as informações de endereço para organizar, caso houver que mudar algum campo que referencia o endereco do aluno só precisaria alterar a classe endereco;

1.2.3 Vamos criar uma classe chamada Endereco dentro do package br.com.vejajava.entidades

@Embeddable
public class Endereco {

 private String rua;
 
 private int numero;
 
 private String cep;
      
         //getters e setters
}

Observe que no lugar da anotação @Entity temos a anotação @Embeddable isso faz com que nao seja criado uma tabela endereco no banco de dados e todos os campos dessa classe será criado na tabela Aluno, veja também que não precisamos definir uma primary key para essa classe.

1.2.4 Vamos criar uma classe chamada TesteOneToMany dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteOneToMany {
 
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Endereco endereco = new Endereco();
  endereco.setRua("Rua 27");
  endereco.setCep("65364-972");
  endereco.setNumero(444);
  
  Aluno aluno = new Aluno();
  aluno.setNome("Maria Eduarda");
  aluno.setEndereco(endereco);
  
  Escola escola = new Escola();
  escola.setNome("São Francisco das Chagas");
  escola.getAlunos().add(aluno);
  
  manager.persist(escola);
  manager.getTransaction().commit();
  manager.close();
  factory.close();
  
 }

Criamos uma instancia de endereco e passamos os valores nos campos.
Observe que a partir de aluno conseguimos pegar todos os valores passado na classe endereco com aluno.setEnderco(endereco).
Fizemos o mesmo para escola, instanciamos a classe passamos os valores e adicionamos na coleção o objeto aluno para que o id do aluno seja referenciado na tabela.

Observe no banco de dados que foi criado uma terceira tabela chamada escola_aluno aonde é passado o id da escola e o id de aluno.

Veja tambem que nao foi preciso persistir o objeto aluno, o elemento cascade = CascadeType.PERSIST como foi explicado anteriormente ele persist todos os objetos que se referencia a classe escola e aluno.

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from aluno;
+----+-----------+--------+--------+---------------+
| id | cep | numero | rua | nome |
+----+-----------+--------+--------+---------------+
| 1 | 65364-972 | 444 | Rua 27 | Maria Eduarda |
+----+-----------+--------+--------+---------------+

mysql> select * from escola;
+----+---------------------------+
| id | nome |
+----+---------------------------+
| 1 | São Francisco das Chagas |
+----+---------------------------+

mysql> select * from escola_aluno;
+-----------+-----------+
| escola_id | alunos_id |
+-----------+-----------+
| 1 | 1 |
+-----------+-----------+


1.3 ManyToOne

No relacionamento ManyToOne (Muitos para UM), irei fazer como exemplo um relacionamento entre Filme e Categoria se "em caixa" perfeitamente nessa condição, aonde muitos Filme pode ter uma Categoria.

1.3.1 Vamos criar uma classe chamada Filme dentro do package br.com.vejajava.entidades

@Entity
@Table(name = "filme")
public class Filme {

 @Id
 @GeneratedValue
 private Long id;

 private String nome;

 @Temporal(TemporalType.DATE)
 @Column(name="data_cadastro")
 private Date dataCadastro;

 @ManyToOne
 private Categoria categoria;

           //getters e setters
}

Observe que temos uma anotação que ainda nao foi usada no projeto. @Temportal(TemporalType.DATE) no campo dataCadastro. A anotação TemporalType.DATE faz com que seja salvo no banco de dados a seguite data 2013-08-28.
Tambem temos anotação @ManyToOne que faz com que mais de um filme pode ter uma categoria.

Outros tipos de TemporalType:
TemporalType.DATE = data (dia, mês e ano).
TemporalType.TIME = Horário (hora, minuto e segundo)
TemporalType.TIMESTAMP (Padrão) = Data e Horário

1.3.2 Vamos criar uma classe chamada Categoria dentro do package br.com.vejajava.entidades

@Entity
@Table(name="categoria")
public class Categoria {
  
 @Id
 @GeneratedValue
 private Long id;
 
 private String descricao;

           //getters e setters
}

Na classe categoria temos apenas o campo id que se refere a primary key da tabela e a descricao que será o nome categoria.

1.3.3 Vamos criar uma classe chamada TesteManyToOne dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteManyToOne {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Categoria categoria = new Categoria();
  categoria.setDescricao("Infantil");
  
  Filme filme = new Filme();
  filme.setNome("Pokémon");
  filme.setDataCadastro(new Date());
  filme.setCategoria(categoria);
  
  manager.persist(filme);
  manager.persist(categoria);

  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Instanciamos a classe categoria e passamos o valor no campo descricao.
O mesmo foi feito na classe Filme o campo data ao ser salvo no banco registrará a data atual do máquina.
Veja também que passamos o valores da Categoria para o objeto filme.
Persistimos os dois objetos e depois fizemos o commit.

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from filme;
+----+---------------+----------+--------------+
| id | data_cadastro | nome | categoria_id |
+----+---------------+----------+--------------+
| 1 | 2013-08-28 | Pokémon | 1 |
+----+---------------+----------+--------------+

mysql> select * from categoria;
+----+-----------+
| id | descricao |
+----+-----------+
| 1 | Infantil |
+----+-----------+

o tópico 1.4 ManyToMany vou explicar criando o projeto exclusivo para esse mapeamento em outro post.

Obrigado pela visita.

Duvidas, Criticas e Sugestões ?

=D

Hibernate e JPA

Olá tudo bem?

Esse é meu primeiro post aqui no blog.

Primeiramente vamos entender o que é ser um ORM (Mapeamento de Objeto-Relacional).
É uma forma de persistir objetos que é representada nas tabelas no banco de dados, usando Hibernate você poderá realizar esse mapeamento entre o banco de dados e objeto.
Esse mapeamento pode ser feito com xml ou melhor ainda, com Anotação.

Hibernate é uma ferramenta para realizar mapeamento de objeto relacional. Ele é capaz de gerar as tabelas no banco. Existem outras como EclipseLink, TopLink etc.
Todas essas ferramentas devem seguir a especificação JPA.

JPA (Java Persistence API) é implementada pelas tecnologias ORM. Especificação JPA trata-se de Mapeamentos, Interfaces, Entidades para gerenciar a persistência de linguagem de consulta.

Configuração do Hibernate

Para configurar o hibernate primeiramente é necessário baixar os jar do hibernate, segue o link download http://sourceforge.net/projects/hibernate/files/hibernate3/.
Precisamos baixar algumas dependência do hibernate como o jar slf4j-log4j12-1.5.8.jar, segue o link http://www.slf4j.org/dist/ e também precisamos do jar do Log4J 1.2.x. segue o link http://logging.apache.org/log4j/1.2/download.html.

Depois de feito o download crie uma pasta chamada lib na raiz da sua aplicação, e cole todos os jar, botão direito em cima Build Path > Add Build Path.

Para configuramos o hibernate na aplicaçao devemos criar um arquivo chamado persistence.xml que fica na pasta META-INF dentro de Src para ativar automaticamente esse arquivo aperte Alt+Enter em cima do projeto será direcionado uma caixa Properties clique em Project Facets e marque JPA.

No arquivo Persistence.xml voce configura baseado na necessidade dos seus projeto, vou postar um exemplo e fala um pouco de cada função para melhor entendimento.

	
		br.com.vejajava.entidades.Pessoa
		
			
			
			
			
			
			
			
			
		
	

Aqui declaramos qual classe vai fazer parte desse relacionamento (nomedopackage+nomedaclasse).

br.com.vejajava.entidades.Pessoa

O name do persistence-unit, serve para voce identificar qual persistence.xml será mapeada no seu projeto.

Exemplo:

 EntityManagerFactory fabrica = Persitence.createEntityManagerFactory("AulaJPA");
 EntityManager manager = fabrica.createEntityManager();

Como exemplo estou fazendo uma configuração com MySQL.
Veja a primeira configuração

hibernate.dialect: Classe Dialect ensina o hibernate a conversar com o meu banco de dados. Todos os bancos precisa ter uma classe Dialect para que o hibernate consiga ter esse feedback com o banco de dados.

driver_class: O nome do driver que representa seu banco de dados.

url: Veja que estou utilizando um servidor local com a porta do meu banco MySQL 3306, verifique qual a porta do banco que voce irá utilizar, em seguida o nome da minha database criada no banco de dados.

username: usuario do banco.
password: password do bancos

hbm2ddl.auto: Essa configuração é muito importante para que seja criada automaticamente as tabelas no banco de dados.
Existe varias opções para esse comando

Update: Ele criar as tabelas no banco de dados ou atualiza se ja existe.
Create-Drop: Ele criar as tabelas no banco de dados e deleta se existe alguma (Muito cuidado com esse);
Create: Apenas cria as tabelas.

Configuração de Debug

Existem varias configurações de Debug, no caso estou utilizando apenas duas

show_sql: Ele mostra no console da ide os comandos criados como exemplo insert into Pessoa (nome, idade) values ('Joao', 33)
format_sql: Imprime o comando SQL executado de forma para melhor entendimento.

existe outras como generate_statistics e use_sql_comments.


É isso galera, qual duvida posta nos comentários.

Criticas, Sugestões serão bem vindas ;)

Obrigado pela a visita, vou tentar postar o máximo.