Foros del Web » Programando para Internet » PHP »

Buscador php MySql

Estas en el tema de Buscador php MySql en el foro de PHP en Foros del Web. Buenos días estoy haciendo un buscador en php pero no se porque no me devuelve ningún valor... creo que lo estoy haciendo bien... esta es ...
  #1 (permalink)  
Antiguo 11/10/2012, 04:28
 
Fecha de Ingreso: mayo-2005
Ubicación: Castellón
Mensajes: 321
Antigüedad: 19 años, 6 meses
Puntos: 0
Pregunta Buscador php MySql

Buenos días estoy haciendo un buscador en php pero no se porque no me devuelve ningún valor... creo que lo estoy haciendo bien... esta es la búsqueda que realizo:

Cita:
$paraula= $_POST['paraula'];
$res="SELECT * , MATCH ( nom, denominacio ) AGAINST ( '$paraula' ) AS score FROM carrers WHERE MATCH ( nom, denominacio ) AGAINST ( '$paraula' ) ORDER BY score DESC";
En la tabla carrers he creado un indice fulltext con los dos campos (nom i denominacio). la conexión a la BBDD es correcta ya que tengo hechos otros tipos de búsqueda y me van bien, el que no va es este.

No se si es que se me pasa algo por alto o que, he hecho otros buscadores antes como este y me han funcionado a la perfección...

Por favor, me pueden comprobar que está todo bien?

Un saludo y gracias
  #2 (permalink)  
Antiguo 11/10/2012, 04:31
 
Fecha de Ingreso: mayo-2005
Ubicación: Castellón
Mensajes: 321
Antigüedad: 19 años, 6 meses
Puntos: 0
Respuesta: Buscador php MySql

... y si le pongo el mysql_query() ???

Cita:
$res=mysql_query("SELECT * , MATCH ( nom, denominacio ) AGAINST ( '$paraula' IN BOOLEAN MODE) AS score FROM carrers WHERE MATCH ( nom, denominacio ) AGAINST ( '$paraula' IN BOOLEAN MODE) ORDER BY score DESC");
era lo que pasaba... ahora ya va... cabeza la mía!!!!
  #3 (permalink)  
Antiguo 11/10/2012, 05:58
Avatar de portalmana  
Fecha de Ingreso: septiembre-2007
Ubicación: Montevideo-Uruguay
Mensajes: 633
Antigüedad: 17 años, 1 mes
Puntos: 80
Respuesta: Buscador php MySql

Generar Consultas FullText para MySQL

Buscador y Paginador , aqui con un paginador y creo que tiene algunos avances mas.

Saludos
__________________
"La imaginación es más importante que el conocimiento. El conocimiento es limitado, mientras que la imaginación no" -- A.Einstein
objetivophp.com,twitter.com/objetivophp
  #4 (permalink)  
Antiguo 11/10/2012, 06:10
Avatar de portalmana  
Fecha de Ingreso: septiembre-2007
Ubicación: Montevideo-Uruguay
Mensajes: 633
Antigüedad: 17 años, 1 mes
Puntos: 80
Respuesta: Buscador php MySql

Código PHP:
Ver original
  1. <?php
  2. /**
  3.  * Clase BuscadorFullText.
  4.  * Es responsable de entregarnos el codigo de una consulta para la Base de datos
  5.  * MySQL con motor MyIsam, basandose en los Indices FullText.
  6.  * Ver http://dev.mysql.com/doc/refman/5.0/es/fulltext-search.html
  7.  * Ver http://dev.mysql.com/doc/refman/5.0/es/fulltext-fine-tuning.html
  8.  * Ver http://dev.mysql.com/doc/refman/5.0/es/information-functions.html
  9.  *
  10.  * @package     varias creado en el projecto opet
  11.  * @copyright   2011 - ObjetivoPHP
  12.  * @license     Gratuito (Free) http://www.opensource.org/licenses/gpl-license.html
  13.  * @author      Marcelo Castro (ObjetivoPHP)
  14.  * @link        [email protected]
  15.  * @version     2.3.0 (27/12/2009 - 15/05/2011)
  16.  * @since       ver uso de str_word_count( $_POST['buscar'], 1, '+-~<>');
  17.  *              para proxima version
  18.  * @since       Continua  serie BuscadorGenerico 4.4.6 del 21/05/2007.
  19.  */
  20. class BuscadorFullText
  21. {
  22.     /**
  23.      * Contiene la cadena de busqueda, generalmente su contenido se correlaciona
  24.      * con un campo en el formulario de busqueda.
  25.      * @var string
  26.      */
  27.     private $_textoDeBusqueda;
  28.  
  29.     /**
  30.      * Contiene la tabla de la base en la cual se realizara la consulta.
  31.      * @var string
  32.      */
  33.     private $_tablaMysql;
  34.  
  35.     /**
  36.      * Coleccion de campos que se retornaran como resultado.
  37.      * @var array
  38.      */
  39.     private $_colCamposResultado = array();
  40.  
  41.     /**
  42.      * Coleccion de campos que se utilizan para la busqueda de tipo fulltext.
  43.      * @var array
  44.      */
  45.     private $_colCamposFullText = array();
  46.  
  47.     /**
  48.      * Coleccion de parametros adiccionales a incluirle a la consulta.
  49.      * Todos se añaden con tipo AND.
  50.      * @var array
  51.      */
  52.     private $_colParametros = array();
  53.  
  54.     /**
  55.      * Contiene el tipo de consulta que se realizo.
  56.      * @var string
  57.      */
  58.     private $_tipoConsulta = 'FULLTEXT';
  59.  
  60.     /**
  61.      * Configura si utiliza SQL_CALC_FOUND_ROWS en la consulta mysql para luego extraer la
  62.      * cantidad de resultados con limit.
  63.      * @var boolean
  64.      */
  65.     private $_SQL_CALC_FOUND_ROWS = true;
  66.  
  67.     /**
  68.      * Contiene el metodo de envio del Formulario.
  69.      * Utilizado en los metodos getValue y addParametros.
  70.      * @var string
  71.      */
  72.     private $_metodoEnvio = 'POST';
  73.  
  74.     /**
  75.      * Contiene los operadores para parametros variables permitidos.
  76.      * @var array
  77.      */
  78.     private static $_operadores = array('=', '<=>', '<>', '!=', '<=', '<',
  79.                                         '>', 'IS', 'IS NOT', 'IS NULL',
  80.                                         'IS NOT NULL');
  81.  
  82.     /**
  83.      * Configura si la palabra se toma en cuenta una vez, o cada vez que aparece.
  84.      * Por defecto cada vez que aparece se toma en cuenta.
  85.      * @var boolean
  86.      */
  87.     private $_sumarUnaVez = false;
  88.  
  89.    
  90.     private $_filtrarPalabras = array();
  91.    
  92.     /**
  93.      * Metodo __construct.
  94.      * Crea un objeto BuscadorFullText
  95.      * @param   string  $buscar Cadena de busqueda puede contener +-~><
  96.      * @param   string  $tabla  Nombre de la Tabla MySQL a usar en la consulta.
  97.      * @return  void
  98.      */
  99.     public function  __construct($buscar, $tabla)
  100.     {
  101.         $this->_textoDeBusqueda = addslashes($buscar);
  102.         $this->_tablaMysql      = addslashes($tabla);
  103.     }
  104.  
  105.     /**
  106.      * Metodo addCamposResultado.
  107.      * Ingresa los campos que se usaran como resultado de la consulta.
  108.      * @param   string/array  $campo Contiene el o los nombres de los campos.
  109.      * @return  void
  110.      */
  111.     public function addCamposResultado($campo)
  112.     {
  113.         if (is_string($campo)) {
  114.             $campo  = explode(',', $campo);
  115.         }
  116.         if (is_array($campo)) {
  117.             foreach ($campo as $valor) {
  118.                 $this->_colCamposResultado[] = $valor;
  119.             }
  120.         }
  121.     }
  122.    
  123.     /**
  124.      * Metodo addFiltro.
  125.      * Agrega palabras que seran eliminados de la consulta de busqueda.
  126.      * @param   array   Contiene las palabras a eliminar.
  127.      * @return  void
  128.      */
  129.     public function addFiltro(array $filtrar)
  130.     {
  131.         if (!is_array($filtrar)) {
  132.             return false;
  133.         }
  134.         // Si es un arreglo lo dejo preparado.
  135.         foreach($filtrar as $palabra) {
  136.             $palabra    = '/[\w]*(\s' . $palabra . '\*)[\w]*/';
  137.             $this->_filtrarPalabras[] = $palabra;
  138.         }
  139.     }
  140.  
  141.     /**
  142.      * Metodo limitarLargo.
  143.      * Limita el largo de un campo a un determinado numero de caracteres.
  144.      * @version 2.1.0 (21/11/2010)
  145.      * @param   string  $campo      nombre de campo.
  146.      * @param   integer $caracteres Cantidad de caracteres que retornara la consulta.
  147.      * @return  void
  148.      */
  149.     public function limitarLargo($campo, $caracteres)
  150.     {
  151.         $clave  = array_search($campo, $this->_colCamposResultado);
  152.         if ($clave !== false) {
  153.             $caracteres = ($caracteres > 0)? $caracteres : 250;
  154.             $this->_colCamposResultado[$clave] = 'LEFT(`' . $campo . '`, ' .$caracteres . ') as ' . $campo;
  155.         }
  156.     }
  157.  
  158.     /**
  159.      * Metodo addCamposFullText.
  160.      * Ingresa los campos que se usaran para la consulta.
  161.      * @param   string/array  $campo Contiene el o los nombres de los campos.
  162.      * @return  void
  163.      */
  164.     public function addCamposFullText($campo)
  165.     {
  166.         if (is_string($campo)) {
  167.             $campo  = explode(',', $campo);
  168.         }
  169.         if (is_array($campo)) {
  170.             foreach ($campo as $valor) {
  171.                 $this->_colCamposFullText[] = $valor;
  172.             }
  173.         }
  174.     }
  175.  
  176.     /**
  177.      * Metodo addParametrosVariables.
  178.      * Inserta un parametro a la consulta.
  179.      * @param   string  $campo      Nombre del campo en el formulario de consulta, debe
  180.      *                              coincidir con el de la base de datos.
  181.      * @param   string  $operador   operador de consulta = > < etc.
  182.      * @return  void
  183.      */
  184.     public function addParametrosVariables($campo, $operador)
  185.     {
  186.         $valor      = ($this->_metodoEnvio == 'POST')? $_POST[$campo] : $_GET[$campo];
  187.         if (!in_array($operador, self::$_operadores)) {
  188.             trigger_error('Operador de Consulta no valido en Metodo ' . __METHOD__, E_USER_ERROR);
  189.         }
  190.         $parametro  = $campo . ' ' . $operador . " '" . addslashes($valor) . "'";
  191.         $this->_colParametros[] = $parametro;
  192.     }
  193.  
  194.     /**
  195.      * Metodo addParametrosFijos.
  196.      * Agrega parametros fijos en la consulta.
  197.      * @param   string  $parametros parametro tipo campo='valor'
  198.      * @return  void
  199.      */
  200.     public function addParametrosFijos($parametros)
  201.     {
  202.         $this->_colParametros[] = $parametros;
  203.     }
  204.  
  205.     /**
  206.      * Metodo setSqlCalcFoundRows.
  207.      * Configura si debe ponerse en la consulta MySQL la clausula SQL_CALC_FOUND_ROWS.
  208.      * @param   boolean $boolean    true por si, false por no.
  209.      * @return  void
  210.      */
  211.     public function setSqlCalcFoundRows($boolean)
  212.     {
  213.         $this->_SQL_CALC_FOUND_ROWS = ($boolean)? true:false;
  214.     }
  215.  
  216.     /**
  217.      * Metodo setMetodoEnvio.
  218.      * Configura por que metodo se envia el formulario (GET, POST).
  219.      * @param   string  $metodo Metodo a utilizarce para levantar las variables
  220.      *                          del formulario.
  221.      * @return  void
  222.      */
  223.     public function setMetodoEnvio($metodo = 'POST')
  224.     {
  225.         ($metodo == 'GET')? $this->_metodoEnvio = 'GET' : $this->_metodoEnvio = 'POST';
  226.     }
  227.  
  228.     /**
  229.      * Metodo getValue.
  230.      * Retorna una cadena que se puede colocar dentro del value de un campo
  231.      * de busqueda.
  232.      * @param   string  $campo  Nombre del campo que se debe levantar.
  233.      * @param   string  $metodo metodo POST o GET. Por defecto POST.
  234.      * @return  string  Cadena tipo value.
  235.      */
  236.     public function getValue($campo)
  237.     {
  238.         $valor  = ($this->_metodoEnvio == 'POST')? $_POST[$campo] : $_GET[$campo];
  239.         return stripslashes(str_replace('"', "'", $valor));
  240.     }
  241.  
  242.     /**
  243.      * Configura si se desea tomar una palabra con incidencia igual 1 por mas que
  244.      * se repita (true), o si la palabra incide cada vez que aparece (false)
  245.      * @param boolean $cont
  246.      */
  247.     public function setContarUnaVez($cont = false)
  248.     {
  249.         $this->_sumarUnaVez = $cont ? true : false;
  250.     }
__________________
"La imaginación es más importante que el conocimiento. El conocimiento es limitado, mientras que la imaginación no" -- A.Einstein
objetivophp.com,twitter.com/objetivophp
  #5 (permalink)  
Antiguo 11/10/2012, 06:11
Avatar de portalmana  
Fecha de Ingreso: septiembre-2007
Ubicación: Montevideo-Uruguay
Mensajes: 633
Antigüedad: 17 años, 1 mes
Puntos: 80
Respuesta: Buscador php MySql

Continuación de la clase
Código PHP:
Ver original
  1. /**
  2.      * Metodo getConsultaMysql.
  3.      * Genera una consulta MySQL, para un buscador dependiendo de el largo de la
  4.      * cadena utiliza like o modo fulltext.
  5.      * @param   string  $texto
  6.      * @return  string  Consulta MySQL para busqueda.
  7.      */
  8.     public function getConsultaMysql($texto='')
  9.     {
  10.         // Veo si cambia el texto de busqueda o si lo mantiene.
  11.         $this->_textoDeBusqueda = ($texto)? addslashes($texto) : $this->_textoDeBusqueda;
  12.         // Comienzo a generar la consulta MySql
  13.         $mySqlQuery             = (strlen($this->_textoDeBusqueda) < 4)?
  14.                                 $this->_getConsultaLike($this->_textoDeBusqueda) :
  15.                                 $this->_getConsultaFullText($this->_textoDeBusqueda);
  16.         // Agregamos los Parametros a la consulta
  17.         if ($this->_colParametros) {
  18.             $mySqlQuery        .= ' && (' . implode(' && ', $this->_colParametros) . ' ) ';
  19.         }
  20.         // Cerramos la consulta
  21.         $mySqlQuery             = ($this->_tipoConsulta == 'FULLTEXT')? $mySqlQuery . " ORDER BY puntuacion DESC" : $mySqlQuery;
  22.         $mySqlQuery             = $mySqlQuery . ' LIMIT %d, %d';
  23.         return $mySqlQuery;
  24.     }
  25.  
  26.     /**
  27.      * Genera la consulta tipo Like.
  28.      * @param   string      $texto  Texto de busqueda.
  29.      * @return  string      Cadena para consulta MySQL con LIKE.
  30.      */
  31.     private function _getConsultaLike($texto)
  32.     {   $this->_tipoConsulta= 'LIKE';
  33.         $inicio             = ($this->_SQL_CALC_FOUND_ROWS)? 'SELECT SQL_CALC_FOUND_ROWS ':'SELECT ';
  34.         $camposResultados   = (count($this->_colCamposResultado))? implode(', ', $this->_colCamposResultado) : '*';
  35.         $consulta           = $inicio . $camposResultados . " FROM " . $this->_tablaMysql . " WHERE ( ";
  36.  
  37.         foreach($this->_colCamposFullText as $campo)
  38.         {
  39.             $consulta       = $consulta . " " . $campo . " LIKE '%%" . $texto . "%%' OR ";
  40.         }
  41.         $consulta           = substr($consulta,0,strlen($consulta)-3) ." ) ";
  42.         return $consulta;
  43.     }
  44.  
  45.     /**
  46.      * Genera la consulta fulltext.
  47.      * @param   string      $texto  Texto de busqueda
  48.      * @return  string      Cadena para consulta MySQL tipo FULLTEXT.
  49.      */
  50.     private function _getConsultaFullText($texto)
  51.     {
  52.         $this->_tipoConsulta= 'FULLTEXT';
  53.  
  54.         $camposFullText     = implode(', ', $this->_colCamposFullText);
  55.         $parsearTexto       = $this->_cadenaFullText($texto);
  56.         $inicio             = ($this->_SQL_CALC_FOUND_ROWS)? 'SELECT SQL_CALC_FOUND_ROWS ':'SELECT ';
  57.         $camposResultados   = (count($this->_colCamposResultado))? implode(', ', $this->_colCamposResultado) : '*';
  58.         $consulta           = $inicio . " " . $camposResultados . ", MATCH( $camposFullText ) AGAINST ('$parsearTexto' ";
  59.         $consulta          .= ($this->_sumarUnaVez)? 'IN BOOLEAN MODE )' : ')';
  60.         $consulta          .= " AS puntuacion FROM $this->_tablaMysql "
  61.                             . " WHERE MATCH( $camposFullText ) AGAINST ('$parsearTexto' IN BOOLEAN MODE)";
  62.         return  $consulta;
  63.     }
  64.  
  65.     /**
  66.      * Metodo cadenaFullText.
  67.      * Genera la cadena que ira en la parte  AGAINST, de la consulta MySQL.
  68.      * @param   string  $texto  Texto digitado por el usuario.
  69.      * @return  string
  70.      */
  71.     private function _cadenaFullText($texto)
  72.     {
  73.         $patron     = array('/\s\s+/',                      // Quito espacios en blanco de mas
  74.                             '/\'/',                         // Cambio comillas simples por dobles
  75.                             '/([\+\-\~\<\>])(\s)/',         // junto los simbolos con las palabras de busqueda
  76.                             '/([\w]*)([\+\-\~\<\>\)])/',    // Separo los simbolos de las palabras que los anteceden);
  77.                             '/\*/',
  78.                             '/\s\s+/');                     // Vuelvo a sacar espacios en blanco por las dudas
  79.         $remplazo   = array(' ', '"','\1', '\1 \2', '', ' ');
  80.         $texto      = preg_replace($patron, $remplazo, $texto);
  81.  
  82.         // Separamos las cadenas entre comillas.
  83.         $datos      = explode('"', str_replace('\\', '', $texto));
  84.  
  85.         $cantidad   = count($datos);
  86.         for ($index = 0; $index < $cantidad; $index++) {
  87.             if(($index % 2) == 0 && $datos[$index] ) {
  88.                 $partes         = explode(' ', trim($datos[$index]));
  89.                 $datos[$index]  = implode('* ', $partes) . '* ';
  90.             } elseif ($datos[$index]) {
  91.                 // Ordeno en caso que sea una cadena entrecomillada
  92.                 $simbolo    = substr($datos[$index - 1], strlen($datos[$index - 1])-3,1);
  93.                 $datos[$index]  = '"' . $datos[$index] .'"';
  94.                 if (strpos("+-~<>", $simbolo) !== false) {
  95.                     $datos[$index]  = $simbolo . $datos[$index];
  96.                     $datos[$index-1]= substr($datos[$index-1], 0, strlen($datos[$index - 1])-3);
  97.                 }
  98.             }
  99.         }
  100.         $texto  = implode(' ', $datos);
  101.  
  102.         // Correcciones Finales
  103.         $patron     = array('/\(\*/', '/\)\*/', '/[\+\-\~\<\>]\*/','(á)','(é)','(í)','(ó)','(ú)','(Á)','(É)','(Í)','(Ó)','(Ú)');
  104.         $remplazo   = array('(', ')', '','a','e','i','o','u','A','E','I','O','U');
  105.         $texto      = preg_replace($patron, $remplazo, $texto);
  106.         // Filtrado final
  107.         if (count($this->_filtrarPalabras)) {
  108.             $texto  = preg_replace($this->_filtrarPalabras, '', $texto);
  109.         }
  110.         return $texto;
  111.     }
  112. }

Esa es la ultima version
__________________
"La imaginación es más importante que el conocimiento. El conocimiento es limitado, mientras que la imaginación no" -- A.Einstein
objetivophp.com,twitter.com/objetivophp
  #6 (permalink)  
Antiguo 11/10/2012, 06:23
Avatar de portalmana  
Fecha de Ingreso: septiembre-2007
Ubicación: Montevideo-Uruguay
Mensajes: 633
Antigüedad: 17 años, 1 mes
Puntos: 80
Respuesta: Buscador php MySql

Y el uso es mas o menos asi:
Código PHP:
Ver original
  1. // Configuro el paginador
  2.         require_once 'BuscadorFullText.php';
  3.         $objBuscador                = new BuscadorFullText($_POST['buscar'], 'buscador');
  4.         // Agregamos los campos donde se buscara las palabras o criterios de busqueda
  5.         $objBuscador->addCamposFullText('titulo, desarrollo');
  6.         // Si queremos que cada vez que aparece una palabra se cuente ponemos false
  7.         // que es el valor por defecto si solo queremos que se tome en cuenta una vez
  8.         // ponemos true
  9.         $objBuscador->setContarUnaVez(false);
  10.         // Filtrar palabras que no queremos buscar
  11.         $filtrar = array('de', 'la', 'mi', 'la', 'o', 'y', 'el');
  12.         $objBuscador->addFiltro($filtrar);
  13.        
  14.         // Campos que se obtendran como resultado
  15.         $objBuscador->addCamposResultado(array('idNoticia', 'titulo', 'desarrollo', 'categoria'));
  16.  
  17.         // Parametros que pueden variar en este caso debe coincidir el nombre del campo en el form html
  18.         // con el nombre en la tabla MySQL
  19.         if (isset($_POST['categoria']) && $_POST['categoria'] ) {
  20.             $objBuscador->addParametrosVariables('categoria' , '=');
  21.         }
  22.         // añade a la consulta una condicion fija
  23.         $objBuscador->addParametrosFijos("estado LIKE 'aprobada'");
  24.        
  25.         // Para limitar la cantidad de caracteres en la salida de algun campo
  26.         $objBuscador->limitarLargo('titulo', 100);
  27.         $objBuscador->limitarLargo('desarrollo', 250);
  28.         // Capturamos la consulta que se debe realizar y agregamos el limit
  29.         $consulta                = $objBuscador->getConsultaMysql();
  30.         $consulta Limit          = sprintf($consulta, $inicioLimit, $cantidadDeRegistros);
  31.         echo 'Generada' .$consulta;
__________________
"La imaginación es más importante que el conocimiento. El conocimiento es limitado, mientras que la imaginación no" -- A.Einstein
objetivophp.com,twitter.com/objetivophp

Etiquetas: mysql, tabla, buscadores
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 12:17.