OSDN Git Service

chnge:$nucleus['version'] v3.5SVN to v3.50SVN
[nucleus-jp/nucleus-jp-ancient.git] / utf8 / nucleus / libs / SEARCH.php
1 <?php
2
3 /*
4  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
5  * Copyright (C) 2003-2009 The Nucleus Group
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  * (see nucleus/documentation/index.html#license for more info)
12  */
13 /**
14  * SEARCH(querystring) offers different functionality to create an
15  * SQL query to find certain items. (and comments)
16  *
17  * based on code by David Altherr:
18  * http://www.evolt.org/article/Boolean_Fulltext_Searching_with_PHP_and_MySQL/18/15665/
19  * http://davidaltherr.net/web/php_functions/boolean/funcs.mysql.boolean.txt
20  *
21  * @license http://nucleuscms.org/license.txt GNU General Public License
22  * @copyright Copyright (C) 2002-2009 The Nucleus Group
23  * @version $Id$
24  * @version $NucleusJP: SEARCH.php,v 1.7 2006/07/20 08:01:52 kimitake Exp $
25  */
26
27
28
29 class SEARCH {
30
31         var $querystring;
32         var $marked;
33         var $inclusive;
34         var $blogs;
35
36
37         function SEARCH($text) {
38                 global $blogid;
39 //              $text = preg_replace ("/[<,>,=,?,!,#,^,(,),[,\],:,;,\\\,%]/","",$text);
40
41
42                 /* * * for jp * * * * * * * * * * */
43                 $this->encoding = strtolower(preg_replace('|[^a-z0-9-_]|i', '', _CHARSET));
44                 if ($this->encoding != 'utf-8') {
45                         $text = mb_convert_encoding($text, "UTF-8", $this->encoding);
46                 }
47                 $text = str_replace ("\xE3\x80\x80",' ',$text);
48                 $text = preg_replace ("/[<>=?!#^()[\]:;\\%]/","",$text);
49
50                 $this->ascii = '[\x00-\x7F]';
51                 $this->two = '[\xC0-\xDF][\x80-\xBF]';
52                 $this->three = '[\xE0-\xEF][\x80-\xBF][\x80-\xBF]';
53
54                 $this->jpmarked      = $this->boolean_mark_atoms_jp($text);
55                 /* * * * * * * * * * * * * * * * */
56
57                 $this->querystring      = $text;
58 //              $this->marked           = $this->boolean_mark_atoms($text);
59                 $this->inclusive        = $this->boolean_inclusive_atoms($text);
60                 $this->blogs            = array();
61
62                 // get all public searchable blogs, no matter what, include the current blog allways.
63                 $res = sql_query('SELECT bnumber FROM '.sql_table('blog').' WHERE bincludesearch=1 ');
64                 while ($obj = sql_fetch_object($res)) 
65                         $this->blogs[] = intval($obj->bnumber);
66                 }
67
68         function  boolean_sql_select($match){
69                 if (strlen($this->inclusive) > 0) {
70                         /* build sql for determining score for each record */
71                         $result=explode(" ",$this->inclusive);
72                         for($cth=0;$cth<count($result);$cth++){
73                                 if(strlen($result[$cth])>=4){
74                                         $stringsum_long .=  " $result[$cth] ";
75                                 }else{
76                                         $stringsum_a[] = ' '.$this->boolean_sql_select_short($result[$cth],$match).' ';
77                                 }
78                         }
79
80                         if(strlen($stringsum_long)>0){
81                                 $stringsum_long = addslashes($stringsum_long);
82                                 $stringsum_a[] = " match ($match) against ('$stringsum_long') ";
83                         }
84
85                         $stringsum .= implode("+",$stringsum_a);
86
87                         return $stringsum;
88                 }
89         }
90
91         
92
93         function boolean_inclusive_atoms($string){
94                 $result=trim($string);
95                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
96
97                 /* convert normal boolean operators to shortened syntax */
98                 $result=eregi_replace(' not ',' -',$result);
99                 $result=eregi_replace(' and ',' ',$result);
100                 $result=eregi_replace(' or ',',',$result);
101
102                 /* drop unnecessary spaces */
103                 $result=str_replace(' ,',',',$result);
104                 $result=str_replace(', ',',',$result);
105                 $result=str_replace('- ','-',$result);
106                 $result=str_replace('+','',$result);
107
108                 /* strip exlusive atoms */
109                 $result=preg_replace(
110 //                      "(\-\([A-Za-z0-9]{1,}[A-Za-z0-9\-\.\_\,]{0,}\))",
111                         "(\-\(([A-Za-z0-9]|$this->two|$this->three){1,}([A-Za-z0-9\-\.\_\,]|$this->two|$this->three){0,}\))",
112                         '',
113                         $result);
114
115 /*              $result=preg_replace(
116 //                      "(\-[A-Za-z0-9]{1,}[A-Za-z0-9\-\.\_]{0,})",
117                         "(\-([A-Za-z0-9]|$this->two|$this->three){1,}([A-Za-z0-9\-\.\_\,]|$this->two|$this->three){0,})",
118                         '',
119                         $result);
120 */
121                 $result=str_replace('(',' ',$result);
122                 $result=str_replace(')',' ',$result);
123                 $result=str_replace(',',' ',$result);
124                 if ($this->encoding != 'utf-8') {
125                         $result = mb_convert_encoding($result, $this->encoding, "UTF-8");
126                 }
127                 return $result;
128         }
129
130         function boolean_sql_where($match){
131 /*
132                 $result = $this->marked;
133                 $result = preg_replace(
134                         "/foo\[\(\'([^\)]{4,})\'\)\]bar/e",
135                         " 'match ('.\$match.') against (\''.\$this->copyvalue(\"$1\").'\') > 0 ' ",
136
137
138
139
140
141
142                         $result);
143
144                 $result = preg_replace(
145                         "/foo\[\(\'([^\)]{1,3})\'\)\]bar/e",
146                         " '('.\$this->boolean_sql_where_short(\"$1\",\"$match\").')' ",
147
148
149
150
151
152                         $result);
153 */
154                 $result = $this->jpmarked; /* for jp */
155                 $result = $this->boolean_sql_where_jp_short($result,$match);/* for jp */
156                 if ($this->encoding != 'utf-8') {
157                         $result = mb_convert_encoding($result, $this->encoding, "UTF-8");
158                 }
159                 return $result;
160
161         }
162
163
164
165         // there must be a simple way to simply copy a value with backslashes in it through
166         // the preg_replace, but I cannot currently find it (karma 2003-12-30)
167         function copyvalue($foo) {
168                 return $foo;
169
170
171         }
172
173
174
175 /*
176
177
178
179
180
181
182
183         function boolean_mark_atoms($string){
184                 $result=trim($string);
185                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
186
187                 // convert normal boolean operators to shortened syntax
188                 $result=eregi_replace(' not ',' -',$result);
189                 $result=eregi_replace(' and ',' ',$result);
190                 $result=eregi_replace(' or ',',',$result);
191
192
193                 // strip excessive whitespace
194                 $result=str_replace('( ','(',$result);
195                 $result=str_replace(' )',')',$result);
196                 $result=str_replace(', ',',',$result);
197                 $result=str_replace(' ,',',',$result);
198                 $result=str_replace('- ','-',$result);
199                 $result=str_replace('+','',$result);
200
201                 // remove double spaces (we might have introduced some new ones above)
202                 $result=trim($result);
203                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
204
205                 // apply arbitrary function to all 'word' atoms
206
207                 $result_a = explode(" ",$result);
208                 for($word=0;$word<count($result_a);$word++){
209                         $result_a[$word] = "foo[('".$result_a[$word]."')]bar";
210                 }
211                 $result = implode(" ",$result_a);
212
213                 // dispatch ' ' to ' AND '
214                 $result=str_replace(' ',' AND ',$result);
215
216                 // dispatch ',' to ' OR '
217                 $result=str_replace(',',' OR ',$result);
218
219                 // dispatch '-' to ' NOT '
220                 $result=str_replace(' -',' NOT ',$result);
221                 return $result;
222         }
223
224         function boolean_sql_where_short($string,$match){
225                 $match_a = explode(',',$match);
226                 for($ith=0;$ith<count($match_a);$ith++){
227                         $like_a[$ith] = " $match_a[$ith] LIKE '% $string %' ";
228                 }
229                 $like = implode(" OR ",$like_a);
230
231                 return $like;
232         }
233 */
234
235         function boolean_sql_select_short($string,$match){
236                 $match_a = explode(',',$match);
237                 $score_unit_weight = .2;
238                 for($ith=0;$ith<count($match_a);$ith++){
239                         $score_a[$ith] =
240                                                         " $score_unit_weight*(
241                                                         LENGTH(" . addslashes($match_a[$ith]) . ") -
242                                                         LENGTH(REPLACE(LOWER(" . addslashes($match_a[$ith]) . "),LOWER('" . addslashes($string) . "'),'')))
243                                                         /LENGTH('" . addslashes($string) . "') ";
244                 }
245                 $score = implode(" + ",$score_a);
246
247                 return $score;
248         }
249
250 /***********************************************
251         Make "WHERE" (jp)
252 ***********************************************/
253
254         function boolean_mark_atoms_jp($string){
255
256                 $result=trim($string);
257                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
258                 
259                 /* convert normal boolean operators to shortened syntax */
260                 $result=eregi_replace(' not ',' -',$result);
261                 $result=eregi_replace(' and ',' ',$result);
262                 $result=eregi_replace(' or ',',',$result);
263
264                 /* strip excessive whitespace */
265                 $result=str_replace(', ',',',$result);
266                 $result=str_replace(' ,',',',$result);
267                 $result=str_replace('- ','-',$result);
268                 $result=str_replace('+','',$result);
269                 
270                 $result=str_replace(',',' ,',$result);
271
272                 return $result;
273         }
274
275         function boolean_sql_where_jp_short($string,$match){
276                 $match_a = explode(',',$match);
277                         $key_a = explode(' ',$string);
278                         
279                 for($ith=0;$ith<count($match_a);$ith++){
280 //                      $temp_a[$ith] = "(i.$match_a[$ith] LIKE '%" . addslashes($key_a[0]) . "%') ";
281                         $temp_a[$ith] = "(i.$match_a[$ith] LIKE "
282                                                         . preg_match('/[a-zA-Z]/', $key_a[0]) ?
283                                                                 '' :
284                                                                 'BINARY'
285                                                         . " '%" . addslashes($key_a[0]) . "%') ";
286                 }
287                 $like = '('.implode(' or ',$temp_a).')';
288
289                 for($kn=1; $kn<count($key_a); $kn++){
290                         if(substr($key_a[$kn],0,1) == ","){
291                                 for($ith=0;$ith<count($match_a);$ith++){
292 //                                      $temp_a[$ith] = " (i.$match_a[$ith] LIKE '%" . addslashes(substr($key_a[$kn],1)) . "%') ";
293                                         $temp_a[$ith] = " (i.$match_a[$ith] LIKE "
294                                                                         . preg_match('/[a-zA-Z]/',$key_a[$kn]) ?
295                                                                                 '' :
296                                                                                 'BINARY'
297                                                                         . " '%" . addslashes(substr($key_a[$kn],1)) . "%') ";
298                                 }
299                                 $like .=' OR ('. implode(' or ',$temp_a).')';
300                         }elseif(substr($key_a[$kn],0,1) != '-'){
301                                 for($ith=0;$ith<count($match_a);$ith++){
302 //                                      $temp_a[$ith] = " (i.$match_a[$ith] LIKE '%" . addslashes($key_a[$kn]) . "%') ";
303                                         $temp_a[$ith] = " (i.$match_a[$ith] LIKE "
304                                                                   . preg_match('/[a-zA-Z]/', $key_a[$kn]) ?
305                                                                                 '' :
306                                                                                 'BINARY'
307                                                                   . " '%" . addslashes($key_a[$kn]) . "%') ";
308                                 }
309                                 $like .=' AND ('. implode(' or ',$temp_a).')';
310                         }else{
311                                 for($ith=0;$ith<count($match_a);$ith++){
312 //                                      $temp_a[$ith] = " NOT(i.$match_a[$ith] LIKE '%" . addslashes(substr($key_a[$kn],1)) . "%') ";
313                                         $temp_a[$ith] = " NOT(i.$match_a[$ith] LIKE "
314                                                                   . preg_match('/[a-zA-Z]/', $key_a[$kn]) ?
315                                                                                 '' :
316                                                                                 'BINARY'
317                                                                   . " '%" . addslashes(substr($key_a[$kn],1)) . "%') ";
318                                 }
319                                 $like .=' AND ('. implode(' and ',$temp_a).')';
320                         }
321                 }
322                 
323                 $like = '('.$like.')';
324                 return $like;
325         }
326
327 /***********************************************/
328 }
329 ?>