passar pra RTF é só dar um "salva como" e criar um PDF é só mandar imprimir na impressora de PDF do Adobe, mas no que isso pode me ajudar?
Podemos ter:
class LigacaoBD extends PDO, PDOStatement {
}
Em vez de termos duas classes tipo isto:
<?php
class Database extends
PDO {
...
}
}
class DBStatement extends
PDOStatement {
...
}
}
?>
Existe alguma vantagem em separarmos as duas? A única vantagem que vejo é o possível evitar de erros, caso o PDO venha a ter nomes de métodos iguais para classes diferentes…
O que acham?
Obrigado,
Márcio
Você quer deixar a instância do PDO privada? Mas você vai injetá-lo no
construtor ou não?
A PDOStatement é o objeto preparado. Então alguém cria ele. Quem faz
isso é a PDO. Então isso é correto.
Depois da query preparada, você pode executá-la:
$s1->execute();
$s2->execute();
$s1->execute();
$s2->execute();
Se tivermos uma classe assim:
class NkPDO extends PDO {
private $username;
private $password;
private $dsn;
public function __construct () {
$this->dsn="mysql:unix_socket=/tmp/mysql.sock;dbname=nometeste";
$this->username = "userteste";
$this->password = "pass12345";
try {
parent::__construct($this->dsn, $this->username, $this->password);
}
catch(PDOException $e) {
echo "Erro de Conexão: " .$e->getMessage();
}
}
}
Podemos instanciar a classe assim:
$conn = new NkPDO();
E obtemos logo uma ligacao à base de dados com os parametros definidos no construtor da classe.
Se eu fizer:
$conn->prepare('SELECT id_cliente, nome_cliente FROM cliente');
Funciona.
Se (depois) eu fizer:
$conn->execute();
Não funciona.
"Depois da query preparada, você pode executá-la:
$s1->execute();"
Está a dizer-me que, se eu fizer algo do tipo:
$query=$conn->prepare('SELECT id_cliente, nome_cliente FROM cliente');
E depois fizer:
$query->execute();
Isto vai funcionar e, isto é melhor do que ter uma classe adicionar definida da seguinte forma:
class NkPDOQuerys extends PDOStatement {
private $stmt;
public function __construct() {
//mete o fetchmode por omissão em fetch_obj.
$this->setFetchMode(PDO::FETCH_OBJ);
}
public function getStmt () {
return $this->stmt;
}
}
É isso?
Esta a minha primeira classe em PHP por isso, desculpem lá alguma barbaridade evidente.
Brigado,
Márcio
Primeiro: Isso é uma boa prática, altamente recomendável, mas não é uma regra.
O que você precisa primeiro é entender porquê você não deve deixar que
os atributos de uma classe sejam acessados diratamente: Porquê já que
você está agrupando os atributos de acordo com seu escopo, é
logicamente definido que sua classe saiba como seus atributos devem
ser definidos. Se deixar publico, qualquer um pode alterar, e sua
classe nem sequer saber dessa alteração. Imagine a situação:
class Calculator {
public $num;
public function __construct()
{
$this->num = 2;
}
public function divide($pNum)
{
return $pNum / $this->num;
}
}
O uso normal dessa classe poderia ser
$calc = new Calculator();
echo $calc->divide(10);
Ok? Só que como o atributo é público poderia acontecer o seguinte:
$calc = new Calculator();
$calc->num = 0;
echo $calc->divide(10);
Nesse caso, ocorre erro de divisão por zero. Entendeu o problema?
Sendo pública, acaba permitindo um erro de programação.
Levando em conta tudo isso, eu não vejo a necessidade de fazer com o
PDO o que você está pensando.
Obrigado. E de facto, eu não sabia que quando fazemos um prepare, era devolve um objecto da classe PDOStatement, logo, para aquilo que pretendia, que era usar o comando prepare(), execute() a partir de uma classe criada, não faz sentido fazer extend do PDOStatement…
Vou agora ler mais sobre interfaces.
Obrigado,
Márcio
From: list...@googlegroups.com [mailto:list...@googlegroups.com] On Behalf Of Applicata // Cabral
Sent: quarta-feira, 1 de Abril de 2009 19:26
To: list...@googlegroups.com
<BR