Vamos mostrar como desenvolver um sistema na arquitetura MVC com PHP e PostgreSQL, fazendo somente o DTR no DB Visual ARCHITECT 4.3. Não vamos abordar nesse exemplo apenas a apresentação dos dados (View).

Programas utilizados neste artigo:

1. DB Visual ARCHITECT 4.3

2. DB-VA SQL 1.3

3. Visual Paradigm for UML 6.3 Community Edition

4. NetBeans IDE Early Access for PHP

5. pgAdmin III

O problema proposto é fazer a base de um sistema para lançamento de notas de alunos, bem simples, com as seguintes tabelas e campos:

Alunos

• idAluno
• nome

Turma

• serie
• ano

Matéria

• idmateria
• matéria

Vamos começar criando o DTR com o DB Visual ARCHITECT 4.3

Dê um clique em Entity e um clique na área branca à direita.

Vamos agora à criação das tabelas:

Com dois cliques sobre a entidade, aparece a opção para alteração do nome.

Em nosso exemplo, vamos criar três tabelas: alunos, turma e matéria.

Vamos definir os campos das tabelas:

Clicando com o botão direito sobre a entidade, vamos marcar a opção Open Specification.

Marque 2º aba, da esquerda para a direita, com o nome de columns e clique em add no canto direito inferior da tela.

Agora abriremos a tela para especificar os campos de nossa tabela. Temos a opção de documentar a criação dos campos e tipos como no exemplo.

Nossa tabela turma possui apenas dois campos que formam a chave composta.

Após criar os campos da tabela, temos.

Crie os campos da tabela aluno:

Crie os campos da tabela matéria:

Crie um índice para a tabela matéria. Vamos à especificação da entidade e clique na 3º aba da esquerda para a direita. Selecionar add.

Na especificação do índice, vamos selecionar o campo idmateria e dar ok. Coloque o nome de ind_idmateria. (índice do campo idmateria).

Vamos fazer o mesmo para a tabela aluno. Vale lembrar que o índice deixa a consulta aos dados mais rápida.

Agora vamos aos relacionamentos entre as tabelas. Selecionando a tabela, com um clique do botão esquerdo do mouse, são exibidas as opções de relacionamento em que temos:

O primeiro à esquerda, selecionado em cinza.

Relacionamento Um para Um

O segundo à esquerda, selecionado em cinza.

Relacionamento Um para muitos.

O terceiro à esquerda, selecionado em cinza.

Relacionamento muitos para muitos.

Apesar de termos mais quatro opções, não vamos abordá-las nesse momento.

Vamos criar o relacionamento entre as tabelas.

Relacionamento Turma – Alunos

Regra de negócio: Um aluno está em uma e apenas uma turma. Já uma turma pode ter N alunos.

Assim vamos até a entidade turma, selecionaremos a opção One-to-Many e arrastaremos até a tabela alunos. Será informada a criação de dois campos como chave estrangeira na tabela aluno como na imagem a seguir.

Nosso relacionamento fica assim.

Observação:

Campo em negrito precedido de + é chave primária.

Campo em itálico precedido de # é chave estrangeira.

Relacionamento Matéria – Alunos

Regra de negócio: Um aluno pode fazer N matérias e uma matéria pode ser feita por N alunos.

Temos então o relacionamento N para N.

Vamos selecionar a 3º opção de relacionamento da esquerda para a direita e arrastar até a tabela alunos.

Será criada uma 3º tabela Matéria_alunos, já com a chave primária das duas tabelas.

Agora vamos adicionar o campo nota na tabela, gerada pelo relacionamento da mesma forma que fizemos nas demais entidades.

Terminamos com isso nosso DTR.

Vamos fazer agora a exportação para o PostgreSQL e PHP para darmos seqüência.

A primeira coisa que temos que fazer é sincronizar as tabelas com as classes. Vamos seguir o caminho que nos mostra a figura.

Com um único botão do mouse, criamos nossas classes. O mapeamento objeto relacional está feito (ORM).

Vamos agora criar o banco de dados e o código fonte em PHP.

Será exibida a tela abaixo:

Vamos selecionar a opção para gerar o código SQL e PHP. Temos também a opção de gerar só o banco ou só o código PHP.

Aqui definimos onde serão gerados os arquivos.

Vamos selecionar o PostgreSQL como banco e suas configurações.

Procurar o arquivo Adapter File:

No meu caso está em

“C:\Arquivos de programas \PostgreSQL\8.2\jdbc\postgresql-8.2-506.jdbc2.jar” .

Essas são as configurações para acessar o BD. Mas cada um deve preencher com os dados que estão salvos no seu elefante (PostgreSQL).

Vamos fazer um teste clicando em Test Connection.

Essas são as configurações que usaremos. Vale lembrar que o PostgreSQL tem que estar instalado e com as configurações definidas.

Vamos então gerar o código fonte clicando no botão ok.

Como nós tínhamos definido no arquivo de saída, foi gerado o sistema quase completo. A camada de apresentação não é gerada.

Vamos agora entender os arquivos gerados:

SistemaEscola.ddl

Contém as instruções sql para criação das tabelas e comentários da documentação. Vamos ao Elefante criar as tabelas:

O código gerado segue abaixo:

create table alunos (idAluno  bigserial not null, nome varchar(40), Turmaserie char(1) not null, Turmaano char(4) not null, primary key (idAluno));
create table Turma (serie char(1) not null, ano char(4) not null, primary key (serie, ano));
comment on column Turma.serie is ´Série da turma: 

Exemplo 5 para 5º série, 6 para 6º série etc...´;
comment on column Turma.ano is ´ano da turma 
exemplo: 2006, 2007 etc´;
create table Materia (idmateria  serial not null, materia varchar(20), primary key (idmateria));
create table Materia_alunos (Materiaidmateria int4 not null, alunosidAluno int8 not null, nota numeric(19, 0), primary key (Materiaidmateria, alunosidAluno));
create index ind_idAluno on alunos (idAluno);
create index ind_idmateria on Materia (idmateria);
alter table alunos add constraint FKalunos146083 foreign key (Turmaserie, Turmaano) references Turma;
alter table Materia_alunos add constraint FKMateria_al323317 foreign key (Materiaidmateria) references Materia;
alter table Materia_alunos add constraint FKMateria_al392160 foreign key (alunosidAluno) references alunos;

Vamos passar agora para o Elefante.

Abrindo o pgAdmin III, vamos criar um novo banco de dados:

Vamos criar o banco Notas e com bsgces como Owner. Você deve usar o super-usuário que está definido no seu banco de dados.

Vamos agora clicar no 6º Item da esquerda para direita para inserirmos o código SQL gerado pelo VP.

Vamos agora executar o comando.

O resultado desse comando deve ser:

NOTICE: CREATE TABLE will create implicit sequence "alunos_idaluno_seq" for serial column "alunos.idaluno"

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "alunos_pkey" for table "alunos"

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "turma_pkey" for table "turma"

NOTICE: CREATE TABLE will create implicit sequence "materia_idmateria_seq" for serial column "materia.idmateria"

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "materia_pkey" for table "materia"

NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "materia_alunos_pkey" for table "materia_alunos"

Query returned successfully with no result in 312 ms.

Do lado esquerdo da tela aparecerão as tabelas criadas:

Está criado nosso novo banco de dados.

Agora vamos às classes criadas pelo VP em PHP.

Vamos ver a classe alunos:

class Alunos {
  public function deleteAndDissociate() {
    if($this->getTurmaserie() != null) {
      foreach($this->getTurmaserie()->alunos as $index => $obj) {
        if (($obj->idAluno == $this->idAluno)) {
          $indexes[] = $index;
        }
      }
      if($indexes) {
        foreach($indexes as $index) {
          $this->getTurmaserie()->alunos[$index] = null;
        }
      }
    }
    foreach($this->materia_alunos as $lMateria_alunos) {
      $lMateria_alunos->setAlunosidAluno(null);
    }
    return true;
  }
  
  /**
   * @orm idAluno int
   * @dbva id(autogenerate) 
   */

  private $idAluno;
  
  /**
   * @orm nome char
   */
  private $nome;
  
  /**
   * @orm has one Turma inverse(alunos)
   * @dbva fk(Turmaserie,Turmaano) 
   */
  private $turmaserie;
  
  /**
   * @orm has many Materia_alunos inverse(alunosidAluno)
   * @dbva inverse(alunosidAluno) 
   */
  private $materia_alunos;
  
  public function &getIdAluno() {
    return $this->idAluno;
  }
   
  public function setIdAluno(&$idAluno) {
    $this->idAluno = $idAluno;
  }
  
  public function &getNome() {
    return $this->nome;
  }
  
  public function setNome(&$nome) {
    $this->nome = $nome;
  }
  
  public function &getTurmaserie() {
    return $this->turmaserie;
  }
    
  public function setTurmaserie(&$turmaserie) {
    $this->turmaserie = $turmaserie;
  }
  
  public function getMateria_alunos() {
    return $this->materia_alunos;
  }
  
  public function setMateria_alunos($materia_alunos) {
    $this->materia_alunos = $materia_alunos;
  }
   
  public function __toString() {
    $s = ´´;
    $s .= $this->idAluno;
    return $s;
  }
}

?>

A classe foi gerada sem digitar uma linha de código em PHP, lembramos que podem ser usadas várias linguagens de programação.

Passando para o Netbeans for PHP e resumindo o código fica assim. Bem mais fácil de entender. Lembramos que o VP agiliza muito seu trabalho, mas tenha por certo que terá que alterar alguma coisa. Bom trabalho em sua IDE favorita.

O VP também criou uma classe para acesso à tabela. Assim ficam separadas as regras de negócio do acesso aos dados como reza o padrão MVC.

O arquivo config.xml traz as configurações para acesso ao Banco de Dados

Conseguimos criar a base de um sistema em MVC fazendo apenas o DTR e pressionando o botão do mouse.

Agora vamos conhecer um recurso para usarmos em nossa aplicação, afinal de contas programar em PHP OO com persistência não é uma tarefa tão fácil.

Abriremos o DB-VA SQL. Vamos criar de forma fácil os métodos para usarmos em nossa aplicação e as consultas SQL que talvez sejam necessárias.

Lembramos que digitar código dá tendinite.

Vamos criar um Scrapbook em PHP.

Um clique com o botão direito sobre DB-VA PHP e new. Vamos dar o nome de consultaPHP

Vamos agora para a 3º aba CLASS.

Vamos gerar os métodos de persistência, como vemos na figura podemos escolher a linguagem e a operação que queremos fazer.

Geramos os métodos de persistência de dados da classe turma sem digitar uma linha de código.

Agora vamos criar consultas SQL. Vamos marcar a segunda aba da esquerda para a direita. Como estamos dando seqüência à aplicação, nossa conexão com o Elefante já está feita e não precisamos refazer.

Vamos criar as instruções SQL da tabela aluno.

Como mostra a figura fizemos todas as operações SQL com o mouse.

Caso seja necessário temos os SQL para acessarmos a tabela aluno.

Terminamos aqui.

Até a próxima!