← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/php/phpBB3/includes/search/search.php

  • Committer: William Grant
  • Date: 2009-02-23 23:47:02 UTC
  • mfrom: (1099.1.211 new-dispatch)
  • Revision ID: grantw@unimelb.edu.au-20090223234702-db4b1llly46ignwo
Merge from lp:~ivle-dev/ivle/new-dispatch.

Pretty much everything changes. Reread the setup docs. Backup your databases.
Every file is now in a different installed location, the configuration system
is rewritten, the dispatch system is rewritten, URLs are different, the
database is different, worksheets and exercises are no longer on the
filesystem, we use a templating engine, jail service protocols are rewritten,
we don't repeat ourselves, we have authorization rewritten, phpBB is gone,
and probably lots of other things that I cannot remember.

This is certainly the biggest commit I have ever made, and hopefully
the largest I ever will.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/php/phpBB3/includes/search/search.php
1
 
<?php
2
 
/**
3
 
*
4
 
* @package search
5
 
* @version $Id: search.php,v 1.16 2007/10/05 14:36:33 acydburn Exp $
6
 
* @copyright (c) 2005 phpBB Group
7
 
* @license http://opensource.org/licenses/gpl-license.php GNU Public License
8
 
*
9
 
*/
10
 
 
11
 
/**
12
 
* @ignore
13
 
*/
14
 
if (!defined('IN_PHPBB'))
15
 
{
16
 
        exit;
17
 
}
18
 
 
19
 
/**
20
 
* @ignore
21
 
*/
22
 
define('SEARCH_RESULT_NOT_IN_CACHE', 0);
23
 
define('SEARCH_RESULT_IN_CACHE', 1);
24
 
define('SEARCH_RESULT_INCOMPLETE', 2);
25
 
 
26
 
/**
27
 
* search_backend
28
 
* optional base class for search plugins providing simple caching based on ACM
29
 
* and functions to retrieve ignore_words and synonyms
30
 
* @package search
31
 
*/
32
 
class search_backend
33
 
{
34
 
        var $ignore_words = array();
35
 
        var $match_synonym = array();
36
 
        var $replace_synonym = array();
37
 
 
38
 
        function search_backend(&$error)
39
 
        {
40
 
                // This class cannot be used as a search plugin
41
 
                $error = true;
42
 
        }
43
 
 
44
 
        /**
45
 
        * Retrieves a language dependend list of words that should be ignored by the search
46
 
        */
47
 
        function get_ignore_words()
48
 
        {
49
 
                if (!sizeof($this->ignore_words))
50
 
                {
51
 
                        global $user, $phpEx;
52
 
 
53
 
                        $words = array();
54
 
 
55
 
                        if (file_exists("{$user->lang_path}/search_ignore_words.$phpEx"))
56
 
                        {
57
 
                                // include the file containing ignore words
58
 
                                include("{$user->lang_path}/search_ignore_words.$phpEx");
59
 
                        }
60
 
 
61
 
                        $this->ignore_words = $words;
62
 
                        unset($words);
63
 
                }
64
 
        }
65
 
 
66
 
        /**
67
 
        * Stores a list of synonyms that should be replaced in $this->match_synonym and $this->replace_synonym and caches them
68
 
        */
69
 
        function get_synonyms()
70
 
        {
71
 
                if (!sizeof($this->match_synonym))
72
 
                {
73
 
                        global $user, $phpEx;
74
 
 
75
 
                        $synonyms = array();
76
 
 
77
 
                        if (file_exists("{$user->lang_path}/search_synonyms.$phpEx"))
78
 
                        {
79
 
                                // include the file containing synonyms
80
 
                                include("{$user->lang_path}/search_synonyms.$phpEx");
81
 
                        }
82
 
 
83
 
                        $this->match_synonym = array_keys($synonyms);
84
 
                        $this->replace_synonym = array_values($synonyms);
85
 
 
86
 
                        unset($synonyms);
87
 
                }
88
 
        }
89
 
 
90
 
        /**
91
 
        * Retrieves cached search results
92
 
        *
93
 
        * @param int &$result_count will contain the number of all results for the search (not only for the current page)
94
 
        * @param array &$id_ary is filled with the ids belonging to the requested page that are stored in the cache
95
 
        *
96
 
        * @return int SEARCH_RESULT_NOT_IN_CACHE or SEARCH_RESULT_IN_CACHE or SEARCH_RESULT_INCOMPLETE
97
 
        */
98
 
        function obtain_ids($search_key, &$result_count, &$id_ary, $start, $per_page, $sort_dir)
99
 
        {
100
 
                global $cache;
101
 
 
102
 
                if (!($stored_ids = $cache->get('_search_results_' . $search_key)))
103
 
                {
104
 
                        // no search results cached for this search_key
105
 
                        return SEARCH_RESULT_NOT_IN_CACHE;
106
 
                }
107
 
                else
108
 
                {
109
 
                        $result_count = $stored_ids[-1];
110
 
                        $reverse_ids = ($stored_ids[-2] != $sort_dir) ? true : false;
111
 
                        $complete = true;
112
 
 
113
 
                        // change the start to the actual end of the current request if the sort direction differs
114
 
                        // from the dirction in the cache and reverse the ids later
115
 
                        if ($reverse_ids)
116
 
                        {
117
 
                                $start = $result_count - $start - $per_page;
118
 
 
119
 
                                // the user requested a page past the last index
120
 
                                if ($start < 0)
121
 
                                {
122
 
                                        return SEARCH_RESULT_NOT_IN_CACHE;
123
 
                                }
124
 
                        }
125
 
 
126
 
                        for ($i = $start, $n = $start + $per_page; ($i < $n) && ($i < $result_count); $i++)
127
 
                        {
128
 
                                if (!isset($stored_ids[$i]))
129
 
                                {
130
 
                                        $complete = false;
131
 
                                }
132
 
                                else
133
 
                                {
134
 
                                        $id_ary[] = $stored_ids[$i];
135
 
                                }
136
 
                        }
137
 
                        unset($stored_ids);
138
 
 
139
 
                        if ($reverse_ids)
140
 
                        {
141
 
                                $id_ary = array_reverse($id_ary);
142
 
                        }
143
 
 
144
 
                        if (!$complete)
145
 
                        {
146
 
                                return SEARCH_RESULT_INCOMPLETE;
147
 
                        }
148
 
                        return SEARCH_RESULT_IN_CACHE;
149
 
                }
150
 
        }
151
 
 
152
 
        /**
153
 
        * Caches post/topic ids
154
 
        *
155
 
        * @param array &$id_ary contains a list of post or topic ids that shall be cached, the first element
156
 
        *       must have the absolute index $start in the result set.
157
 
        */
158
 
        function save_ids($search_key, $keywords, $author_ary, $result_count, &$id_ary, $start, $sort_dir)
159
 
        {
160
 
                global $cache, $config, $db, $user;
161
 
 
162
 
                $length = min(sizeof($id_ary), $config['search_block_size']);
163
 
 
164
 
                // nothing to cache so exit
165
 
                if (!$length)
166
 
                {
167
 
                        return;
168
 
                }
169
 
 
170
 
                $store_ids = array_slice($id_ary, 0, $length);
171
 
 
172
 
                // create a new resultset if there is none for this search_key yet
173
 
                // or add the ids to the existing resultset
174
 
                if (!($store = $cache->get('_search_results_' . $search_key)))
175
 
                {
176
 
                        // add the current keywords to the recent searches in the cache which are listed on the search page
177
 
                        if (!empty($keywords) || sizeof($author_ary))
178
 
                        {
179
 
                                $sql = 'SELECT search_time
180
 
                                        FROM ' . SEARCH_RESULTS_TABLE . '
181
 
                                        WHERE search_key = \'' . $db->sql_escape($search_key) . '\'';
182
 
                                $result = $db->sql_query($sql);
183
 
 
184
 
                                if (!$db->sql_fetchrow($result))
185
 
                                {
186
 
                                        $sql_ary = array(
187
 
                                                'search_key'            => $search_key,
188
 
                                                'search_time'           => time(),
189
 
                                                'search_keywords'       => $keywords,
190
 
                                                'search_authors'        => ' ' . implode(' ', $author_ary) . ' '
191
 
                                        );
192
 
 
193
 
                                        $sql = 'INSERT INTO ' . SEARCH_RESULTS_TABLE . ' ' . $db->sql_build_array('INSERT', $sql_ary);
194
 
                                        $db->sql_query($sql);
195
 
                                }
196
 
                                $db->sql_freeresult($result);
197
 
                        }
198
 
 
199
 
                        $sql = 'UPDATE ' . USERS_TABLE . '
200
 
                                SET user_last_search = ' . time() . '
201
 
                                WHERE user_id = ' . $user->data['user_id'];
202
 
                        $db->sql_query($sql);
203
 
 
204
 
                        $store = array(-1 => $result_count, -2 => $sort_dir);
205
 
                        $id_range = range($start, $start + $length - 1);
206
 
                }
207
 
                else
208
 
                {
209
 
                        // we use one set of results for both sort directions so we have to calculate the indizes
210
 
                        // for the reversed array and we also have to reverse the ids themselves
211
 
                        if ($store[-2] != $sort_dir)
212
 
                        {
213
 
                                $store_ids = array_reverse($store_ids);
214
 
                                $id_range = range($store[-1] - $start - $length, $store[-1] - $start - 1);
215
 
                        }
216
 
                        else
217
 
                        {
218
 
                                $id_range = range($start, $start + $length - 1);
219
 
                        }
220
 
                }
221
 
 
222
 
                $store_ids = array_combine($id_range, $store_ids);
223
 
 
224
 
                // append the ids
225
 
                if (is_array($store_ids))
226
 
                {
227
 
                        $store += $store_ids;
228
 
 
229
 
                        // if the cache is too big
230
 
                        if (sizeof($store) - 2 > 20 * $config['search_block_size'])
231
 
                        {
232
 
                                // remove everything in front of two blocks in front of the current start index
233
 
                                for ($i = 0, $n = $id_range[0] - 2 * $config['search_block_size']; $i < $n; $i++)
234
 
                                {
235
 
                                        if (isset($store[$i]))
236
 
                                        {
237
 
                                                unset($store[$i]);
238
 
                                        }
239
 
                                }
240
 
 
241
 
                                // remove everything after two blocks after the current stop index
242
 
                                end($id_range);
243
 
                                for ($i = $store[-1] - 1, $n = current($id_range) + 2 * $config['search_block_size']; $i > $n; $i--)
244
 
                                {
245
 
                                        if (isset($store[$i]))
246
 
                                        {
247
 
                                                unset($store[$i]);
248
 
                                        }
249
 
                                }
250
 
                        }
251
 
                        $cache->put('_search_results_' . $search_key, $store, $config['search_store_results']);
252
 
 
253
 
                        $sql = 'UPDATE ' . SEARCH_RESULTS_TABLE . '
254
 
                                SET search_time = ' . time() . '
255
 
                                WHERE search_key = \'' . $db->sql_escape($search_key) . '\'';
256
 
                        $db->sql_query($sql);
257
 
                }
258
 
 
259
 
                unset($store);
260
 
                unset($store_ids);
261
 
                unset($id_range);
262
 
        }
263
 
 
264
 
        /**
265
 
        * Removes old entries from the search results table and removes searches with keywords that contain a word in $words.
266
 
        */
267
 
        function destroy_cache($words, $authors = false)
268
 
        {
269
 
                global $db, $cache, $config;
270
 
 
271
 
                // clear all searches that searched for the specified words
272
 
                if (sizeof($words))
273
 
                {
274
 
                        $sql_where = '';
275
 
                        foreach ($words as $word)
276
 
                        {
277
 
                                $sql_where .= " OR search_keywords " . $db->sql_like_expression($db->any_char . $word . $db->any_char);
278
 
                        }
279
 
 
280
 
                        $sql = 'SELECT search_key
281
 
                                FROM ' . SEARCH_RESULTS_TABLE . "
282
 
                                WHERE search_keywords LIKE '%*%' $sql_where";
283
 
                        $result = $db->sql_query($sql);
284
 
 
285
 
                        while ($row = $db->sql_fetchrow($result))
286
 
                        {
287
 
                                $cache->destroy('_search_results_' . $row['search_key']);
288
 
                        }
289
 
                        $db->sql_freeresult($result);
290
 
                }
291
 
 
292
 
                // clear all searches that searched for the specified authors
293
 
                if (is_array($authors) && sizeof($authors))
294
 
                {
295
 
                        $sql_where = '';
296
 
                        foreach ($authors as $author)
297
 
                        {
298
 
                                $sql_where .= (($sql_where) ? ' OR ' : '') . 'search_authors LIKE \'% ' . (int) $author . ' %\'';
299
 
                        }
300
 
 
301
 
                        $sql = 'SELECT search_key
302
 
                                FROM ' . SEARCH_RESULTS_TABLE . "
303
 
                                WHERE $sql_where";
304
 
                        $result = $db->sql_query($sql);
305
 
 
306
 
                        while ($row = $db->sql_fetchrow($result))
307
 
                        {
308
 
                                $cache->destroy('_search_results_' . $row['search_key']);
309
 
                        }
310
 
                        $db->sql_freeresult($result);
311
 
                }
312
 
 
313
 
                $sql = 'DELETE
314
 
                        FROM ' . SEARCH_RESULTS_TABLE . '
315
 
                        WHERE search_time < ' . (time() - $config['search_store_results']);
316
 
                $db->sql_query($sql);
317
 
        }
318
 
}
319
 
 
320
 
?>
 
 
b'\\ No newline at end of file'