[Resolvido] pdo + singleton

[Beto Lima 0]

Pessoal queria saber se está correto esta forma de singleton com pdo.

e tenho uma dúvida no final do script.

se há algo a melhorar não exitem em opinar...

agradeço...

 

conn.php

<?php
class Connection extends PDO {
private $banco = 'mysql:dbname=nome_da_base;host=localhost';
private $usuario = 'root';
private $senha = '';
public static $handle = null;


function __construct( ) {
	try {
		if ( self::$handle == null ) {
			$dados_conexao = parent::__construct( $this->banco , $this->usuario , $this->senha );
			self::$handle = $dados_conexao;
			return self::$handle;
		}
	}
	catch ( PDOException $e ) {
		echo 'Connection failed: ' . $e->getMessage( );
		return false;
	}
}

function __destruct( ) {
	self::$handle = NULL;
}
}
?>

teste.php
<?php
require_once ("conn.php"); 

$conn = new Connection; 

$result = $conn->query("SELECT * FROM tabela");

if($result)
{
	//percorre os resultados via o fetch()
	while ($linha = $result->fetch(PDO::FETCH_OBJ))
	{
		echo $linha->coluna_da_tabela;

	}

}
//fecha a conexão
$conn = null;
?>

 

Este $conn = null limpa a conexão de fato ou não preciso usar?

[João Batista Neto 448]

Pessoal queria saber se está correto esta forma de singleton com pdo.

 

@Beto Lima,

 

Antes de eu lhe dizer que não tem o menor sentido em utilizar Singleton com banco de dados, vamos ver primeiro, com o que estamos lidando:

 

Singleton:

 

Tipo:

Padrão de projeto de criação

 

Intenção:

Garantir que um objeto de uma determinada classe tenha uma, e somente uma instância, que pode ser acessada globalmente por toda a aplicação.

 

Motivação:

Muitas vezes, durante o desenvolvimento de uma aplicação, um determinado objeto não deve ter mais do que uma instância. É o caso de um modelo de objeto de documentos (DOM), você deverá ter sempre, somente 1 instância de DOM.

A forma mais simples de garantir que uma classe tenha somente 1 instância de um objeto, é deixar a responsabilidade de gerenciamento dessa instância dentro da própria classe.

 

Aplicabilidade:

Quando for necessário garantir que exista apenas 1 instância de um objeto, acessível globalmente, por toda a aplicação.

Quando for necessário que uma determinada instância de um objeto possa ser extensível, por subclasses, sem modificar seu código.

 

Estrutura:

 

Participantes:

Singleton:

Define uma operação estática getInstance(), responsável por permitir que sua única instância seja recuperada para ser utilizada pelos clientes.

Pode ser, mas não necessariamente, responsável pela criação da instância do objeto.

 

Colaborações:

Os clientes, por meio do método estático getInstance(), acessam e utilizam a única instância de Singleton.

 

Implementação:

<?php
/**
* Exemplo de implementação de Singleton
* Dica de leitura: Design Patterns, elements of reusable object-oriented software
* ISBN: 0-201-63361-2
* GoF: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
* 3.5 Creational patterns, Singleton
*/
class Singleton implements IteratorAggregate {
/**
 * Instância única de Singleton
 * @staticvar
 * @var Singleton
 */
private static $instance;

/**
 * @var array
 */
private $data;

/**
 * Sim, o construtor possui visibilidade protected, isso garantirá que apenas o método
 * getInstance() possa criar a instância do objeto
 */
protected function __construct(){
	$this->data = array();
}

/**
 * Adiciona um dado qualquer à instância do objeto, ao contrário do getInstance(), esse
 * é um método do objeto (instância única de Singleton)
 * @param mixed $data Um dado qualquer que será adicionado à instância do objeto
 */
public function addData( $data ){
	$this->data[] = $data;
}

/**
 * Provê um Iterator para iteração dos dados armazenados pelo Singleton
 * @return Iterator
 */
public function getIterator(){
	return new ArrayIterator( $this->data );
}

/**
 * Operação de classe (estática) que permite acessar a única instância de Singleton
 * @return Singleton
 */
public static function getInstance(){
	if ( self::$instance ) return self::$instance;
	else {
		self::$instance = new Singleton();

		return self::$instance;
	}
}

}

 

Usando:

$obj = Singleton::getInstance();
$obj->addData( 'Teste' );

//... muitas linhas depois, provavelmente em um ponto totalmente distinto da aplicação

$obj = Singleton::getInstance();
$obj->addData( 'Outro teste' );

//muito código depois...

foreach ( Singleton::getInstance() as $item ){
echo $item , PHP_EOL;
}

 

Saída:

Teste

Outro teste

 

Ok, porque não tem sentido em usar Singleton com banco de dados ?

 

Simples, talvez nessa sua aplicação específica você vá sim, utilizar apenas 1 único banco de dados mas, se amanhã você estiver com um outro projeto que precise, necessariamente, lidar com mais de um servidor de banco de dados, você terá um problema.

 

Utilize Singleton com controladores de output, DOM, etc.

 

Para controlar instâncias de banco de dados, procure utilizar (Singleton)? Registry

[Beto Lima 0]

Caro João, que aula hein....agradeço pela total atenção...mas assim, estou meio que engatinhando ainda nesse tema pdo, oo, singleton, não consegui ainda me aprofundar em design paterns.

Especificamente eu vou utilizar somente um banco, porque é pra um site simples que usa mysql. e a minha preocupação seria em utilizar o singleton corretamente aliado ao PDO.

Preciso estudar e entender melhor o seu exemplo que de cara já me mostra que é mais avançado.

De imediato realmente não vou ter como adaptar isso a minha necessidade justamente porque preciso entender melhor isso. o que voce diria do script que coloquei? posso usar ele sem problemas? ha algo de errado?

mais uma vez agradeço pela total atenção e a colaboração, gostaria muito de utilizar o seu exemplo e aprofundar mais, mas não vou ficar pedindo para que alguém meta a mão no script pra mim né....então por isso vou precisar de mais tempo pra estudar a fundo...por enquanto só preciso estar seguro com que estou usando....

[Matias Rezende 50]

Neste post (e restante do tópico) o João Batista discorre um pouco mais sobre o assunto. Quem sabe pode te ajudar a compreender a lógica.

 

Carlos Eduardo

[Evandro Oliveira 331]

Beto, ninguém está sugerindo que comece com códigos avançados e técnicas de programação estruturadas, seguras, de alta performance e à prova de erros. Óbvio, devemos começar do começo simples como tudo e todos.

 

Você já deve ter feito algum curso de qualquer coisa, e sempre começam ensinando os conceitos, como começou, porque começou, pra que serve, como funciona pra depois sim "por a mão na massa".

 

Vou tomar algumas linhas do seu último post para lhe apontar alguns conceitos, afinal eles fazem parte do começo:

 

Caro João, que aula hein....agradeço pela total atenção...mas assim, estou meio que engatinhando ainda nesse tema pdo, oo, singleton, não consegui ainda me aprofundar em design paterns.[1]

Especificamente eu vou utilizar somente um banco, porque é pra um site simples que usa mysql. e a minha preocupação seria em utilizar o singleton corretamente aliado ao PDO.[2]

Preciso estudar e entender melhor o seu exemplo que de cara já me mostra que é mais avançado.

De imediato realmente não vou ter como adaptar isso a minha necessidade justamente porque preciso entender melhor isso. o que voce diria do script que coloquei? posso usar ele sem problemas? ha algo de errado?[3]

mais uma vez agradeço pela total atenção e a colaboração, gostaria muito de utilizar o seu exemplo e aprofundar mais, mas não vou ficar pedindo para que alguém meta a mão no script pra mim né....então por isso vou precisar de mais tempo pra estudar a fundo...por enquanto só preciso estar seguro com que estou usando....

[1] - Então comece a se aprofundar. Design Patters e Orientação a Objetos andam de mãos dadas. Impossível ter um sem ter o outro, ainda que você não saiba que está aplicando um PP.

[2] - Despreocupe. Já foi dito que não é certo utilizar Singleton com bancos de dados.

[3] - Especificamente para este caso onde você diz que irá utilizar apenas uma conexão, não. Mas já foi dito o que há de errado, não se usa Singleton em bancos de dados.

 

Programação modular e OO se aproximam muito em um conceito: Reusabilidade. O que quer que você esteja desenvolvendo hoje, por mais específico e exclusivo que pareça, pode e DEVE ser reutilizado futuramente. Por este motivo a preocupação em permitir que, mesmo que não seja necessário utilizar mais de um banco agora, futuramente seja possível se conectar com mais de um servidor, ou mais de um tipo de BD diferente.

[João Batista Neto 448]

o que voce diria do script que coloquei?

 

Bom, além do problema já citado, referente ao Singleton com banco de dados, seu código não é reutilizável e isso é um problema.

 

posso usar ele sem problemas?

 

Bom, como eu disse, procure utilizar Registry para banco de dados:

 

<?php
/**
* Exemplo de Registry
*/
class Registry {
/**
 * Instância única de Registry
 * @var Registry
 */
private static $instance;

/**
 * Nosso registro
 * @var ArrayObject
 */
private $storage;

/**
 * Registry é um caso de uso de Singleton
 */
protected function __construct() {
	$this->storage = new ArrayObject();
}

/**
 * Recupera um registro utilizando sua chave
 * @param string $key
 * @return mixed O valor armazenado
 * @throws RuntimeException Se não houver um registro para a chave especificada
 */
public function get( $key ) {
	if ( $this->storage->offsetExists( $key ) ) {
		return $this->storage->offsetGet( $key );
	} else {
		throw new RuntimeException( sprintf( 'Não existe um registro para a chave "%s".' , $key ) );
	}
}

/**
 * Recupera a instância única de Registry
 * @return Registry
 */
public static function getInstance() {
	if ( !self::$instance )
		self::$instance = new Registry();

	return self::$instance;
}

/**
 * Registra um valor à uma chave
 * @param string $key A chave que será utilizada no registro
 * @param mixed $value O valor que será registrado
 * @throws LogicException Se a chave já estiver registrada
 */
public function set( $key , $value ) {
	if ( !$this->storage->offsetExists( $key ) ) {
		$this->storage->offsetSet( $key , $value );
	} else {
		throw new LogicException( sprintf( 'Já existe um registro para a chave "%s".' , $key ) );
	}
}

/**
 * Remove o registro de uma chave específica
 * @param string $key A chave que será removida
 * @throws RuntimeException Se não houver um registro para a chave especificada
 */
public function unregister( $key ) {
	if ( $this->storage->offsetExists( $key ) ) {
		$this->storage->offsetUnset( $key );
	} else {
		throw new RuntimeException( sprintf( 'Não existe um registro para a chave "%s".' , $key ) );
	}
}
}

 

Como isso ai, você pode utilizar com seus objetos sem problemas...

 

$registry = Registry::getInstance();
$registry->set( 'Banco de dados' , new Connection() ); //Usando sua própria classe para criar o objeto.

//muito código depois...

$db = Registry::getInstance()->get( 'Banco de dados' );
$stm = $db->prepare( 'SELECT :message AS `message`;' );
$stm->bindValue( ':message' , 'DRY !!!' , PDO::PARAM_STR );
$stm->execute();

echo $stm->fetch( PDO::FETCH_OBJ )->message;

 

ha algo de errado?

 

Existe, além do problema de reutilização, há também um problema de encapsulamento, que pode te trazer problemas sérios.

 

class Connection extends PDO {
//...
public static $handle = null;
//...
}

 

http://forum.imasters.com.br/public/style_emoticons/default/seta.gif $handle não deve ser público !!!

 

Outro ponto problemático no seu código:

 

try {
if ( self::$handle == null ) {
	$dados_conexao = parent::__construct( $this->banco , $this->usuario , $this->senha );
	self::$handle = $dados_conexao; //você não precisaria dessa variável, $this resolveria
	return self::$handle; //Isso está errado
}
} catch ( PDOException $e ) {
echo 'Connection failed: ' . $e->getMessage();
return false; //Isso também
}

 

Construtores constroem, eles não retornam:

 

class Exemplo {
public function __construct(){
	return 'Construtores, como construtores, constroem. Eles não retornam a não ser que sejam usados como métodos.';
}
}

var_dump( new Exemplo() );

 

No tópico que o Carlos Eduardo citou logo acima, eu disse uma coisa que acho que você deve considerar:

 

...procure saber o que é e porque usar. Lembrem-se sempre que uma solução só é uma solução se você tiver de fato, o problema que a justifique; Não usem alguma coisa só porque alguém falou para vocês que é elegante ou porque muita gente usa (ou tenta), encarem qualquer "solução" como o remédio que você só toma se estiver doente.

 

[Will Fernando 2]

fica uma dica pra estudo

http://www.php5dp.com/

 

as postagems demoram a sai .. mas quando saem o conteudo é de primeira ;)

 

valww

[Beto Lima 0]

Gente obrigado pelas dicas, realmente vou ter que dar uma parada e analisar tudo novamente e tentar se adaptar a estas situações....não consegui entender ainda o registry mas acredito que com mais tempo de estudo tudo ficará mais claro...não vou extender este post perguntando novamente sobre as mesmas coisas....acho que o que tem aqui já é muito bom para estudo e vou tentar seguir...

obrigado mesmo a todos....

qualquer coisa prendo o grito ok?

abs

[João Batista Neto 448]

não consegui entender ainda o registry mas acredito que com mais tempo de estudo tudo ficará mais claro...

 

Pense no Registry como uma caixa onde você coloca coisas; Cada uma dessas coisas, são objetos que você usará por toda a aplicação:

 

1. Em algum momento da sua aplicação você colocará nessa caixa uma instância de PDO.

2. Os vários módulos (clientes, usuários, produtos, etc...) de sua aplicação, quando forem precisar usar essa instância, vão até a caixa, pegam a instância e usam.

 

 

Simples assim.

 

;)

[Beto Lima 0]

Caro João Batista, pelo simples fato entendi o conceito..."como uma caixa onde você coloca coisas; Cada uma dessas coisas, são objetos que você usará por toda a aplicação"

Assim, eu comentei que não iria pedir esmolas e coisas prontas, mas por acaso você teria como demonstrar um exemplo de uma conexão com pdo selecionando uma tabela qualquer no mysql ou postgres? para eu ter um compreendimento melhor.

 

/**
 * Exemplo de Registry
 */
class Registry {
        /**
         * Instância única de Registry
         * @var Registry
         */
        private static $instance;
e o resto de todo seu cód....não vou copiar todo, mas imagina ele todo aqui.

e a parte de baixo nao entendi 100% de como usa-la

 

$registry = Registry::getInstance();
$registry->set( 'Banco de dados' , new Connection() ); //Usando sua própria classe para criar o objeto.

//muito código depois...

$db = Registry::getInstance()->get( 'Banco de dados' ); // ali vai somente o nome da base?
$stm = $db->prepare( 'SELECT :message AS `message`;' );
$stm->bindValue( ':message' , 'DRY !!!' , PDO::PARAM_STR ); // DRY???
$stm->execute();

echo $stm->fetch( PDO::FETCH_OBJ )->message;

grato

[João Batista Neto 448]

Caro João Batista, pelo simples fato entendi o conceito..."como uma caixa onde você coloca coisas; Cada uma dessas coisas, são objetos que você usará por toda a aplicação"

 

:D

 

você teria como demonstrar um exemplo de uma conexão com pdo selecionando uma tabela qualquer no mysql ou postgres?

 

Ok, vamos lá:

 

1. Usando PDO para conectar ao banco:

$pdo = new PDO( 'mysql:host=127.0.0.1;dbname=nome_do_banco' , 'usuario' , 'senha' );

 

2. Guardando na caixa:

$registry = Registry::getInstance();
$registry->set( 'um nome qualquer que você usará para identificar seu objeto na caixa' , $pdo ); //$pdo é o objeto que criamos logo acima

 

3. Recuperando o objeto da caixa:

$registry = Registry::getInstance();
$pdo = $registry->get( 'um nome qualquer que você usará para identificar seu objeto na caixa' ); //claro que você usará um nome curto e simples de usar :P

 

4. Recuperando os registros da tabela de clientes:

$stm = $pdo->query( 'SELECT * FROM `clientes`' );

foreach ( $stm->fetchAll( PDO::FETCH_OBJ ) as $cliente ){
echo $cliente->nome;
}

 

Juntando tudo:

<?php
require 'Registry.php';

$pdo = new PDO( 'mysql:host=127.0.0.1;dbname=nome_do_banco' , 'usuario' , 'senha' );

$registry = Registry::getInstance();
$registry->set( 'PDO' , $pdo );

//...depois

$registry = Registry::getInstance();
$pdo = $registry->get( 'PDO' );
$stm = $pdo->query( 'SELECT * FROM `clientes`' );

foreach ( $stm->fetchAll( PDO::FETCH_OBJ ) as $cliente ){
echo $cliente->nome;
}

 

PS: DRY http://forum.imasters.com.br/public/style_emoticons/default/seta.gif Don't Repeat Yourself

[Beto Lima 0]

João, entendi da forma que voce postou.

Caso eu queira fazer dois selects de tabelas distintas na mesma pagina eu só replico isso?

 

$registry = Registry::getInstance();
$pdo = $registry->get( 'PDO' );
$stm = $pdo->query( 'SELECT * FROM `outra_tabela`' );

foreach ( $stm->fetchAll( PDO::FETCH_OBJ ) as $outra_tabela ){
        echo $outra_tabela->campo;
        echo $outra_tabela->outro_campo;
}

E outra dúvida, no final do script não preciso definir nada como null para limpar, fechar conexão ou algo do tipo?

[João Batista Neto 448]

Caso eu queira fazer dois selects de tabelas distintas na mesma pagina eu só replico isso?

 

Depois de ter pego o objeto PDO da caixa, você só precisará utilizá-lo:

 

<?php
require 'Registry.php';

$pdo = Registry::getInstance()->get( 'PDO' );
$stm1 = $pdo->query( 'SELECT * FROM `clientes`' );

foreach ( $stm1->fetchAll( PDO::FETCH_OBJ ) as $cliente ){
echo $cliente->nome;
}

$stm2 = $pdo->query( 'SELECT * FROM `outra_tabela`' );

foreach ( $stm2->fetchAll( PDO::FETCH_OBJ ) as $outra_tabela ){
echo $outra_tabela->campo;
echo $outra_tabela->outro_campo;
}

$stm3 = $pdo->query( 'SELECT * FROM `mais_outra_tabela`' );

foreach ( $stm3->fetchAll( PDO::FETCH_OBJ ) as $mais_outra_tabela ){
echo $mais_outra_tabela->campo;
echo $mais_outra_tabela->outro_campo;
echo $mais_outra_tabela->mais_outro_campo;
}

 

E outra dúvida, no final do script não preciso definir nada como null para limpar, fechar conexão ou algo do tipo?

 

Com PDO não é necessário;

[Beto Lima 0]

certo, hoje eu uso assim

 

while ($linha = $result->fetch(PDO::FETCH_OBJ))

{

echo $linha->campo

}

 

vi que você colocou o fetchAll, mas o fetch não pega todos os registros tb?

[Evandro Oliveira 331]

Beto, a forma como você usa o objeto propriamente dito, não se altera. Por isso são padrões.

 

A partir do momento que você referencia o objeto PDO a partir do Registro, você pode simplesmente esquecer que algum dia na sua vida passou por "uma caixa para pegar o PDO".

 

Pense no Registry como uma caixa onde você coloca coisas; [...]

Caixas guardam e "desguardam" coisas. A forma como você trabalha com essas coisas não se altera, venham elas de uma caixa grande, pequena, de papelão, de isopor, ela é apenas uma caixa. ;)

 

 

Edit João, aliando Registry à Factory eu dispensaria a necessidade de 'registrar' os objetos, não?

 

Registry::getInstance('pdo','localhost','root','','iMasters');

/* Se não existe PDO, cria PDO e retorna. Senão retorna a instância existente */

[Beto Lima 0]

ok Evandro entendi essa parte, a minha última dúvida seria a diferença de fetch pra fetchAll

 

Pessoal não sei o que pode estar havendo pois fiz exatamente como passado....

 

Registry.php

<?php
/**
 * Exemplo de implementação de Singleton
 * Dica de leitura: Design Patterns, elements of reusable object-oriented software
 * ISBN: 0-201-63361-2
 * GoF: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
 * 3.5 Creational patterns, Singleton
 */
class Singleton implements IteratorAggregate {
        /**
         * Instância única de Singleton
         * @staticvar
         * @var Singleton
         */
        private static $instance;

        /**
         * @var array
         */
        private $data;

        /**
         * Sim, o construtor possui visibilidade protected, isso garantirá que apenas o método
         * getInstance() possa criar a instância do objeto
         */
        protected function __construct(){
                $this->data = array();
        }

        /**
         * Adiciona um dado qualquer à instância do objeto, ao contrário do getInstance(), esse
         * é um método do objeto (instância única de Singleton)
         * @param mixed $data Um dado qualquer que será adicionado à instância do objeto
         */
        public function addData( $data ){
                $this->data[] = $data;
        }

        /**
         * Provê um Iterator para iteração dos dados armazenados pelo Singleton
         * @return Iterator
         */
        public function getIterator(){
                return new ArrayIterator( $this->data );
        }

        /**
         * Operação de classe (estática) que permite acessar a única instância de Singleton
         * @return Singleton
         */
        public static function getInstance(){
                if ( self::$instance ) return self::$instance;
                else {
                        self::$instance = new Singleton();

                        return self::$instance;
                }
        }

}
?>

teste.php

<?php
require 'Registry.php';

$pdo = new PDO( 'mysql:host=localhost;dbname=base' , 'root' , '' );

$Registry = Registry::getInstance();
$Registry->set( 'PDO' , $pdo );

$pdo = Registry::getInstance()->get( 'PDO' );
$stm1 = $pdo->query( 'SELECT * FROM eventos' );

foreach ( $stm1->fetchAll( PDO::FETCH_OBJ ) as $evento ){
        echo $evento->id;
}

$stm2 = $pdo->query( 'SELECT * FROM noticias' );

foreach ( $stm2->fetchAll( PDO::FETCH_OBJ ) as $noticia ){
        echo $noticia->titulo;
}

$stm3 = $pdo->query( 'SELECT * FROM login' );

foreach ( $stm3->fetchAll( PDO::FETCH_OBJ ) as $login ){
        echo $login->usuario;
}
?>

 

erro:

 

Fatal error: Class 'Registry' not found in /var/www/TEMP/registry/teste.php on line 6

[William Bruno 1501]

olha oq contém o arquivo:

class Singleton

apesar do arquivo se chamar: Registry.php, a classe dentro dele se chama: Singleton..

 

decide ai.. se vai invocar um Registry:

$Registry = Registry::getInstance();

declare um Registry.. e não um Singleton..

 

E caras, na minha humilde opinião, de iniciante em POO, vcs superestimam demais..

[Beto Lima 0]

ta certo William, realmente foi uma mancada...perdão aí...

 

Obrigado João pela força, obrigado a todos tb....

[João Batista Neto 448]

Edit João, aliando Registry à Factory eu dispensaria a necessidade de 'registrar' os objetos, não?

 

Registry::getInstance('pdo','localhost','root','','iMasters');
/* Se não existe PDO, cria PDO e retorna. Senão retorna a instância existente */

 

Evandro, isso ai é totalmente problemático e não vai funcionar; Pense que nessa caixa, eu posso guardar qualquer coisa, não apenas PDO.

 

Pense que posso ter no meu Registry, ao mesmo tempo, PDO, DOM e mais um mooonte de coisas, coisas essas com interfaces totalmente distintas umas das outras.

 

Então, apesar de Factory Method e Singleton serem padrões de criação, é equivocado esse tipo de implementação e você terá, como consequencia, a não possibilidade de reutilização do código.

[ReinaldoJr 0]

Por favor, me tirem uma dúvida.

 

Supondo que eu tenha uma classe de conexao, haveria alguma forma, claro se realmente fizer sentido, de fazer algo parecido com o abaixo?

 

require_once('registry.php'); 

class Conexao extends PDO {
	private $banco = 'mysql:dbname=meubd;host=localhost';
	private $usuario = 'root';
	private $senha = '';
	private $opcoes = array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION);
	private $pdo;

	function __construct( ) {
		try {
				$this->pdo = parent::__construct( $this->banco , $this->usuario , $this->senha, $this->opcoes);
		}
		catch ( PDOException $e ) {
			echo 'Erro de Conexão';
		}
	}
	
	public function getMyInstance( ) {
		Registry::getInstance()->set( 'PDO' , $this->pdo);
		return = Registry::getInstance()->get('PDO');
		}
	}

}

$a= new Conexao;
$b = $a->getMyInstance();
$stm = $b->query( 'SELECT * FROM usuario');

foreach ( $stm->fetchAll( PDO::FETCH_OBJ ) as $usuario ){
	        echo $usuario->cod_usu . '<br />';
		echo $usuario->email . '<br />';
}

da forma acima, recebo o seguinte erro: Fatal error: Call to a member function query() on a non-object in, para a seguinte linha $stm = $b->query( 'SELECT * FROM usuario);

 

sou bem iniciante nessa área e estou indo meio que na tentativa e erro.

 

abraço,