]> git.openstreetmap.org Git - nominatim.git/blob - lib/TokenList.php
allow nginx to serve files without php extensions
[nominatim.git] / lib / TokenList.php
1 <?php
2
3 namespace Nominatim;
4
5 require_once(CONST_BasePath.'/lib/TokenCountry.php');
6 require_once(CONST_BasePath.'/lib/TokenHousenumber.php');
7 require_once(CONST_BasePath.'/lib/TokenPostcode.php');
8 require_once(CONST_BasePath.'/lib/TokenSpecialTerm.php');
9 require_once(CONST_BasePath.'/lib/TokenWord.php');
10 require_once(CONST_BasePath.'/lib/SpecialSearchOperator.php');
11
12 /**
13  * Saves information about the tokens that appear in a search query.
14  *
15  * Tokens are sorted by their normalized form, the token word. There are different
16  * kinds of tokens, represented by different Token* classes. Note that
17  * tokens do not have a common base class. All tokens need to have a field
18  * with the word id that points to an entry in the `word` database table
19  * but otherwise the information saved about a token can be very different.
20  *
21  * There are two different kinds of token words: full words and partial terms.
22  *
23  * Full words start with a space. They represent a complete name of a place.
24  * All special tokens are normally full words.
25  *
26  * Partial terms have no space at the beginning. They may represent a part of
27  * a name of a place (e.g. in the name 'World Trade Center' a partial term
28  * would be 'Trade' or 'Trade Center'). They are only used in TokenWord.
29  */
30 class TokenList
31 {
32     // List of list of tokens indexed by their word_token.
33     private $aTokens = array();
34
35
36     /**
37      * Return total number of tokens.
38      *
39      * @return Integer
40      */
41     public function count()
42     {
43         return count($this->aTokens);
44     }
45
46     /**
47      * Check if there are tokens for the given token word.
48      *
49      * @param string $sWord Token word to look for.
50      *
51      * @return bool True if there is one or more token for the token word.
52      */
53     public function contains($sWord)
54     {
55         return isset($this->aTokens[$sWord]);
56     }
57
58     /**
59      * Get the list of tokens for the given token word.
60      *
61      * @param string $sWord Token word to look for.
62      *
63      * @return object[] Array of tokens for the given token word or an
64      *                  empty array if no tokens could be found.
65      */
66     public function get($sWord)
67     {
68         return isset($this->aTokens[$sWord]) ? $this->aTokens[$sWord] : array();
69     }
70
71     /**
72      * Add token information from the word table in the database.
73      *
74      * @param object   $oDB           Database connection.
75      * @param string[] $aTokens       List of tokens to look up in the database.
76      * @param string[] $aCountryCodes List of country restrictions.
77      * @param string   $sNormQuery    Normalized query string.
78      * @param object   $oNormalizer   Normalizer function to use on tokens.
79      *
80      * @return void
81      */
82     public function addTokensFromDB(&$oDB, &$aTokens, &$aCountryCodes, $sNormQuery, $oNormalizer)
83     {
84         // Check which tokens we have, get the ID numbers
85         $sSQL = 'SELECT word_id, word_token, word, class, type, country_code,';
86         $sSQL .= ' operator, coalesce(search_name_count, 0) as count';
87         $sSQL .= ' FROM word WHERE word_token in (';
88         $sSQL .= join(',', array_map('getDBQuoted', $aTokens)).')';
89
90         Debug::printSQL($sSQL);
91
92         $aDBWords = chksql($oDB->getAll($sSQL), 'Could not get word tokens.');
93
94         foreach ($aDBWords as $aWord) {
95             $oToken = null;
96             $iId = (int) $aWord['word_id'];
97
98             if ($aWord['class']) {
99                 // Special terms need to appear in their normalized form.
100                 if ($aWord['word']) {
101                     $sNormWord = $aWord['word'];
102                     if ($oNormalizer != null) {
103                         $sNormWord = $oNormalizer->transliterate($aWord['word']);
104                     }
105                     if (strpos($sNormQuery, $sNormWord) === false) {
106                         continue;
107                     }
108                 }
109
110                 if ($aWord['class'] == 'place' && $aWord['type'] == 'house') {
111                     $oToken = new Token\HouseNumber($iId, trim($aWord['word_token']));
112                 } elseif ($aWord['class'] == 'place' && $aWord['type'] == 'postcode') {
113                     if ($aWord['word']
114                         && pg_escape_string($aWord['word']) == $aWord['word']
115                     ) {
116                         $oToken = new Token\Postcode(
117                             $iId,
118                             $aWord['word'],
119                             $aWord['country_code']
120                         );
121                     }
122                 } else {
123                     // near and in operator the same at the moment
124                     $oToken = new Token\SpecialTerm(
125                         $iId,
126                         $aWord['class'],
127                         $aWord['type'],
128                         $aWord['operator'] ? Operator::NEAR : Operator::NONE
129                     );
130                 }
131             } elseif ($aWord['country_code']) {
132                 // Filter country tokens that do not match restricted countries.
133                 if (!$aCountryCodes
134                     || in_array($aWord['country_code'], $aCountryCodes)
135                 ) {
136                     $oToken = new Token\Country($iId, $aWord['country_code']);
137                 }
138             } else {
139                 $oToken = new Token\Word(
140                     $iId,
141                     $aWord['word_token'][0] != ' ',
142                     (int) $aWord['count']
143                 );
144             }
145
146             if ($oToken) {
147                 $this->addToken($aWord['word_token'], $oToken);
148             }
149         }
150     }
151
152     /**
153      * Add a new token for the given word.
154      *
155      * @param string $sWord  Word the token describes.
156      * @param object $oToken Token object to add.
157      *
158      * @return void
159      */
160     public function addToken($sWord, $oToken)
161     {
162         if (isset($this->aTokens[$sWord])) {
163             $this->aTokens[$sWord][] = $oToken;
164         } else {
165             $this->aTokens[$sWord] = array($oToken);
166         }
167     }
168
169     public function debugTokenByWordIdList()
170     {
171         $aWordsIDs = array();
172         foreach ($this->aTokens as $sToken => $aWords) {
173             foreach ($aWords as $aToken) {
174                 if ($aToken->iId !== null) {
175                     $aWordsIDs[$aToken->iId] =
176                         '#'.$sToken.'('.$aToken->iId.')#';
177                 }
178             }
179         }
180
181         return $aWordsIDs;
182     }
183
184     public function debugInfo()
185     {
186         return $this->aTokens;
187     }
188 }