]> git.openstreetmap.org Git - nominatim.git/blob - lib-sql/tokenizer/icu_tokenizer.sql
Merge remote-tracking branch 'upstream/master'
[nominatim.git] / lib-sql / tokenizer / icu_tokenizer.sql
1 -- SPDX-License-Identifier: GPL-2.0-only
2 --
3 -- This file is part of Nominatim. (https://nominatim.org)
4 --
5 -- Copyright (C) 2022 by the Nominatim developer community.
6 -- For a full list of authors see the git log.
7
8 -- Get tokens used for searching the given place.
9 --
10 -- These are the tokens that will be saved in the search_name table.
11 CREATE OR REPLACE FUNCTION token_get_name_search_tokens(info JSONB)
12   RETURNS INTEGER[]
13 AS $$
14   SELECT (info->>'names')::INTEGER[]
15 $$ LANGUAGE SQL IMMUTABLE STRICT;
16
17
18 -- Get tokens for matching the place name against others.
19 --
20 -- This should usually be restricted to full name tokens.
21 CREATE OR REPLACE FUNCTION token_get_name_match_tokens(info JSONB)
22   RETURNS INTEGER[]
23 AS $$
24   SELECT (info->>'names')::INTEGER[]
25 $$ LANGUAGE SQL IMMUTABLE STRICT;
26
27
28 -- Return the housenumber tokens applicable for the place.
29 CREATE OR REPLACE FUNCTION token_get_housenumber_search_tokens(info JSONB)
30   RETURNS INTEGER[]
31 AS $$
32   SELECT (info->>'hnr_tokens')::INTEGER[]
33 $$ LANGUAGE SQL IMMUTABLE STRICT;
34
35
36 -- Return the housenumber in the form that it can be matched during search.
37 CREATE OR REPLACE FUNCTION token_normalized_housenumber(info JSONB)
38   RETURNS TEXT
39 AS $$
40   SELECT info->>'hnr';
41 $$ LANGUAGE SQL IMMUTABLE STRICT;
42
43
44 CREATE OR REPLACE FUNCTION token_is_street_address(info JSONB)
45   RETURNS BOOLEAN
46 AS $$
47   SELECT info->>'street' is not null or info->>'place' is null;
48 $$ LANGUAGE SQL IMMUTABLE;
49
50
51 CREATE OR REPLACE FUNCTION token_has_addr_street(info JSONB)
52   RETURNS BOOLEAN
53 AS $$
54   SELECT info->>'street' is not null and info->>'street' != '{}';
55 $$ LANGUAGE SQL IMMUTABLE;
56
57
58 CREATE OR REPLACE FUNCTION token_has_addr_place(info JSONB)
59   RETURNS BOOLEAN
60 AS $$
61   SELECT info->>'place' is not null;
62 $$ LANGUAGE SQL IMMUTABLE;
63
64
65 CREATE OR REPLACE FUNCTION token_matches_street(info JSONB, street_tokens INTEGER[])
66   RETURNS BOOLEAN
67 AS $$
68   SELECT (info->>'street')::INTEGER[] && street_tokens
69 $$ LANGUAGE SQL IMMUTABLE STRICT;
70
71
72 CREATE OR REPLACE FUNCTION token_matches_place(info JSONB, place_tokens INTEGER[])
73   RETURNS BOOLEAN
74 AS $$
75   SELECT (info->>'place')::INTEGER[] <@ place_tokens
76 $$ LANGUAGE SQL IMMUTABLE STRICT;
77
78
79 CREATE OR REPLACE FUNCTION token_addr_place_search_tokens(info JSONB)
80   RETURNS INTEGER[]
81 AS $$
82   SELECT (info->>'place')::INTEGER[]
83 $$ LANGUAGE SQL IMMUTABLE STRICT;
84
85
86 CREATE OR REPLACE FUNCTION token_get_address_keys(info JSONB)
87   RETURNS SETOF TEXT
88 AS $$
89   SELECT * FROM jsonb_object_keys(info->'addr');
90 $$ LANGUAGE SQL IMMUTABLE STRICT;
91
92
93 CREATE OR REPLACE FUNCTION token_get_address_search_tokens(info JSONB, key TEXT)
94   RETURNS INTEGER[]
95 AS $$
96   SELECT (info->'addr'->>key)::INTEGER[];
97 $$ LANGUAGE SQL IMMUTABLE STRICT;
98
99
100 CREATE OR REPLACE FUNCTION token_matches_address(info JSONB, key TEXT, tokens INTEGER[])
101   RETURNS BOOLEAN
102 AS $$
103   SELECT (info->'addr'->>key)::INTEGER[] <@ tokens;
104 $$ LANGUAGE SQL IMMUTABLE STRICT;
105
106
107 CREATE OR REPLACE FUNCTION token_get_postcode(info JSONB)
108   RETURNS TEXT
109 AS $$
110   SELECT info->>'postcode';
111 $$ LANGUAGE SQL IMMUTABLE STRICT;
112
113
114 -- Return token info that should be saved permanently in the database.
115 CREATE OR REPLACE FUNCTION token_strip_info(info JSONB)
116   RETURNS JSONB
117 AS $$
118   SELECT NULL::JSONB;
119 $$ LANGUAGE SQL IMMUTABLE STRICT;
120
121 --------------- private functions ----------------------------------------------
122
123 CREATE OR REPLACE FUNCTION getorcreate_full_word(norm_term TEXT, lookup_terms TEXT[],
124                                                  OUT full_token INT,
125                                                  OUT partial_tokens INT[])
126   AS $$
127 DECLARE
128   partial_terms TEXT[] = '{}'::TEXT[];
129   term TEXT;
130   term_id INTEGER;
131   term_count INTEGER;
132 BEGIN
133   SELECT min(word_id) INTO full_token
134     FROM word WHERE word = norm_term and type = 'W';
135
136   IF full_token IS NULL THEN
137     full_token := nextval('seq_word');
138     INSERT INTO word (word_id, word_token, type, word, info)
139       SELECT full_token, lookup_term, 'W', norm_term,
140              json_build_object('count', 0)
141         FROM unnest(lookup_terms) as lookup_term;
142   END IF;
143
144   FOR term IN SELECT unnest(string_to_array(unnest(lookup_terms), ' ')) LOOP
145     term := trim(term);
146     IF NOT (ARRAY[term] <@ partial_terms) THEN
147       partial_terms := partial_terms || term;
148     END IF;
149   END LOOP;
150
151   partial_tokens := '{}'::INT[];
152   FOR term IN SELECT unnest(partial_terms) LOOP
153     SELECT min(word_id), max(info->>'count') INTO term_id, term_count
154       FROM word WHERE word_token = term and type = 'w';
155
156     IF term_id IS NULL THEN
157       term_id := nextval('seq_word');
158       term_count := 0;
159       INSERT INTO word (word_id, word_token, type, info)
160         VALUES (term_id, term, 'w', json_build_object('count', term_count));
161     END IF;
162
163     partial_tokens := array_merge(partial_tokens, ARRAY[term_id]);
164   END LOOP;
165 END;
166 $$
167 LANGUAGE plpgsql;
168
169
170 CREATE OR REPLACE FUNCTION getorcreate_partial_word(partial TEXT)
171   RETURNS INTEGER
172   AS $$
173 DECLARE
174   token INTEGER;
175 BEGIN
176   SELECT min(word_id) INTO token
177     FROM word WHERE word_token = partial and type = 'w';
178
179   IF token IS NULL THEN
180     token := nextval('seq_word');
181     INSERT INTO word (word_id, word_token, type, info)
182         VALUES (token, partial, 'w', json_build_object('count', 0));
183   END IF;
184
185   RETURN token;
186 END;
187 $$
188 LANGUAGE plpgsql;
189
190
191 CREATE OR REPLACE FUNCTION getorcreate_hnr_id(lookup_term TEXT)
192   RETURNS INTEGER
193   AS $$
194 DECLARE
195   return_id INTEGER;
196 BEGIN
197   SELECT min(word_id) INTO return_id FROM word
198     WHERE word_token = lookup_term and type = 'H';
199
200   IF return_id IS NULL THEN
201     return_id := nextval('seq_word');
202     INSERT INTO word (word_id, word_token, type)
203       VALUES (return_id, lookup_term, 'H');
204   END IF;
205
206   RETURN return_id;
207 END;
208 $$
209 LANGUAGE plpgsql;
210
211
212 CREATE OR REPLACE FUNCTION create_analyzed_hnr_id(norm_term TEXT, lookup_terms TEXT[])
213   RETURNS INTEGER
214   AS $$
215 DECLARE
216   return_id INTEGER;
217 BEGIN
218   SELECT min(word_id) INTO return_id
219     FROM word WHERE word = norm_term and type = 'H';
220
221   IF return_id IS NULL THEN
222     return_id := nextval('seq_word');
223     INSERT INTO word (word_id, word_token, type, word, info)
224       SELECT return_id, lookup_term, 'H', norm_term,
225              json_build_object('lookup', lookup_terms[1])
226         FROM unnest(lookup_terms) as lookup_term;
227   END IF;
228
229   RETURN return_id;
230 END;
231 $$
232 LANGUAGE plpgsql;
233
234 CREATE OR REPLACE FUNCTION create_postcode_word(postcode TEXT, lookup_terms TEXT[])
235   RETURNS BOOLEAN
236   AS $$
237 DECLARE
238   existing INTEGER;
239 BEGIN
240   SELECT count(*) INTO existing
241     FROM word WHERE word = postcode and type = 'P';
242
243   IF existing > 0 THEN
244     RETURN TRUE;
245   END IF;
246
247   -- postcodes don't need word ids
248   INSERT INTO word (word_token, type, word)
249     SELECT lookup_term, 'P', postcode FROM unnest(lookup_terms) as lookup_term;
250
251   RETURN FALSE;
252 END;
253 $$
254 LANGUAGE plpgsql;
255