Discussion :

[johweb]

Bonjour à tous.

J'ai une base de données mysql contenant une table articles (identifiant, titre, contenu).
J'indexe chaque article dans une table articles_mots_index : chaque mot rencontré dans titre et contenu est stocké dans la table. Voici la structure de la table : id_article, mot, nbr_mot (ce dernier champ correspondant au nombre de fois où le mot apparaît dans l'article).

Je cherche à mettre en place une recherche où les utilisateurs peuvent saisir par exemple "bleu peur -(chat - chien)"
Ce qui reviendrait à chercher les articles contenant "bleu" ou "peur sauf (chat sauf chien)".

Je cherche des pistes de réflexion car je n'arrive pas à généraliser le raisonnement pour construire dynamiquement les différentes requêtes...

Merci d'avance pour les pistes.

ps : je sais qu'il existe des recherches plein texte dans les versions récentes de mysql, mais je dois utiliser le système décrit ci-dessus...

[Inazo]

Bonjour,

Petite question est déjà dans la possibilité de trier les mots en fonction qu'ils soient oui ou non interdit dans la recherche ?

Ensuite ta recherche doit-elle être effectué sur le mot exact ou sur contient ce mot ? Idem pour ceux qui sont exclus on exclu le mot exact ou contient ce mot ?

Cordialement,

[Benjamin Delespierre]

C'est assez compliqué, il s'agit là de compiler une expression en langage SQL. Tu peux définir une grammaire simple à base d'opérateurs + et - qui seront traduits en AND ou OR ou NOT IN en SQL.

Est-ce que tu pourrais nous décrire cette grammaire ou nous donner davantage d'exemples ?

Si ça peut t'aider, voici une classe que j'ai implémenté récemment pour gérer les routes d'une application MVC, la grammaire permet de transformer des templates de routes de la forme /{:controller}/hello/{:id:\d+} en éxpressions régulières:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
<?php
 
 
class Route {
 
    protected $_template;
 
    protected $_pattern;
 
    protected $_keys;
 
    protected $_params;
 
    protected $_options;
 
    public function __construct ($template, array $params = array(), array $options = array()) {
        $this->_template = $template;
        $this->_params = $params;
 
        if (isset($options['module']) && is_string($options['module']))
            $options['module'] = array($options['module']);
 
        $this->_options = $options;
        $this->_keys = array();
    }
 
    public function match ($url) {
        $url = '/' . trim($url, '/');
 
        if (empty($this->_pattern))
            $this->_compileTemplate($this->_template);
 
        if (preg_match($this->_pattern, $url, $matches)) {
            unset($matches[0]);
            if (!empty($this->_keys) && !empty($matches)) {
                $this->_params = array_merge($this->_params, array_combine($this->_keys, $matches));
            }
            return true;
        }
        return false;
    }
 
    protected function _compileTemplate ($template) {
        $token = strtok($template, '/');
        $pattern_pieces = array();
        $current_key = 1;
        do {
            if (preg_match('~{:(.+)}~', $token, $matches)) {
                if ($matches[1] === 'lang') {
                    $key = 'lang';
                    $subpattern = "([a-z]{2})";
                }
                elseif ($matches[1] === 'id') {
                    $key = 'id';
                    $subpattern = "([0-9]+)";
                }
                elseif ($matches[1] === 'controller' || $matches[1] === 'action') {
                    $key = $matches[1];
                    $subpattern = "(\w{3,})";
                }
                elseif (($offset = strpos($matches[1], ':')) !== false) {
                    list($key, $subpattern) = explode(':', $matches[1]);
                    $subpattern = "($subpattern)";
                }
                else {
                    $key = $matches[1];
                    $subpattern = "([^/]+)";
                }
                $pattern_pieces[] = $subpattern;
                $this->_keys[$current_key++] = $key;
            }
            else {
                $pattern_pieces[] = $token;
            }
        } while ($token = strtok('/'));
        $this->_pattern = '~^/' . implode('/', $pattern_pieces) . '$~';
    }
 
    public function getParams () {
        return $this->_params;
    }
 
    public function getOptions () {
        return $this->_options;
    }
 
    public function getTemplate () {
        return $this->_template;
    }
 
    public function getPattern () {
        return $this->_pattern;
    }
}

(on s'intéressera surtout ici à la méthode _compileTemplate).

Une fonction qui t'aidera grandement dans la création de ce genre de syntaxe est strtok qui permet de découper une chaine selon une série de séparateurs (et non un seul comme le fait explode).