lib-sql/tokenizer/legacy_tokenizer.sql

   1 -- Get tokens used for searching the given place.
   2 --
   3 -- These are the tokens that will be saved in the search_name table.
   4 CREATE OR REPLACE FUNCTION token_get_name_search_tokens(info JSONB)
   5   RETURNS INTEGER[]
   6 AS $$
   7   SELECT (info->>'names')::INTEGER[]
   8 $$ LANGUAGE SQL IMMUTABLE STRICT;
   9
  10
  11 -- Get tokens for matching the place name against others.
  12 --
  13 -- This should usually be restricted to full name tokens.
  14 CREATE OR REPLACE FUNCTION token_get_name_match_tokens(info JSONB)
  15   RETURNS INTEGER[]
  16 AS $$
  17   SELECT (info->>'names')::INTEGER[]
  18 $$ LANGUAGE SQL IMMUTABLE STRICT;
  19
  20
  21 -- Return the housenumber tokens applicable for the place.
  22 CREATE OR REPLACE FUNCTION token_get_housenumber_search_tokens(info JSONB)
  23   RETURNS INTEGER[]
  24 AS $$
  25   SELECT (info->>'hnr_tokens')::INTEGER[]
  26 $$ LANGUAGE SQL IMMUTABLE STRICT;
  27
  28
  29 -- Return the housenumber in the form that it can be matched during search.
  30 CREATE OR REPLACE FUNCTION token_normalized_housenumber(info JSONB)
  31   RETURNS TEXT
  32 AS $$
  33   SELECT info->>'hnr';
  34 $$ LANGUAGE SQL IMMUTABLE STRICT;
  35
  36
  37 CREATE OR REPLACE FUNCTION token_addr_street_match_tokens(info JSONB)
  38   RETURNS INTEGER[]
  39 AS $$
  40   SELECT (info->>'street')::INTEGER[]
  41 $$ LANGUAGE SQL IMMUTABLE STRICT;
  42
  43
  44 CREATE OR REPLACE FUNCTION token_addr_place_match_tokens(info JSONB)
  45   RETURNS INTEGER[]
  46 AS $$
  47   SELECT (info->>'place_match')::INTEGER[]
  48 $$ LANGUAGE SQL IMMUTABLE STRICT;
  49
  50
  51 CREATE OR REPLACE FUNCTION token_addr_place_search_tokens(info JSONB)
  52   RETURNS INTEGER[]
  53 AS $$
  54   SELECT (info->>'place_search')::INTEGER[]
  55 $$ LANGUAGE SQL IMMUTABLE STRICT;
  56
  57
  58 DROP TYPE IF EXISTS token_addresstoken CASCADE;
  59 CREATE TYPE token_addresstoken AS (
  60   key TEXT,
  61   match_tokens INT[],
  62   search_tokens INT[]
  63 );
  64
  65 CREATE OR REPLACE FUNCTION token_get_address_tokens(info JSONB)
  66   RETURNS SETOF token_addresstoken
  67 AS $$
  68   SELECT key, (value->>1)::int[] as match_tokens,
  69          (value->>0)::int[] as search_tokens
  70   FROM jsonb_each(info->'addr');
  71 $$ LANGUAGE SQL IMMUTABLE STRICT;
  72
  73
  74 CREATE OR REPLACE FUNCTION token_normalized_postcode(postcode TEXT)
  75   RETURNS TEXT
  76 AS $$
  77   SELECT CASE WHEN postcode SIMILAR TO '%(,|;)%' THEN NULL ELSE upper(trim(postcode))END;
  78 $$ LANGUAGE SQL IMMUTABLE STRICT;
  79
  80
  81 -- Return token info that should be saved permanently in the database.
  82 CREATE OR REPLACE FUNCTION token_strip_info(info JSONB)
  83   RETURNS JSONB
  84 AS $$
  85   SELECT NULL::JSONB;
  86 $$ LANGUAGE SQL IMMUTABLE STRICT;
  87
  88 --------------- private functions ----------------------------------------------
  89
  90 -- Functions for term normalisation and access to the 'word' table.
  91
  92 CREATE OR REPLACE FUNCTION transliteration(text) RETURNS text
  93   AS '{{ modulepath }}/nominatim.so', 'transliteration'
  94 LANGUAGE c IMMUTABLE STRICT;
  95
  96
  97 CREATE OR REPLACE FUNCTION gettokenstring(text) RETURNS text
  98   AS '{{ modulepath }}/nominatim.so', 'gettokenstring'
  99 LANGUAGE c IMMUTABLE STRICT;
 100
 101
 102 CREATE OR REPLACE FUNCTION make_standard_name(name TEXT) RETURNS TEXT
 103   AS $$
 104 DECLARE
 105   o TEXT;
 106 BEGIN
 107   o := public.gettokenstring(public.transliteration(name));
 108   RETURN trim(substr(o,1,length(o)));
 109 END;
 110 $$
 111 LANGUAGE plpgsql IMMUTABLE;
 112
 113 -- returns NULL if the word is too common
 114 CREATE OR REPLACE FUNCTION getorcreate_word_id(lookup_word TEXT)
 115   RETURNS INTEGER
 116   AS $$
 117 DECLARE
 118   lookup_token TEXT;
 119   return_word_id INTEGER;
 120   count INTEGER;
 121 BEGIN
 122   lookup_token := trim(lookup_word);
 123   SELECT min(word_id), max(search_name_count) FROM word
 124     WHERE word_token = lookup_token and class is null and type is null
 125     INTO return_word_id, count;
 126   IF return_word_id IS NULL THEN
 127     return_word_id := nextval('seq_word');
 128     INSERT INTO word VALUES (return_word_id, lookup_token, null, null, null, null, 0);
 129   ELSE
 130     IF count > {{ max_word_freq }} THEN
 131       return_word_id := NULL;
 132     END IF;
 133   END IF;
 134   RETURN return_word_id;
 135 END;
 136 $$
 137 LANGUAGE plpgsql;
 138
 139
 140 -- Create housenumber tokens from an OSM addr:housenumber.
 141 -- The housnumber is split at comma and semicolon as necessary.
 142 -- The function returns the normalized form of the housenumber suitable
 143 -- for comparison.
 144 CREATE OR REPLACE FUNCTION create_housenumbers(housenumbers TEXT[],
 145                                                OUT tokens TEXT,
 146                                                OUT normtext TEXT)
 147   AS $$
 148 BEGIN
 149   SELECT array_to_string(array_agg(trans), ';'), array_agg(tid)::TEXT
 150     INTO normtext, tokens
 151     FROM (SELECT lookup_word as trans, getorcreate_housenumber_id(lookup_word) as tid
 152           FROM (SELECT make_standard_name(h) as lookup_word
 153                 FROM unnest(housenumbers) h) x) y;
 154 END;
 155 $$ LANGUAGE plpgsql STABLE STRICT;
 156
 157
 158 CREATE OR REPLACE FUNCTION getorcreate_housenumber_id(lookup_word TEXT)
 159   RETURNS INTEGER
 160   AS $$
 161 DECLARE
 162   lookup_token TEXT;
 163   return_word_id INTEGER;
 164 BEGIN
 165   lookup_token := ' ' || trim(lookup_word);
 166   SELECT min(word_id) FROM word
 167     WHERE word_token = lookup_token and class='place' and type='house'
 168     INTO return_word_id;
 169   IF return_word_id IS NULL THEN
 170     return_word_id := nextval('seq_word');
 171     INSERT INTO word VALUES (return_word_id, lookup_token, null,
 172                              'place', 'house', null, 0);
 173   END IF;
 174   RETURN return_word_id;
 175 END;
 176 $$
 177 LANGUAGE plpgsql;
 178
 179
 180 CREATE OR REPLACE FUNCTION create_postcode_id(postcode TEXT)
 181   RETURNS BOOLEAN
 182   AS $$
 183 DECLARE
 184   r RECORD;
 185   lookup_token TEXT;
 186   return_word_id INTEGER;
 187 BEGIN
 188   lookup_token := ' ' || make_standard_name(postcode);
 189   FOR r IN
 190     SELECT word_id FROM word
 191     WHERE word_token = lookup_token and word = postcode
 192           and class='place' and type='postcode'
 193   LOOP
 194     RETURN false;
 195   END LOOP;
 196
 197   INSERT INTO word VALUES (nextval('seq_word'), lookup_token, postcode,
 198                            'place', 'postcode', null, 0);
 199   RETURN true;
 200 END;
 201 $$
 202 LANGUAGE plpgsql;
 203
 204
 205 CREATE OR REPLACE FUNCTION getorcreate_name_id(lookup_word TEXT, src_word TEXT)
 206   RETURNS INTEGER
 207   AS $$
 208 DECLARE
 209   lookup_token TEXT;
 210   nospace_lookup_token TEXT;
 211   return_word_id INTEGER;
 212 BEGIN
 213   lookup_token := ' '||trim(lookup_word);
 214   SELECT min(word_id) FROM word
 215   WHERE word_token = lookup_token and class is null and type is null
 216   INTO return_word_id;
 217   IF return_word_id IS NULL THEN
 218     return_word_id := nextval('seq_word');
 219     INSERT INTO word VALUES (return_word_id, lookup_token, src_word,
 220                              null, null, null, 0);
 221   END IF;
 222   RETURN return_word_id;
 223 END;
 224 $$
 225 LANGUAGE plpgsql;
 226
 227
 228 -- Normalize a string and lookup its word ids (partial words).
 229 CREATE OR REPLACE FUNCTION addr_ids_from_name(lookup_word TEXT)
 230   RETURNS INTEGER[]
 231   AS $$
 232 DECLARE
 233   words TEXT[];
 234   id INTEGER;
 235   return_word_id INTEGER[];
 236   word_ids INTEGER[];
 237   j INTEGER;
 238 BEGIN
 239   words := string_to_array(make_standard_name(lookup_word), ' ');
 240   IF array_upper(words, 1) IS NOT NULL THEN
 241     FOR j IN 1..array_upper(words, 1) LOOP
 242       IF (words[j] != '') THEN
 243         SELECT array_agg(word_id) INTO word_ids
 244           FROM word
 245          WHERE word_token = words[j] and class is null and type is null;
 246
 247         IF word_ids IS NULL THEN
 248           id := nextval('seq_word');
 249           INSERT INTO word VALUES (id, words[j], null, null, null, null, 0);
 250           return_word_id := return_word_id || id;
 251         ELSE
 252           return_word_id := array_merge(return_word_id, word_ids);
 253         END IF;
 254       END IF;
 255     END LOOP;
 256   END IF;
 257
 258   RETURN return_word_id;
 259 END;
 260 $$
 261 LANGUAGE plpgsql;
 262
 263
 264 -- Normalize a string and look up its name ids (full words).
 265 CREATE OR REPLACE FUNCTION word_ids_from_name(lookup_word TEXT)
 266   RETURNS INTEGER[]
 267   AS $$
 268 DECLARE
 269   lookup_token TEXT;
 270   return_word_ids INTEGER[];
 271 BEGIN
 272   lookup_token := ' '|| make_standard_name(lookup_word);
 273   SELECT array_agg(word_id) FROM word
 274     WHERE word_token = lookup_token and class is null and type is null
 275     INTO return_word_ids;
 276   RETURN return_word_ids;
 277 END;
 278 $$
 279 LANGUAGE plpgsql STABLE STRICT;
 280
 281
 282 CREATE OR REPLACE FUNCTION make_keywords(src HSTORE)
 283   RETURNS INTEGER[]
 284   AS $$
 285 DECLARE
 286   result INTEGER[];
 287   s TEXT;
 288   w INTEGER;
 289   words TEXT[];
 290   item RECORD;
 291   j INTEGER;
 292 BEGIN
 293   result := '{}'::INTEGER[];
 294
 295   FOR item IN SELECT (each(src)).* LOOP
 296
 297     s := make_standard_name(item.value);
 298     w := getorcreate_name_id(s, item.value);
 299
 300     IF not(ARRAY[w] <@ result) THEN
 301       result := result || w;
 302     END IF;
 303
 304     w := getorcreate_word_id(s);
 305
 306     IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 307       result := result || w;
 308     END IF;
 309
 310     words := string_to_array(s, ' ');
 311     IF array_upper(words, 1) IS NOT NULL THEN
 312       FOR j IN 1..array_upper(words, 1) LOOP
 313         IF (words[j] != '') THEN
 314           w = getorcreate_word_id(words[j]);
 315           IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 316             result := result || w;
 317           END IF;
 318         END IF;
 319       END LOOP;
 320     END IF;
 321
 322     words := regexp_split_to_array(item.value, E'[,;()]');
 323     IF array_upper(words, 1) != 1 THEN
 324       FOR j IN 1..array_upper(words, 1) LOOP
 325         s := make_standard_name(words[j]);
 326         IF s != '' THEN
 327           w := getorcreate_word_id(s);
 328           IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 329             result := result || w;
 330           END IF;
 331         END IF;
 332       END LOOP;
 333     END IF;
 334
 335     s := regexp_replace(item.value, '市$', '');
 336     IF s != item.value THEN
 337       s := make_standard_name(s);
 338       IF s != '' THEN
 339         w := getorcreate_name_id(s, item.value);
 340         IF NOT (ARRAY[w] <@ result) THEN
 341           result := result || w;
 342         END IF;
 343       END IF;
 344     END IF;
 345
 346   END LOOP;
 347
 348   RETURN result;
 349 END;
 350 $$
 351 LANGUAGE plpgsql;
 352
 353
 354 CREATE OR REPLACE FUNCTION precompute_words(src TEXT)
 355   RETURNS INTEGER
 356   AS $$
 357 DECLARE
 358   s TEXT;
 359   w INTEGER;
 360   words TEXT[];
 361   i INTEGER;
 362   j INTEGER;
 363 BEGIN
 364   s := make_standard_name(src);
 365   w := getorcreate_name_id(s, src);
 366
 367   w := getorcreate_word_id(s);
 368
 369   words := string_to_array(s, ' ');
 370   IF array_upper(words, 1) IS NOT NULL THEN
 371     FOR j IN 1..array_upper(words, 1) LOOP
 372       IF (words[j] != '') THEN
 373         w := getorcreate_word_id(words[j]);
 374       END IF;
 375     END LOOP;
 376   END IF;
 377
 378   words := regexp_split_to_array(src, E'[,;()]');
 379   IF array_upper(words, 1) != 1 THEN
 380     FOR j IN 1..array_upper(words, 1) LOOP
 381       s := make_standard_name(words[j]);
 382       IF s != '' THEN
 383         w := getorcreate_word_id(s);
 384       END IF;
 385     END LOOP;
 386   END IF;
 387
 388   s := regexp_replace(src, '市$', '');
 389   IF s != src THEN
 390     s := make_standard_name(s);
 391     IF s != '' THEN
 392       w := getorcreate_name_id(s, src);
 393     END IF;
 394   END IF;
 395
 396   RETURN 1;
 397 END;
 398 $$
 399 LANGUAGE plpgsql;