Pdo

se for começar do zero crie uma classe, se for uma sistema ja em uso tente separar em funções, evite deixar o codigo.

Shinhi

Cara , pode ser uma pergunta babaca , mas eu não consegui entender o motivo de criar um classe usando PDO , você poderia me dizer como irá melhorar ?

>
Shinhi

Cara , pode ser uma pergunta babaca , mas eu não consegui entender o motivo de criar um classe usando PDO , você poderia me dizer como irá melhorar ?

Isso é muito elementar.

Vejamos, você irá criar uma classe abstrata, onde suas filhas irão especificar todos os métodos de conexão, de inserção, remoção e atualização de registros.

Por fim, será feito a instanciação da classe, basta agora especificar o metódo que deseja realizar. Como o algoritmo de conexão da PDO já existe no método da classe, basta então informarmos os valores que a classe herdeira da classe abstrata irá tratar-los.

Ou seja, você especifica o modelo de conexão, e depois apenas informa os dados, dessa forma, quando for preciso alterar de banco de dados, é apenas alterado na classe (ex.: Classe.db.php).

// o que eu disse sobre a classe abstrata, poderia ser uma interface, etc. foi apenas uma sugestão.

Matheus Lucca Carmo

veja o exemplo

index.php

<?php

//inserir a classe

include_once"amigos.class.php";

//criando objeto

$amigo1 = new amigo;
$amigo2 = new amigo;

$amigo1->nome ="Matheus Lucca Carmo";

$amigo1->slogan="Ainda bem que nada é impossível";

$amigo2->nome ="shini";

$amigo2->slogan="Spammer";

//exibindo

$amigo1->meuamigos();
$amigo2->meuamigos();

?>

amigos.class.php

<?php

class amigo {

var $nome;

var $slogan;

function meuamigos(){

echo'Nome :'.$this->nome.' <br>';

echo'Slogan :'.$this->slogan.'<br>';

}
}

?>

Resultado :

Nome :Matheus Lucca Carmo
Slogan :Ainda bem que nada é impossível
Nome :shini
Slogan :Spammer

Eu tenho que criar uma class com PDO , ou apenas usar suas funções , nas funções que preciso.

depende.

Se a troca é pouco frequente, não vejo menor problema em:

$pdo = new PDO('mysql:host=127.0.0.1', 'root', 'root');
$pdo->exec('use mysql;');
var_dump($pdo->query('show tables;')->fetchAll());
$pdo->exec('use information_schema;');
var_dump($pdo->query('show tables;')->fetchAll());

Em alguns SGDB's também é possível acessar outros bancos de dados sem trocar o atual. Chama-se schema.

$pdo = new PDO('mysql:host=127.0.0.1', 'root', 'root');
$pdo->exec('use mysql;');
var_dump($pdo->query('show columns from information_schema.TABLES;')->fetchAll());

Se a troca for muito frequente ou você precisar trabalhar muitos valores em até mais de dois schemas ao mesmo tempo, sugiro que a classe que for fazer uso disso guarde instâncias das conexões aos bancos:

<?php

class Transportador
{

 private $pessoas;
 private $localidades;

 public function __construct(PDO $pessoas, PDO $localidades)
 {
 $this->pessoas = $pessoas;
 $this->localidades = $localidades;
 }

 public function listarLocalidades($cidade)
 {
 $query = "Select id, nome from lugares inner join cidade on lugares.cidade = cidade.id where cidade.nome = {$cidade};";
 return $this->localidades->query($query)->fetchAll();
 }

 public function transportar($idPessoa, $idLugar)
 {
 $query = "Update pessoa set lugar = {$idLugar} where id = {$idPessoa};";
 return $this->pessoas->exec($query);
 }
}

Shini

Ele na verdade uma classe agiliza o processo de CRUD no banco ? Mas , o PDO já previne caso eu tenho que mudar de banco ? Correto ?

Marcos

Desculpe , mas não entendi muito bem oque você quis dizer , obrigado.

Evandro Oliveira

Entendi Evandro. Confirma pra mim , uma classe seria então para agilizar funções que eu uso sempre certo ? É porque quando trabalhei em um projeto nós usávamos uma classe de conexão com o banco / crud que abstraia funções de banco. Quando a gente ia fazer alguma query , fazíamos assim:

function listarParticipante($par_id) {
 $getRegistro = array(
 "table" => "participante",
 "fields" => "par_nome",
 "where" => "par_id = $par_id",
 );

 $lista = $this->crud->read($getRegistro);
 return $lista;

 }

A minha dúvida maior é que se o PDO substituiu isso , ou é realmente preciso criar uma classe que irá fazer isso também.

Obrigado !

>
Matheus Lucca Carmo

veja o exemplo

index.php

<?php

//inserir a classe

include_once"amigos.class.php";

//criando objeto

$amigo1 = new amigo;

$amigo2 = new amigo;

//atribuido valores

$amigo1->nome ="Matheus Lucca Carmo";

 

$amigo1->slogan="Ainda bem que nada é impossível";

 

$amigo2->nome ="shini";

 

$amigo2->slogan="Spammer";

//exibindo

$amigo1->meuamigos();

$amigo2->meuamigos();

?>

amigos.class.php

<?php

class amigo {

var $nome;

 

var $slogan;

 

function meuamigos(){

 

echo'Nome :'.$this->nome.' <br>';

 

echo'Slogan :'.$this->slogan.'<br>';

 

}

}

?>

Resultado :

Nome :Matheus Lucca Carmo

Slogan :Ainda bem que nada é impossível

Nome :shini

Slogan :Spammer

Seu post ficou fora do contexto do tópico.

No entanto, você poderia ter utilizado o método mágico __clone().

:seta: http://php.net/manual/pt_BR/language.oop5.cloning.php

>
@Evandro Oliveira

Entendi Evandro. Confirma pra mim , uma classe seria então para agilizar funções que eu uso sempre certo ?

Não.

A minha dúvida maior é que se o PDO substituiu isso

E não.

PDO vai fazer a interação entre PHP -> DB. Via consultas SQL. Sempre.

O que você deseja é um mapeador-objeto-relacional. Já que é para fins de estudo, sugiro que dê uma olhada no projeto doctrine.

Não é tão fácil aprender, mas depois fica excelente pra trabalhar com ele.

<?php

/**
* @Entity @Table(name="person")
*/
class Person
{
/**
* @Id @Column(type="integer") @GeneratedValue
* @var int Índice do registro na tabela
*/

 private $id;

 /**
 * @Column(type="string")
 * @var string Nome da pessoa
 */
 private $name;

 /**
 * @OneToOne(targetEntity="Person")
 * @var Person Registro na tabela que referencia a mãe desta pessoa
 */
 private $mother;

 /**
 * @OneToOne(targetEntity="Person")
 * @var Person Registro que referencia o pai desta pessoa
 */
 private $father;

 /**
 * @return int
 */
 public function getId()
 {
 return $this->id;
 }

 /**
 * @param $name string Novo nome do registro
 * @return void
 */
 public function setName($name)
 {
 $this->name = $name;
 }

 /**
 * @return string
 */
 public function getName()
 {
 return $this->name;
 }

 /**
 * @param Person $mother Referencia o registro como mãe deste registro
 * @return void
 */
 public function setMother(Person $mother)
 {
 $this->mother = $mother;
 }

 /**
 * @return null|Person
 */
 public function getMother()
 {
 return $this->mother;
 }

 /**
 * @param Person $father Referencia o registro como pai deste registro
 * @return void
 */
 public function setFather(Person $father)
 {
 $this->father = $father;
 }

 /**
 * @return null|Person
 */
 public function getFather()
 {
 return $this->father;
 }
}

Salvando

<?php

$Mother = new Person();
$Mother->setName('Mother');

$Father = new Person();
$Father->setName('Father');

$doctrineEM->persist($Mother);
$doctrineEM->persist($Father);
$doctrineEM->flush();

$son = new Person();
$son->setName('Kid');
$son->setMother($Mother);
$son->setFather($Father);

$doctrineEM->persist($son);
$doctrineEM->flush();

Obtendo

<?php

/** @var $son Person */

$son = $doctrineEM->find('Person', 3);
echo $son->getMother()->getName() . PHP_EOL . $son->getFather()->getName();

Evandro Oliveira

Então não tinha entendido é nada ! Enfim , você me esclarecendo que se tratava de um mapeamento objeto-relacional ficou um pouco mais claro , mas não consegui tirar minha dúvida ainda , minha cabeça não consegue entender o motivo de criar uma classe que abstrai as funções PDO sendo que ele já facilita muito . Vou estudar o Doctrine então , muito oborigado !

PDO facilita, mas não faz tudo pra você...

É um conjunto de camadas que vai tornando cada vez mais simples o uso.

Por exemplo, se você cria uma interface que é capaz de acessar um banco de dados tanto com PDO quanto com as extensões "nativas" te salva quando você está em um servidor que não possui PDO.