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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
  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 PARALLEL SAFE;
 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 PARALLEL SAFE;
 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 PARALLEL SAFE;
 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 BEGIN
 132   SELECT min(word_id) INTO full_token
 133     FROM word WHERE word = norm_term and type = 'W';
 134
 135   IF full_token IS NULL THEN
 136     full_token := nextval('seq_word');
 137     INSERT INTO word (word_id, word_token, type, word)
 138       SELECT full_token, lookup_term, 'W', norm_term
 139         FROM unnest(lookup_terms) as lookup_term;
 140   END IF;
 141
 142   FOR term IN SELECT unnest(string_to_array(unnest(lookup_terms), ' ')) LOOP
 143     term := trim(term);
 144     IF NOT (ARRAY[term] <@ partial_terms) THEN
 145       partial_terms := partial_terms || term;
 146     END IF;
 147   END LOOP;
 148
 149   partial_tokens := '{}'::INT[];
 150   FOR term IN SELECT unnest(partial_terms) LOOP
 151     SELECT min(word_id) INTO term_id
 152       FROM word WHERE word_token = term and type = 'w';
 153
 154     IF term_id IS NULL THEN
 155       term_id := nextval('seq_word');
 156       INSERT INTO word (word_id, word_token, type)
 157         VALUES (term_id, term, 'w');
 158     END IF;
 159
 160     partial_tokens := array_merge(partial_tokens, ARRAY[term_id]);
 161   END LOOP;
 162 END;
 163 $$
 164 LANGUAGE plpgsql;
 165
 166
 167 CREATE OR REPLACE FUNCTION getorcreate_partial_word(partial TEXT)
 168   RETURNS INTEGER
 169   AS $$
 170 DECLARE
 171   token INTEGER;
 172 BEGIN
 173   SELECT min(word_id) INTO token
 174     FROM word WHERE word_token = partial and type = 'w';
 175
 176   IF token IS NULL THEN
 177     token := nextval('seq_word');
 178     INSERT INTO word (word_id, word_token, type, info)
 179         VALUES (token, partial, 'w', json_build_object('count', 0));
 180   END IF;
 181
 182   RETURN token;
 183 END;
 184 $$
 185 LANGUAGE plpgsql;
 186
 187
 188 CREATE OR REPLACE FUNCTION getorcreate_hnr_id(lookup_term TEXT)
 189   RETURNS INTEGER
 190   AS $$
 191 DECLARE
 192   return_id INTEGER;
 193 BEGIN
 194   SELECT min(word_id) INTO return_id FROM word
 195     WHERE word_token = lookup_term and type = 'H';
 196
 197   IF return_id IS NULL THEN
 198     return_id := nextval('seq_word');
 199     INSERT INTO word (word_id, word_token, type)
 200       VALUES (return_id, lookup_term, 'H');
 201   END IF;
 202
 203   RETURN return_id;
 204 END;
 205 $$
 206 LANGUAGE plpgsql;
 207
 208
 209 CREATE OR REPLACE FUNCTION create_analyzed_hnr_id(norm_term TEXT, lookup_terms TEXT[])
 210   RETURNS INTEGER
 211   AS $$
 212 DECLARE
 213   return_id INTEGER;
 214 BEGIN
 215   SELECT min(word_id) INTO return_id
 216     FROM word WHERE word = norm_term and type = 'H';
 217
 218   IF return_id IS NULL THEN
 219     return_id := nextval('seq_word');
 220     INSERT INTO word (word_id, word_token, type, word, info)
 221       SELECT return_id, lookup_term, 'H', norm_term,
 222              json_build_object('lookup', lookup_terms[1])
 223         FROM unnest(lookup_terms) as lookup_term;
 224   END IF;
 225
 226   RETURN return_id;
 227 END;
 228 $$
 229 LANGUAGE plpgsql;
 230
 231 CREATE OR REPLACE FUNCTION create_postcode_word(postcode TEXT, lookup_terms TEXT[])
 232   RETURNS BOOLEAN
 233   AS $$
 234 DECLARE
 235   existing INTEGER;
 236 BEGIN
 237   SELECT count(*) INTO existing
 238     FROM word WHERE word = postcode and type = 'P';
 239
 240   IF existing > 0 THEN
 241     RETURN TRUE;
 242   END IF;
 243
 244   -- postcodes don't need word ids
 245   INSERT INTO word (word_token, type, word)
 246     SELECT lookup_term, 'P', postcode FROM unnest(lookup_terms) as lookup_term;
 247
 248   RETURN FALSE;
 249 END;
 250 $$
 251 LANGUAGE plpgsql;
 252