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