settings/flex-base.lua

   1 -- Core functions for Nominatim import flex style.
   2 --
   3
   4 local module = {}
   5
   6 local PRE_DELETE = nil
   7 local PRE_EXTRAS = nil
   8 local POST_DELETE = nil
   9 local MAIN_KEYS = nil
  10 local NAMES = nil
  11 local ADDRESS_TAGS = nil
  12 local SAVE_EXTRA_MAINS = false
  13 local POSTCODE_FALLBACK = true
  14
  15 -- tables required for taginfo
  16 module.TAGINFO_MAIN = {keys = {}, delete_tags = {}}
  17 module.TAGINFO_NAME_KEYS = {}
  18 module.TAGINFO_ADDRESS_KEYS = {}
  19
  20
  21 -- The single place table.
  22 local place_table = osm2pgsql.define_table{
  23     name = "place",
  24     ids = { type = 'any', id_column = 'osm_id', type_column = 'osm_type' },
  25     columns = {
  26         { column = 'class', type = 'text', not_null = true },
  27         { column = 'type', type = 'text', not_null = true },
  28         { column = 'admin_level', type = 'smallint' },
  29         { column = 'name', type = 'hstore' },
  30         { column = 'address', type = 'hstore' },
  31         { column = 'extratags', type = 'hstore' },
  32         { column = 'geometry', type = 'geometry', projection = 'WGS84', not_null = true },
  33     },
  34     data_tablespace = os.getenv("NOMINATIM_TABLESPACE_PLACE_DATA"),
  35     index_tablespace = os.getenv("NOMINATIM_TABLESPACE_PLACE_INDEX"),
  36     indexes = {}
  37 }
  38
  39 ------------ Geometry functions for relations ---------------------
  40
  41 function module.relation_as_multipolygon(o)
  42     return o:as_multipolygon()
  43 end
  44
  45 function module.relation_as_multiline(o)
  46     return o:as_multilinestring():line_merge()
  47 end
  48
  49
  50 module.RELATION_TYPES = {
  51     multipolygon = module.relation_as_multipolygon,
  52     boundary = module.relation_as_multipolygon,
  53     waterway = module.relation_as_multiline
  54 }
  55
  56 ------------- Place class ------------------------------------------
  57
  58 local Place = {}
  59 Place.__index = Place
  60
  61 function Place.new(object, geom_func)
  62     local self = setmetatable({}, Place)
  63     self.object = object
  64     self.geom_func = geom_func
  65
  66     self.admin_level = tonumber(self.object:grab_tag('admin_level'))
  67     if self.admin_level == nil
  68        or self.admin_level <= 0 or self.admin_level > 15
  69        or math.floor(self.admin_level) ~= self.admin_level then
  70         self.admin_level = 15
  71     end
  72
  73     self.num_entries = 0
  74     self.has_name = false
  75     self.names = {}
  76     self.address = {}
  77     self.extratags = {}
  78
  79     return self
  80 end
  81
  82 function Place:clean(data)
  83     for k, v in pairs(self.object.tags) do
  84         if data.delete ~= nil and data.delete(k, v) then
  85             self.object.tags[k] = nil
  86         elseif data.extra ~= nil and data.extra(k, v) then
  87             self.extratags[k] = v
  88             self.object.tags[k] = nil
  89         end
  90     end
  91 end
  92
  93 function Place:delete(data)
  94     if data.match ~= nil then
  95         for k, v in pairs(self.object.tags) do
  96             if data.match(k, v) then
  97                 self.object.tags[k] = nil
  98             end
  99         end
 100     end
 101 end
 102
 103 function Place:grab_extratags(data)
 104     local count = 0
 105
 106     if data.match ~= nil then
 107         for k, v in pairs(self.object.tags) do
 108             if data.match(k, v) then
 109                 self.object.tags[k] = nil
 110                 self.extratags[k] = v
 111                 count = count + 1
 112             end
 113         end
 114     end
 115
 116     return count
 117 end
 118
 119 local function strip_address_prefix(k)
 120     if k:sub(1, 5) == 'addr:' then
 121         return k:sub(6)
 122     end
 123
 124     if k:sub(1, 6) == 'is_in:' then
 125         return k:sub(7)
 126     end
 127
 128     return k
 129 end
 130
 131
 132 function Place:grab_address_parts(data)
 133     local count = 0
 134
 135     if data.groups ~= nil then
 136         for k, v in pairs(self.object.tags) do
 137             local atype = data.groups(k, v)
 138
 139             if atype ~= nil then
 140                 if atype == 'main' then
 141                     self.has_name = true
 142                     self.address[strip_address_prefix(k)] = v
 143                     count = count + 1
 144                 elseif atype == 'extra' then
 145                     self.address[strip_address_prefix(k)] = v
 146                 else
 147                     self.address[atype] = v
 148                 end
 149                 self.object.tags[k] = nil
 150             end
 151         end
 152     end
 153
 154     return count
 155 end
 156
 157
 158 function Place:grab_name_parts(data)
 159     local fallback = nil
 160
 161     if data.groups ~= nil then
 162         for k, v in pairs(self.object.tags) do
 163             local atype = data.groups(k, v)
 164
 165             if atype ~= nil then
 166                 self.names[k] = v
 167                 self.object.tags[k] = nil
 168                 if atype == 'main' then
 169                     self.has_name = true
 170                 elseif atype == 'house' then
 171                     self.has_name = true
 172                     fallback = {'place', 'house', 'always'}
 173                 end
 174             end
 175         end
 176     end
 177
 178     return fallback
 179 end
 180
 181
 182 function Place:write_place(k, v, mtype, save_extra_mains)
 183     if mtype == nil then
 184         return 0
 185     end
 186
 187     v = v or self.object.tags[k]
 188     if v == nil then
 189         return 0
 190     end
 191
 192     if type(mtype) == 'table' then
 193         mtype = mtype[v] or mtype[1]
 194     end
 195
 196     if mtype == 'always' or (self.has_name and mtype == 'named') then
 197         return self:write_row(k, v, save_extra_mains)
 198     end
 199
 200     if mtype == 'named_with_key' then
 201         local names = {}
 202         local prefix = k .. ':name'
 203         for namek, namev in pairs(self.object.tags) do
 204             if namek:sub(1, #prefix) == prefix
 205                and (#namek == #prefix
 206                     or namek:sub(#prefix + 1, #prefix + 1) == ':') then
 207                 names[namek:sub(#k + 2)] = namev
 208             end
 209         end
 210
 211         if next(names) ~= nil then
 212             local saved_names = self.names
 213             self.names = names
 214
 215             local results = self:write_row(k, v, save_extra_mains)
 216
 217             self.names = saved_names
 218
 219             return results
 220         end
 221     end
 222
 223     return 0
 224 end
 225
 226 function Place:write_row(k, v, save_extra_mains)
 227     if self.geometry == nil then
 228         self.geometry = self.geom_func(self.object)
 229     end
 230     if self.geometry:is_null() then
 231         return 0
 232     end
 233
 234     if save_extra_mains ~= nil then
 235         for extra_k, extra_v in pairs(self.object.tags) do
 236             if extra_k ~= k and save_extra_mains(extra_k, extra_v) then
 237                 self.extratags[extra_k] = extra_v
 238             end
 239         end
 240     end
 241
 242     place_table:insert{
 243         class = k,
 244         type = v,
 245         admin_level = self.admin_level,
 246         name = next(self.names) and self.names,
 247         address = next(self.address) and self.address,
 248         extratags = next(self.extratags) and self.extratags,
 249         geometry = self.geometry
 250     }
 251
 252     if save_extra_mains then
 253         for tk, tv in pairs(self.object.tags) do
 254             if save_extra_mains(tk, tv) then
 255                 self.extratags[tk] = nil
 256             end
 257         end
 258     end
 259
 260     self.num_entries = self.num_entries + 1
 261
 262     return 1
 263 end
 264
 265
 266 function module.tag_match(data)
 267     if data == nil or next(data) == nil then
 268         return nil
 269     end
 270
 271     local fullmatches = {}
 272     local key_prefixes = {}
 273     local key_suffixes = {}
 274
 275     if data.keys ~= nil then
 276         for _, key in pairs(data.keys) do
 277             if key:sub(1, 1) == '*' then
 278                 if #key > 1 then
 279                     if key_suffixes[#key - 1] == nil then
 280                         key_suffixes[#key - 1] = {}
 281                     end
 282                     key_suffixes[#key - 1][key:sub(2)] = true
 283                 end
 284             elseif key:sub(#key, #key) == '*' then
 285                 if key_prefixes[#key - 1] == nil then
 286                     key_prefixes[#key - 1] = {}
 287                 end
 288                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = true
 289             else
 290                 fullmatches[key] = true
 291             end
 292         end
 293     end
 294
 295     if data.tags ~= nil then
 296         for k, vlist in pairs(data.tags) do
 297             if fullmatches[k] == nil then
 298                 fullmatches[k] = {}
 299                 for _, v in pairs(vlist) do
 300                     fullmatches[k][v] = true
 301                 end
 302             end
 303         end
 304     end
 305
 306     return function (k, v)
 307         if fullmatches[k] ~= nil and (fullmatches[k] == true or fullmatches[k][v] ~= nil) then
 308             return true
 309         end
 310
 311         for slen, slist in pairs(key_suffixes) do
 312             if #k >= slen and slist[k:sub(-slen)] ~= nil then
 313                 return true
 314             end
 315         end
 316
 317         for slen, slist in pairs(key_prefixes) do
 318             if #k >= slen and slist[k:sub(1, slen)] ~= nil then
 319                 return true
 320             end
 321         end
 322
 323         return false
 324     end
 325 end
 326
 327
 328 function module.tag_group(data)
 329     if data == nil or next(data) == nil then
 330         return nil
 331     end
 332
 333     local fullmatches = {}
 334     local key_prefixes = {}
 335     local key_suffixes = {}
 336
 337     for group, tags in pairs(data) do
 338         for _, key in pairs(tags) do
 339             if key:sub(1, 1) == '*' then
 340                 if #key > 1 then
 341                     if key_suffixes[#key - 1] == nil then
 342                         key_suffixes[#key - 1] = {}
 343                     end
 344                     key_suffixes[#key - 1][key:sub(2)] = group
 345                 end
 346             elseif key:sub(#key, #key) == '*' then
 347                 if key_prefixes[#key - 1] == nil then
 348                     key_prefixes[#key - 1] = {}
 349                 end
 350                 key_prefixes[#key - 1][key:sub(1, #key - 1)] = group
 351             else
 352                 fullmatches[key] = group
 353             end
 354         end
 355     end
 356
 357     return function (k, v)
 358         local val = fullmatches[k]
 359         if val ~= nil then
 360             return val
 361         end
 362
 363         for slen, slist in pairs(key_suffixes) do
 364             if #k >= slen then
 365                 val = slist[k:sub(-slen)]
 366                 if val ~= nil then
 367                     return val
 368                 end
 369             end
 370         end
 371
 372         for slen, slist in pairs(key_prefixes) do
 373             if #k >= slen then
 374                 val = slist[k:sub(1, slen)]
 375                 if val ~= nil then
 376                     return val
 377                 end
 378             end
 379         end
 380     end
 381 end
 382
 383 -- Returns prefix part of the keys, and reject suffix matching keys
 384 local function process_key(key)
 385     if key:sub(1, 1) == '*' then
 386         return nil
 387     end
 388     if key:sub(#key, #key) == '*' then
 389         return key:sub(1, #key - 2)
 390     end
 391     return key
 392 end
 393
 394 -- Process functions for all data types
 395 function module.process_node(object)
 396
 397     local function geom_func(o)
 398         return o:as_point()
 399     end
 400
 401     module.process_tags(Place.new(object, geom_func))
 402 end
 403
 404 function module.process_way(object)
 405
 406     local function geom_func(o)
 407         local geom = o:as_polygon()
 408
 409         if geom:is_null() then
 410             geom = o:as_linestring()
 411         end
 412
 413         return geom
 414     end
 415
 416     module.process_tags(Place.new(object, geom_func))
 417 end
 418
 419 function module.process_relation(object)
 420     local geom_func = module.RELATION_TYPES[object.tags.type]
 421
 422     if geom_func ~= nil then
 423         module.process_tags(Place.new(object, geom_func))
 424     end
 425 end
 426
 427 -- The process functions are used by default by osm2pgsql.
 428 osm2pgsql.process_node = module.process_node
 429 osm2pgsql.process_way = module.process_way
 430 osm2pgsql.process_relation = module.process_relation
 431
 432 function module.process_tags(o)
 433     o:clean{delete = PRE_DELETE, extra = PRE_EXTRAS}
 434
 435     -- Exception for boundary/place double tagging
 436     if o.object.tags.boundary == 'administrative' then
 437         o:grab_extratags{match = function (k, v)
 438             return k == 'place' and v:sub(1,3) ~= 'isl'
 439         end}
 440     end
 441
 442     -- name keys
 443     local fallback = o:grab_name_parts{groups=NAMES}
 444
 445     -- address keys
 446     if o:grab_address_parts{groups=ADDRESS_TAGS} > 0 and fallback == nil then
 447         fallback = {'place', 'house', 'always'}
 448     end
 449     if o.address.country ~= nil and #o.address.country ~= 2 then
 450         o.address['country'] = nil
 451     end
 452     if POSTCODE_FALLBACK and fallback == nil and o.address.postcode ~= nil then
 453         fallback = {'place', 'postcode', 'always'}
 454     end
 455
 456     if o.address.interpolation ~= nil then
 457         o:write_place('place', 'houses', 'always', SAVE_EXTRA_MAINS)
 458         return
 459     end
 460
 461     o:clean{delete = POST_DELETE}
 462
 463     -- collect main keys
 464     for k, v in pairs(o.object.tags) do
 465         local ktype = MAIN_KEYS[k]
 466         if ktype == 'fallback' then
 467             if o.has_name then
 468                 fallback = {k, v, 'named'}
 469             end
 470         elseif ktype ~= nil then
 471             o:write_place(k, v, MAIN_KEYS[k], SAVE_EXTRA_MAINS)
 472         end
 473     end
 474
 475     if fallback ~= nil and o.num_entries == 0 then
 476         o:write_place(fallback[1], fallback[2], fallback[3], SAVE_EXTRA_MAINS)
 477     end
 478 end
 479
 480 --------- Convenience functions for simple style configuration -----------------
 481
 482
 483 function module.set_prefilters(data)
 484     PRE_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 485     PRE_EXTRAS = module.tag_match{keys = data.extra_keys,
 486                                   tags = data.extra_tags}
 487     module.TAGINFO_MAIN.delete_tags = data.delete_tags
 488 end
 489
 490 function module.set_main_tags(data)
 491     MAIN_KEYS = data
 492     local keys = {}
 493     for k, _ in pairs(data) do
 494         table.insert(keys, k)
 495     end
 496     module.TAGINFO_MAIN.keys = keys
 497 end
 498
 499 function module.set_name_tags(data)
 500     NAMES = module.tag_group(data)
 501
 502     for _, lst in pairs(data) do
 503         for _, k in ipairs(lst) do
 504             local key = process_key(k)
 505             if key ~= nil then
 506                 module.TAGINFO_NAME_KEYS[key] = true
 507             end
 508         end
 509     end
 510 end
 511
 512 function module.set_address_tags(data)
 513     if data.postcode_fallback ~= nil then
 514         POSTCODE_FALLBACK = data.postcode_fallback
 515         data.postcode_fallback = nil
 516     end
 517     ADDRESS_TAGS = module.tag_group(data)
 518
 519     for _, lst in pairs(data) do
 520         if lst ~= nil then
 521             for _, k in ipairs(lst) do
 522                 local key = process_key(k)
 523                 if key ~= nil then
 524                     module.TAGINFO_ADDRESS_KEYS[key] = true
 525                 end
 526             end
 527         end
 528     end
 529 end
 530
 531 function module.set_unused_handling(data)
 532     if data.extra_keys == nil and data.extra_tags == nil then
 533         POST_DELETE = module.tag_match{keys = data.delete_keys, tags = data.delete_tags}
 534         SAVE_EXTRA_MAINS = function() return true end
 535     elseif data.delete_keys == nil and data.delete_tags == nil then
 536         POST_DELETE = nil
 537         SAVE_EXTRA_MAINS = module.tag_match{keys = data.extra_keys, tags = data.extra_tags}
 538     else
 539         error("unused handler can have only 'extra_keys' or 'delete_keys' set.")
 540     end
 541 end
 542
 543 function module.set_relation_types(data)
 544     module.RELATION_TYPES = {}
 545     for k, v in data do
 546         if v == 'multipolygon' then
 547             module.RELATION_TYPES[k] = module.relation_as_multipolygon
 548         elseif v == 'multiline' then
 549             module.RELATION_TYPES[k] = module.relation_as_multiline
 550         end
 551     end
 552 end
 553
 554 return module