OSDN Git Service

Add some codes from 3.61. Currently files under /nucleus/libs and /nucleus/libs/sql...
[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-2010 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 class SEARCH {
28
29         var $querystring;
30         var $marked;
31         var $inclusive;
32         var $blogs;
33
34         function SEARCH($text) {
35                 global $blogid;
36 //              $text = preg_replace ("/[<,>,=,?,!,#,^,(,),[,\],:,;,\\\,%]/","",$text);
37                 /* * * for jp * * * * * * * * * * */
38                 $this->encoding = strtolower(preg_replace('|[^a-z0-9-_]|i', '', _CHARSET));
39                 if ($this->encoding != 'utf-8') {
40                         $text = mb_convert_encoding($text, "UTF-8", $this->encoding);
41                 }
42                 $text = str_replace ("\xE3\x80\x80",' ',$text);
43                 $text = preg_replace ("/[<>=?!#^()[\]:;\\%]/","",$text);
44
45                 $this->ascii       = '[\x00-\x7F]';
46                 $this->two               = '[\xC0-\xDF][\x80-\xBF]';
47                 $this->three       = '[\xE0-\xEF][\x80-\xBF][\x80-\xBF]';
48
49                 $this->jpmarked = $this->boolean_mark_atoms_jp($text);
50                 /* * * * * * * * * * * * * * * * */
51
52                 $this->querystring = $text;
53 //              $this->marked     = $this->boolean_mark_atoms($text);
54                 $this->inclusive   = $this->boolean_inclusive_atoms($text);
55                 $this->blogs       = array();
56
57                 // get all public searchable blogs, no matter what, include the current blog allways.
58                 $res = sql_query('SELECT bnumber FROM ' . sql_table('blog') . ' WHERE bincludesearch=1 ');
59                 while ($obj = sql_fetch_object($res)) {
60                         $this->blogs[] = intval($obj->bnumber);
61                 }
62         }
63
64         function  boolean_sql_select($match) {
65                 if (!isset($stringsum)) {
66                         $stringsum = '';
67                 }
68                 if (strlen($this->inclusive) > 0) {
69                         /* build sql for determining score for each record */
70                         $result=explode(" ",$this->inclusive);
71                         if (!isset($stringsum_long)) {
72                                 $stringsum_long = '';
73                         }
74                         for ($cth = 0; $cth < count($result); $cth++) {
75                                 if (strlen($result[$cth])>=4) {
76                                         $stringsum_long .=  " $result[$cth] ";
77                                 } else {
78                                         $stringsum_a[] = ' ' . $this->boolean_sql_select_short($result[$cth], $match) . ' ';
79                                 }
80                         }
81
82                         if (strlen($stringsum_long) > 0) {
83                                 $stringsum_long = sql_real_escape_string($stringsum_long);
84                                 $stringsum_a[]  = " match ($match) against ('$stringsum_long') ";
85                         }
86
87                         $stringsum .= implode("+", $stringsum_a);
88
89                         return $stringsum;
90                 }
91         }
92
93         
94
95         function boolean_inclusive_atoms($string) {
96                 $result = trim($string);
97                 $result = preg_replace("/([[:space:]]{2,})/", ' ', $result);
98                 
99                 # replaced eregi_replace() below with preg_replace(). ereg* functions are deprecated in PHP 5.3.0
100                 # just added delimiters to regex and the 'i' for case-insensitive matching
101                 
102                 /* convert normal boolean operators to shortened syntax */
103                 $result = preg_replace('# not #i', ' -', $result);
104                 $result = preg_replace('# and #i', ' ', $result);
105                 $result = preg_replace('# or #i', ',', $result);
106                 
107                 /* drop unnecessary spaces */
108                 $result = str_replace(' ,', ',', $result);
109                 $result = str_replace(', ', ',', $result);
110                 $result = str_replace('- ', '-', $result);
111                 $result = str_replace('+', '', $result);
112                 
113                 /* strip exlusive atoms */
114                 $result = preg_replace(
115                         "(\-\(([A-Za-z0-9]|$this->two|$this->three){1,}([A-Za-z0-9\-\.\_\,]|$this->two|$this->three){0,}\))",
116                         '',
117                         $result);
118                 
119                 $result = str_replace('(', ' ', $result);
120                 $result = str_replace(')', ' ', $result);
121                 $result = str_replace(',', ' ', $result);
122                 if ($this->encoding != 'utf-8') {
123                         $result = mb_convert_encoding($result, $this->encoding, "UTF-8");
124                 }
125                 return $result;
126         }
127
128         function boolean_sql_where($match) {
129 /*
130                 $result = $this->marked;
131                 $result = preg_replace(
132                         "/foo\[\(\'([^\)]{4,})\'\)\]bar/e",
133                         " 'match ('.\$match.') against (\''.\$this->copyvalue(\"$1\").'\') > 0 ' ",
134                         $result);
135                 $result = preg_replace(
136                         "/foo\[\(\'([^\)]{1,3})\'\)\]bar/e",
137                         " '('.\$this->boolean_sql_where_short(\"$1\",\"$match\").')' ",
138                         $result);
139 */
140                 $result = $this->jpmarked; /* for jp */
141                 $result = $this->boolean_sql_where_jp_short($result, $match);/* for jp */
142                 if ($this->encoding != 'utf-8') {
143                         $result = mb_convert_encoding($result, $this->encoding, "UTF-8");
144                 }
145                 return $result;
146         }
147
148         // there must be a simple way to simply copy a value with backslashes in it through
149         // the preg_replace, but I cannot currently find it (karma 2003-12-30)
150         function copyvalue($foo) {
151                 return $foo;
152         }
153 /*
154         function boolean_mark_atoms($string){
155                 $result=trim($string);
156                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
157
158                 // convert normal boolean operators to shortened syntax
159                 $result=eregi_replace(' not ',' -',$result);
160                 $result=eregi_replace(' and ',' ',$result);
161                 $result=eregi_replace(' or ',',',$result);
162
163                 // strip excessive whitespace
164                 $result=str_replace('( ','(',$result);
165                 $result=str_replace(' )',')',$result);
166                 $result=str_replace(', ',',',$result);
167                 $result=str_replace(' ,',',',$result);
168                 $result=str_replace('- ','-',$result);
169                 $result=str_replace('+','',$result);
170
171                 // remove double spaces (we might have introduced some new ones above)
172                 $result=trim($result);
173                 $result=preg_replace("/([[:space:]]{2,})/",' ',$result);
174
175                 // apply arbitrary function to all 'word' atoms
176
177                 $result_a = explode(" ",$result);
178                 for($word=0;$word<count($result_a);$word++){
179                         $result_a[$word] = "foo[('".$result_a[$word]."')]bar";
180                 }
181                 $result = implode(" ",$result_a);
182
183                 // dispatch ' ' to ' AND '
184                 $result=str_replace(' ',' AND ',$result);
185
186                 // dispatch ',' to ' OR '
187                 $result=str_replace(',',' OR ',$result);
188
189                 // dispatch '-' to ' NOT '
190                 $result=str_replace(' -',' NOT ',$result);
191                 return $result;
192         }
193
194         function boolean_sql_where_short($string,$match){
195                 $match_a = explode(',',$match);
196                 for($ith=0;$ith<count($match_a);$ith++){
197                         $like_a[$ith] = " $match_a[$ith] LIKE '% $string %' ";
198                 }
199                 $like = implode(" OR ",$like_a);
200
201                 return $like;
202         }
203 */
204
205         function boolean_sql_select_short($string, $match) {
206                 $match_a                   = explode(',', $match);
207                 $score_unit_weight = .2;
208                 for ($ith = 0; $ith< count($match_a); $ith++){
209                         $score_a[$ith] =
210                                                         " $score_unit_weight*(
211                                                         LENGTH(" . sql_real_escape_string($match_a[$ith]) . ") -
212                                                         LENGTH(REPLACE(LOWER(" . sql_real_escape_string($match_a[$ith]) . "),LOWER('" . sql_real_escape_string($string) . "'),'')))
213                                                         /LENGTH('" . sql_real_escape_string($string) . "') ";
214                 }
215                 $score = implode(" + ", $score_a);
216
217                 return $score;
218         }
219
220 /***********************************************
221         Make "WHERE" (jp)
222 ***********************************************/
223
224         function boolean_mark_atoms_jp($string) {
225                 $result = trim($string);
226                 $result = preg_replace("/([[:space:]]{2,})/", ' ', $result);
227                 
228                 /* convert normal boolean operators to shortened syntax */
229                 $result = eregi_replace(' not ', ' -', $result);
230                 $result = eregi_replace(' and ', ' ',  $result);
231                 $result = eregi_replace(' or ',  ',',  $result);
232
233                 /* strip excessive whitespace */
234                 $result = str_replace(', ', ',',  $result);
235                 $result = str_replace(' ,', ',',  $result);
236                 $result = str_replace('- ', '-',  $result);
237                 $result = str_replace('+',  '',   $result);
238                 $result = str_replace(',',  ' ,', $result);
239
240                 return $result;
241         }
242
243         function boolean_sql_where_jp_short($string, $match) {
244                 $match_a = explode(',', $match);
245                 $key_a   = explode(' ', $string);
246
247                 for ($ith=0; $ith<count($match_a); $ith++) {
248 //                      $temp_a[$ith] = "(i.$match_a[$ith] LIKE '%" . sql_real_escape_string($key_a[0]) . "%') ";
249                         $binKey    = preg_match('/[a-zA-Z]/', $key_a[0]) ? '' : 'BINARY';
250                         $temp_a[$ith] = "(i.$match_a[$ith] LIKE " . $binKey . " '%" . sql_real_escape_string($key_a[0]) . "%') ";
251                 }
252                 $like = '('.implode(' or ',$temp_a).')';
253
254                 for ($kn = 1; $kn < count($key_a); $kn++) {
255                         $binKey    = preg_match('/[a-zA-Z]/', $key_a[$kn]) ? '' : 'BINARY';
256                         if (substr($key_a[$kn], 0, 1) == ",") {
257                                 for($ith = 0; $ith < count($match_a); $ith++) {
258 //                                      $temp_a[$ith] = " (i.$match_a[$ith] LIKE '%" . sql_real_escape_string(substr($key_a[$kn],1)) . "%') ";
259                                         $temp_a[$ith] = " (i.$match_a[$ith] LIKE " . $binKey . " '%" . sql_real_escape_string(substr($key_a[$kn], 1)) . "%') ";
260                                 }
261                                 $like .=' OR ('. implode(' or ', $temp_a).')';
262                         }elseif(substr($key_a[$kn],0,1) != '-'){
263                                 for($ith=0;$ith<count($match_a);$ith++){
264 //                                      $temp_a[$ith] = " (i.$match_a[$ith] LIKE '%" . sql_real_escape_string($key_a[$kn]) . "%') ";
265                                         $temp_a[$ith] = " (i.$match_a[$ith] LIKE " . $binKey . " '%" . sql_real_escape_string($key_a[$kn]) . "%') ";
266                                 }
267                                 $like .=' AND ('. implode(' or ', $temp_a).')';
268                         }else{
269                                 for($ith=0;$ith<count($match_a);$ith++){
270 //                                      $temp_a[$ith] = " NOT(i.$match_a[$ith] LIKE '%" . sql_real_escape_string(substr($key_a[$kn],1)) . "%') ";
271                                         $temp_a[$ith] = " NOT(i.$match_a[$ith] LIKE " . $binKey . " '%" . sql_real_escape_string(substr($key_a[$kn], 1)) . "%') ";
272                                 }
273                                 $like .=' AND ('. implode(' and ', $temp_a).')';
274                         }
275                 }
276                 
277                 $like = '('.$like.')';
278                 return $like;
279         }
280 }
281 ?>