Idéia para organizar paginação

[tocho 0]

Faço um select da seguinte maneira:

 

$db = Mysql::getInstance();
$db->open();

$result = $db->select('tabela', array('WHERE codigo' => 10) ); 

$db->close();

Estou implementado uma paginação, e queria idéias de implementações, não como fazer, mas sim como organizar.

 

Pensei assim:

 

$db = Mysql::getInstance();
$db->open();

$pagination = new Pagination('$perPage', '$_GET['page']' );

$result = $db->select('tabela', array('WHERE codigo' => 10), $pagination); 

$db->close();

foreach( $result as $r ):
//
endforeach;

echo $pagination->next();
echo $pagination->previous();

Queria a opinião quanto a organização desse código, e/ou idéias mais interessantes.

 

att

[Henrique Barcelos 290]

$result = $db->select('tabela', array('WHERE codigo' => 10) );

Como exatamente funciona isso?

 

Se quer uma idéia, dê uma olhada no código abaixo, é a minha última versão para se trabalhar com banco de dados, tem algumas melhorias por fazer ainda, mas funciona muito bem:

 

<?php 
class MySQLx extends ConfigDB {

 //Informações sobre esta classe... 
 private static $className = "MySQLx";
 private static $classVersion = " V 0.1 BETA";
 private static $classDate = "2009/09/12";
 
 
 //Conexão e dados... 
 protected $conn = null; //Instância do objeto MySQLi 
 protected $result = null; //Armazena o resultado de uma query 
 protected $SQL = null; //Senteça SQL a ser executada 
 protected $obj_fetched = null; //Objeto criado pelo método mysqli::fetch_object() 
 protected $data_result = null; //Dados retornados pelas funções fetch 
 protected $total_rows = 0; //Total de linhas retornadas por uma query 
 
 //Paginacao... 
 protected $query_string;
 protected $num_reg_show = 10;
 protected $num_pgs_show = 0;
 protected $total_pages;
 protected $pagina;
 protected $pg_load;
 protected $self_page;
 protected $first_reg;
 protected $last_reg;
 protected $first_page;
 protected $last_page;
 protected $show_inactive;
 protected $panel;
 protected $final_data;
 protected $paginacao;
 
 public function __construct() {
 $this->connect();
 }
 
 public function __toString() {
 return "<strong>".self::$className." ".self::$classVersion." - ".self::$classDate."</strong>";
 }
 
 public function __set($property, $value) {
 //$this->$property = $value; 
 }
 
 public function __get($property) {
 return $this->$property;
 }
 
 function __call($method, $arg) {
 $this->throwError("Unkown Method ".$method, "PHP", __LINE__, __FILE__);
 }
 
 public function connect() {
 $this->conn = new mysqli(self::$xHost, self::$xUser, self::$xPw, self::$xDB, self::$xPort);
 if (!$this->conn) {
 $error = $this->conn->connect_error;
 $arr_error = array($error, "connection", __LINE__, __FILE__);
 new ErrorController($arr_error);
 return false;
 }
 }
 
 public function disconnect() {
 $this->conn->close();
 } 
 public function execute($sql) {
 $this->SQL = $sql;
 if ($this->result = $this->conn->query($this->SQL)) {
 return $this->result;
 }else {
 $error = $this->conn->error;
 $arr_error = array($error, "query", __LINE__, __FILE__);
 new ErrorController($arr_error);
 return false;
 }
 $this->disconnect();
 }
 
 public function fetch_one($sql) {
 $one = NULL;
 $data = $this->fetch_n($sql, 1);
 if (isset($data[0]))
 $one = $data[0];
 return $one;
 } 
 public function fetch_n($sql, $n = 0) {
 $this->SQL = $this->removeLimt($sql);
 if ($n != 0)
 $this->SQL = $this->addLimt($this->SQL, $n);
 
 $exec = $this->execute($this->SQL);
 
 if (!$exec)
 return false;
 $this->total_rows = $exec->num_rows;
 if ($this->total_rows) {
 while($this->obj_fetched = $exec->fetch_object()) {
 $this->data_result[] = $this->obj_fetched;
 }
 }
 
 return $this->data_result;
 } 
 public function fetch_all($sql) {
 return $this->fetch_n($sql);
 }
 
 public function paginate($sql, $num_reg = null, $num_pg = null, $array_config = null) {
 
 //Fazendo as configurações, se definidas pelo usuário 
 if ($array_config != null) {
 $allowed = array("pg_load", "query_string", "show_inactive");
 foreach ($array_config as $key=>$config) {
 if (in_array($key, $allowed)) {
 $this->$key = $config;
 
 }
 }
 }
 //Atribuindo o valor do parâmetro à variavel estática $sql 
 $this->SQL = $this->removeLimt($sql);
 
 //Se não houver uma query string sendo passada, deixo o valor como null 
 $this->query_string = isset($this->query_string) ? $this->query_string : null;
 $this->query_string = htmlentities($this->query_string);
 
 //Se não houver um numero de registros por página, uso um valor padrão 
 $this->num_reg_show = isset($num_reg) ? $num_reg : 10;
 
 //Verificando o total de registros existentes 
 $getTotal = $this->execute($this->SQL);
 $this->total_rows = $getTotal->num_rows;
 
 if ($this->total_rows == 0)
 return null;
 
 $this->total_pages = ceil($this->total_rows / $this->num_reg_show);
 
 //Se não houver um valor enviado via GET para a página, então será a primeira 
 $this->pagina = isset($_GET["pagina"]) ? (int) $_GET["pagina"] : 1;
 
 /* Muitas vezes, a página que queremos carregar não é a página atual, 
 * então podemos definir outra, mas por padrão carregamos a página atual */
 $this->pg_load = isset($pg_load) ? $pg_load : $_SERVER['PHP_SELF'];
 //Pegando o endereço atual do página. Se ouver uma query string, adicono-a antes de passar o valor da página 
 $this->self_page = empty($this->query_string) ? $this->pg_load."?" : $this->pg_load."?".$this->query_string."&";
 
 //Se a página enviada for maior que o total de páginas, redireciona para a última 
 if ($this->pagina > $this->total_pages) {
 $this->pagina = $this->total_pages;
 }
 //Se a página enviada for menor ou igual a zero, redireciona para a última 
 if ($this->pagina <= 0) {
 $this->pagina = 1;
 }
 
 // Definir o número do primeiro registro da página. 
 $start = (($this->pagina) - 1) * ($this->num_reg_show);
 
 // consulta apenas os registros da página em questão utilizando como auxilio a 
 // definição LIMIT. Ordene os registros pela quantidade de pontos, 
 $this->SQL = $this->SQL." LIMIT ".$start.", ".$this->num_reg_show."";
 
 //Executo a query para o comando SQL e já crio o array de objetos com o fetch_all(); 
 $this->data_result = $this->fetch_all($this->SQL);
 
 //Definindo qual é o primeiro e o ultimo registro mostrado... 
 $sum = $this->first_reg + $this->num_reg_show;
 $this->first_reg = $this->first_reg + 1;
 $this->last_reg = $sum > $this->total_rows ? $this->total_rows : $sum;
 
 /* Definimos aqui a quantidade de páginas que vão ser mostradas na paginação, se estiver como 0 (padrão)
 * ou for maior que o total de páginas, mostramos todas */
 if ($this->num_pgs_show <= 0 || $this->num_pgs_show > $this->total_pages) {
 $this->num_pgs_show = $this->total_pages;
 }
 
 if ($this->num_pgs_show < $this->total_pages && $this->num_pgs_show) {
 /* ================= Essa daqui é a parte mais complicada da lógica da coisa =================== */
 
 //Decidindo de qual até qual página iremos mostrar 
 /* Se a página atual for maior que um metade da quantidade de páginas a serem mostradas e
 * menor ou igual ao total de páginas menos a metade da qtde de páginas a serem mostradas... */
 if ($this->pagina > floor($this->num_pgs_show / 2) && $this->pagina <= $this->total_pages - ($this->num_pgs_show / 2)) {
 //A a primeira página que será mostrada é a atual - metade da qtde de páginas a serem mostradas; 
 $this->first_page = $this->pagina - floor($this->num_pgs_show / 2);
 //Senão... 
 }else {
 //A a primeira página que será mostrada é a 1ª 
 $this->first_page = 1;
 }
 
 //Se a página atual é maior que o total de páginas menos a metade da qtde de páginas a mostrar... 
 if ($this->pagina > $this->total_pages - ($this->num_pgs_show / 2)) {
 //A primeira página é o total de páginas - (a qtde de páginas a mostrar - 1) 
 $this->first_page = $this->total_pages - ($this->num_pgs_show - 1);
 //A útlima é o total de páginas 
 $this->last_page = $this->total_pages;
 }else {
 //A útlima é a página inicial + a quantidade de páginas a ser mostrada 
 $this->last_page = $this->first_page + ($this->num_pgs_show - 1);
 }
 
 /* ========================================================================================= */
 
 }else {
 $this->first_page = 1;
 $this->last_page = $this->total_pages;
 }
 
 if ($this->total_pages > 1) {
 $prev_pg = $this->pagina - 1;
 $next_pg = $this->pagina + 1;
 
 $first = null;
 $prev = null;
 $next = null;
 $last = null;
 
 // Se página maior que 1 , então temos links para a página anterior e para a primeira página 
 if ($this->pagina > 1) {
 $first = "<a href='".$this->self_page."pagina=".$this->first_page."'class='link_paginacao'>««</a>\n";
 $prev = "<a href='".$this->self_page."pagina=".$prev_pg."' class='link_paginacao'>«</a>\n";
 }else {
 /* Se a opção para mostrar os links desativados estiver ativada (propriedade mostrar_desativados = true),
 * mostramos os spans contendo o texto dos links... */
 if ($this->show_inactive) {
 $first = "<span class='desativado'>««</span>";
 $prev = "<span class='desativado'>«</span>";
 }
 }
 
 /* Se número total de páginas for maior que a página corrente, 
 * então temos link para a próxima página e para a útlima */
 if ($this->total_pages > $this->pagina) {
 $next = "<a href='".$this->self_page."pagina=".$next_pg."' class='link_paginacao'>»</a>\n";
 $last = "<a href='".$this->self_page."pagina=".$this->last_page."' class='link_paginacao'>»»</a>\n";
 }else {
 if ($this->show_inactive) {
 /* Idem ao exemplo anterior */ 
 $next = "<span class='desativado'>»</span>\n";
 $last = "<span class='desativado'>»»</span>\n";
 }
 }
 
 //Painel com os números das páginas 
 $this->panel = null;
 //Se a página inicial for maior que 1, colocamos reticências no início painel... 
 if ($this->first_page > 1) {
 $this->$panel .= "<span class='ret'>...</span>\n";
 }
 
 //Este loop é o responsavel por mostrar todas as páginas desde a inicial até a final 
 for ($i = $this->first_page; $i <= $this->last_page; $i++) {
 if ($i == $this->pagina) {
 //Se estivermos na página atual, não exibir o link para visualizaçãoo desta página 
 $this->panel .= "<span class='selecionado'>".$i."</span>\n";
 }else {
 $this->panel .= "<a href='".$this->self_page."pagina=".$i."' name='link_paginacao' class='link_paginacao'>".$i."</a>\n";
 }
 }
 
 //Se última página for menor que o total de páginas, colocamos reticências no final do panel... 
 if ($this->last_page < $this->total_pages) {
 $this->panel .= "<span class='ret'>...</span>\n";
 }
 
 //Aqui concatenamos todos os links em uma só variável. 
 $this->paginacao = $first.$prev.$this->panel.$next.$last;
 }else {
 $this->paginacao = NULL;
 }
 
 /** Crio um array que conterá os dados finais da paginacao...**/
 
 //Recebe o retorno do banco de dados... 
 $this->final_data["dados"] = $this->data_result;
 
 //Rebece as informações sobre a paginação... 
 $this->final_data["info"] = array();
 $this->final_data["info"]["first_reg"] = $this->first_reg;
 $this->final_data["info"]["last_reg"] = $this->last_reg;
 $this->final_data["info"]["total_pages"] = $this->total_pages;
 $this->final_data["info"]["total_reg"] = $this->total_rows;
 
 //Recebe a paginaçao... 
 $this->final_data["paginacao"] = $this->paginacao;
 
 return $this->final_data;
 }
 
 public static function antiInjection($str) {
 $str = $this->conn->real_escape_string($str);
 return $str;
 }
 
 public function removeLimt($sql) {
 return $sql = preg_replace("/LIMIT \d+$/", "", $sql);
 }
 
 public function addLimt($sql, $n) {
 return $sql." LIMIT ".$n;
 } 
}
?>