imposm3 Documentation

Imposm is an importer for OpenStreetMap (OSM) data. It reads PBF files and imports the data into PostgreSQL/PostGIS databases. It is specifically designed to create databases optimized for rendering, tile services, and map services.

Key capabilities include:

• Custom database schemas: Creates separate tables for different feature types to improve styling and rendering performance.
• Parallel processing: Designed from the ground up to distribute parsing and processing across multiple CPU cores.
• Data unification: Normalizes values (e.g., converting 1, on, true, and yes to TRUE).
• Tag filtering: Allows importing only the specific data needed for rendering or use.
• Efficient node caching: Uses a file-based key-value database to cache nodes, reducing memory usage during the construction of ways and relations.
• Generalized tables: Can automatically create tables with lower spatial resolutions.
• Geometry limiting: Can limit imported geometries to polygons from GeoJSON.
• hstore support: Can store all OSM tags in a PostgreSQL hstore column if specific tags are unknown beforehand.

The tables section is the core of the mapping file. Each table is defined by a unique name and contains several configuration blocks:

• type: The geometry or entity type. Supported values are point, linestring, polygon, geometry, relation, and relation_member.
• mapping: Defines the OSM key/value pairs required for an element to be imported. Use __any__ to match all values for a key (e.g., amenity: [__any__]). To match elements regardless of tags, use __any__: [__any__] (requires load_all tags).
• relation_types: (For relation, relation_member, or polygon types) Restricts imports to specific OSM relation types (e.g., [route, master_route]). For polygon types, this controls which relations are built into multi-polygons. Defaults to [multipolygon, boundary, land_area].
• columns: A list of columns to create for the table.
• filters: Logic to include or exclude elements based on tags.
• mappings: (Optional) Allows an element to be inserted multiple times into the same table if it matches different sub-mappings.

When relations contain mixed geometry types (e.g., a bus route containing nodes for stops and ways for platforms) or would result in invalid geometries if flattened, use the relation_member table type. This type inserts each member of the relation as a separate row.

Each row in a relation_member table provides access to:

• The relation's osm_id.
• The member's member_id.
• The member's index (useful for maintaining order, e.g., stop sequences).
• The member's role and type (0 for nodes, 1 for ways, 2 for relations).
• The member's geometry.
• Tags from the relation itself.
• Tags from the member (if from_member: true is used in the mapping).

To import tags from the member element, use the from_member: true option in your column configuration.

route_members:
  type: relation_member
  columns:
  - name: osm_id
    type: id
  - name: member
    type: member_id
  - name: index
    type: member_index
  - name: role
    type: member_role
  - name: type
    type: member_type
  - name: geometry
    type: geometry
  - name: relname
    key: name
    type: string
  - name: name
    key: name
    type: string
    from_member: true
  - key: ref
    name: ref
    type: string
  relation_types: [route]
  mapping:
    route: [bus]

You can limit which elements are inserted into a table using filters.

• require: Only import elements that have these specific tags.
• reject: Do not import elements that have these specific tags.
• require_regexp: Only import elements where the tag value matches a regular expression.
• reject_regexp: Do not import elements where the tag value matches a regular expression.

Important:

• Regular expressions in require_regexp and reject_regexp must be enclosed in single quotes (') to prevent YAML from interpreting backslashes as escape sequences.
• You can only filter tags that are explicitly referenced in the mapping or columns of any table.

tables:
  buildings:
    type: polygon
    filters:
      require:
        name: [__any__]
      reject:
        building: ['no', none]
      reject_regexp:
        level: '^\D+.*$'
    mapping:
      building: [__any__]
    columns:
      ...