Classe para banco de dados com PDO

Fala galera beleza?

bom eu tenho algumas bibliotecas que me auxiliam para criação de novos sites e agora estou criando um para conexão e modificação de dados para o Mysql.

Bom o código é bem novo e estou adaptando e estou com uma dificuldade de como criar o select pois sabemos que é muito mais muito extenso e o objetivo é poder pegar todos os dados sem essa de "essa função não vou usar" e acabar limitando a classe.

Bom a principio esta assim:

<?php
/**
Classe para banco de dados.

@author Luiz Vinicius Rangel <vinicius@rgidentidadevisual.com.br> | Roberto Gadducci Filho <roberto@rgidentidadevisual.com.br>
@version 0.1
@copyright ®2012 - Todos os direitos reservados a RG Identidade Visual
*/

Class DB{

/**
* Selecionar banco de dados a se conectar
* @acess Privado
* @type Stirng
*/

	private $db = 'class';

	/**
 * Verifica se existe conexão aberta
 * @acess Privado
 */
	private static $conn = null;

	/**
 * Dados para conexão do banco de dados
 *	@acess Privado
 *	@type String
 */
	private $host = 'localhost';
	private $db_user = 'root';
	private $db_password = '';

	private $conecta;

	/**
 *	Tabela em que sera feita a query
 *	@acess Publico
 *	@type String
 */
	public $tabela = '';

	/**
 * Recebe os parametros para interagir com as funções
 * @acess Publico
 * @type Array
 */
	public $param = array();

	/**
 *	Recebe os campos que serão selecionados, seleciona tudo por padrão
 *	@acess Publico
 *	@type String
 */
	public $selectCampos = '*';

	/**
 * Clausula para condição, aceita WHERE
 * @acess Publico
 * @type String
 */
	public $clausula = "";

	/**
 *
 */
 public $lol = array();

	/**
 * Inicia conexão toda vez que a função DB é chamada
 * @acess Publico
 */
	public function __construct(){
 if(is_null(self::$conn)){
 try{
 self::$conn = new PDO("mysql:host={$this->host};dbname={$this->db}", "{$this->db_user}", "{$this->db_password}", array("PDO::ATTR_ERRMODE" => "PDO::ERRMODE_EXCEPTION"));
 } catch(PDOException $e){
 self::$conn = die($e->getMessage());
 }
 }
 return self::$conn;
	}

	/**
 * Verifica se dentro da função do mysql há algum item
 * retorna true se tiver algum caracter na string
 * @acess Privado
 */
	private function checkFunctionNull($string){
 $check = explode("(", $string);
 if(empty($check[1])){
 return false;
 }else{
 return true;
 }
	}

	/**
 * Verifica se vai ser apenas uma função ou vai retornar algo
 * @acess Privado
 */
	private function checkFunctionSql($function){
 $first_value = explode(")", $function);
 $checktype = substr($first_value[0], 0, 1);
 if($checktype == '('){
 return false;
 }else{
 return true;
 }

	}

	/**
 * Função de proteger a DB contra SQL injection
 * @acess Privado
 */
	private function bind($dados, $pdo){
	$string = explode("-->", $dados);
	$array = array();

	foreach($string as $s){
 $values = explode(",", $s);
 $array[$values[0]] = $values[1];
	}

	foreach($array as $k => $val){
 if($this->checkFunctionNull($k)){
 $campArray = explode("(", $k);
 $campo = substr($campArray[1], 0, -1);
 }else{
 $campo = $k;
 }
 if(is_string($val)){
 $param = PDO::PARAM_STR;
 }else{
 $param = PDO::PARAM_INT;
 }
 $pdo->bindValue($campo, $val, $param);
	}

	return $pdo;

	}

	/**
 * Função responsável por gerar a sql, retorna array contendo a sql e os campos e valores separados para utilizar na @funcao Bind
 * @acess Privada
 */
	private function readData(){
 $ret = array();
 $sql = '';
 $query = '';
 $subconsulta = '';
 $dadosArray = '';
 $dadosString = '';
 foreach($this->param as $k => $valores){
 $equal = '=';
 $separetor = ',';
 if(is_array($valores)){
 if($this->checkFunctionSql($valores[1])){
 $campo = $k;
 $value = $valores[1];
 $dadosArray .= $valores[1].','.$valores[0].'-->';
 }else{
 $subconsulta .= ', '.$valores[1].', ';
 $equal = '';
 $campo = '';
 $value = '';
 $separetor = '';
 }
 }else{
 $campo = $k;
 if($this->checkFunctionNull($valores)){
 $value = $valores;
 }else{
 $value = ':'.$k;
 $dadosString .= '-->'.$value.','.$valores;
 }

 }

 $query .= "{$campo} {$equal} {$value} {$separetor}";

 }

 $dadosStr = substr($dadosString, 3);
 $dados = $dadosArray.$dadosStr;

 $sql .= substr($query, 0, -2);
 $sql .= ' '.$this->clausula;

 $ret['sql'] = $sql;
 $ret['dados'] = $dados;
 return $ret;
	}

	/**
 * Insere os dados da @var param no banco de dados @var db na tabela @var tabela
 * Aceita variaveis de tipo Array
 * @acess Publico
 */
	public function insert($retorno = ''){
 $sql = "INSERT INTO {$this->tabela} SET ";
 $data = $this->readData();
 $sql .= $data['sql'];
 $pdo = self::$conn->prepare($sql);
 $exe = $this->bind($data['dados'], $pdo);
 if($exe->execute()){
 if($retorno == 'true'){
 return $sql;
 }else if($retorno != ''){
 echo "#ERRO -> Parâmetro inválido";
 }
 }else{
 echo "#ERRO -> não foi possível inserir os dados na tabela {$this->tabela}, verifique os campos e valores informados!";
 }
	}

	/**
 * Deleta os dados da @var db na tabela @var tabela
 * aceita String, valor pego da @var clausula
 * @acess Publico
 */
	public function delete($retorno = ''){
 try{
 $sql = "DELETE FROM {$this->tabela}";
 $sql .= " {$this->clausula}";
 $pdo = self::$conn->prepare($sql);
 if($pdo->execute()){
 if($retorno == 'true'){
 return $sql;
 }else if($retorno != ''){
 echo "#ERRO -> Parâmetro inválido";
 }
 }else{
 echo "#ERRO -> Não foi possível deletar os dados da {$this->tabela}";
 }
 }catch(PDOException $e){
 throw new Exception($e->getMessage());
 }
	}

	/**
 * atualiza os dados da @var param no banco de dados @var db na tabela @var tabela
 * Aceita variaveis de tipo Array
 * @acess Publico
 */
	public function update($retorno = ''){
 try{
 $sql = "UPDATE {$this->tabela} SET ";
 $data = $this->readData();
 $sql .= $data['sql'];
 $pdo = self::$conn->prepare($sql);
 $exe = $this->bind($data['dados'], $pdo);
 if($exe->execute()){
 if($retorno == 'true'){
 return $sql;
 }else if($retorno != ''){
 echo "#ERRO -> Parâmetro inválido";
 }
 }else{
 echo "#ERRO -> não foi possível atualizar os dados na tabela {$this->tabela}, verifique os campos e valores informados!";
 }
 }catch(PDOException $e){
 throw new Exception($e->getMessage());
 }
	}

	public function select(){
 $sql = 'SELECT ';
 $sql .= $this->selectCampos;
 $sql .= ' FROM '.$this->tabela.' ';
 $sql .= $this->clausula;
 foreach($this->param as $param){
 if(isset($param[3])){
 $x = $param[3];
 }else{
 $x = '';
 }
 $sql .= ' '.$param[0].' '.$param[1].' :'.$param[0].' '.$x;
 }
 echo $sql;
	}

	/**
 * Destroi a classe junto com a conexão
 * @acess Publica
 */
	public function __destruct(){
 self::$conn = null;
	}

}
?>

eu ainda vou trocar muitas coisas para economizar code mais o que peço de ajuda se concentra na função SELECT

o modo de uso estava desse modo

$db = new DB();
$db->tabela = 'user';
$db->clausula = 'WHERE';

$db->param = array( array('id', '=', 23, 'AND'), //campo condiçao e valor. array('nome', '!=', 'Igor')

);

$db->select();

agora por que eu simplesmente não fiz

$db->clausula = "WHERE id = 23 AND nome != Igor";

bom eu preciso passar um bind ainda para proteger os dados.

Eis a questão.

como proceder? para tratar tudo separado e ainda ter a possibilidade de colocar as função do mysql caso um HEX ou DATE_ADD etc..

vlw