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