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   value TEXT;
 291   j INTEGER;
 292 BEGIN
 293   result := '{}'::INTEGER[];
 294
 295   FOR value IN SELECT unnest(regexp_split_to_array(svals(src), E'[,;]')) LOOP
 296     -- full name
 297     s := make_standard_name(value);
 298     w := getorcreate_name_id(s, value);
 299
 300     IF not(ARRAY[w] <@ result) THEN
 301       result := result || w;
 302     END IF;
 303
 304     -- partial single-word terms
 305     words := string_to_array(s, ' ');
 306     IF array_upper(words, 1) IS NOT NULL THEN
 307       FOR j IN 1..array_upper(words, 1) LOOP
 308         IF (words[j] != '') THEN
 309           w = getorcreate_word_id(words[j]);
 310           IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 311             result := result || w;
 312           END IF;
 313         END IF;
 314       END LOOP;
 315     END IF;
 316
 317     -- consider parts before an opening braket a full word as well
 318     words := regexp_split_to_array(value, E'[(]');
 319     IF array_upper(words, 1) > 1 THEN
 320       s := make_standard_name(words[1]);
 321       IF s != '' THEN
 322         w := getorcreate_name_id(s, words[1]);
 323         IF w IS NOT NULL AND NOT (ARRAY[w] <@ result) THEN
 324           result := result || w;
 325         END IF;
 326       END IF;
 327     END IF;
 328
 329     s := regexp_replace(value, '市$', '');
 330     IF s != value THEN
 331       s := make_standard_name(s);
 332       IF s != '' THEN
 333         w := getorcreate_name_id(s, value);
 334         IF NOT (ARRAY[w] <@ result) THEN
 335           result := result || w;
 336         END IF;
 337       END IF;
 338     END IF;
 339
 340   END LOOP;
 341
 342   RETURN result;
 343 END;
 344 $$
 345 LANGUAGE plpgsql;
 346
 347
 348 CREATE OR REPLACE FUNCTION precompute_words(src TEXT)
 349   RETURNS INTEGER
 350   AS $$
 351 DECLARE
 352   s TEXT;
 353   w INTEGER;
 354   words TEXT[];
 355   i INTEGER;
 356   j INTEGER;
 357 BEGIN
 358   s := make_standard_name(src);
 359   w := getorcreate_name_id(s, src);
 360
 361   w := getorcreate_word_id(s);
 362
 363   words := string_to_array(s, ' ');
 364   IF array_upper(words, 1) IS NOT NULL THEN
 365     FOR j IN 1..array_upper(words, 1) LOOP
 366       IF (words[j] != '') THEN
 367         w := getorcreate_word_id(words[j]);
 368       END IF;
 369     END LOOP;
 370   END IF;
 371
 372   words := regexp_split_to_array(src, E'[,;()]');
 373   IF array_upper(words, 1) != 1 THEN
 374     FOR j IN 1..array_upper(words, 1) LOOP
 375       s := make_standard_name(words[j]);
 376       IF s != '' THEN
 377         w := getorcreate_word_id(s);
 378       END IF;
 379     END LOOP;
 380   END IF;
 381
 382   s := regexp_replace(src, '市$', '');
 383   IF s != src THEN
 384     s := make_standard_name(s);
 385     IF s != '' THEN
 386       w := getorcreate_name_id(s, src);
 387     END IF;
 388   END IF;
 389
 390   RETURN 1;
 391 END;
 392 $$
 393 LANGUAGE plpgsql;