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_amenity(lookup_word TEXT, normalized_word TEXT,
 206                                                lookup_class text, lookup_type text)
 207   RETURNS INTEGER
 208   AS $$
 209 DECLARE
 210   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 word = normalized_word
 216         and class = lookup_class and type = lookup_type
 217   INTO return_word_id;
 218   IF return_word_id IS NULL THEN
 219     return_word_id := nextval('seq_word');
 220     INSERT INTO word VALUES (return_word_id, lookup_token, normalized_word,
 221                              lookup_class, lookup_type, null, 0);
 222   END IF;
 223   RETURN return_word_id;
 224 END;
 225 $$
 226 LANGUAGE plpgsql;
 227
 228
 229 CREATE OR REPLACE FUNCTION getorcreate_amenityoperator(lookup_word TEXT,
 230                                                        normalized_word TEXT,
 231                                                        lookup_class text,
 232                                                        lookup_type text,
 233                                                        op text)
 234   RETURNS INTEGER
 235   AS $$
 236 DECLARE
 237   lookup_token TEXT;
 238   return_word_id INTEGER;
 239 BEGIN
 240   lookup_token := ' '||trim(lookup_word);
 241   SELECT min(word_id) FROM word
 242   WHERE word_token = lookup_token and word = normalized_word
 243         and class = lookup_class and type = lookup_type and operator = op
 244   INTO return_word_id;
 245   IF return_word_id IS NULL THEN
 246     return_word_id := nextval('seq_word');
 247     INSERT INTO word VALUES (return_word_id, lookup_token, normalized_word,
 248                              lookup_class, lookup_type, null, 0, op);
 249   END IF;
 250   RETURN return_word_id;
 251 END;
 252 $$
 253 LANGUAGE plpgsql;
 254
 255
 256 CREATE OR REPLACE FUNCTION getorcreate_name_id(lookup_word TEXT, src_word TEXT)
 257   RETURNS INTEGER
 258   AS $$
 259 DECLARE
 260   lookup_token TEXT;
 261   nospace_lookup_token TEXT;
 262   return_word_id INTEGER;
 263 BEGIN
 264   lookup_token := ' '||trim(lookup_word);
 265   SELECT min(word_id) FROM word
 266   WHERE word_token = lookup_token and class is null and type is null
 267   INTO return_word_id;
 268   IF return_word_id IS NULL THEN
 269     return_word_id := nextval('seq_word');
 270     INSERT INTO word VALUES (return_word_id, lookup_token, src_word,
 271                              null, null, null, 0);
 272   END IF;
 273   RETURN return_word_id;
 274 END;
 275 $$
 276 LANGUAGE plpgsql;
 277
 278
 279 CREATE OR REPLACE FUNCTION getorcreate_name_id(lookup_word TEXT)
 280   RETURNS INTEGER
 281   AS $$
 282 DECLARE
 283 BEGIN
 284   RETURN getorcreate_name_id(lookup_word, '');
 285 END;
 286 $$
 287 LANGUAGE plpgsql;
 288
 289 -- Normalize a string and lookup its word ids (partial words).
 290 CREATE OR REPLACE FUNCTION addr_ids_from_name(lookup_word TEXT)
 291   RETURNS INTEGER[]
 292   AS $$
 293 DECLARE
 294   words TEXT[];
 295   id INTEGER;
 296   return_word_id INTEGER[];
 297   word_ids INTEGER[];
 298   j INTEGER;
 299 BEGIN
 300   words := string_to_array(make_standard_name(lookup_word), ' ');
 301   IF array_upper(words, 1) IS NOT NULL THEN
 302     FOR j IN 1..array_upper(words, 1) LOOP
 303       IF (words[j] != '') THEN
 304         SELECT array_agg(word_id) INTO word_ids
 305           FROM word
 306          WHERE word_token = words[j] and class is null and type is null;
 307
 308         IF word_ids IS NULL THEN
 309           id := nextval('seq_word');
 310           INSERT INTO word VALUES (id, words[j], null, null, null, null, 0);
 311           return_word_id := return_word_id || id;
 312         ELSE
 313           return_word_id := array_merge(return_word_id, word_ids);
 314         END IF;
 315       END IF;
 316     END LOOP;
 317   END IF;
 318
 319   RETURN return_word_id;
 320 END;
 321 $$
 322 LANGUAGE plpgsql;
 323
 324
 325 -- Normalize a string and look up its name ids (full words).
 326 CREATE OR REPLACE FUNCTION word_ids_from_name(lookup_word TEXT)
 327   RETURNS INTEGER[]
 328   AS $$
 329 DECLARE
 330   lookup_token TEXT;
 331   return_word_ids INTEGER[];
 332 BEGIN
 333   lookup_token := ' '|| make_standard_name(lookup_word);
 334   SELECT array_agg(word_id) FROM word
 335     WHERE word_token = lookup_token and class is null and type is null
 336     INTO return_word_ids;
 337   RETURN return_word_ids;
 338 END;
 339 $$
 340 LANGUAGE plpgsql STABLE STRICT;
 341
 342
 343 CREATE OR REPLACE FUNCTION make_keywords(src HSTORE)
 344   RETURNS INTEGER[]
 345   AS $$
 346 DECLARE
 347   result INTEGER[];
 348   s TEXT;
 349   w INTEGER;
 350   words TEXT[];
 351   item RECORD;
 352   j INTEGER;
 353 BEGIN
 354   result := '{}'::INTEGER[];
 355
 356   FOR item IN SELECT (each(src)).* LOOP
 357
 358     s := make_standard_name(item.value);
 359     w := getorcreate_name_id(s, item.value);
 360
 361     IF not(ARRAY[w] <@ result) THEN
 362       result := result || w;
 363     END IF;
 364
 365     w := getorcreate_word_id(s);
 366
 367     IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 368       result := result || w;
 369     END IF;
 370
 371     words := string_to_array(s, ' ');
 372     IF array_upper(words, 1) IS NOT NULL THEN
 373       FOR j IN 1..array_upper(words, 1) LOOP
 374         IF (words[j] != '') THEN
 375           w = getorcreate_word_id(words[j]);
 376           IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 377             result := result || w;
 378           END IF;
 379         END IF;
 380       END LOOP;
 381     END IF;
 382
 383     words := regexp_split_to_array(item.value, E'[,;()]');
 384     IF array_upper(words, 1) != 1 THEN
 385       FOR j IN 1..array_upper(words, 1) LOOP
 386         s := make_standard_name(words[j]);
 387         IF s != '' THEN
 388           w := getorcreate_word_id(s);
 389           IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 390             result := result || w;
 391           END IF;
 392         END IF;
 393       END LOOP;
 394     END IF;
 395
 396     s := regexp_replace(item.value, '市$', '');
 397     IF s != item.value THEN
 398       s := make_standard_name(s);
 399       IF s != '' THEN
 400         w := getorcreate_name_id(s, item.value);
 401         IF NOT (ARRAY[w] <@ result) THEN
 402           result := result || w;
 403         END IF;
 404       END IF;
 405     END IF;
 406
 407   END LOOP;
 408
 409   RETURN result;
 410 END;
 411 $$
 412 LANGUAGE plpgsql;
 413
 414
 415 CREATE OR REPLACE FUNCTION precompute_words(src TEXT)
 416   RETURNS INTEGER
 417   AS $$
 418 DECLARE
 419   s TEXT;
 420   w INTEGER;
 421   words TEXT[];
 422   i INTEGER;
 423   j INTEGER;
 424 BEGIN
 425   s := make_standard_name(src);
 426   w := getorcreate_name_id(s, src);
 427
 428   w := getorcreate_word_id(s);
 429
 430   words := string_to_array(s, ' ');
 431   IF array_upper(words, 1) IS NOT NULL THEN
 432     FOR j IN 1..array_upper(words, 1) LOOP
 433       IF (words[j] != '') THEN
 434         w := getorcreate_word_id(words[j]);
 435       END IF;
 436     END LOOP;
 437   END IF;
 438
 439   words := regexp_split_to_array(src, E'[,;()]');
 440   IF array_upper(words, 1) != 1 THEN
 441     FOR j IN 1..array_upper(words, 1) LOOP
 442       s := make_standard_name(words[j]);
 443       IF s != '' THEN
 444         w := getorcreate_word_id(s);
 445       END IF;
 446     END LOOP;
 447   END IF;
 448
 449   s := regexp_replace(src, '市$', '');
 450   IF s != src THEN
 451     s := make_standard_name(s);
 452     IF s != '' THEN
 453       w := getorcreate_name_id(s, src);
 454     END IF;
 455   END IF;
 456
 457   RETURN 1;
 458 END;
 459 $$
 460 LANGUAGE plpgsql;