Merge branch 'master' into gh-master

# Conflicts:
#	Makefile
#	layers/landuse/landuse.sql
#	layers/poi/poi.sql

.env

@@ -1,7 +1,10 @@
 # This file defines default environment variables for all images
 
+# Layers definition and meta data
+TILESET_FILE=openmaptiles.yaml
+
 # Use 3-part patch version to ignore patch updates, e.g. 5.0.0
-TOOLS_VERSION=5.2
+TOOLS_VERSION=5.3
 
 # Make sure these values are in sync with the ones in .env-postgres file
 PGDATABASE=openmaptiles
@@ -11,7 +14,8 @@ PGHOST=postgres
 PGPORT=5432
 
 # BBOX may get overwritten by the computed bbox of the specific area:
-#   make generate-dc-config
+#   make generate-bbox-file
+# By default, the Makefile will use the content of data/$(area).bbox file if it exists.
 BBOX=-180.0,-85.0511,180.0,85.0511
 
 # Which zooms to generate in   make generate-tiles
@@ -41,3 +45,11 @@ BORDERS_CSV_FILE=data/borders/lines.csv
 
 # Number of parallel processes to use when importing sql files
 MAX_PARALLEL_PSQL=5
+
+# Number of parallel threads to use when generating vector map tiles
+COPY_CONCURRENCY=10
+
+# Variables for generate tiles using PGquery
+PGHOSTS_LIST=
+NO_GZIP=1
+USE_KEY_COLUMN=1

.github/workflows/tests.yml

@@ -22,11 +22,8 @@ jobs:
           area: monaco
           MIN_ZOOM: 0
           MAX_ZOOM: 14
+          QUIET: 1
         run: |
-          # For now, change the quickstart values directly in the .env file	
-          # TODO: We should probably use env vars instead	
-          sed -i 's/MAX_ZOOM=7/MAX_ZOOM=14/g' .env
-          export QUIET=1
           ./quickstart.sh $area
 
       - name: Save quickstart.log
@@ -106,7 +103,7 @@ jobs:
         with:
           path: perf_cache
           # If profiling result cache has incompatible format, increase this "v" number
-          key: "v11-${{ steps.calc.outputs.hash }}-${{ env.TEST_DATA_URL }}"
+          key: "v12-${{ steps.calc.outputs.hash }}-${{ env.TEST_DATA_URL }}"
 
       - name: Load test data into DB and run performance test
         id: main

Makefile

@@ -9,9 +9,12 @@ SHELL         = /bin/bash
 # Make all .env variables available for make targets
 include .env
 
+# Layers definition and meta data
+TILESET_FILE ?= openmaptiles.yaml
+
 # Options to run with docker and docker-compose - ensure the container is destroyed on exit
 # Containers run as the current user rather than root (so that created files are not root-owned)
-DC_OPTS ?= --rm -u $(shell id -u):$(shell id -g)
+DC_OPTS ?= --rm --user=$(shell id -u):$(shell id -g)
 
 DC_USER?=openmaptiles
 DC_PASSWORD?=openmaptiles
@@ -56,6 +59,7 @@ endif
 
 # Set OpenMapTiles host
 OMT_HOST := http://$(firstword $(subst :, ,$(subst tcp://,,$(DOCKER_HOST))) localhost)
+export OMT_HOST
 
 # This defines an easy $(newline) value to act as a "\n". Make sure to keep exactly two empty lines after newline.
 define newline
@@ -66,40 +70,66 @@ endef
 
 #
 # Determine area to work on
-# If $(area) parameter is not set and data/*.osm.pbf finds only one file, use it as $(area).
+# If $(area) parameter is not set, and only one *.osm.pbf file is found in ./data, use it as $(area).
-# Otherwise all make targets requiring area param will show an error.
+# Otherwise, all make targets requiring an area will show an error.
-# Note: If there are no data files, and user calls  make download area=... once,
+# Note: If no *.osm.pbf files are found, once the users call  "make download area=..."
-#       they will not need to use area= parameter after that because there will be just a single file.
+#       they will not need to use an "area=" parameter again because there will be just a single file.
 #
 
 # historically we have been using $(area) rather than $(AREA), so make both work
 area ?= $(AREA)
-# Ensure the $(AREA) param is set, or try to automatically determine it based on available data files
+# Ensure the $(area) param is set, or try to automatically determine it based on available data files
 ifeq ($(strip $(area)),)
-  # if $area is not set. set it to the name of the *.osm.pbf file, but only if there is only one
+  # An $(area) parameter is not set. If only one *.osm.pbf file is found in ./data, use it as $(area).
-  data_files := $(wildcard data/*.osm.pbf)
+  data_files := $(shell find data -name '*.osm.pbf' 2>/dev/null)
   ifneq ($(word 2,$(data_files)),)
-    AREA_ERROR := The 'area' parameter (or env var) has not been set, and there are more than one data/*.osm.pbf files: $(patsubst data/%.osm.pbf,'%',$(data_files))
+    define assert_area_is_given
+	  @echo ""
+	  @echo "ERROR: The 'area' parameter or environment variable have not been set, and there several 'area' options:"
+	  @$(patsubst data/%.osm.pbf,echo "  '%'";,$(data_files))
+	  @echo ""
+	  @echo "To specify an area use:"
+	  @echo "  make $@ area=<area-id>"
+	  @echo ""
+	  @exit 1
+    endef
   else
     ifeq ($(word 1,$(data_files)),)
-      AREA_ERROR := The 'area' parameter (or env var) has not been set, and there are no data/*.osm.pbf files
+      define assert_area_is_given
+        @echo ""
+        @echo "ERROR: The 'area' parameter (or env var) has not been set, and there are no data/*.osm.pbf files"
+        @echo ""
+        @echo "To specify an area use"
+        @echo "  make $@ area=<area-id>"
+        @echo ""
+        @echo "To download an area, use   make download area=<area-id>"
+        @echo "To list downloadable areas, use   make list-geofabrik   and/or   make list-bbbike"
+        @exit 1
+        @echo ""
+      endef
     else
       # Keep just the name of the data file, without the .osm.pbf extension
-      area := $(strip $(basename $(basename $(notdir $(data_files)))))
+      area := $(patsubst data/%.osm.pbf,%,$(data_files))
       # Rename area-latest.osm.pbf to area.osm.pbf
       # TODO: This if statement could be removed in a few months once everyone is using the file without the `-latest`?
       ifneq ($(area),$(area:-latest=))
         $(shell mv "data/$(area).osm.pbf" "data/$(area:-latest=).osm.pbf")
         area := $(area:-latest=)
         $(warning ATTENTION: File data/$(area)-latest.osm.pbf was renamed to $(area).osm.pbf.)
-        AREA_INFO := Detected area=$(area) based on the found data/$(area)-latest.osm.pbf (renamed to $(area).osm.pbf). Use 'area' parameter (or env var) to override.
+        AREA_INFO := Detected area=$(area) based on finding a 'data/$(area)-latest.osm.pbf' file - renamed to '$(area).osm.pbf'. Use 'area' parameter or environment variable to override.
       else
-        AREA_INFO := Detected area=$(area) based on the found data/ pbf file. Use 'area' parameter (or env var) to override.
+        AREA_INFO := Detected area=$(area) based on finding a 'data/$(area).osm.pbf' file. Use 'area' parameter or environment variable to override.
       endif
     endif
   endif
 endif
 
+ifneq ($(strip $(AREA_INFO)),)
+  define assert_area_is_given
+      @echo "$(AREA_INFO)"
+  endef
+endif
+
 # If set, this file will be downloaded in download-osm and imported in the import-osm targets
 PBF_FILE ?= data/$(area).osm.pbf
 
@@ -126,8 +156,13 @@ ifeq ($(strip $(DIFF_MODE)),true)
   export IMPOSM_CONFIG_FILE = data/$(area).repl.json
 endif
 
-# download-osm generates this file with metadata about the file
+# Load area-specific bbox file that gets generated by the download-osm --bbox
-AREA_DC_CONFIG_FILE ?= data/$(area).dc-config.yml
+AREA_BBOX_FILE ?= data/$(area).bbox
+ifneq (,$(wildcard $(AREA_BBOX_FILE)))
+  cat := $(if $(filter $(OS),Windows_NT),type,cat)
+  BBOX := $(shell $(cat) ${AREA_BBOX_FILE})
+  export BBOX
+endif
 
 ifeq ($(strip $(area)),)
   define assert_area_is_given
@@ -148,8 +183,6 @@ else
   endif
 endif
 
-
-
 #
 #  TARGETS
 #
@@ -167,7 +200,7 @@ help:
 	@echo " "
 	@echo "Hints for designers:"
 	@echo "  make start-maputnik                  # start Maputnik Editor + dynamic tile server [ see $(OMT_HOST):8088 ]"
-	@echo "  make start-postserve                 # start dynamic tile server                   [ see $(OMT_HOST):$(PPORT)} ]"
+	@echo "  make start-postserve                 # start dynamic tile server                   [ see $(OMT_HOST):$(PPORT) ]"
 	@echo "  make start-tileserver                # start maptiler/tileserver-gl                [ see $(OMT_HOST):$(TPORT) ]"
 	@echo " "
 	@echo "Hints for developers:"
@@ -178,12 +211,12 @@ help:
 	@echo "  make download-geofabrik area=albania # download OSM data from geofabrik.de     and create config file"
 	@echo "  make download-osmfr area=asia/qatar  # download OSM data from openstreetmap.fr and create config file"
 	@echo "  make download-bbbike area=Amsterdam  # download OSM data from bbbike.org       and create config file"
-	@echo "  make generate-dc-config              # scan data file and generate tile generation config file with bbox"
+	@echo "  make generate-bbox-file              # compute bounding box of a data file and store it in a file"
 	@echo "  make psql                            # start PostgreSQL console"
 	@echo "  make psql-list-tables                # list all PostgreSQL tables"
 	@echo "  make vacuum-db                       # PostgreSQL: VACUUM ANALYZE"
 	@echo "  make analyze-db                      # PostgreSQL: ANALYZE"
-	@echo "  make generate-qareports              # generate reports                                [./build/qareports]"
+	@echo "  make generate-qa                     # statistics for a given layer's field"
 	@echo "  make generate-devdoc                 # generate devdoc including graphs for all layers [./layers/...]"
 	@echo "  make bash                            # start openmaptiles-tools /bin/bash terminal"
 	@echo "  make destroy-db                      # remove docker containers and PostgreSQL data volume"
@@ -193,8 +226,8 @@ help:
 	@echo "  make clean-unnecessary-docker        # clean unnecessary docker image(s) and container(s)"
 	@echo "  make refresh-docker-images           # refresh openmaptiles docker images from Docker HUB"
 	@echo "  make remove-docker-images            # remove openmaptiles docker images"
-	@echo "  make pgclimb-list-views              # list PostgreSQL public schema views"
+	@echo "  make list-views                      # list PostgreSQL public schema views"
-	@echo "  make pgclimb-list-tables             # list PostgreSQL public schema tables"
+	@echo "  make list-tables                     # list PostgreSQL public schema tables"
 	@echo "  cat  .env                            # list PG database and MIN_ZOOM and MAX_ZOOM information"
 	@echo "  cat  quickstart.log                  # transcript of the last ./quickstart.sh run"
 	@echo "  make help                            # help about available commands"
@@ -209,12 +242,12 @@ init-dirs:
 
 build/openmaptiles.tm2source/data.yml: init-dirs
 ifeq (,$(wildcard build/openmaptiles.tm2source/data.yml))
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools generate-tm2source openmaptiles.yaml --host="postgres" --port=5432 --database="openmaptiles" --user="$(DC_USER)" --password="$(DC_PASSWORD)" > $@
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools generate-tm2source $(TILESET_FILE) --host="postgres" --port=5432 --database="openmaptiles" --user="$(DC_USER)" --password="$(DC_PASSWORD)" > $@
 endif
 
 build/mapping.yaml: init-dirs
 ifeq (,$(wildcard build/mapping.yaml))
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools generate-imposm3 openmaptiles.yaml > $@
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools generate-imposm3 $(TILESET_FILE) > $@
 endif
 
 .PHONY: build-sql
@@ -222,8 +255,8 @@ build-sql: init-dirs
 ifeq (,$(wildcard build/sql/run_last.sql))
 	@mkdir -p build/sql/parallel
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools bash -c \
-		'generate-sql openmaptiles.yaml --dir ./build/sql \
+		'generate-sql $(TILESET_FILE) --dir ./build/sql \
-		&& generate-sqltomvt openmaptiles.yaml \
+		&& generate-sqltomvt $(TILESET_FILE) \
 							 --key --gzip --postgis-ver 3.0.1 \
 							 --function --fname=getmvt >> ./build/sql/run_last.sql'
 endif
@@ -288,10 +321,12 @@ ifeq (,$(wildcard $(PBF_FILE)))
 	@echo "Downloading $(DOWNLOAD_AREA) with replication support into $(PBF_FILE) and $(IMPOSM_CONFIG_FILE) from $(if $(OSM_SERVER),$(OSM_SERVER),any source)"
 	@$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools download-osm $(OSM_SERVER) "$(DOWNLOAD_AREA)" \
 				--imposm-cfg "$(IMPOSM_CONFIG_FILE)" \
+				--bbox "$(AREA_BBOX_FILE)" \
 				--output "$(PBF_FILE)"
  else
 	@echo "Downloading $(DOWNLOAD_AREA) into $(PBF_FILE) from $(if $(OSM_SERVER),$(OSM_SERVER),any source)"
 	@$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools download-osm $(OSM_SERVER) "$(DOWNLOAD_AREA)" \
+				--bbox "$(AREA_BBOX_FILE)" \
 				--output "$(PBF_FILE)"
  endif
 	@echo ""
@@ -313,40 +348,45 @@ else
  endif
 endif
 
-.PHONY: generate-dc-config
+.PHONY: generate-bbox-file
-generate-dc-config:
+generate-bbox-file:
 	@$(assert_area_is_given)
-ifeq (,$(wildcard $(AREA_DC_CONFIG_FILE)))
+ifeq (,$(wildcard $(AREA_BBOX_FILE)))
-	@$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools bash -c ' \
+	@$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools download-osm bbox "$(PBF_FILE)" "$(AREA_BBOX_FILE)"
-		download-osm make-dc "$(PBF_FILE)" \
-			--make-dc "$(AREA_DC_CONFIG_FILE)" \
-			--id "$(area)"'
 else
-	@echo "Configuration file $(AREA_DC_CONFIG_FILE) already exists, no need to regenerate."
+	@echo "Configuration file $(AREA_BBOX_FILE) already exists, no need to regenerate.  BBOX=$(BBOX)"
 endif
 
 .PHONY: psql
 psql: start-db-nowait
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c 'pgwait && psql.sh'
 
+# Special cache handling for Docker Toolbox on Windows
+ifeq ($(MSYSTEM),MINGW64)
+  DC_CONFIG_CACHE := -f docker-compose.yml -f docker-compose-$(MSYSTEM).yml
+  DC_OPTS_CACHE := $(strip $(filter-out --user=%,$(DC_OPTS)))
+else
+  DC_OPTS_CACHE := $(DC_OPTS)
+endif
+
 .PHONY: import-osm
 import-osm: all start-db-nowait
 	@$(assert_area_is_given)
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c 'pgwait && import-osm $(PBF_FILE)'
+	$(DOCKER_COMPOSE) $(DC_CONFIG_CACHE) run $(DC_OPTS_CACHE) openmaptiles-tools sh -c 'pgwait && import-osm $(PBF_FILE)'
 
 .PHONY: update-osm
 update-osm: all start-db-nowait
 	@$(assert_area_is_given)
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c 'pgwait && import-update'
+	$(DOCKER_COMPOSE) $(DC_CONFIG_CACHE) run $(DC_OPTS_CACHE) openmaptiles-tools sh -c 'pgwait && import-update'
 
 .PHONY: import-diff
 import-diff: all start-db-nowait
 	@$(assert_area_is_given)
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c 'pgwait && import-diff'
+	$(DOCKER_COMPOSE) $(DC_CONFIG_CACHE) run $(DC_OPTS_CACHE) openmaptiles-tools sh -c 'pgwait && import-diff'
 
 .PHONY: import-data
 import-data: start-db
-	$(DOCKER_COMPOSE) run $(DC_OPTS) import-data
+	$(DOCKER_COMPOSE) $(DC_CONFIG_CACHE) run $(DC_OPTS_CACHE) import-data
 
 .PHONY: import-borders
 import-borders: start-db-nowait
@@ -358,20 +398,27 @@ import-borders: start-db-nowait
 .PHONY: import-sql
 import-sql: all start-db-nowait
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c 'pgwait && import-sql' | \
-	  awk -v s=": WARNING:" '$$0~s{print; print "\n*** WARNING detected, aborting"; exit(1)} 1'
+	  awk -v s=": WARNING:" '1{print; fflush()} $$0~s{print "\n*** WARNING detected, aborting"; exit(1)}'
 
-ifneq ($(wildcard $(AREA_DC_CONFIG_FILE)),)
-  DC_CONFIG_TILES := -f docker-compose.yml -f $(AREA_DC_CONFIG_FILE)
-endif
 .PHONY: generate-tiles
 generate-tiles: all start-db
 	@$(assert_area_is_given)
 	@echo "Generating tiles into $(MBTILES_LOCAL_FILE) (will delete if already exists)..."
 	@rm -rf "$(MBTILES_LOCAL_FILE)"
-	$(DOCKER_COMPOSE) $(DC_CONFIG_TILES) run $(DC_OPTS) generate-vectortiles
+	$(DOCKER_COMPOSE) run $(DC_OPTS) generate-vectortiles
 	@echo "Updating generated tile metadata ..."
-	$(DOCKER_COMPOSE) $(DC_CONFIG_TILES) run $(DC_OPTS) openmaptiles-tools \
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools \
-			mbtiles-tools meta-generate "$(MBTILES_LOCAL_FILE)" ./openmaptiles.yaml --auto-minmax --show-ranges
+			mbtiles-tools meta-generate "$(MBTILES_LOCAL_FILE)" $(TILESET_FILE) --auto-minmax --show-ranges
+
+.PHONY: generate-tiles-pg
+generate-tiles-pg: all start-db
+	@$(assert_area_is_given)
+	@echo "Generating tiles into $(MBTILES_LOCAL_FILE) (will delete if already exists)..."
+	@rm -rf "$(MBTILES_LOCAL_FILE)"
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools generate-tiles
+	@echo "Updating generated tile metadata ..."
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools \
+			mbtiles-tools meta-generate "$(MBTILES_LOCAL_FILE)" $(TILESET_FILE) --auto-minmax --show-ranges
 
 .PHONY: start-tileserver
 start-tileserver: init-dirs
@@ -430,17 +477,22 @@ start-maputnik: stop-maputnik start-postserve
 stop-maputnik:
 	-docker rm -f maputnik_editor
 
-.PHONY: generate-qareports
+# STAT_FUNCTION=frequency|toplength|variance
-generate-qareports: start-db
+.PHONY: generate-qa
-	./qa/run.sh
+generate-qa: all start-db-nowait
+	@echo " "
+	@echo "e.g. make generate-qa STAT_FUNCTION=frequency LAYER=transportation ATTRIBUTE=class"
+	@echo " "
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools \
+		layer-stats $(STAT_FUNCTION) $(TILESET_FILE) $(LAYER) $(ATTRIBUTE) -m 0 -n 14 -v
 
 # generate all etl and mapping graphs
 .PHONY: generate-devdoc
 generate-devdoc: init-dirs
 	mkdir -p ./build/devdoc && \
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools sh -c \
-			'generate-etlgraph openmaptiles.yaml $(GRAPH_PARAMS) && \
+			'generate-etlgraph $(TILESET_FILE) $(GRAPH_PARAMS) && \
-			 generate-mapping-graph openmaptiles.yaml $(GRAPH_PARAMS)'
+			 generate-mapping-graph $(TILESET_FILE) $(GRAPH_PARAMS)'
 
 .PHONY: bash
 bash: init-dirs
@@ -448,7 +500,7 @@ bash: init-dirs
 
 .PHONY: import-wikidata
 import-wikidata: init-dirs
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools import-wikidata --cache /cache/wikidata-cache.json openmaptiles.yaml
+	$(DOCKER_COMPOSE) $(DC_CONFIG_CACHE) run $(DC_OPTS_CACHE) openmaptiles-tools import-wikidata --cache /cache/wikidata-cache.json $(TILESET_FILE)
 
 .PHONY: reset-db-stats
 reset-db-stats: init-dirs
@@ -457,12 +509,12 @@ reset-db-stats: init-dirs
 .PHONY: list-views
 list-views: init-dirs
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools psql.sh -v ON_ERROR_STOP=1 -A -F"," -P pager=off -P footer=off \
-		-c "select schemaname, viewname from pg_views where schemaname='public' order by viewname;"
+		-c "select viewname from pg_views where schemaname='public' order by viewname;"
 
 .PHONY: list-tables
 list-tables: init-dirs
 	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools psql.sh -v ON_ERROR_STOP=1 -A -F"," -P pager=off -P footer=off \
-		-c "select schemaname, tablename from pg_tables where schemaname='public' order by tablename;"
+		-c "select tablename from pg_tables where schemaname='public' order by tablename;"
 
 .PHONY: psql-list-tables
 psql-list-tables: init-dirs
@@ -510,12 +562,21 @@ clean-unnecessary-docker:
 	@echo "Deleting unnecessary container(s)..."
 	@docker ps -a -q --filter "status=exited" | $(XARGS) docker rm
 	@echo "Deleting unnecessary image(s)..."
-	@docker images | grep \<none\> | awk -F" " '{print $$3}' | $(XARGS) docker rmi
+	@docker images | awk -F" " '/<none>/{print $$3}' | $(XARGS) docker rmi
 
 .PHONY: test-perf-null
 test-perf-null: init-dirs
-	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools test-perf openmaptiles.yaml --test null --no-color
+	$(DOCKER_COMPOSE) run $(DC_OPTS) openmaptiles-tools test-perf $(TILESET_FILE) --test null --no-color
 
 .PHONY: build-test-pbf
 build-test-pbf: init-dirs
 	docker-compose run $(DC_OPTS) openmaptiles-tools /tileset/.github/workflows/build-test-data.sh
+
+.PHONY: debug
+debug:  ## Use this target when developing Makefile itself to verify loaded environment variables
+	@$(assert_area_is_given)
+	@echo file_exists = $(wildcard $(AREA_BBOX_FILE))
+	@echo AREA_BBOX_FILE = $(AREA_BBOX_FILE) , $$AREA_ENV_FILE
+	@echo BBOX = $(BBOX) , $$BBOX
+	@echo MIN_ZOOM = $(MIN_ZOOM) , $$MIN_ZOOM
+	@echo MAX_ZOOM = $(MAX_ZOOM) , $$MAX_ZOOM

QUICKSTART.md

@@ -363,12 +363,13 @@ This is generating `.mbtiles` for your area :  [ MIN_ZOOM: "0"  - MAX_ZOOM: "7"
 ./quickstart.sh yukon                        # Yukon, Canada
 ```
 ### Using your own OSM data
-Mbtiles can be generated from an arbitrary osm.pbf (e.g. for a region that is not covered by an existing extract) by making the `data/` directory and placing an *-latest.osm.pbf inside. Inside of folder have to be `docker-compose-config.yml` file too, otherwize whole folder `data/` will be deleted and `download-osm` will try to download osm.pbf file from `geofabric`, `osmfr` or `bbbike`.
+Mbtiles can be generated from an arbitrary osm.pbf (e.g. for a region that is not covered by an existing extract) by making the `data/` directory and placing an *.osm.pbf (e.g. `mydata.osm.pbf`) inside.
 
 ```
 mkdir -p data
-mv my-latest.osm.pbf data/
+mv mydata.osm.pbf data/
-./quickstart.sh my
+make generate-bbox-file area=mydata
+./quickstart.sh mydata
 ```
 
 ### Check postserve
@@ -390,12 +391,21 @@ modify the settings in the `.env` file, the defaults:
 * `MIN_ZOOM=0`
 * `MAX_ZOOM=7`
 
-Delete the `./data/<area>.dc-config.yml` file, and re-start `./quickstart.sh <area>`
-
 Hints:
 * Small increments! Never starts with the `MAX_ZOOM = 14`
 * The suggested  `MAX_ZOOM = 14`  - use only with small extracts
 
+### Set the bounding box to generate
+
+By default, tile generation is done for the full extent of the area.
+If you want to generate a tiles for a smaller extent, modify the settings in the `.env` file, the default:
+* `BBOX=-180.0,-85.0511,180.0,85.0511`
+
+Delete the `./data/<area>.bbox` file, and re-start `./quickstart.sh <area>`
+
+Hint:
+* The [boundingbox.klokantech.com](https://boundingbox.klokantech.com/) site can be used to find a bounding box (CSV format) using a map.
+
 ### Check other commands
 
 `make help`
@@ -421,7 +431,7 @@ Hints for developers:
   make psql-list-tables                # list all PostgreSQL tables
   make psql-vacuum-analyze             # PostgreSQL: VACUUM ANALYZE
   make psql-analyze                    # PostgreSQL: ANALYZE
-  make generate-qareports              # generate reports [./build/qareports]
+  make generate-qa                     # statistics for a given layer's field
   make generate-devdoc                 # generate devdoc  [./build/devdoc]
   make tools-dev                       # start import-sql  /bin/bash terminal
   make db-destroy                      # remove docker containers, PG data volume

README.md

@@ -1,6 +1,6 @@
 ## OpenMapTiles [![Build Status](https://github.com/openmaptiles/openmaptiles/workflows/OMT_CI/badge.svg?branch=master)](https://github.com/openmaptiles/openmaptiles/actions)
 
-OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information [openmaptiles.org](https://openmaptiles.org/) and [openmaptiles.com](https://openmaptiles.com/).
+OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information [openmaptiles.org](https://openmaptiles.org/) and [maptiler.com/data/](https://www.maptiler.com/data/).
 
 We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the [openmaptiles/openmaptiles-tools](https://github.com/openmaptiles/openmaptiles-tools) to simplify vector tile creation.
 
@@ -8,7 +8,7 @@ Please keep in mind that OpenMapTiles schema should display general topographic
 
 - :link: Schema https://openmaptiles.org/schema
 - :link: Docs https://openmaptiles.org/docs
-- :link: Production package: https://openmaptiles.com/production-package/
+- :link: Data for download: https://www.maptiler.com/data/
 - :link: Hosting https://www.maptiler.com/cloud/
 - :link: Create own layer https://github.com/openmaptiles/openmaptiles-skiing
 - :link: Discuss at the #openmaptiles channel at [OSM Slack](https://osmus-slack.herokuapp.com/)
@@ -135,10 +135,10 @@ make
 make import-sql
 ```
 
-Now you are ready to **generate the vector tiles**. By default, `./.env` specifies the entire planet BBOX for zooms 0-7, but running `generate-dc-config` will analyze the data file and set the `BBOX` param to limit tile generation. It will also modify `MIN_ZOOM` and `MAX_ZOOM` values based on the .env, but can be changed.
+Now you are ready to **generate the vector tiles**. By default, `./.env` specifies the entire planet BBOX for zooms 0-7, but running `generate-bbox-file` will analyze the data file and set the `BBOX` param to limit tile generation.
 
 ```
-make generate-dc-config  # compute data bbox -- not needed for the whole planet
+make generate-bbox-file  # compute data bbox -- not needed for the whole planet
 make generate-tiles      # generate tiles
 ```
 

docker-compose-MINGW64.yml

@@ -0,0 +1,11 @@
+# This version must match the MAKE_DC_VERSION in docker-compose.yml
+version: "3"
+
+volumes:
+  cache:
+
+services:
+
+  openmaptiles-tools:
+    volumes:
+      - cache:/cache

docker-compose.yml

@@ -1,11 +1,11 @@
 # This version must match the MAKE_DC_VERSION value below
-version: "2.3"
+version: "3"
 
 volumes:
   pgdata:
 
 networks:
-  postgres_conn:
+  postgres:
     driver: bridge
 
 services:
@@ -16,7 +16,7 @@ services:
     volumes:
       - pgdata:/var/lib/postgresql/data
     networks:
-      - postgres_conn
+      - postgres
     ports:
       - "5432"
     env_file: .env-postgres
@@ -25,7 +25,7 @@ services:
     image: "openmaptiles/import-data:${TOOLS_VERSION}"
     env_file: .env
     networks:
-      - postgres_conn
+      - postgres
 
   openmaptiles-tools:
     image: "openmaptiles/openmaptiles-tools:${TOOLS_VERSION}"
@@ -33,9 +33,13 @@ services:
     environment:
       # Must match the version of this file (first line)
       # download-osm will use it when generating a composer file
-      MAKE_DC_VERSION: "2.3"
+      MAKE_DC_VERSION: "3"
-      # Allow DIFF_MODE to be overwritten from shell
+      # Allow DIFF_MODE, MIN_ZOOM, and MAX_ZOOM to be overwritten from shell
       DIFF_MODE: ${DIFF_MODE}
+      MIN_ZOOM: ${MIN_ZOOM}
+      MAX_ZOOM: ${MAX_ZOOM}
+      #Provide BBOX from *.bbox file if exists, else from .env
+      BBOX: ${BBOX}
       # Imposm configuration file describes how to load updates when enabled
       IMPOSM_CONFIG_FILE: ${IMPOSM_CONFIG_FILE}
       # Which files to use during import-borders processing
@@ -45,10 +49,11 @@ services:
       # Control import-sql processes
       MAX_PARALLEL_PSQL: ${MAX_PARALLEL_PSQL}
     networks:
-      - postgres_conn
+      - postgres
     volumes:
       - .:/tileset
       - ./data:/import
+      - ./data:/export
       - ./build/sql:/sql
       - ./build:/mapping
       - ./cache:/cache
@@ -60,11 +65,13 @@ services:
       - ./data:/export
       - ./build/openmaptiles.tm2source:/tm2source
     networks:
-      - postgres_conn
+      - postgres
     env_file: .env
     environment:
       FILTER_MAPNIK_OUTPUT: ${FILTER_MAPNIK_OUTPUT}
       MBTILES_NAME: ${MBTILES_FILE}
+      # Control tilelive-copy threads
+      COPY_CONCURRENCY: ${COPY_CONCURRENCY}
 
   generate-vectortiles:
     image: "openmaptiles/generate-vectortiles:${TOOLS_VERSION}"
@@ -72,7 +79,7 @@ services:
       - ./data:/export
       - ./build/openmaptiles.tm2source:/tm2source
     networks:
-      - postgres_conn
+      - postgres
     env_file: .env
     environment:
       FILTER_MAPNIK_OUTPUT: ${FILTER_MAPNIK_OUTPUT}
@@ -80,13 +87,18 @@ services:
       BBOX: ${BBOX}
       MIN_ZOOM: ${MIN_ZOOM}
       MAX_ZOOM: ${MAX_ZOOM}
+      # Control tilelive-copy threads
+      COPY_CONCURRENCY: ${COPY_CONCURRENCY}
+      #
 
   postserve:
     image: "openmaptiles/openmaptiles-tools:${TOOLS_VERSION}"
-    command: "postserve openmaptiles.yaml --verbose --port ${PPORT:-8090}"
+    command: "postserve ${TILESET_FILE} --verbose --serve=${OMT_HOST:-http://localhost}:${PPORT:-8090}"
     env_file: .env
+    environment:
+      TILESET_FILE: ${TILESET_FILE}
     networks:
-      - postgres_conn
+      - postgres
     ports:
       - "${PPORT:-8090}:${PPORT:-8090}"
     volumes:

layers/aerodrome_label/aerodrome_label.sql

@@ -24,16 +24,16 @@ SELECT
     osm_id,
     geometry,
     name,
-    COALESCE(NULLIF(name_en, ''), name)                                  AS name_en,
+    COALESCE(NULLIF(name_en, ''), name) AS name_en,
-    COALESCE(NULLIF(name_de, ''), name, name_en)                         AS name_de,
+    COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
     tags,
     CASE
         %%FIELD_MAPPING: class %%
         ELSE 'other'
-        END                                                              AS class,
+        END AS class,
-    NULLIF(iata, '')                                                     AS iata,
+    NULLIF(iata, '') AS iata,
-    NULLIF(icao, '')                                                     AS icao,
+    NULLIF(icao, '') AS icao,
-    substring(ele FROM E'^(-?\\d+)(\\D|$)')::int                         AS ele,
+    substring(ele FROM E'^(-?\\d+)(\\D|$)')::int AS ele,
     round(substring(ele FROM E'^(-?\\d+)(\\D|$)')::int * 3.2808399)::int AS ele_ft
 FROM osm_aerodrome_label_point
 WHERE geometry && bbox

layers/aerodrome_label/aerodrome_label.yaml

@@ -44,7 +44,7 @@ layer:
     query: (SELECT osm_id, geometry, name, name_en, name_de, {name_languages}, class, iata, icao, ele, ele_ft FROM layer_aerodrome_label(!bbox!, z(!scale_denominator!))) AS t
 schema:
   - ./update_aerodrome_label_point.sql
-  - ./layer.sql
+  - ./aerodrome_label.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/aerodrome_label/update_aerodrome_label_point.sql

@@ -1,30 +1,49 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_aerodrome_label_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_aerodrome_label_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON aerodrome_label.updates;
 
+CREATE SCHEMA IF NOT EXISTS aerodrome_label;
+
+CREATE TABLE IF NOT EXISTS aerodrome_label.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc: osm_aerodrome_label_point -> osm_aerodrome_label_point
-CREATE OR REPLACE FUNCTION update_aerodrome_label_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_aerodrome_label_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
     UPDATE osm_aerodrome_label_point
     SET geometry = ST_Centroid(geometry)
-    WHERE ST_GeometryType(geometry) <> 'ST_Point';
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM aerodrome_label.osm_ids))
+        AND ST_GeometryType(geometry) <> 'ST_Point';
 
     UPDATE osm_aerodrome_label_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM aerodrome_label.osm_ids))
-END;
+        AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
-$$ LANGUAGE plpgsql;
+        AND tags != update_tags(tags, geometry);
+$$ LANGUAGE SQL;
 
-SELECT update_aerodrome_label_point();
+SELECT update_aerodrome_label_point(true);
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS aerodrome_label;
+CREATE OR REPLACE FUNCTION aerodrome_label.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO aerodrome_label.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO aerodrome_label.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS aerodrome_label.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION aerodrome_label.flag() RETURNS trigger AS
@@ -37,15 +56,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION aerodrome_label.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh aerodrome_label';
-    PERFORM update_aerodrome_label_point();
+    PERFORM update_aerodrome_label_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM aerodrome_label.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM aerodrome_label.updates;
+
+    RAISE LOG 'Refresh aerodrome_label done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_aerodrome_label_point
+    FOR EACH ROW
+EXECUTE PROCEDURE aerodrome_label.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_aerodrome_label_point

layers/aeroway/aeroway.sql

@@ -12,19 +12,19 @@ AS
 $$
 SELECT geometry, aeroway AS class, ref
 FROM (
-         -- etldoc:  osm_aeroway_linestring_gen3 -> layer_aeroway:z10
+         -- etldoc:  osm_aeroway_linestring_gen_z10 -> layer_aeroway:z10
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_linestring_gen3
+         FROM osm_aeroway_linestring_gen_z10
          WHERE zoom_level = 10
          UNION ALL
-         -- etldoc:  osm_aeroway_linestring_gen2 -> layer_aeroway:z11
+         -- etldoc:  osm_aeroway_linestring_gen_z11 -> layer_aeroway:z11
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_linestring_gen2
+         FROM osm_aeroway_linestring_gen_z11
          WHERE zoom_level = 11
          UNION ALL
-         -- etldoc:  osm_aeroway_linestring_gen1 -> layer_aeroway:z12
+         -- etldoc:  osm_aeroway_linestring_gen_z12 -> layer_aeroway:z12
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_linestring_gen1
+         FROM osm_aeroway_linestring_gen_z12
          WHERE zoom_level = 12
          UNION ALL
          -- etldoc:  osm_aeroway_linestring -> layer_aeroway:z13
@@ -33,27 +33,36 @@ FROM (
          FROM osm_aeroway_linestring
          WHERE zoom_level >= 13
          UNION ALL
-
+         -- etldoc:  osm_aeroway_polygon_gen_z10 -> layer_aeroway:z10
-         -- etldoc:  osm_aeroway_polygon_gen3 -> layer_aeroway:z10
-         -- etldoc:  osm_aeroway_polygon_gen3 -> layer_aeroway:z11
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_polygon_gen3
+         FROM osm_aeroway_polygon_gen_z10
-         WHERE zoom_level BETWEEN 10 AND 11
+         WHERE zoom_level = 10
          UNION ALL
-         -- etldoc:  osm_aeroway_polygon_gen2 -> layer_aeroway:z12
+         -- etldoc:  osm_aeroway_polygon_gen_z11 -> layer_aeroway:z11
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_polygon_gen2
+         FROM osm_aeroway_polygon_gen_z11
+         WHERE zoom_level = 11
+         UNION ALL
+         -- etldoc:  osm_aeroway_polygon_gen_z12 -> layer_aeroway:z12
+         SELECT geometry, aeroway, ref
+         FROM osm_aeroway_polygon_gen_z12
          WHERE zoom_level = 12
          UNION ALL
-         -- etldoc:  osm_aeroway_polygon_gen1 -> layer_aeroway:z13
+         -- etldoc:  osm_aeroway_polygon_gen_z13 -> layer_aeroway:z13
          SELECT geometry, aeroway, ref
-         FROM osm_aeroway_polygon_gen1
+         FROM osm_aeroway_polygon_gen_z13
          WHERE zoom_level = 13
          UNION ALL
          -- etldoc:  osm_aeroway_polygon -> layer_aeroway:z14_
          SELECT geometry, aeroway, ref
          FROM osm_aeroway_polygon
          WHERE zoom_level >= 14
+         UNION ALL
+         
+         -- etldoc:  osm_aeroway_point -> layer_aeroway:z14_
+         SELECT geometry, aeroway, ref
+         FROM osm_aeroway_point
+         WHERE zoom_level >= 14
      ) AS zoom_levels
 WHERE geometry && bbox;
 $$ LANGUAGE SQL STABLE

layers/aeroway/aeroway.yaml

@@ -19,11 +19,12 @@ layer:
       - helipad
       - taxiway
       - apron
+      - gate
   datasource:
     geometry_field: geometry
     query: (SELECT geometry, ref, class FROM layer_aeroway(!bbox!, z(!scale_denominator!))) AS t
 schema:
-  - ./layer.sql
+  - ./aeroway.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/aeroway/mapping.yaml

@@ -1,34 +1,40 @@
 generalized_tables:
-  # etldoc: imposm3 -> osm_aeroway_linestring_gen3
+  # etldoc: osm_aeroway_linestring_gen_z11 -> osm_aeroway_linestring_gen_z10
-  aeroway_linestring_gen3:
+  aeroway_linestring_gen_z10:
-    source: aeroway_linestring_gen2
+    source: aeroway_linestring_gen_z11
     tolerance: ZRES11
 
-  # etldoc: imposm3 -> osm_aeroway_linestring_gen2
+  # etldoc: osm_aeroway_linestring_gen_z12 -> osm_aeroway_linestring_gen_z11
-  aeroway_linestring_gen2:
+  aeroway_linestring_gen_z11:
-    source: aeroway_linestring_gen1
+    source: aeroway_linestring_gen_z12
     tolerance: ZRES12
 
-  # etldoc: imposm3 -> osm_aeroway_linestring_gen1
+  # etldoc: osm_aeroway_linestring -> osm_aeroway_linestring_gen_z12
-  aeroway_linestring_gen1:
+  aeroway_linestring_gen_z12:
     source: aeroway_linestring
     sql_filter: ST_IsValid(geometry)
     tolerance: ZRES13
 
-  # etldoc: imposm3 -> osm_aeroway_polygon_gen3
+  # etldoc: osm_aeroway_polygon_gen_z11 -> osm_aeroway_polygon_gen_z10
-  aeroway_polygon_gen3:
+  aeroway_polygon_gen_z10:
-    source: aeroway_polygon_gen2
+    source: aeroway_polygon_gen_z11
+    sql_filter: area>power(ZRES9,2)
+    tolerance: ZRES10
+
+  # etldoc: osm_aeroway_polygon_gen_z12 -> osm_aeroway_polygon_gen_z11
+  aeroway_polygon_gen_z11:
+    source: aeroway_polygon_gen_z12
     sql_filter: area>power(ZRES10,2)
     tolerance: ZRES11
 
-  # etldoc: imposm3 -> osm_aeroway_polygon_gen2
+  # etldoc: osm_aeroway_polygon_gen_z13 -> osm_aeroway_polygon_gen_z12
-  aeroway_polygon_gen2:
+  aeroway_polygon_gen_z12:
-    source: aeroway_polygon_gen1
+    source: aeroway_polygon_gen_z13
     sql_filter: area>power(ZRES11,2)
     tolerance: ZRES12
 
-  # etldoc: imposm3 -> osm_aeroway_polygon_gen1
+  # etldoc: osm_aeroway_polygon -> osm_aeroway_polygon_gen_z13
-  aeroway_polygon_gen1:
+  aeroway_polygon_gen_z13:
     source: aeroway_polygon
     sql_filter: area>power(ZRES12,2) AND ST_IsValid(geometry)
     tolerance: ZRES13
@@ -80,3 +86,19 @@ tables:
       aeroway:
       - runway
       - taxiway
+      
+  # etldoc: imposm3 -> osm_aeroway_point
+  aeroway_point:
+    type: point
+    columns:
+    - *ref
+    - name: osm_id
+      type: id
+    - name: geometry
+      type: geometry
+    - name: aeroway
+      key: aeroway
+      type: string
+    mapping:
+      aeroway:
+      - gate

layers/boundary/boundary.yaml

@@ -14,6 +14,10 @@ layer:
         The `admin_level` corresponds to the lowest `admin_level`
         the line participates in.
         At low zoom levels the Natural Earth boundaries are mapped to the equivalent admin levels.
+    adm0_l: |
+        State name on the left of the border. For country boundaries only (`admin_level = 2`).
+    adm0_r: |
+        State name on the right of the border. For country boundaries only (`admin_level = 2`).
     disputed:
       description: |
           Mark with `1` if the border is disputed.
@@ -46,8 +50,9 @@ layer:
   buffer_size: 4
   datasource:
     geometry_field: geometry
-    query: (SELECT geometry, admin_level, disputed, disputed_name, claimed_by, maritime FROM layer_boundary(!bbox!, z(!scale_denominator!))) AS t
+    query: (SELECT geometry, admin_level, adm0_l, adm0_r, disputed, disputed_name, claimed_by, maritime FROM layer_boundary(!bbox!, z(!scale_denominator!))) AS t
 schema:
+  - ./boundary_name.sql
   - ./boundary.sql
 datasources:
   - type: imposm3

layers/boundary/boundary_name.sql

@@ -0,0 +1,99 @@
+DROP TABLE IF EXISTS osm_border_linestring_adm CASCADE;
+
+-- etldoc: osm_border_linestring -> osm_border_linestring_adm
+CREATE TABLE IF NOT EXISTS osm_border_linestring_adm AS ( 
+  WITH 
+    -- Prepare lines from osm to be merged
+	multiline AS (
+    	SELECT ST_Node(ST_Collect(geometry)) AS geometry, 
+			   maritime,
+			   disputed
+    	FROM osm_border_linestring
+    	WHERE admin_level = 2
+		    AND osm_id NOT IN (SELECT DISTINCT osm_id FROM osm_border_disp_linestring)
+		GROUP BY maritime,
+				 disputed
+		),
+
+	mergedline AS (
+		SELECT (ST_Dump(
+      		     ST_LineMerge(geometry))).geom AS geometry,
+			maritime,
+			disputed
+  		FROM multiline
+		),
+    -- Create polygons from all boundaries to preserve real shape of country
+	polyg AS (
+    	SELECT (ST_Dump(
+        		 ST_Polygonize(geometry))).geom AS geometry  
+    	FROM (
+			SELECT (ST_Dump(
+      				ST_LineMerge(geometry))).geom AS geometry
+  			FROM (SELECT ST_Node(
+                          ST_Collect(geometry)) AS geometry
+    			FROM osm_border_linestring
+    			WHERE admin_level = 2
+                ) nodes
+			) linemerge
+  		), 
+
+    centroids AS (
+		SELECT polyg.geometry,
+			   ne.adm0_a3
+		FROM polyg,
+			 ne_10m_admin_0_countries AS ne
+		WHERE ST_Within(
+			   ST_PointOnSurface(polyg.geometry), ne.geometry)
+    	),
+
+	country_osm_polyg AS  (
+		SELECT country.adm0_a3,
+			   border.geometry
+  		FROM polyg border,
+			 centroids country
+  		WHERE ST_Within(country.geometry, border.geometry)
+	),
+
+	rights AS (
+    	SELECT adm0_r,
+			   geometry,
+			   maritime,
+			   disputed
+		FROM (
+			SELECT b.adm0_a3 AS adm0_r,
+                   a.geometry,
+                   a.maritime,
+                   a.disputed
+			FROM mergedline AS a
+			LEFT JOIN country_osm_polyg AS b
+            -- Create short line on the right of the boundary (mergedline) and find state where line lies.
+			ON ST_Within(
+				ST_OffsetCurve(
+				(ST_LineSubString(a.geometry, 0.3,0.3004)), 70, 'quad_segs=4 join=mitre'), b.geometry)
+            ) line_rights
+		)
+
+  SELECT adm0_l,
+		 adm0_r,
+		 geometry,
+		 maritime,
+		 2::integer AS admin_level,
+		 disputed
+  FROM (
+    SELECT b.adm0_a3 AS adm0_l,
+           r.adm0_r AS adm0_r,
+           r.geometry,
+           r.maritime,
+           r.disputed
+    FROM rights AS r
+    LEFT JOIN country_osm_polyg AS b
+      -- Create short line on the left of the boundary (mergedline) and find state where line lies.
+      ON ST_Within(
+        ST_OffsetCurve(
+          (ST_LineSubString(r.geometry, 0.4,0.4004)), -70, 'quad_segs=4 join=mitre'), b.geometry)
+    ) both_lines
+);
+
+CREATE INDEX IF NOT EXISTS osm_border_linestring_adm_geom_idx
+  ON osm_border_linestring_adm
+  USING GIST (geometry);

layers/boundary/mapping.yaml

@@ -1,70 +1,82 @@
 generalized_tables:
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen11
+  # etldoc: osm_border_disp_linestring_gen_z2 -> osm_border_disp_linestring_gen_z1
-  border_disp_linestring_gen11:
+  border_disp_linestring_gen_z1:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z2
     sql_filter: admin_level = 2
-    tolerance: 9600
+    tolerance: ZRES2
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen10
+  # etldoc: osm_border_disp_linestring_gen_z3 -> osm_border_disp_linestring_gen_z2
-  border_disp_linestring_gen10:
+  border_disp_linestring_gen_z2:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z3
     sql_filter: admin_level = 2
-    tolerance: 4800
+    tolerance: ZRES3
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen9
+  # etldoc: osm_border_disp_linestring_gen_z4 -> osm_border_disp_linestring_gen_z3
-  border_disp_linestring_gen9:
+  border_disp_linestring_gen_z3:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z4
     sql_filter: admin_level = 2
-    tolerance: 2400
+    tolerance: ZRES4
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen8
+  # etldoc: osm_border_disp_linestring_gen_z5 -> osm_border_disp_linestring_gen_z4
-  border_disp_linestring_gen8:
+  border_disp_linestring_gen_z4:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z5
     sql_filter: admin_level = 2
-    tolerance: 1200
+    tolerance: ZRES5
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen7
+  # etldoc: osm_border_disp_linestring_gen_z6 -> osm_border_disp_linestring_gen_z5
-  border_disp_linestring_gen7:
+  border_disp_linestring_gen_z5:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z6
     sql_filter: admin_level = 2
-    tolerance: 600
+    tolerance: ZRES6
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen6
+  # etldoc: osm_border_disp_linestring_gen_z7 -> osm_border_disp_linestring_gen_z6
-  border_disp_linestring_gen6:
+  border_disp_linestring_gen_z6:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z7
     sql_filter: admin_level = 2
-    tolerance: 300
+    tolerance: ZRES7
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen5
+  # etldoc: osm_border_disp_linestring_gen_z8 -> osm_border_disp_linestring_gen_z7
-  border_disp_linestring_gen5:
+  border_disp_linestring_gen_z7:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z8
     sql_filter: admin_level = 2
-    tolerance: 160
+    tolerance: ZRES8
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen4
+  # etldoc: osm_border_disp_linestring_gen_z9 -> osm_border_disp_linestring_gen_z8
-  border_disp_linestring_gen4:
+  border_disp_linestring_gen_z8:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z9
     sql_filter: admin_level = 2
-    tolerance: 80
+    tolerance: ZRES9
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen3
+  # etldoc: osm_border_disp_linestring_gen_z10 -> osm_border_disp_linestring_gen_z9
-  border_disp_linestring_gen3:
+  border_disp_linestring_gen_z9:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z10
     sql_filter: admin_level = 2
-    tolerance: 40
+    tolerance: ZRES10
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen2
+  # etldoc: osm_border_disp_linestring_gen_z11 -> osm_border_disp_linestring_gen_z10
-  border_disp_linestring_gen2:
+  border_disp_linestring_gen_z10:
-    source: border_disp_linestring
+    source: border_disp_linestring_gen_z11
     sql_filter: admin_level = 2
-    tolerance: 20
+    tolerance: ZRES11
 
-  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen1
+  # etldoc: osm_border_disp_linestring_gen_z12 -> osm_border_disp_linestring_gen_z11
-  border_disp_linestring_gen1:
+  border_disp_linestring_gen_z11:
+    source: border_disp_linestring_gen_z12
+    sql_filter: admin_level = 2
+    tolerance: ZRES12
+
+  # etldoc: osm_border_disp_linestring_gen_z13 -> osm_border_disp_linestring_gen_z12
+  border_disp_linestring_gen_z12:
+    source: border_disp_linestring_gen_z13
+    sql_filter: admin_level = 2
+    tolerance: ZRES13
+
+  # etldoc: osm_border_disp_linestring -> osm_border_disp_linestring_gen_z13
+  border_disp_linestring_gen_z13:
     source: border_disp_linestring
     sql_filter: admin_level = 2
-    tolerance: 10
+    tolerance: ZRES14
 
   # etldoc: osm_border_disp_relation -> osm_border_disp_linestring
   border_disp_linestring:

layers/building/building.sql

@@ -9,15 +9,15 @@ CREATE OR REPLACE VIEW osm_all_buildings AS
 SELECT
     -- etldoc: osm_building_relation -> layer_building:z14_
     -- Buildings built from relations
-    member                                                               AS osm_id,
+    member AS osm_id,
     geometry,
-    COALESCE(CleanNumeric(height), CleanNumeric(buildingheight))         AS height,
+    COALESCE(CleanNumeric(height), CleanNumeric(buildingheight)) AS height,
     COALESCE(CleanNumeric(min_height), CleanNumeric(buildingmin_height)) AS min_height,
-    COALESCE(CleanNumeric(levels), CleanNumeric(buildinglevels))         AS levels,
+    COALESCE(CleanNumeric(levels), CleanNumeric(buildinglevels)) AS levels,
-    COALESCE(CleanNumeric(min_level), CleanNumeric(buildingmin_level))   AS min_level,
+    COALESCE(CleanNumeric(min_level), CleanNumeric(buildingmin_level)) AS min_level,
-    nullif(material, '')                                                 AS material,
+    nullif(material, '') AS material,
-    nullif(colour, '')                                                   AS colour,
+    nullif(colour, '') AS colour,
-    FALSE                                                                AS hide_3d
+    FALSE AS hide_3d
 FROM osm_building_relation
 WHERE building = ''
   AND ST_GeometryType(geometry) = 'ST_Polygon'
@@ -28,13 +28,13 @@ SELECT
     -- Standalone buildings
     obp.osm_id,
     obp.geometry,
-    COALESCE(CleanNumeric(obp.height), CleanNumeric(obp.buildingheight))         AS height,
+    COALESCE(CleanNumeric(obp.height), CleanNumeric(obp.buildingheight)) AS height,
     COALESCE(CleanNumeric(obp.min_height), CleanNumeric(obp.buildingmin_height)) AS min_height,
-    COALESCE(CleanNumeric(obp.levels), CleanNumeric(obp.buildinglevels))         AS levels,
+    COALESCE(CleanNumeric(obp.levels), CleanNumeric(obp.buildinglevels)) AS levels,
-    COALESCE(CleanNumeric(obp.min_level), CleanNumeric(obp.buildingmin_level))   AS min_level,
+    COALESCE(CleanNumeric(obp.min_level), CleanNumeric(obp.buildingmin_level)) AS min_level,
-    nullif(obp.material, '')                                                     AS material,
+    nullif(obp.material, '') AS material,
-    nullif(obp.colour, '')                                                       AS colour,
+    nullif(obp.colour, '') AS colour,
-    obr.role IS NOT NULL                                                         AS hide_3d
+    obr.role IS NOT NULL AS hide_3d
 FROM osm_building_polygon obp
          LEFT JOIN osm_building_relation obr ON
         obp.osm_id >= 0 AND
@@ -78,19 +78,19 @@ SELECT geometry,
                             WHEN 'timber_framing' THEN '#b3b0a9'
                             WHEN 'sandstone' THEN '#b4a995' -- same as stone
                             WHEN 'clay' THEN '#9d8b75' -- same as mud
-           END)                        AS colour,
+           END) AS colour,
        CASE WHEN hide_3d THEN TRUE END AS hide_3d
 FROM (
          SELECT
-             -- etldoc: osm_building_block_gen1 -> layer_building:z13
+             -- etldoc: osm_building_block_gen_z13 -> layer_building:z13
              osm_id,
              geometry,
-             NULL::int  AS render_height,
+             NULL::int AS render_height,
-             NULL::int  AS render_min_height,
+             NULL::int AS render_min_height,
              NULL::text AS material,
              NULL::text AS colour,
-             FALSE      AS hide_3d
+             FALSE AS hide_3d
-         FROM osm_building_block_gen1
+         FROM osm_building_block_gen_z13
          WHERE zoom_level = 13
            AND geometry && bbox
          UNION ALL
@@ -98,7 +98,7 @@ FROM (
                                   -- etldoc: osm_building_polygon -> layer_building:z14_
              DISTINCT ON (osm_id) osm_id,
                                   geometry,
-                                  ceil(COALESCE(height, levels * 3.66, 5))::int         AS render_height,
+                                  ceil(COALESCE(height, levels * 3.66, 5))::int AS render_height,
                                   floor(COALESCE(min_height, min_level * 3.66, 0))::int AS render_min_height,
                                   material,
                                   colour,

layers/building/update_building.sql

@@ -1,13 +1,13 @@
 DROP TRIGGER IF EXISTS trigger_refresh ON buildings.updates;
 DROP TRIGGER IF EXISTS trigger_flag ON osm_building_polygon;
 
---creating aggregated building blocks with removed small polygons and small
+-- Creating aggregated building blocks with removed small polygons and small
---holes. Aggregated polygons are simplified.
+-- holes. Aggregated polygons are simplified by Visvalingam-Whyatt algorithm.
+-- Aggregating is made block by block using country_osm_grid polygon table.
 
---function returning recordset for matview
+-- Function returning recordset for matview.
---returning recordset of buildings aggregates by zres 14, with removed small
+-- Returning recordset of buildings aggregates by zres 14, with removed small
---holes and with removed small buildings/blocks
+-- holes and with removed small buildings/blocks.
---
 
 CREATE OR REPLACE FUNCTION osm_building_block_gen1()
     RETURNS table
@@ -20,50 +20,68 @@ $$
 DECLARE
     zres14 float := Zres(14);
     zres12 float := Zres(12);
+    zres14vw float := Zres(14) * Zres(14);
+    polyg_world record;
+
 BEGIN
-    FOR osm_id, geometry IN
+    FOR polyg_world IN 
-        WITH dta AS ( -- CTE is used because of optimization
+        SELECT ST_Transform(country.geometry, 3857) AS geometry 
-            SELECT o.osm_id, o.geometry, ST_ClusterDBSCAN(o.geometry, eps := zres14, minpoints := 1) OVER () cid
+        FROM country_osm_grid country
-            FROM osm_building_polygon o
+        
-        )
-        SELECT (array_agg(dta.osm_id))[1]                                                                   osm_id,
-               ST_Buffer(ST_MemUnion(ST_Buffer(dta.geometry, zres14, 'join=mitre')), -zres14, 'join=mitre') geometry
-        FROM dta
-        GROUP BY cid
-
         LOOP
-            -- removing holes smaller than
+            FOR osm_id, geometry IN
-            IF ST_NumInteriorRings(geometry) > 0 THEN -- only from geometries wih holes
+                WITH dta AS ( -- CTE is used because of optimization
-                geometry := (
+                    SELECT o.osm_id,
-                    -- there are some multi-geometries in this layer
+                            o.geometry,
-                    SELECT ST_Collect(gn)
+                            ST_ClusterDBSCAN(o.geometry, eps := zres14, minpoints := 1) OVER () cid
-                    FROM (
+                    FROM osm_building_polygon o
-                             -- in some cases are "holes" NULL, because all holes are smaller than
+                    WHERE ST_Intersects(o.geometry, polyg_world.geometry)
-                             SELECT COALESCE(
+                )
-                                        -- exterior ring
+                SELECT (array_agg(dta.osm_id))[1] AS osm_id,
-                                            ST_MakePolygon(ST_ExteriorRing(dmp.geom), holes),
+                    ST_Buffer(
-                                            ST_MakePolygon(ST_ExteriorRing(dmp.geom))
+                        ST_Union(
-                                        ) gn
+                            ST_Buffer(
+                                ST_SnapToGrid(dta.geometry, 0.000001)
+                                , zres14, 'join=mitre')
+                            )
+                        , -zres14, 'join=mitre') AS geometry
+                FROM dta
+                GROUP BY cid
 
-                             FROM ST_Dump(geometry) dmp, -- 1 dump polygons
+                LOOP
-                                  LATERAL (
+                    -- removing holes smaller than
-                                      SELECT array_agg(ST_Boundary(rg.geom)) holes -- 2 create array
+                    IF ST_NumInteriorRings(geometry) > 0 THEN -- only from geometries wih holes
-                                      FROM ST_DumpRings(dmp.geom) rg -- 3 from rings
+                        geometry := (
-                                      WHERE rg.path[1] > 0 -- 5 except inner ring
+                            -- there are some multi-geometries in this layer
-                                        AND ST_Area(rg.geom) >= power(zres12, 2) -- 4 bigger than
+                            SELECT ST_Collect(gn)
-                                      ) holes
+                            FROM (
-                         ) new_geom
+                                    -- in some cases are "holes" NULL, because all holes are smaller than
-                );
+                                    SELECT COALESCE(
-            END IF;
+                                                -- exterior ring
+                                                    ST_MakePolygon(ST_ExteriorRing(dmp.geom), holes),
+                                                    ST_MakePolygon(ST_ExteriorRing(dmp.geom))
+                                                ) gn
 
-            IF ST_Area(geometry) < power(zres12, 2) THEN
+                                    FROM ST_Dump(geometry) dmp, -- 1 dump polygons
-                CONTINUE;
+                                        LATERAL (
-            END IF;
+                                            SELECT array_agg(ST_Boundary(rg.geom)) holes -- 2 create array
+                                            FROM ST_DumpRings(dmp.geom) rg -- 3 from rings
+                                            WHERE rg.path[1] > 0 -- 5 except inner ring
+                                                AND ST_Area(rg.geom) >= power(zres12, 2) -- 4 bigger than
+                                            ) holes
+                                ) new_geom
+                        );
+                    END IF;
 
-            -- simplify
+                    IF ST_Area(geometry) < power(zres12, 2) THEN
-            geometry := ST_SimplifyPreserveTopology(geometry, zres14::float);
+                        CONTINUE;
+                    END IF;
 
-            RETURN NEXT;
+                    -- simplify
+                    geometry := ST_SimplifyVW(geometry, zres14vw);
+
+                    RETURN NEXT;
+                END LOOP;
         END LOOP;
 END;
 $$ LANGUAGE plpgsql STABLE
@@ -71,15 +89,52 @@ $$ LANGUAGE plpgsql STABLE
                     PARALLEL SAFE;
 
 
-DROP MATERIALIZED VIEW IF EXISTS osm_building_block_gen1;
+DROP MATERIALIZED VIEW IF EXISTS osm_building_block_gen1_dup CASCADE;
 
-CREATE MATERIALIZED VIEW osm_building_block_gen1 AS
+CREATE MATERIALIZED VIEW osm_building_block_gen1_dup AS
 SELECT *
 FROM osm_building_block_gen1();
 
-CREATE INDEX ON osm_building_block_gen1 USING gist (geometry);
+CREATE INDEX ON osm_building_block_gen1_dup USING gist (geometry);
-CREATE UNIQUE INDEX ON osm_building_block_gen1 USING btree (osm_id);
 
+-- etldoc: osm_building_polygon -> osm_building_block_gen_z13
+DROP MATERIALIZED VIEW IF EXISTS osm_building_block_gen_z13;
+CREATE MATERIALIZED VIEW osm_building_block_gen_z13 AS
+(
+WITH 
+    counts AS (
+        SELECT count(osm_id) AS counts,
+		        osm_id
+	    FROM osm_building_block_gen1_dup
+	GROUP BY osm_id
+    ),
+
+    duplicates AS (
+        SELECT counts.osm_id
+	    FROM counts
+	    WHERE counts.counts > 1
+    )
+
+SELECT osm.osm_id,
+		ST_Union(
+            ST_MakeValid(osm.geometry)) AS geometry
+	FROM osm_building_block_gen1_dup osm,
+			duplicates
+	WHERE osm.osm_id = duplicates.osm_id
+	GROUP BY osm.osm_id
+	
+	UNION ALL
+
+	SELECT osm.osm_id, 
+			osm.geometry 
+	FROM osm_building_block_gen1_dup osm, 
+            counts 
+	WHERE counts.counts = 1 
+		AND osm.osm_id = counts.osm_id
+);
+
+CREATE INDEX ON osm_building_block_gen_z13 USING gist (geometry);
+CREATE UNIQUE INDEX ON osm_building_block_gen_z13 USING btree (osm_id);
 
 -- Handle updates
 
@@ -88,7 +143,7 @@ CREATE SCHEMA IF NOT EXISTS buildings;
 CREATE TABLE IF NOT EXISTS buildings.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 
@@ -102,11 +157,16 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION buildings.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh buildings block';
-    REFRESH MATERIALIZED VIEW osm_building_block_gen1;
+    REFRESH MATERIALIZED VIEW osm_building_block_gen1_dup;
+    REFRESH MATERIALIZED VIEW osm_building_block_gen_z13;
     -- noinspection SqlWithoutWhere
     DELETE FROM buildings.updates;
+
+    RAISE LOG 'Update buildings block done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;

layers/housenumber/housenumber.yaml

@@ -13,7 +13,7 @@ layer:
     query: (SELECT geometry, housenumber FROM layer_housenumber(!bbox!, z(!scale_denominator!))) AS t
 schema:
   - ./housenumber_centroid.sql
-  - ./layer.sql
+  - ./housenumber.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/housenumber/housenumber_centroid.sql

@@ -1,10 +1,17 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_housenumber_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_housenumber_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON housenumber.updates;
 
+CREATE SCHEMA IF NOT EXISTS housenumber;
+
+CREATE TABLE IF NOT EXISTS housenumber.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc: osm_housenumber_point -> osm_housenumber_point
-CREATE OR REPLACE FUNCTION convert_housenumber_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION convert_housenumber_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
     UPDATE osm_housenumber_point
     SET geometry =
             CASE
@@ -12,20 +19,31 @@ BEGIN
                     THEN ST_Centroid(geometry)
                 ELSE ST_PointOnSurface(geometry)
                 END
-    WHERE ST_GeometryType(geometry) <> 'ST_Point';
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM housenumber.osm_ids))
-END;
+        AND ST_GeometryType(geometry) <> 'ST_Point'
-$$ LANGUAGE plpgsql;
+        AND ST_IsValid(geometry);
+$$ LANGUAGE SQL;
 
-SELECT convert_housenumber_point();
+SELECT convert_housenumber_point(true);
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS housenumber;
+CREATE OR REPLACE FUNCTION housenumber.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO housenumber.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO housenumber.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS housenumber.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION housenumber.flag() RETURNS trigger AS
@@ -38,15 +56,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION housenumber.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh housenumber';
-    PERFORM convert_housenumber_point();
+    PERFORM convert_housenumber_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM housenumber.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM housenumber.updates;
+
+    RAISE LOG 'Refresh housenumber done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_housenumber_point
+    FOR EACH ROW
+EXECUTE PROCEDURE housenumber.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_housenumber_point

layers/landcover/generalized.sql

@@ -0,0 +1,349 @@
+DROP TABLE IF EXISTS osm_landcover_gen_z7;
+DROP TABLE IF EXISTS osm_landcover_gen_z8;
+DROP TABLE IF EXISTS osm_landcover_gen_z9;
+DROP TABLE IF EXISTS osm_landcover_gen_z10;
+DROP TABLE IF EXISTS osm_landcover_gen_z11;
+DROP TABLE IF EXISTS osm_landcover_gen_z12;
+DROP TABLE IF EXISTS osm_landcover_gen_z13;
+DROP TABLE IF EXISTS simplify_vw_z7 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z8 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z9 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z10 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z11 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z12 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z13 CASCADE;
+
+-- etldoc: osm_landcover_polygon ->  osm_landcover_gen_z13
+CREATE TABLE simplify_vw_z13 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(13),2)),
+             0.001)) AS geometry
+    FROM osm_landcover_polygon
+    WHERE ST_Area(geometry) > power(zres(10),2)
+);
+CREATE INDEX ON simplify_vw_z13 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z13 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z13
+        WHERE ST_NPoints(geometry) < 50
+          AND subclass IN ('wood', 'forest')) union_geom50
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass, ST_MakeValid((ST_dump(ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z13
+        WHERE ST_NPoints(geometry) >= 50
+          AND ST_NPoints(geometry) < 300
+          AND subclass IN ('wood', 'forest')) union_geom300
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z13
+    WHERE (ST_NPoints(geometry) >= 300 AND subclass IN ('wood', 'forest'))
+       OR (subclass NOT IN ('wood', 'forest'))
+    );
+
+CREATE INDEX ON osm_landcover_gen_z13 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z13 ->  osm_landcover_gen_z12
+CREATE TABLE simplify_vw_z12 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(12),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z13
+    WHERE ST_Area(geometry) > power(zres(9),2)
+);
+CREATE INDEX ON simplify_vw_z12 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z12 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z12
+        WHERE ST_NPoints(geometry) < 50
+          AND subclass IN ('wood', 'forest')) union_geom50
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass, ST_MakeValid((ST_dump(ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z12
+        WHERE ST_NPoints(geometry) >= 50
+          AND ST_NPoints(geometry) < 300
+          AND subclass IN ('wood', 'forest')) union_geom300
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z12
+    WHERE (ST_NPoints(geometry) >= 300  AND subclass IN ('wood', 'forest'))
+       OR (subclass NOT IN ('wood', 'forest'))
+    );
+
+CREATE INDEX ON osm_landcover_gen_z12 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z12 ->  osm_landcover_gen_z11
+CREATE TABLE simplify_vw_z11 AS
+(
+    SELECT subclass,
+            ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(11),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z12
+    WHERE ST_Area(geometry) > power(zres(8),2)
+);
+CREATE INDEX ON simplify_vw_z11 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z11 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z11
+        WHERE ST_NPoints(geometry) < 50
+          AND subclass IN ('wood', 'forest')) union_geom50
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass, ST_MakeValid((ST_dump(ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z11
+        WHERE ST_NPoints(geometry) >= 50
+          AND ST_NPoints(geometry) < 300
+          AND subclass IN ('wood', 'forest')) union_geom300
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z11
+    WHERE (ST_NPoints(geometry) >= 300 AND subclass IN ('wood', 'forest'))
+       OR (subclass NOT IN ('wood', 'forest'))
+    );
+
+CREATE INDEX ON osm_landcover_gen_z11 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z11 ->  osm_landcover_gen_z10
+CREATE TABLE simplify_vw_z10 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(10),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z11
+    WHERE ST_Area(geometry) > power(zres(8),2)
+);
+CREATE INDEX ON simplify_vw_z10 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z10 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z10
+        WHERE ST_NPoints(geometry) < 50
+          AND subclass IN ('wood', 'forest')) union_geom50
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass, ST_MakeValid((ST_dump(ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z10
+        WHERE ST_NPoints(geometry) >= 50
+          AND ST_NPoints(geometry) < 300
+          AND subclass IN ('wood', 'forest')) union_geom300
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z10
+    WHERE (ST_NPoints(geometry) >= 300 AND subclass IN ('wood', 'forest'))
+       OR (subclass NOT IN ('wood', 'forest'))
+    );
+
+CREATE INDEX ON osm_landcover_gen_z10 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z10 ->  osm_landcover_gen_z9
+CREATE TABLE simplify_vw_z9 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(9),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z10
+    WHERE ST_Area(geometry) > power(zres(7),2)
+);
+CREATE INDEX ON simplify_vw_z9 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z9 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z9
+        WHERE ST_NPoints(geometry) < 50
+          AND subclass IN ('wood', 'forest')) union_geom50
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass, ST_MakeValid((ST_dump(ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z9
+        WHERE ST_NPoints(geometry) >= 50
+          AND ST_NPoints(geometry) < 300
+          AND subclass IN ('wood', 'forest')) union_geom300
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           ST_MakeValid(
+            (ST_Dump(
+             ST_Union(geometry))).geom) AS geometry
+    FROM (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) over () AS cid, geometry
+        FROM simplify_vw_z9
+        WHERE ST_NPoints(geometry) >= 300
+          AND subclass IN ('wood', 'forest')) union_geom_rest
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z9
+    WHERE subclass NOT IN ('wood', 'forest')
+    );
+
+CREATE INDEX ON osm_landcover_gen_z9 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z9 ->  osm_landcover_gen_z8
+CREATE TABLE simplify_vw_z8 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(8),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z9
+    WHERE ST_Area(geometry) > power(zres(6),2)
+    );
+CREATE INDEX ON simplify_vw_z8 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z8 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_Dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM
+        (
+        SELECT subclass,
+               ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) OVER () AS cid,
+               geometry
+        FROM simplify_vw_z8
+        ) union_geom
+    GROUP BY subclass,
+             cid
+    UNION ALL
+    SELECT subclass,
+           geometry
+    FROM simplify_vw_z8
+    WHERE subclass NOT IN ('wood', 'forest')
+    );
+
+CREATE INDEX ON osm_landcover_gen_z8 USING GIST (geometry);
+
+
+-- etldoc: osm_landcover_gen_z8 ->  osm_landcover_gen_z7
+CREATE TABLE simplify_vw_z7 AS
+(
+    SELECT subclass,
+           ST_MakeValid(
+            ST_SnapToGrid(
+             ST_SimplifyVW(geometry, power(zres(7),2)),
+             0.001)) AS geometry
+    FROM simplify_vw_z8
+    WHERE ST_Area(geometry) > power(zres(5),2)
+);
+CREATE INDEX ON simplify_vw_z7 USING GIST (geometry);
+
+CREATE TABLE osm_landcover_gen_z7 AS
+(
+SELECT subclass,
+       ST_MakeValid(
+        (ST_Dump(
+         ST_Union(geometry))).geom) AS geometry
+    FROM
+        (
+        SELECT  subclass,
+                ST_ClusterDBSCAN(geometry, eps := 0, minpoints := 1) OVER () AS cid,
+                geometry
+        FROM simplify_vw_z7
+        ) union_geom
+GROUP BY subclass,
+         cid
+    );
+
+CREATE INDEX ON osm_landcover_gen_z7 USING GIST (geometry);
+
+DROP TABLE IF EXISTS simplify_vw_z7 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z8 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z9 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z10 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z11 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z12 CASCADE;
+DROP TABLE IF EXISTS simplify_vw_z13 CASCADE;

layers/landcover/landcover.sql

@@ -18,174 +18,356 @@ $$ LANGUAGE SQL IMMUTABLE
                 -- STRICT
                 PARALLEL SAFE;
 
--- etldoc: ne_110m_glaciated_areas ->  landcover_z0
+-- ne_50m_antarctic_ice_shelves_polys
+-- etldoc: ne_50m_antarctic_ice_shelves_polys ->  ne_50m_antarctic_ice_shelves_polys_gen_z4
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_antarctic_ice_shelves_polys_gen_z4 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(6)) as geometry,
+    'ice_shelf'::text AS subclass
+FROM ne_50m_antarctic_ice_shelves_polys
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z4_idx ON ne_50m_antarctic_ice_shelves_polys_gen_z4 USING gist (geometry);
+
+-- ne_110m_glaciated_areas
+-- etldoc: ne_110m_glaciated_areas ->  ne_110m_glaciated_areas_gen_z1
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_glaciated_areas_gen_z1 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_glaciated_areas_gen_z1 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(3)) as geometry,
+    'glacier'::text AS subclass
+FROM ne_110m_glaciated_areas
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_glaciated_areas_gen_z1_idx ON ne_110m_glaciated_areas_gen_z1 USING gist (geometry);
+
+-- etldoc: ne_110m_glaciated_areas_gen_z1 ->  ne_110m_glaciated_areas_gen_z0
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_glaciated_areas_gen_z0 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_glaciated_areas_gen_z0 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(2)) as geometry,
+    subclass
+FROM ne_110m_glaciated_areas_gen_z1
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_glaciated_areas_gen_z0_idx ON ne_110m_glaciated_areas_gen_z0 USING gist (geometry);
+
+-- etldoc: ne_50m_antarctic_ice_shelves_polys_gen_z4 ->  ne_50m_antarctic_ice_shelves_polys_gen_z3
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z3 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_antarctic_ice_shelves_polys_gen_z3 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(5)) as geometry,
+    subclass
+FROM ne_50m_antarctic_ice_shelves_polys_gen_z4
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z3_idx ON ne_50m_antarctic_ice_shelves_polys_gen_z3 USING gist (geometry);
+
+-- etldoc: ne_50m_antarctic_ice_shelves_polys_gen_z3 ->  ne_50m_antarctic_ice_shelves_polys_gen_z2
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z2 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_antarctic_ice_shelves_polys_gen_z2 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(4)) as geometry,
+    subclass
+FROM ne_50m_antarctic_ice_shelves_polys_gen_z3
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_antarctic_ice_shelves_polys_gen_z2_idx ON ne_50m_antarctic_ice_shelves_polys_gen_z2 USING gist (geometry);
+
+-- ne_50m_glaciated_areas
+-- etldoc: ne_50m_glaciated_areas ->  ne_50m_glaciated_areas_gen_z4
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_glaciated_areas_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_glaciated_areas_gen_z4 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(6)) as geometry,
+    'glacier'::text AS subclass
+FROM ne_50m_glaciated_areas
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_glaciated_areas_gen_z4_idx ON ne_50m_glaciated_areas_gen_z4 USING gist (geometry);
+
+-- etldoc: ne_50m_glaciated_areas_gen_z4 ->  ne_50m_glaciated_areas_gen_z3
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_glaciated_areas_gen_z3 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_glaciated_areas_gen_z3 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(5)) as geometry,
+    subclass
+FROM ne_50m_glaciated_areas_gen_z4
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_glaciated_areas_gen_z3_idx ON ne_50m_glaciated_areas_gen_z3 USING gist (geometry);
+
+-- etldoc: ne_50m_glaciated_areas_gen_z3 ->  ne_50m_glaciated_areas_gen_z2
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_glaciated_areas_gen_z2 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_glaciated_areas_gen_z2 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(4)) as geometry,
+    subclass
+FROM ne_50m_glaciated_areas_gen_z3
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_glaciated_areas_gen_z2_idx ON ne_50m_glaciated_areas_gen_z2 USING gist (geometry);
+
+-- ne_10m_glaciated_areas
+-- etldoc: ne_10m_glaciated_areas ->  ne_10m_glaciated_areas_gen_z6
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_glaciated_areas_gen_z6 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_glaciated_areas_gen_z6 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(8)) as geometry,
+    'glacier'::text AS subclass
+FROM ne_10m_glaciated_areas
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_glaciated_areas_gen_z6_idx ON ne_10m_glaciated_areas_gen_z6 USING gist (geometry);
+
+-- etldoc: ne_10m_glaciated_areas_gen_z6 ->  ne_10m_glaciated_areas_gen_z5
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_glaciated_areas_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_glaciated_areas_gen_z5 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(7)) as geometry,
+    subclass
+FROM ne_10m_glaciated_areas_gen_z6
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_glaciated_areas_gen_z5_idx ON ne_10m_glaciated_areas_gen_z5 USING gist (geometry);
+
+-- ne_10m_antarctic_ice_shelves_polys
+-- etldoc: ne_10m_antarctic_ice_shelves_polys ->  ne_10m_antarctic_ice_shelves_polys_gen_z6
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_antarctic_ice_shelves_polys_gen_z6 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_antarctic_ice_shelves_polys_gen_z6 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(8)) as geometry,
+    'ice_shelf'::text AS subclass
+FROM ne_10m_antarctic_ice_shelves_polys
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_antarctic_ice_shelves_polys_gen_z6_idx ON ne_10m_antarctic_ice_shelves_polys_gen_z6 USING gist (geometry);
+
+-- etldoc: ne_10m_antarctic_ice_shelves_polys_gen_z6 ->  ne_10m_antarctic_ice_shelves_polys_gen_z5
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_antarctic_ice_shelves_polys_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_antarctic_ice_shelves_polys_gen_z5 AS
+(
+SELECT
+    ST_Simplify(geometry, ZRes(7)) as geometry,
+    subclass
+FROM ne_10m_antarctic_ice_shelves_polys_gen_z6
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_antarctic_ice_shelves_polys_gen_z5_idx ON ne_10m_antarctic_ice_shelves_polys_gen_z5 USING gist (geometry);
+
+-- etldoc: ne_110m_glaciated_areas_gen_z0 ->  landcover_z0
 CREATE OR REPLACE VIEW landcover_z0 AS
 (
-SELECT NULL::bigint AS osm_id, geometry, 'glacier'::text AS subclass
+SELECT
-FROM ne_110m_glaciated_areas
+    geometry,
+    subclass
+FROM ne_110m_glaciated_areas_gen_z0
+    );
+
+-- etldoc: ne_110m_glaciated_areas_gen_z1 ->  landcover_z1
+CREATE OR REPLACE VIEW landcover_z1 AS
+(
+SELECT
+    geometry,
+    subclass
+FROM ne_110m_glaciated_areas_gen_z1
     );
 
 CREATE OR REPLACE VIEW landcover_z2 AS
 (
--- etldoc: ne_50m_glaciated_areas ->  landcover_z2
+-- etldoc: ne_50m_glaciated_areas_gen_z2 ->  landcover_z2
-SELECT NULL::bigint AS osm_id, geometry, 'glacier'::text AS subclass
+SELECT
-FROM ne_50m_glaciated_areas
+    geometry,
+    subclass
+FROM ne_50m_glaciated_areas_gen_z2
 UNION ALL
--- etldoc: ne_50m_antarctic_ice_shelves_polys ->  landcover_z2
+-- etldoc: ne_50m_antarctic_ice_shelves_polys_gen_z2 ->  landcover_z2
-SELECT NULL::bigint AS osm_id, geometry, 'ice_shelf'::text AS subclass
+SELECT
-FROM ne_50m_antarctic_ice_shelves_polys
+    geometry,
+    subclass
+FROM ne_50m_antarctic_ice_shelves_polys_gen_z2
+    );
+
+CREATE OR REPLACE VIEW landcover_z3 AS
+(
+-- etldoc: ne_50m_glaciated_areas_gen_z3 ->  landcover_z3
+SELECT
+    geometry,
+    subclass
+FROM ne_50m_glaciated_areas_gen_z3
+UNION ALL
+-- etldoc: ne_50m_antarctic_ice_shelves_polys_gen_z3 ->  landcover_z3
+SELECT
+    geometry,
+    subclass
+FROM ne_50m_antarctic_ice_shelves_polys_gen_z3
+    );
+
+CREATE OR REPLACE VIEW landcover_z4 AS
+(
+-- etldoc: ne_50m_glaciated_areas_gen_z4 ->  landcover_z4
+SELECT
+    geometry,
+    subclass
+FROM ne_50m_glaciated_areas_gen_z4
+UNION ALL
+-- etldoc: ne_50m_antarctic_ice_shelves_polys_gen_z4 ->  landcover_z4
+SELECT
+    geometry,
+    subclass
+FROM ne_50m_antarctic_ice_shelves_polys_gen_z4
     );
 
 CREATE OR REPLACE VIEW landcover_z5 AS
 (
--- etldoc: ne_10m_glaciated_areas ->  landcover_z5
+-- etldoc: ne_10m_glaciated_areas_gen_z5 ->  landcover_z5
-SELECT NULL::bigint AS osm_id, geometry, 'glacier'::text AS subclass
+SELECT
-FROM ne_10m_glaciated_areas
+    geometry,
+    subclass
+FROM ne_10m_glaciated_areas_gen_z5
 UNION ALL
--- etldoc: ne_10m_antarctic_ice_shelves_polys ->  landcover_z5
+-- etldoc: ne_10m_antarctic_ice_shelves_polys_gen_z5 ->  landcover_z5
-SELECT NULL::bigint AS osm_id, geometry, 'ice_shelf'::text AS subclass
+SELECT
-FROM ne_10m_antarctic_ice_shelves_polys
+    geometry,
+    subclass
+FROM ne_10m_antarctic_ice_shelves_polys_gen_z5
     );
 
-CREATE OR REPLACE VIEW landcover_z7 AS
+CREATE OR REPLACE VIEW landcover_z6 AS
 (
--- etldoc: osm_landcover_polygon_gen7 ->  landcover_z7
+-- etldoc: ne_10m_glaciated_areas_gen_z6 ->  landcover_z6
-SELECT osm_id, geometry, subclass
+SELECT
-FROM osm_landcover_polygon_gen7
+    geometry,
+    subclass
+FROM ne_10m_glaciated_areas_gen_z6
+UNION ALL
+-- etldoc: ne_10m_antarctic_ice_shelves_polys_gen_z6 ->  landcover_z6
+SELECT
+    geometry,
+    subclass
+FROM ne_10m_antarctic_ice_shelves_polys_gen_z6
     );
 
-CREATE OR REPLACE VIEW landcover_z8 AS
+-- etldoc: layer_landcover[shape=record fillcolor=lightpink, style="rounded, filled", label="layer_landcover | <z0> z0 | <z1> z1 | <z2> z2 | <z3> z3 | <z4> z4 | <z5> z5 | <z6> z6 |<z7> z7 |<z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14_> z14+" ] ;
-(
--- etldoc: osm_landcover_polygon_gen6 ->  landcover_z8
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen6
-    );
-
-CREATE OR REPLACE VIEW landcover_z9 AS
-(
--- etldoc: osm_landcover_polygon_gen5 ->  landcover_z9
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen5
-    );
-
-CREATE OR REPLACE VIEW landcover_z10 AS
-(
--- etldoc: osm_landcover_polygon_gen4 ->  landcover_z10
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen4
-    );
-
-CREATE OR REPLACE VIEW landcover_z11 AS
-(
--- etldoc: osm_landcover_polygon_gen3 ->  landcover_z11
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen3
-    );
-
-CREATE OR REPLACE VIEW landcover_z12 AS
-(
--- etldoc: osm_landcover_polygon_gen2 ->  landcover_z12
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen2
-    );
-
-CREATE OR REPLACE VIEW landcover_z13 AS
-(
--- etldoc: osm_landcover_polygon_gen1 ->  landcover_z13
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon_gen1
-    );
-
-CREATE OR REPLACE VIEW landcover_z14 AS
-(
--- etldoc: osm_landcover_polygon ->  landcover_z14
-SELECT osm_id, geometry, subclass
-FROM osm_landcover_polygon
-    );
-
--- etldoc: layer_landcover[shape=record fillcolor=lightpink, style="rounded, filled", label="layer_landcover | <z0_1> z0-z1 | <z2_4> z2-z4 | <z5_6> z5-z6 |<z7> z7 |<z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14_> z14+" ] ;
 
 CREATE OR REPLACE FUNCTION layer_landcover(bbox geometry, zoom_level int)
     RETURNS TABLE
             (
-                osm_id   bigint,
                 geometry geometry,
                 class    text,
                 subclass text
             )
 AS
 $$
-SELECT osm_id,
+SELECT geometry,
-       geometry,
        landcover_class(subclass) AS class,
        subclass
 FROM (
-         -- etldoc:  landcover_z0 -> layer_landcover:z0_1
+         -- etldoc:  landcover_z0 -> layer_landcover:z0
-         SELECT *
+         SELECT geometry, 
+                subclass
          FROM landcover_z0
-         WHERE zoom_level BETWEEN 0 AND 1
+         WHERE zoom_level = 0
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z2 -> layer_landcover:z2_4
+         -- etldoc:  landcover_z1 -> layer_landcover:z1
-         SELECT *
+         SELECT geometry,
+                subclass
+         FROM landcover_z1
+         WHERE zoom_level = 1
+           AND geometry && bbox
+         UNION ALL
+         -- etldoc:  landcover_z2 -> layer_landcover:z2
+         SELECT geometry, 
+                subclass
          FROM landcover_z2
-         WHERE zoom_level BETWEEN 2 AND 4
+         WHERE zoom_level = 2
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z5 -> layer_landcover:z5_6
+         -- etldoc:  landcover_z3 -> layer_landcover:z3
-         SELECT *
+         SELECT geometry,
+                subclass
+         FROM landcover_z3
+         WHERE zoom_level = 3
+           AND geometry && bbox
+         UNION ALL
+         -- etldoc:  landcover_z4 -> layer_landcover:z4
+         SELECT geometry,
+                subclass
+         FROM landcover_z4
+         WHERE zoom_level = 4
+           AND geometry && bbox
+         UNION ALL
+         -- etldoc:  landcover_z5 -> layer_landcover:z5
+         SELECT geometry, 
+                subclass
          FROM landcover_z5
-         WHERE zoom_level BETWEEN 5 AND 6
+         WHERE zoom_level = 5
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z7 -> layer_landcover:z7
+         -- etldoc:  landcover_z6 -> layer_landcover:z6
-         SELECT *
+         SELECT geometry,
-         FROM landcover_z7
+                subclass
+         FROM landcover_z6
+         WHERE zoom_level = 6
+           AND geometry && bbox
+         UNION ALL
+         -- etldoc:  osm_landcover_gen_z7 -> layer_landcover:z7
+         SELECT geometry, 
+                subclass
+         FROM osm_landcover_gen_z7
          WHERE zoom_level = 7
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z8 -> layer_landcover:z8
+         -- etldoc:  osm_landcover_gen_z8 -> layer_landcover:z8
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z8
+                subclass
+         FROM osm_landcover_gen_z8
          WHERE zoom_level = 8
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z9 -> layer_landcover:z9
+         -- etldoc:  osm_landcover_gen_z9 -> layer_landcover:z9
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z9
+                subclass
+         FROM osm_landcover_gen_z9
          WHERE zoom_level = 9
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z10 -> layer_landcover:z10
+         -- etldoc:  osm_landcover_gen_z10 -> layer_landcover:z10
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z10
+                subclass
+         FROM osm_landcover_gen_z10
          WHERE zoom_level = 10
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z11 -> layer_landcover:z11
+         -- etldoc:  osm_landcover_gen_z11 -> layer_landcover:z11
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z11
+                subclass
+         FROM osm_landcover_gen_z11
          WHERE zoom_level = 11
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z12 -> layer_landcover:z12
+         -- etldoc:  osm_landcover_gen_z12 -> layer_landcover:z12
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z12
+                subclass
+         FROM osm_landcover_gen_z12
          WHERE zoom_level = 12
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z13 -> layer_landcover:z13
+         -- etldoc:  osm_landcover_gen_z13 -> layer_landcover:z13
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z13
+                subclass
+         FROM osm_landcover_gen_z13
          WHERE zoom_level = 13
            AND geometry && bbox
          UNION ALL
-         -- etldoc:  landcover_z14 -> layer_landcover:z14_
+         -- etldoc:  osm_landcover_polygon -> layer_landcover:z14_
-         SELECT *
+         SELECT geometry, 
-         FROM landcover_z14
+                subclass
+         FROM osm_landcover_polygon
          WHERE zoom_level >= 14
            AND geometry && bbox
      ) AS zoom_levels;
 $$ LANGUAGE SQL STABLE
                 -- STRICT
-                PARALLEL SAFE;
+                PARALLEL SAFE;

layers/landcover/landcover.yaml

@@ -73,6 +73,7 @@ layer:
     geometry_field: geometry
     query: (SELECT geometry, class, subclass FROM layer_landcover(!bbox!, z(!scale_denominator!))) AS t
 schema:
+  - ./generalized.sql
   - ./landcover.sql
 datasources:
   - type: imposm3

layers/landcover/mapping.yaml

@@ -1,48 +1,3 @@
-
-generalized_tables:
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen7
-  landcover_polygon_gen7:
-    source: landcover_polygon_gen6
-    sql_filter: area>power(ZRES5,2)
-    tolerance: ZRES7
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen6
-  landcover_polygon_gen6:
-    source: landcover_polygon_gen5
-    sql_filter: area>power(ZRES6,2)
-    tolerance: ZRES8
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen5
-  landcover_polygon_gen5:
-    source: landcover_polygon_gen4
-    sql_filter: area>power(ZRES7,2)
-    tolerance: ZRES9
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen4
-  landcover_polygon_gen4:
-    source: landcover_polygon_gen3
-    sql_filter: area>power(ZRES8,2)
-    tolerance: ZRES10
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen3
-  landcover_polygon_gen3:
-    source: landcover_polygon_gen2
-    sql_filter: area>power(ZRES8,2)
-    tolerance: ZRES11
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen2
-  landcover_polygon_gen2:
-    source: landcover_polygon_gen1
-    sql_filter: area>power(ZRES9,2)
-    tolerance: ZRES12
-
-  # etldoc: imposm3 -> osm_landcover_polygon_gen1
-  landcover_polygon_gen1:
-    source: landcover_polygon
-    sql_filter: area>power(ZRES10,2) AND ST_IsValid(geometry)
-    tolerance: ZRES13
-
 tables:
   # etldoc: imposm3 -> osm_landcover_polygon
   landcover_polygon:

layers/landuse/landuse.sql

@@ -1,156 +1,44 @@
--- etldoc: ne_50m_urban_areas -> landuse_z4
+-- ne_50m_urban_areas
-CREATE OR REPLACE VIEW landuse_z4 AS
+-- etldoc: ne_50m_urban_areas ->  ne_50m_urban_areas_gen_z5
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_urban_areas_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_urban_areas_gen_z5 AS
 (
-SELECT NULL::bigint        AS osm_id,
+SELECT
-       geometry,
+       NULL::bigint AS osm_id,
+       ST_Simplify(geometry, ZRes(7)) as geometry,
        'residential'::text AS landuse,
-       NULL::text          AS amenity,
+       NULL::text AS amenity,
-       NULL::text          AS leisure,
+       NULL::text AS leisure,
-       NULL::text          AS tourism,
+       NULL::text AS tourism,
-       NULL::text          AS place,
+       NULL::text AS place,
-       NULL::text          AS waterway,
+       NULL::text AS waterway,
-       NULL::text          AS man_made
+       NULL::text AS man_made,
+       scalerank
 FROM ne_50m_urban_areas
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_urban_areas_gen_z5_idx ON ne_50m_urban_areas_gen_z5 USING gist (geometry);
+
+-- etldoc: ne_50m_urban_areas_gen_z5 ->  ne_50m_urban_areas_gen_z4
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_urban_areas_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_urban_areas_gen_z4 AS
+(
+SELECT
+       osm_id,
+       ST_Simplify(geometry, ZRes(6)) as geometry,
+       landuse,
+       amenity,
+       leisure,
+       tourism,
+       place,
+       waterway,
+       man_made
+FROM ne_50m_urban_areas_gen_z5
 WHERE scalerank <= 2
-    );
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
-
+CREATE INDEX IF NOT EXISTS ne_50m_urban_areas_gen_z4_idx ON ne_50m_urban_areas_gen_z4 USING gist (geometry);
--- etldoc: ne_50m_urban_areas -> landuse_z5
-CREATE OR REPLACE VIEW landuse_z5 AS
-(
-SELECT NULL::bigint        AS osm_id,
-       geometry,
-       'residential'::text AS landuse,
-       NULL::text          AS amenity,
-       NULL::text          AS leisure,
-       NULL::text          AS tourism,
-       NULL::text          AS place,
-       NULL::text          AS waterway,
-       NULL::text          AS man_made
-FROM ne_50m_urban_areas
-    );
-
--- etldoc: osm_landuse_polygon_gen7 -> landuse_z6
-CREATE OR REPLACE VIEW landuse_z6 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen7
-    );
-
--- etldoc: osm_landuse_polygon_gen6 -> landuse_z8
-CREATE OR REPLACE VIEW landuse_z8 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen6
-    );
-
--- etldoc: osm_landuse_polygon_gen5 -> landuse_z9
-CREATE OR REPLACE VIEW landuse_z9 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen5
-    );
-
--- etldoc: osm_landuse_polygon_gen4 -> landuse_z10
-CREATE OR REPLACE VIEW landuse_z10 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen4
-    );
-
--- etldoc: osm_landuse_polygon_gen3 -> landuse_z11
-CREATE OR REPLACE VIEW landuse_z11 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen3
-    );
-
--- etldoc: osm_landuse_polygon_gen2 -> landuse_z12
-CREATE OR REPLACE VIEW landuse_z12 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen2
-    );
-
--- etldoc: osm_landuse_polygon_gen1 -> landuse_z13
-CREATE OR REPLACE VIEW landuse_z13 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon_gen1
-    );
-
--- etldoc: osm_landuse_polygon -> landuse_z14
-CREATE OR REPLACE VIEW landuse_z14 AS
-(
-SELECT osm_id,
-       geometry,
-       landuse,
-       amenity,
-       leisure,
-       tourism,
-       place,
-       waterway,
-       man_made
-FROM osm_landuse_polygon
-    );
 
 -- etldoc: layer_landuse[shape=record fillcolor=lightpink, style="rounded,filled",
--- etldoc:     label="layer_landuse |<z4> z4|<z5>z5|<z6>z6|<z7>z7| <z8> z8 |<z9> z9 |<z10> z10 |<z11> z11|<z12> z12|<z13> z13|<z14> z14+" ] ;
+-- etldoc:     label="layer_landuse |<z4> z4|<z5> z5|<z6> z6|<z7> z7|<z8> z8|<z9> z9|<z10> z10|<z11> z11|<z12> z12|<z13> z13|<z14> z14+" ] ;
 
 CREATE OR REPLACE FUNCTION layer_landuse(bbox geometry, zoom_level int)
     RETURNS TABLE
@@ -173,55 +61,147 @@ SELECT osm_id,
                NULLIF(man_made, '')
            ) AS class
 FROM (
-         -- etldoc: landuse_z4 -> layer_landuse:z4
+         -- etldoc: ne_50m_urban_areas_gen_z4 -> layer_landuse:z4
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z4
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM ne_50m_urban_areas_gen_z4
          WHERE zoom_level = 4
          UNION ALL
-         -- etldoc: landuse_z5 -> layer_landuse:z5
+         -- etldoc: ne_50m_urban_areas_gen_z5 -> layer_landuse:z5
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z5
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM ne_50m_urban_areas_gen_z5
          WHERE zoom_level = 5
          UNION ALL
-         -- etldoc: landuse_z6 -> layer_landuse:z6
+         -- etldoc: osm_landuse_polygon_gen_z6 -> layer_landuse:z6
-         -- etldoc: landuse_z6 -> layer_landuse:z7
+         SELECT osm_id,
-         SELECT *
+                geometry,
-         FROM landuse_z6
+                landuse,
-         WHERE zoom_level BETWEEN 6 AND 7
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z6
+         WHERE zoom_level = 6
          UNION ALL
-         -- etldoc: landuse_z8 -> layer_landuse:z8
+         -- etldoc: osm_landuse_polygon_gen_z7 -> layer_landuse:z7
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z8
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z7
+         WHERE zoom_level = 7
+         UNION ALL
+         -- etldoc: osm_landuse_polygon_gen_z8 -> layer_landuse:z8
+         SELECT osm_id,
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z8
          WHERE zoom_level = 8
          UNION ALL
-         -- etldoc: landuse_z9 -> layer_landuse:z9
+         -- etldoc: osm_landuse_polygon_gen_z9 -> layer_landuse:z9
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z9
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z9
          WHERE zoom_level = 9
          UNION ALL
-         -- etldoc: landuse_z10 -> layer_landuse:z10
+         -- etldoc: osm_landuse_polygon_gen_z10 -> layer_landuse:z10
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z10
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z10
          WHERE zoom_level = 10
          UNION ALL
-         -- etldoc: landuse_z11 -> layer_landuse:z11
+         -- etldoc: osm_landuse_polygon_gen_z11 -> layer_landuse:z11
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z11
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z11
          WHERE zoom_level = 11
          UNION ALL
-         -- etldoc: landuse_z12 -> layer_landuse:z12
+         -- etldoc: osm_landuse_polygon_gen_z12 -> layer_landuse:z12
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z12
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z12
          WHERE zoom_level = 12
          UNION ALL
-         -- etldoc: landuse_z13 -> layer_landuse:z13
+         -- etldoc: osm_landuse_polygon_gen_z13 -> layer_landuse:z13
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z13
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon_gen_z13
          WHERE zoom_level = 13
          UNION ALL
-         -- etldoc: landuse_z14 -> layer_landuse:z14
+         -- etldoc: osm_landuse_polygon -> layer_landuse:z14
-         SELECT *
+         SELECT osm_id,
-         FROM landuse_z14
+                geometry,
+                landuse,
+                amenity,
+                leisure,
+                tourism,
+                place,
+                waterway,
+                man_made
+         FROM osm_landuse_polygon
          WHERE zoom_level >= 14
      ) AS zoom_levels
 WHERE geometry && bbox;

layers/landuse/landuse.yaml

@@ -22,6 +22,7 @@ layer:
       - residential
       - commercial
       - industrial
+      - garages
       - retail
       - bus_station
       - school
@@ -37,6 +38,7 @@ layer:
       - theme_park
       - zoo
       - suburb
+      - quarter
       - neighbourhood
       - dam
       - sports_centre

layers/landuse/mapping.yaml

@@ -1,35 +1,41 @@
 generalized_tables:
-  # etldoc: imposm3 -> osm_landuse_polygon_gen7
+  # etldoc: osm_landuse_polygon_gen_z7 -> osm_landuse_polygon_gen_z6
-  landuse_polygon_gen7:
+  landuse_polygon_gen_z6:
-    source: landuse_polygon_gen6
+    source: landuse_polygon_gen_z7
+    tolerance: ZRES6
+    sql_filter: area>power(ZRES6,2)
+  # etldoc: osm_landuse_polygon_gen_z8 -> osm_landuse_polygon_gen_z7
+  landuse_polygon_gen_z7:
+    source: landuse_polygon_gen_z8
     tolerance: ZRES7
-  # etldoc: imposm3 -> osm_landuse_polygon_gen6
+    sql_filter: area>power(ZRES6,2)
-  landuse_polygon_gen6:
+  # etldoc: osm_landuse_polygon_gen_z9 -> osm_landuse_polygon_gen_z8
-    source: landuse_polygon_gen5
+  landuse_polygon_gen_z8:
-    sql_filter: area>power(ZRES6,2) AND (landuse='residential' OR place='suburb' OR place='neighbourhood')
+    source: landuse_polygon_gen_z9
+    sql_filter: area>power(ZRES6,2) AND (landuse='residential' OR place='suburb' OR place='quarter' OR place='neighbourhood')
     tolerance: ZRES8
-  # etldoc: imposm3 -> osm_landuse_polygon_gen5
+  # etldoc: osm_landuse_polygon_gen_z10 -> osm_landuse_polygon_gen_z9
-  landuse_polygon_gen5:
+  landuse_polygon_gen_z9:
-    source: landuse_polygon_gen4
+    source: landuse_polygon_gen_z10
     sql_filter: area>power(ZRES7,2)
     tolerance: ZRES9
-  # etldoc: imposm3 -> osm_landuse_polygon_gen4
+  # etldoc: osm_landuse_polygon_gen_z11 -> osm_landuse_polygon_gen_z10
-  landuse_polygon_gen4:
+  landuse_polygon_gen_z10:
-    source: landuse_polygon_gen3
+    source: landuse_polygon_gen_z11
     sql_filter: area>power(ZRES8,2)
     tolerance: ZRES10
-  # etldoc: imposm3 -> osm_landuse_polygon_gen3
+  # etldoc: osm_landuse_polygon_gen_z12 -> osm_landuse_polygon_gen_z11
-  landuse_polygon_gen3:
+  landuse_polygon_gen_z11:
-    source: landuse_polygon_gen2
+    source: landuse_polygon_gen_z12
     sql_filter: area>power(ZRES9,2)
     tolerance: ZRES11
-  # etldoc: imposm3 -> osm_landuse_polygon_gen2
+  # etldoc: osm_landuse_polygon_gen_z13 -> osm_landuse_polygon_gen_z12
-  landuse_polygon_gen2:
+  landuse_polygon_gen_z12:
-    source: landuse_polygon_gen1
+    source: landuse_polygon_gen_z13
     sql_filter: area>power(ZRES10,2)
     tolerance: ZRES12
-  # etldoc: imposm3 -> osm_landuse_polygon_gen1
+  # etldoc: osm_landuse_polygon -> osm_landuse_polygon_gen_z13
-  landuse_polygon_gen1:
+  landuse_polygon_gen_z13:
     source: landuse_polygon
     sql_filter: area>power(ZRES11,2) AND ST_IsValid(geometry)
     tolerance: ZRES13
@@ -104,6 +110,7 @@ tables:
       - picnic_site
       place:
       - suburb
+      - quarter
       - neighbourhood
       waterway:
       - dam

layers/mountain_peak/mountain_peak.sql

@@ -35,10 +35,10 @@ FROM (
          SELECT osm_id,
                 geometry,
                 name,
-                COALESCE(NULLIF(name_en, ''), name)                                  AS name_en,
+                COALESCE(NULLIF(name_en, ''), name) AS name_en,
-                COALESCE(NULLIF(name_de, ''), name, name_en)                         AS name_de,
+                COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
                 tags,
-                substring(ele FROM E'^(-?\\d+)(\\D|$)')::int                         AS ele,
+                substring(ele FROM E'^(-?\\d+)(\\D|$)')::int AS ele,
                 round(substring(ele FROM E'^(-?\\d+)(\\D|$)')::int * 3.2808399)::int AS ele_ft,
                 row_number() OVER (
                     PARTITION BY LabelGrid(geometry, 100 * pixel_width)
@@ -47,7 +47,7 @@ FROM (
                             (CASE WHEN NULLIF(wikipedia, '') IS NOT NULL THEN 10000 ELSE 0 END) +
                             (CASE WHEN NULLIF(name, '') IS NOT NULL THEN 10000 ELSE 0 END)
                         ) DESC
-                    )::int                                                           AS "rank"
+                    )::int AS "rank"
          FROM osm_peak_point
          WHERE geometry && bbox
            AND ele IS NOT NULL

layers/mountain_peak/mountain_peak.yaml

@@ -25,7 +25,7 @@ layer:
     query: (SELECT osm_id, geometry, name, name_en, name_de, {name_languages}, class, ele, ele_ft, rank FROM layer_mountain_peak(!bbox!, z(!scale_denominator!), !pixel_width!)) AS t
 schema:
   - ./update_peak_point.sql
-  - ./layer.sql
+  - ./mountain_peak.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/mountain_peak/update_peak_point.sql

@@ -1,33 +1,86 @@
-DROP TRIGGER IF EXISTS trigger_update_point ON osm_peak_point;
+DROP TRIGGER IF EXISTS trigger_flag ON osm_peak_point;
-
+DROP TRIGGER IF EXISTS trigger_store ON osm_peak_point;
--- etldoc:  osm_peak_point ->  osm_peak_point
+DROP TRIGGER IF EXISTS trigger_refresh ON mountain_peak_point.updates;
--- etldoc:  osm_peak_point ->  osm_peak_point
-CREATE OR REPLACE FUNCTION update_osm_peak_point(new_osm_id bigint) RETURNS void AS
-$$
-UPDATE osm_peak_point
-SET tags = update_tags(tags, geometry)
-WHERE (new_osm_id IS NULL OR osm_id = new_osm_id)
-  AND COALESCE(tags -> 'name:latin', tags -> 'name:nonlatin', tags -> 'name_int') IS NULL
-  AND tags != update_tags(tags, geometry)
-$$ LANGUAGE SQL;
-
-SELECT update_osm_peak_point(NULL);
-
--- Handle updates
 
 CREATE SCHEMA IF NOT EXISTS mountain_peak_point;
 
-CREATE OR REPLACE FUNCTION mountain_peak_point.update() RETURNS trigger AS
+CREATE TABLE IF NOT EXISTS mountain_peak_point.osm_ids
+(
+    osm_id bigint
+);
+
+-- etldoc:  osm_peak_point ->  osm_peak_point
+CREATE OR REPLACE FUNCTION update_osm_peak_point(full_update boolean) RETURNS void AS
+$$
+    UPDATE osm_peak_point
+    SET tags = update_tags(tags, geometry)
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM mountain_peak_point.osm_ids))
+      AND COALESCE(tags -> 'name:latin', tags -> 'name:nonlatin', tags -> 'name_int') IS NULL
+      AND tags != update_tags(tags, geometry)
+$$ LANGUAGE SQL;
+
+SELECT update_osm_peak_point(true);
+
+-- Handle updates
+
+CREATE OR REPLACE FUNCTION mountain_peak_point.store() RETURNS trigger AS
 $$
 BEGIN
-    PERFORM update_osm_peak_point(new.osm_id);
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO mountain_peak_point.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO mountain_peak_point.osm_ids VALUES (NEW.osm_id);
+    END IF;
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE CONSTRAINT TRIGGER trigger_update_point
+CREATE TABLE IF NOT EXISTS mountain_peak_point.updates
-    AFTER INSERT OR UPDATE
+(
+    id serial PRIMARY KEY,
+    t  text,
+    UNIQUE (t)
+);
+CREATE OR REPLACE FUNCTION mountain_peak_point.flag() RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO mountain_peak_point.updates(t) VALUES ('y') ON CONFLICT(t) DO NOTHING;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION mountain_peak_point.refresh() RETURNS trigger AS
+$$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
+BEGIN
+    RAISE LOG 'Refresh mountain_peak_point';
+    PERFORM update_osm_peak_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM mountain_peak_point.osm_ids;
+    -- noinspection SqlWithoutWhere
+    DELETE FROM mountain_peak_point.updates;
+
+    RAISE LOG 'Refresh mountain_peak_point done in %', age(clock_timestamp(), t);
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
     ON osm_peak_point
+    FOR EACH ROW
+EXECUTE PROCEDURE mountain_peak_point.store();
+
+CREATE TRIGGER trigger_flag
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_peak_point
+    FOR EACH STATEMENT
+EXECUTE PROCEDURE mountain_peak_point.flag();
+
+CREATE CONSTRAINT TRIGGER trigger_refresh
+    AFTER INSERT
+    ON mountain_peak_point.updates
     INITIALLY DEFERRED
     FOR EACH ROW
-EXECUTE PROCEDURE mountain_peak_point.update();
+EXECUTE PROCEDURE mountain_peak_point.refresh();

layers/park/mapping.yaml

@@ -1,48 +1,48 @@
 generalized_tables:
-  # etldoc: imposm3 -> osm_park_polygon_gen8
+  # etldoc: osm_park_polygon_gen_z7 -> osm_park_polygon_gen_z6
-  park_polygon_gen8:
+  park_polygon_gen_z6:
-    source: park_polygon_gen7
+    source: park_polygon_gen_z7
     sql_filter: area>power(ZRES5,2)
     tolerance: ZRES8
 
-  # etldoc: imposm3 -> osm_park_polygon_gen7
+  # etldoc: osm_park_polygon_gen_z8 -> osm_park_polygon_gen_z7
-  park_polygon_gen7:
+  park_polygon_gen_z7:
-    source: park_polygon_gen6
+    source: park_polygon_gen_z8
     sql_filter: area>power(ZRES6,2)
     tolerance: ZRES8
 
-  # etldoc: imposm3 -> osm_park_polygon_gen6
+  # etldoc: osm_park_polygon_gen_z9 -> osm_park_polygon_gen_z8
-  park_polygon_gen6:
+  park_polygon_gen_z8:
-    source: park_polygon_gen5
+    source: park_polygon_gen_z9
     sql_filter: area>power(ZRES7,2)
     tolerance: ZRES9
 
-  # etldoc: imposm3 -> osm_park_polygon_gen5
+  # etldoc: osm_park_polygon_gen_z10 -> osm_park_polygon_gen_z9
-  park_polygon_gen5:
+  park_polygon_gen_z9:
-    source: park_polygon_gen4
+    source: park_polygon_gen_z10
     sql_filter: area>power(ZRES8,2)
     tolerance: ZRES10
 
-  # etldoc: imposm3 -> osm_park_polygon_gen4
+  # etldoc: osm_park_polygon_gen_z11 -> osm_park_polygon_gen_z10
-  park_polygon_gen4:
+  park_polygon_gen_z10:
-    source: park_polygon_gen3
+    source: park_polygon_gen_z11
     sql_filter: area>power(ZRES9,2)
     tolerance: ZRES11
 
-  # etldoc: imposm3 -> osm_park_polygon_gen3
+  # etldoc: osm_park_polygon_gen_z12 -> osm_park_polygon_gen_z11
-  park_polygon_gen3:
+  park_polygon_gen_z11:
-    source: park_polygon_gen2
+    source: park_polygon_gen_z12
     sql_filter: area>power(ZRES10,2)
     tolerance: ZRES11
 
-  # etldoc: imposm3 -> osm_park_polygon_gen2
+  # etldoc: osm_park_polygon_gen_z13 -> osm_park_polygon_gen_z12
-  park_polygon_gen2:
+  park_polygon_gen_z12:
-    source: park_polygon_gen1
+    source: park_polygon_gen_z13
     sql_filter: area>power(ZRES11,2)
     tolerance: ZRES12
 
-  # etldoc: imposm3 -> osm_park_polygon_gen1
+  # etldoc: osm_park_polygon -> osm_park_polygon_gen_z13
-  park_polygon_gen1:
+  park_polygon_gen_z13:
     source: park_polygon
     sql_filter: area>power(ZRES12,2) AND ST_IsValid(geometry)
     tolerance: ZRES13

layers/park/park.sql

@@ -30,14 +30,14 @@ FROM (
                         LOWER(REPLACE(NULLIF(protection_title, ''), ' ', '_')),
                         NULLIF(boundary, ''),
                         NULLIF(leisure, '')
-                    )     AS class,
+                    ) AS class,
                 name,
                 name_en,
                 name_de,
                 tags,
                 NULL::int AS rank
          FROM (
-                  -- etldoc: osm_park_polygon_gen8 -> layer_park:z6
+                  -- etldoc: osm_park_polygon_gen_z6 -> layer_park:z6
                   SELECT osm_id,
                          geometry,
                          name,
@@ -47,11 +47,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen8
+                  FROM osm_park_polygon_gen_z6
                   WHERE zoom_level = 6
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen7 -> layer_park:z7
+                  -- etldoc: osm_park_polygon_gen_z7 -> layer_park:z7
                   SELECT osm_id,
                          geometry,
                          name,
@@ -61,11 +61,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen7
+                  FROM osm_park_polygon_gen_z7
                   WHERE zoom_level = 7
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen6 -> layer_park:z8
+                  -- etldoc: osm_park_polygon_gen_z8 -> layer_park:z8
                   SELECT osm_id,
                          geometry,
                          name,
@@ -75,11 +75,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen6
+                  FROM osm_park_polygon_gen_z8
                   WHERE zoom_level = 8
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen5 -> layer_park:z9
+                  -- etldoc: osm_park_polygon_gen_z9 -> layer_park:z9
                   SELECT osm_id,
                          geometry,
                          name,
@@ -89,11 +89,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen5
+                  FROM osm_park_polygon_gen_z9
                   WHERE zoom_level = 9
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen4 -> layer_park:z10
+                  -- etldoc: osm_park_polygon_gen_z10 -> layer_park:z10
                   SELECT osm_id,
                          geometry,
                          name,
@@ -103,11 +103,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen4
+                  FROM osm_park_polygon_gen_z10
                   WHERE zoom_level = 10
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen3 -> layer_park:z11
+                  -- etldoc: osm_park_polygon_gen_z11 -> layer_park:z11
                   SELECT osm_id,
                          geometry,
                          name,
@@ -117,11 +117,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen3
+                  FROM osm_park_polygon_gen_z11
                   WHERE zoom_level = 11
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen2 -> layer_park:z12
+                  -- etldoc: osm_park_polygon_gen_z12 -> layer_park:z12
                   SELECT osm_id,
                          geometry,
                          name,
@@ -131,11 +131,11 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen2
+                  FROM osm_park_polygon_gen_z12
                   WHERE zoom_level = 12
                     AND geometry && bbox
                   UNION ALL
-                  -- etldoc: osm_park_polygon_gen1 -> layer_park:z13
+                  -- etldoc: osm_park_polygon_gen_z13 -> layer_park:z13
                   SELECT osm_id,
                          geometry,
                          name,
@@ -145,7 +145,7 @@ FROM (
                          leisure,
                          boundary,
                          protection_title
-                  FROM osm_park_polygon_gen1
+                  FROM osm_park_polygon_gen_z13
                   WHERE zoom_level = 13
                     AND geometry && bbox
                   UNION ALL
@@ -171,7 +171,7 @@ FROM (
                         LOWER(REPLACE(NULLIF(protection_title, ''), ' ', '_')),
                         NULLIF(boundary, ''),
                         NULLIF(leisure, '')
-                    )          AS class,
+                    ) AS class,
                 name,
                 name_en,
                 name_de,
@@ -182,9 +182,9 @@ FROM (
                         (CASE WHEN boundary = 'national_park' THEN TRUE ELSE FALSE END) DESC,
                         (COALESCE(NULLIF(tags->'wikipedia', ''), NULLIF(tags->'wikidata', '')) IS NOT NULL) DESC,
                         area DESC
-                    )::int     AS "rank"
+                    )::int AS "rank"
          FROM (
-                  -- etldoc: osm_park_polygon_gen8 -> layer_park:z6
+                  -- etldoc: osm_park_polygon_gen_z6 -> layer_park:z6
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -195,13 +195,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen8
+                  FROM osm_park_polygon_gen_z6
                   WHERE zoom_level = 6
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen7 -> layer_park:z7
+                  -- etldoc: osm_park_polygon_gen_z7 -> layer_park:z7
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -212,13 +212,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen7
+                  FROM osm_park_polygon_gen_z7
                   WHERE zoom_level = 7
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen6 -> layer_park:z8
+                  -- etldoc: osm_park_polygon_gen_z8 -> layer_park:z8
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -229,13 +229,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen6
+                  FROM osm_park_polygon_gen_z8
                   WHERE zoom_level = 8
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen5 -> layer_park:z9
+                  -- etldoc: osm_park_polygon_gen_z9 -> layer_park:z9
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -246,13 +246,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen5
+                  FROM osm_park_polygon_gen_z9
                   WHERE zoom_level = 9
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen4 -> layer_park:z10
+                  -- etldoc: osm_park_polygon_gen_z10 -> layer_park:z10
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -263,13 +263,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen4
+                  FROM osm_park_polygon_gen_z10
                   WHERE zoom_level = 10
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen3 -> layer_park:z11
+                  -- etldoc: osm_park_polygon_gen_z11 -> layer_park:z11
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -280,13 +280,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen3
+                  FROM osm_park_polygon_gen_z11
                   WHERE zoom_level = 11
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen2 -> layer_park:z12
+                  -- etldoc: osm_park_polygon_gen_z12 -> layer_park:z12
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -297,13 +297,13 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen2
+                  FROM osm_park_polygon_gen_z12
                   WHERE zoom_level = 12
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)
                   UNION ALL
 
-                  -- etldoc: osm_park_polygon_gen1 -> layer_park:z13
+                  -- etldoc: osm_park_polygon_gen_z13 -> layer_park:z13
                   SELECT osm_id,
                          geometry_point,
                          name,
@@ -314,7 +314,7 @@ FROM (
                          boundary,
                          protection_title,
                          area
-                  FROM osm_park_polygon_gen1
+                  FROM osm_park_polygon_gen_z13
                   WHERE zoom_level = 13
                     AND geometry_point && bbox
                     AND area > 70000*2^(20-zoom_level)

layers/park/park.yaml

@@ -26,7 +26,7 @@ layer:
     query: (SELECT geometry, class, name, name_en, name_de, {name_languages}, rank FROM layer_park(!bbox!, z(!scale_denominator!), !pixel_width!)) AS t
 schema:
   - ./update_park_polygon.sql
-  - ./layer.sql
+  - ./park.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/park/update_park_polygon.sql

@@ -1,41 +1,41 @@
 ALTER TABLE osm_park_polygon
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen1
+ALTER TABLE osm_park_polygon_gen_z13
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen2
+ALTER TABLE osm_park_polygon_gen_z12
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen3
+ALTER TABLE osm_park_polygon_gen_z11
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen4
+ALTER TABLE osm_park_polygon_gen_z10
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen5
+ALTER TABLE osm_park_polygon_gen_z9
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen6
+ALTER TABLE osm_park_polygon_gen_z8
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen7
+ALTER TABLE osm_park_polygon_gen_z7
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
-ALTER TABLE osm_park_polygon_gen8
+ALTER TABLE osm_park_polygon_gen_z6
     ADD COLUMN IF NOT EXISTS geometry_point geometry;
 
 DROP TRIGGER IF EXISTS update_row ON osm_park_polygon;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen1;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z13;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen2;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z12;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen3;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z11;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen4;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z10;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen5;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z9;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen6;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z8;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen7;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z7;
-DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen8;
+DROP TRIGGER IF EXISTS update_row ON osm_park_polygon_gen_z6;
 
 -- etldoc:  osm_park_polygon ->  osm_park_polygon
--- etldoc:  osm_park_polygon_gen1 ->  osm_park_polygon_gen1
+-- etldoc:  osm_park_polygon_gen_z13 ->  osm_park_polygon_gen_z13
--- etldoc:  osm_park_polygon_gen2 ->  osm_park_polygon_gen2
+-- etldoc:  osm_park_polygon_gen_z12 ->  osm_park_polygon_gen_z12
--- etldoc:  osm_park_polygon_gen3 ->  osm_park_polygon_gen3
+-- etldoc:  osm_park_polygon_gen_z11 ->  osm_park_polygon_gen_z11
--- etldoc:  osm_park_polygon_gen4 ->  osm_park_polygon_gen4
+-- etldoc:  osm_park_polygon_gen_z10 ->  osm_park_polygon_gen_z10
--- etldoc:  osm_park_polygon_gen5 ->  osm_park_polygon_gen5
+-- etldoc:  osm_park_polygon_gen_z9 ->  osm_park_polygon_gen_z9
--- etldoc:  osm_park_polygon_gen6 ->  osm_park_polygon_gen6
+-- etldoc:  osm_park_polygon_gen_z8 ->  osm_park_polygon_gen_z8
--- etldoc:  osm_park_polygon_gen7 ->  osm_park_polygon_gen7
+-- etldoc:  osm_park_polygon_gen_z7 ->  osm_park_polygon_gen_z7
--- etldoc:  osm_park_polygon_gen8 ->  osm_park_polygon_gen8
+-- etldoc:  osm_park_polygon_gen_z6 ->  osm_park_polygon_gen_z6
 CREATE OR REPLACE FUNCTION update_osm_park_polygon() RETURNS void AS
 $$
 BEGIN
@@ -43,35 +43,35 @@ BEGIN
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen1
+    UPDATE osm_park_polygon_gen_z13
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen2
+    UPDATE osm_park_polygon_gen_z12
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen3
+    UPDATE osm_park_polygon_gen_z11
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen4
+    UPDATE osm_park_polygon_gen_z10
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen5
+    UPDATE osm_park_polygon_gen_z9
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen6
+    UPDATE osm_park_polygon_gen_z8
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen7
+    UPDATE osm_park_polygon_gen_z7
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
-    UPDATE osm_park_polygon_gen8
+    UPDATE osm_park_polygon_gen_z6
     SET tags           = update_tags(tags, geometry),
         geometry_point = st_centroid(geometry);
 
@@ -80,14 +80,14 @@ $$ LANGUAGE plpgsql;
 
 SELECT update_osm_park_polygon();
 CREATE INDEX IF NOT EXISTS osm_park_polygon_point_geom_idx ON osm_park_polygon USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen1_point_geom_idx ON osm_park_polygon_gen1 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z13_point_geom_idx ON osm_park_polygon_gen_z13 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen2_point_geom_idx ON osm_park_polygon_gen2 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z12_point_geom_idx ON osm_park_polygon_gen_z12 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen3_point_geom_idx ON osm_park_polygon_gen3 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z11_point_geom_idx ON osm_park_polygon_gen_z11 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen4_point_geom_idx ON osm_park_polygon_gen4 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z10_point_geom_idx ON osm_park_polygon_gen_z10 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen5_point_geom_idx ON osm_park_polygon_gen5 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z9_point_geom_idx ON osm_park_polygon_gen_z9 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen6_point_geom_idx ON osm_park_polygon_gen6 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z8_point_geom_idx ON osm_park_polygon_gen_z8 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen7_point_geom_idx ON osm_park_polygon_gen7 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z7_point_geom_idx ON osm_park_polygon_gen_z7 USING gist (geometry_point);
-CREATE INDEX IF NOT EXISTS osm_park_polygon_gen8_point_geom_idx ON osm_park_polygon_gen8 USING gist (geometry_point);
+CREATE INDEX IF NOT EXISTS osm_park_polygon_gen_z6_point_geom_idx ON osm_park_polygon_gen_z6 USING gist (geometry_point);
 
 
 CREATE OR REPLACE FUNCTION update_osm_park_polygon_row()
@@ -109,48 +109,48 @@ EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen1
+    ON osm_park_polygon_gen_z13
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen2
+    ON osm_park_polygon_gen_z12
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen3
+    ON osm_park_polygon_gen_z11
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen4
+    ON osm_park_polygon_gen_z10
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen5
+    ON osm_park_polygon_gen_z9
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen6
+    ON osm_park_polygon_gen_z8
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen7
+    ON osm_park_polygon_gen_z7
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();
 
 CREATE TRIGGER update_row
     BEFORE INSERT OR UPDATE
-    ON osm_park_polygon_gen8
+    ON osm_park_polygon_gen_z6
     FOR EACH ROW
 EXECUTE PROCEDURE update_osm_park_polygon_row();

layers/place/city.sql

@@ -22,12 +22,12 @@ FROM (
          SELECT osm_id,
                 geometry,
                 name,
-                COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+                COALESCE(NULLIF(name_en, ''), name) AS name_en,
                 COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
                 tags,
                 place,
                 "rank",
-                normalize_capital_level(capital)             AS capital
+                normalize_capital_level(capital) AS capital
          FROM osm_city_point
          WHERE geometry && bbox
            AND ((zoom_level = 2 AND "rank" = 1)
@@ -37,17 +37,17 @@ FROM (
          SELECT osm_id,
                 geometry,
                 name,
-                COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+                COALESCE(NULLIF(name_en, ''), name) AS name_en,
                 COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
                 tags,
                 place,
                 COALESCE("rank", gridrank + 10),
-                normalize_capital_level(capital)             AS capital
+                normalize_capital_level(capital) AS capital
          FROM (
                   SELECT osm_id,
                          geometry,
                          name,
-                         COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+                         COALESCE(NULLIF(name_en, ''), name) AS name_en,
                          COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
                          tags,
                          place,
@@ -59,7 +59,7 @@ FROM (
                                  place ASC NULLS LAST,
                                  population DESC NULLS LAST,
                                  length(name) ASC
-                             )::int                                   AS gridrank
+                             )::int AS gridrank
                   FROM osm_city_point
                   WHERE geometry && bbox
                     AND ((zoom_level = 7 AND place <= 'town'::city_place

layers/place/mapping.yaml

@@ -174,5 +174,6 @@ tables:
       - village
       - hamlet
       - suburb
+      - quarter
       - neighbourhood
       - isolated_dwelling

layers/place/place.sql

@@ -21,16 +21,16 @@ SELECT *
 FROM (
          SELECT
              -- etldoc: osm_continent_point -> layer_place:z0_3
-             osm_id * 10                                  AS osm_id,
+             osm_id * 10 AS osm_id,
              geometry,
              name,
-             COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+             COALESCE(NULLIF(name_en, ''), name) AS name_en,
              COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
              tags,
-             'continent'                                  AS class,
+             'continent' AS class,
-             1                                            AS "rank",
+             1 AS "rank",
-             NULL::int                                    AS capital,
+             NULL::int AS capital,
-             NULL::text                                   AS iso_a2
+             NULL::text AS iso_a2
          FROM osm_continent_point
          WHERE geometry && bbox
            AND zoom_level < 4
@@ -42,16 +42,16 @@ FROM (
              -- etldoc: osm_country_point -> layer_place:z4_7
              -- etldoc: osm_country_point -> layer_place:z8_11
              -- etldoc: osm_country_point -> layer_place:z12_14
-             osm_id * 10                                  AS osm_id,
+             osm_id * 10 AS osm_id,
              geometry,
              name,
-             COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+             COALESCE(NULLIF(name_en, ''), name) AS name_en,
              COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
              tags,
-             'country'                                    AS class,
+             'country' AS class,
              "rank",
-             NULL::int                                    AS capital,
+             NULL::int AS capital,
-             iso3166_1_alpha_2                            AS iso_a2
+             iso3166_1_alpha_2 AS iso_a2
          FROM osm_country_point
          WHERE geometry && bbox
            AND "rank" <= zoom_level + 1
@@ -64,39 +64,35 @@ FROM (
              -- etldoc: osm_state_point  -> layer_place:z4_7
              -- etldoc: osm_state_point  -> layer_place:z8_11
              -- etldoc: osm_state_point  -> layer_place:z12_14
-             osm_id * 10                                  AS osm_id,
+             osm_id * 10 AS osm_id,
              geometry,
              name,
-             COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+             COALESCE(NULLIF(name_en, ''), name) AS name_en,
              COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
              tags,
-             'state'                                      AS class,
+             'state' AS class,
              "rank",
-             NULL::int                                    AS capital,
+             NULL::int AS capital,
-             NULL::text                                   AS iso_a2
+             NULL::text AS iso_a2
          FROM osm_state_point
          WHERE geometry && bbox
            AND name <> ''
-           AND ("rank" + 2 <= zoom_level)
+           AND zoom_level > 1
-           AND (
-                 zoom_level >= 5 OR
-                 is_in_country IN ('United Kingdom', 'USA', 'Россия', 'Brasil', 'China', 'India') OR
-                 is_in_country_code IN ('AU', 'CN', 'IN', 'BR', 'US'))
 
          UNION ALL
 
          SELECT
              -- etldoc: osm_island_point    -> layer_place:z12_14
-             osm_id * 10                                  AS osm_id,
+             osm_id * 10 AS osm_id,
              geometry,
              name,
-             COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+             COALESCE(NULLIF(name_en, ''), name) AS name_en,
              COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
              tags,
-             'island'                                     AS class,
+             'island' AS class,
-             7                                            AS "rank",
+             7 AS "rank",
-             NULL::int                                    AS capital,
+             NULL::int AS capital,
-             NULL::text                                   AS iso_a2
+             NULL::text AS iso_a2
          FROM osm_island_point
          WHERE zoom_level >= 12
            AND geometry && bbox
@@ -106,16 +102,16 @@ FROM (
          SELECT
              -- etldoc: osm_island_polygon  -> layer_place:z8_11
              -- etldoc: osm_island_polygon  -> layer_place:z12_14
-             osm_id * 10                                  AS osm_id,
+             osm_id * 10 AS osm_id,
              geometry,
              name,
-             COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+             COALESCE(NULLIF(name_en, ''), name) AS name_en,
              COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
              tags,
-             'island'                                     AS class,
+             'island' AS class,
-             island_rank(area)                            AS "rank",
+             island_rank(area) AS "rank",
-             NULL::int                                    AS capital,
+             NULL::int AS capital,
-             NULL::text                                   AS iso_a2
+             NULL::text AS iso_a2
          FROM osm_island_polygon
          WHERE geometry && bbox
            AND ((zoom_level = 8 AND island_rank(area) <= 3)
@@ -138,7 +134,7 @@ FROM (
              place::text AS class,
              "rank",
              capital,
-             NULL::text  AS iso_a2
+             NULL::text AS iso_a2
          FROM layer_city(bbox, zoom_level, pixel_width)
          ORDER BY "rank" ASC
      ) AS place_all

layers/place/place.yaml

@@ -32,11 +32,12 @@ layer:
       - village
       - hamlet
       - suburb
+      - quarter
       - neighbourhood
       - isolated_dwelling
     iso_a2:
       description: |
-          Two-letter country code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+          Two-letter country code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Available only for `class=country`.
           Original value of the
           [`country_code_iso3166_1_alpha_2`](http://wiki.openstreetmap.org/wiki/Tag:place%3Dcountry) tag.
     rank:
@@ -72,7 +73,7 @@ schema:
   - ./update_island_point.sql
   - ./update_state_point.sql
   - ./update_city_point.sql
-  - ./layer.sql
+  - ./place.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/place/types.sql

@@ -2,7 +2,7 @@ DO
 $$
     BEGIN
         IF NOT EXISTS(SELECT 1 FROM pg_type WHERE typname = 'city_place') THEN
-            CREATE TYPE city_place AS enum ('city', 'town', 'village', 'hamlet', 'suburb', 'neighbourhood', 'isolated_dwelling');
+            CREATE TYPE city_place AS enum ('city', 'town', 'village', 'hamlet', 'suburb', 'quarter', 'neighbourhood', 'isolated_dwelling');
         END IF;
     END
 $$;

layers/place/update_city_point.sql

@@ -1,35 +1,30 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_city_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_city_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_city.updates;
 
 CREATE EXTENSION IF NOT EXISTS unaccent;
 
-CREATE OR REPLACE FUNCTION update_osm_city_point() RETURNS void AS
+CREATE SCHEMA IF NOT EXISTS place_city;
+
+CREATE TABLE IF NOT EXISTS place_city.osm_ids
+(
+    osm_id bigint
+);
+
+CREATE OR REPLACE FUNCTION update_osm_city_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
-
-    -- Clear  OSM key:rank ( https://github.com/openmaptiles/openmaptiles/issues/108 )
-    -- etldoc: osm_city_point          -> osm_city_point
-    UPDATE osm_city_point AS osm SET "rank" = NULL WHERE "rank" IS NOT NULL;
-
     -- etldoc: ne_10m_populated_places -> osm_city_point
     -- etldoc: osm_city_point          -> osm_city_point
 
     WITH important_city_point AS (
-        SELECT osm.geometry, osm.osm_id, osm.name, osm.name_en, ne.scalerank, ne.labelrank
+        SELECT osm.osm_id, ne.scalerank
-        FROM ne_10m_populated_places AS ne,
+        FROM osm_city_point AS osm
-             osm_city_point AS osm
+             -- Clear OSM key:rank ( https://github.com/openmaptiles/openmaptiles/issues/108 )
-        WHERE (
+             LEFT JOIN ne_10m_populated_places AS ne ON
+            (
                 (osm.tags ? 'wikidata' AND osm.tags->'wikidata' = ne.wikidataid) OR
-                ne.name ILIKE osm.name OR
+                lower(osm.name) IN (lower(ne.name), lower(ne.namealt), lower(ne.meganame), lower(ne.gn_ascii), lower(ne.nameascii)) OR
-                ne.name ILIKE osm.name_en OR
+                lower(osm.name_en) IN (lower(ne.name), lower(ne.namealt), lower(ne.meganame), lower(ne.gn_ascii), lower(ne.nameascii)) OR
-                ne.namealt ILIKE osm.name OR
-                ne.namealt ILIKE osm.name_en OR
-                ne.meganame ILIKE osm.name OR
-                ne.meganame ILIKE osm.name_en OR
-                ne.gn_ascii ILIKE osm.name OR
-                ne.gn_ascii ILIKE osm.name_en OR
-                ne.nameascii ILIKE osm.name OR
-                ne.nameascii ILIKE osm.name_en OR
                 ne.name = unaccent(osm.name)
             )
           AND osm.place IN ('city', 'town', 'village')
@@ -40,27 +35,40 @@ BEGIN
         -- are in the scalerank 5 bucket
     SET "rank" = CASE WHEN scalerank <= 5 THEN scalerank + 1 ELSE scalerank END
     FROM important_city_point AS ne
-    WHERE osm.osm_id = ne.osm_id;
+    WHERE (full_update OR osm.osm_id IN (SELECT osm_id FROM place_city.osm_ids))
+      AND rank IS DISTINCT FROM CASE WHEN scalerank <= 5 THEN scalerank + 1 ELSE scalerank END
+      AND osm.osm_id = ne.osm_id;
 
     UPDATE osm_city_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_city.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-END;
+$$ LANGUAGE SQL;
-$$ LANGUAGE plpgsql;
 
-SELECT update_osm_city_point();
+SELECT update_osm_city_point(true);
 
 CREATE INDEX IF NOT EXISTS osm_city_point_rank_idx ON osm_city_point ("rank");
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_city;
+CREATE OR REPLACE FUNCTION place_city.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_city.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_city.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_city.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_city.flag() RETURNS trigger AS
@@ -73,15 +81,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_city.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_city rank';
-    PERFORM update_osm_city_point();
+    PERFORM update_osm_city_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_city.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_city.updates;
+
+    RAISE LOG 'Refresh place_city done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_city_point
+    FOR EACH ROW
+EXECUTE PROCEDURE place_city.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_city_point

layers/place/update_continent_point.sql

@@ -1,27 +1,44 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_continent_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_continent_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_continent_point.updates;
 
+CREATE SCHEMA IF NOT EXISTS place_continent_point;
+
+CREATE TABLE IF NOT EXISTS place_continent_point.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc:  osm_continent_point ->  osm_continent_point
-CREATE OR REPLACE FUNCTION update_osm_continent_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_osm_continent_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
     UPDATE osm_continent_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_continent_point.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
+$$ LANGUAGE SQL;
 
-END;
+SELECT update_osm_continent_point(true);
-$$ LANGUAGE plpgsql;
-
-SELECT update_osm_continent_point();
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_continent_point;
+CREATE OR REPLACE FUNCTION place_continent_point.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_continent_point.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_continent_point.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_continent_point.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_continent_point.flag() RETURNS trigger AS
@@ -34,15 +51,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_continent_point.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_continent_point';
-    PERFORM update_osm_continent_point();
+    PERFORM update_osm_continent_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_continent_point.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_continent_point.updates;
+
+    RAISE LOG 'Refresh place_continent_point done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_continent_point
+    FOR EACH ROW
+EXECUTE PROCEDURE place_continent_point.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_continent_point

layers/place/update_country_point.sql

@@ -1,23 +1,28 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_country_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_country_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_country.updates;
 
-ALTER TABLE osm_country_point
+CREATE SCHEMA IF NOT EXISTS place_country;
-    DROP CONSTRAINT IF EXISTS osm_country_point_rank_constraint;
+
+CREATE TABLE IF NOT EXISTS place_country.osm_ids
+(
+    osm_id bigint
+);
 
 -- etldoc: ne_10m_admin_0_countries   -> osm_country_point
 -- etldoc: osm_country_point          -> osm_country_point
 
-CREATE OR REPLACE FUNCTION update_osm_country_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_osm_country_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
-
     UPDATE osm_country_point AS osm
     SET "rank"            = 7,
         iso3166_1_alpha_2 = COALESCE(
                 NULLIF(osm.country_code_iso3166_1_alpha_2, ''),
                 NULLIF(osm.iso3166_1_alpha_2, ''),
                 NULLIF(osm.iso3166_1, '')
-            );
+            )
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND rank IS NULL;
 
     WITH important_country_point AS (
         SELECT osm.geometry,
@@ -39,7 +44,9 @@ BEGIN
         -- where the ranks are still distributed uniform enough across all countries
     SET "rank" = LEAST(6, CEILING((scalerank + labelrank) / 2.0))
     FROM important_country_point AS ne
-    WHERE osm.osm_id = ne.osm_id;
+    WHERE (full_update OR osm.osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND rank = 7
+      AND osm.osm_id = ne.osm_id;
 
     -- Repeat the step for archipelago countries like Philippines or Indonesia
     -- whose label point is not within country's polygon
@@ -65,38 +72,52 @@ BEGIN
         -- where the ranks are still distributed uniform enough across all countries
     SET "rank" = LEAST(6, CEILING((ne.scalerank + ne.labelrank) / 2.0))
     FROM important_country_point AS ne
-    WHERE osm.osm_id = ne.osm_id
+    WHERE (full_update OR osm.osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND rank = 7
+      AND osm.osm_id = ne.osm_id
       AND ne.rk = 1;
 
     UPDATE osm_country_point AS osm
     SET "rank" = 6
-    WHERE "rank" = 7;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND "rank" = 7;
 
     -- TODO: This shouldn't be necessary? The rank function makes something wrong...
     UPDATE osm_country_point AS osm
     SET "rank" = 1
-    WHERE "rank" = 0;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND "rank" = 0;
 
     UPDATE osm_country_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_country.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-END;
+$$ LANGUAGE SQL;
-$$ LANGUAGE plpgsql;
 
-SELECT update_osm_country_point();
+SELECT update_osm_country_point(true);
 
--- ALTER TABLE osm_country_point ADD CONSTRAINT osm_country_point_rank_constraint CHECK("rank" BETWEEN 1 AND 6);
 CREATE INDEX IF NOT EXISTS osm_country_point_rank_idx ON osm_country_point ("rank");
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_country;
+CREATE OR REPLACE FUNCTION place_country.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_country.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_country.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_country.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_country.flag() RETURNS trigger AS
@@ -109,15 +130,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_country.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_country rank';
-    PERFORM update_osm_country_point();
+    PERFORM update_osm_country_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_country.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_country.updates;
+
+    RAISE LOG 'Refresh place_country done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_country_point
+    FOR EACH ROW
+EXECUTE PROCEDURE place_country.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_country_point

layers/place/update_island_point.sql

@@ -1,27 +1,44 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_island_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_island_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_island_point.updates;
 
+CREATE SCHEMA IF NOT EXISTS place_island_point;
+
+CREATE TABLE IF NOT EXISTS place_island_point.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc:  osm_island_point ->  osm_island_point
-CREATE OR REPLACE FUNCTION update_osm_island_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_osm_island_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
     UPDATE osm_island_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_island_point.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
+$$ LANGUAGE SQL;
 
-END;
+SELECT update_osm_island_point(true);
-$$ LANGUAGE plpgsql;
-
-SELECT update_osm_island_point();
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_island_point;
+CREATE OR REPLACE FUNCTION place_island_point.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_island_point.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_island_point.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_island_point.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_island_point.flag() RETURNS trigger AS
@@ -34,15 +51,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_island_point.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_island_point';
-    PERFORM update_osm_island_point();
+    PERFORM update_osm_island_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_island_point.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_island_point.updates;
+
+    RAISE LOG 'Refresh place_island_point done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_island_point
+    FOR EACH ROW
+EXECUTE PROCEDURE place_island_point.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_island_point

layers/place/update_island_polygon.sql

@@ -1,30 +1,51 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_island_polygon;
+DROP TRIGGER IF EXISTS trigger_store ON osm_island_polygon;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_island_polygon.updates;
 
+CREATE SCHEMA IF NOT EXISTS place_island_polygon;
+
+CREATE TABLE IF NOT EXISTS place_island_polygon.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc:  osm_island_polygon ->  osm_island_polygon
-CREATE OR REPLACE FUNCTION update_osm_island_polygon() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_osm_island_polygon(full_update boolean) RETURNS void AS
 $$
-BEGIN
+    UPDATE osm_island_polygon
-    UPDATE osm_island_polygon SET geometry=ST_PointOnSurface(geometry) WHERE ST_GeometryType(geometry) <> 'ST_Point';
+    SET geometry = ST_PointOnSurface(geometry)
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_island_polygon.osm_ids))
+      AND ST_GeometryType(geometry) <> 'ST_Point'
+      AND ST_IsValid(geometry);
 
     UPDATE osm_island_polygon
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_island_polygon.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-    ANALYZE osm_island_polygon;
+$$ LANGUAGE SQL;
-END;
-$$ LANGUAGE plpgsql;
 
-SELECT update_osm_island_polygon();
+SELECT update_osm_island_polygon(true);
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_island_polygon;
+CREATE OR REPLACE FUNCTION place_island_polygon.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_island_polygon.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_island_polygon.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_island_polygon.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_island_polygon.flag() RETURNS trigger AS
@@ -37,15 +58,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_island_polygon.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_island_polygon';
-    PERFORM update_osm_island_polygon();
+    PERFORM update_osm_island_polygon(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_island_polygon.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_island_polygon.updates;
+
+    RAISE LOG 'Refresh place_island_polygon done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_island_polygon
+    FOR EACH ROW
+EXECUTE PROCEDURE place_island_polygon.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_island_polygon

layers/place/update_state_point.sql

@@ -1,16 +1,19 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_state_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_state_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON place_state.updates;
 
-ALTER TABLE osm_state_point
+CREATE SCHEMA IF NOT EXISTS place_state;
-    DROP CONSTRAINT IF EXISTS osm_state_point_rank_constraint;
+
+CREATE TABLE IF NOT EXISTS place_state.osm_ids
+(
+    osm_id bigint
+);
 
 -- etldoc: ne_10m_admin_1_states_provinces   -> osm_state_point
 -- etldoc: osm_state_point                       -> osm_state_point
 
-CREATE OR REPLACE FUNCTION update_osm_state_point() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_osm_state_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
-
     WITH important_state_point AS (
         SELECT osm.geometry,
                osm.osm_id,
@@ -33,35 +36,50 @@ BEGIN
         -- Normalize both scalerank and labelrank into a ranking system from 1 to 6.
     SET "rank" = LEAST(6, CEILING((scalerank + labelrank + datarank) / 3.0))
     FROM important_state_point AS ne
-    WHERE osm.osm_id = ne.osm_id;
+    WHERE (full_update OR osm.osm_id IN (SELECT osm_id FROM place_state.osm_ids))
+      AND rank IS NULL
+      AND osm.osm_id = ne.osm_id;
 
     -- TODO: This shouldn't be necessary? The rank function makes something wrong...
     UPDATE osm_state_point AS osm
     SET "rank" = 1
-    WHERE "rank" = 0;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_state.osm_ids))
+      AND "rank" = 0;
 
-    DELETE FROM osm_state_point WHERE "rank" IS NULL;
+    DELETE FROM osm_state_point
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_state.osm_ids))
+      AND "rank" IS NULL;
 
     UPDATE osm_state_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM place_state.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-END;
+$$ LANGUAGE SQL;
-$$ LANGUAGE plpgsql;
 
-SELECT update_osm_state_point();
+SELECT update_osm_state_point(true);
 
--- ALTER TABLE osm_state_point ADD CONSTRAINT osm_state_point_rank_constraint CHECK("rank" BETWEEN 1 AND 6);
 CREATE INDEX IF NOT EXISTS osm_state_point_rank_idx ON osm_state_point ("rank");
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS place_state;
+CREATE OR REPLACE FUNCTION place_state.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO place_state.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO place_state.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS place_state.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION place_state.flag() RETURNS trigger AS
@@ -74,15 +92,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION place_state.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh place_state rank';
-    PERFORM update_osm_state_point();
+    PERFORM update_osm_state_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM place_state.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM place_state.updates;
+
+    RAISE LOG 'Refresh place_state done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_state_point
+    FOR EACH ROW
+EXECUTE PROCEDURE place_state.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_state_point

layers/poi/poi.sql

@@ -20,17 +20,13 @@ CREATE OR REPLACE FUNCTION layer_poi(bbox geometry, zoom_level integer, pixel_wi
             )
 AS
 $$
-SELECT osm_id_hash                                  AS osm_id,
+SELECT osm_id_hash AS osm_id,
        geometry,
-       NULLIF(name, '')                             AS name,
+       NULLIF(name, '') AS name,
-       COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+       COALESCE(NULLIF(name_en, ''), name) AS name_en,
        COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
        tags,
-       poi_class(
+       poi_class(subclass, mapping_key, subtype) AS class,
-        subclass,
-        mapping_key,
-        subtype
-       )                                            AS class,
        CASE
            WHEN subclass = 'information'
                THEN NULLIF(information, '')
@@ -41,11 +37,11 @@ SELECT osm_id_hash                                  AS osm_id,
            WHEN subclass = 'sports_centre'
                THEN NULLIF(sport, subclass)
            ELSE subclass
-           END                                      AS subclass,
+           END AS subclass,
        agg_stop,
-       NULLIF(layer, 0)                             AS layer,
+       NULLIF(layer, 0) AS layer,
        "level",
-       CASE WHEN indoor = TRUE THEN 1 END           AS indoor,
+       CASE WHEN indoor = TRUE THEN 1 END AS indoor,
        row_number() OVER (
            PARTITION BY LabelGrid(geometry, 100 * pixel_width)
            ORDER BY
@@ -103,7 +99,7 @@ FROM (
                 CASE
                     WHEN osm_id < 0 THEN -osm_id * 10 + 4
                     ELSE osm_id * 10 + 1
-                    END       AS osm_id_hash
+                    END AS osm_id_hash
          FROM osm_poi_polygon
          WHERE geometry && bbox
            AND zoom_level BETWEEN 12 AND 13
@@ -118,7 +114,7 @@ FROM (
                 CASE
                     WHEN osm_id < 0 THEN -osm_id * 10 + 4
                     ELSE osm_id * 10 + 1
-                    END       AS osm_id_hash
+                    END AS osm_id_hash
          FROM osm_poi_polygon
          WHERE geometry && bbox
            AND zoom_level >= 14

layers/poi/poi.yaml

@@ -201,7 +201,7 @@ schema:
   - ./poi_stop_agg.sql
   - ./update_poi_polygon.sql
   - ./update_poi_point.sql
-  - ./layer.sql
+  - ./poi.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/poi/poi_stop_agg.sql

@@ -2,7 +2,7 @@ DROP MATERIALIZED VIEW IF EXISTS osm_poi_stop_centroid CASCADE;
 CREATE MATERIALIZED VIEW osm_poi_stop_centroid AS
 (
 SELECT uic_ref,
-       count(*)                                                        AS count,
+       count(*) AS count,
        CASE WHEN count(*) > 2 THEN ST_Centroid(ST_UNION(geometry)) END AS centroid
 FROM osm_poi_point
 WHERE nullif(uic_ref, '') IS NOT NULL

layers/poi/update_poi_point.sql

@@ -57,7 +57,7 @@ CREATE SCHEMA IF NOT EXISTS poi_point;
 CREATE TABLE IF NOT EXISTS poi_point.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION poi_point.flag() RETURNS trigger AS
@@ -70,6 +70,8 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION poi_point.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh poi_point';
     PERFORM update_osm_poi_point();
@@ -78,6 +80,8 @@ BEGIN
     PERFORM update_osm_poi_point_agg();
     -- noinspection SqlWithoutWhere
     DELETE FROM poi_point.updates;
+
+    RAISE LOG 'Refresh poi_point done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;

layers/poi/update_poi_polygon.sql

@@ -1,11 +1,18 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_poi_polygon;
+DROP TRIGGER IF EXISTS trigger_store ON osm_poi_polygon;
 DROP TRIGGER IF EXISTS trigger_refresh ON poi_polygon.updates;
 
+CREATE SCHEMA IF NOT EXISTS poi_polygon;
+
+CREATE TABLE IF NOT EXISTS poi_polygon.osm_ids
+(
+    osm_id bigint
+);
+
 -- etldoc:  osm_poi_polygon ->  osm_poi_polygon
 
-CREATE OR REPLACE FUNCTION update_poi_polygon() RETURNS void AS
+CREATE OR REPLACE FUNCTION update_poi_polygon(full_update boolean) RETURNS void AS
 $$
-BEGIN
     UPDATE osm_poi_polygon
     SET geometry =
             CASE
@@ -13,36 +20,50 @@ BEGIN
                     THEN ST_Centroid(geometry)
                 ELSE ST_PointOnSurface(geometry)
                 END
-    WHERE ST_GeometryType(geometry) <> 'ST_Point';
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM poi_polygon.osm_ids))
+      AND ST_GeometryType(geometry) <> 'ST_Point'
+      AND ST_IsValid(geometry);
 
     UPDATE osm_poi_polygon
     SET subclass = 'subway'
-    WHERE station = 'subway'
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM poi_polygon.osm_ids))
+      AND station = 'subway'
       AND subclass = 'station';
 
     UPDATE osm_poi_polygon
     SET subclass = 'halt'
-    WHERE funicular = 'yes'
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM poi_polygon.osm_ids))
+      AND funicular = 'yes'
       AND subclass = 'station';
 
     UPDATE osm_poi_polygon
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM poi_polygon.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-    ANALYZE osm_poi_polygon;
+$$ LANGUAGE SQL;
-END;
-$$ LANGUAGE plpgsql;
 
-SELECT update_poi_polygon();
+SELECT update_poi_polygon(true);
 
 -- Handle updates
 
-CREATE SCHEMA IF NOT EXISTS poi_polygon;
+CREATE OR REPLACE FUNCTION poi_polygon.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO poi_polygon.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO poi_polygon.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS poi_polygon.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION poi_polygon.flag() RETURNS trigger AS
@@ -55,15 +76,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION poi_polygon.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh poi_polygon';
-    PERFORM update_poi_polygon();
+    PERFORM update_poi_polygon(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM poi_polygon.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM poi_polygon.updates;
+
+    RAISE LOG 'Refresh poi_polygon done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_poi_polygon
+    FOR EACH ROW
+EXECUTE PROCEDURE poi_polygon.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_poi_polygon

layers/transportation/layer.sql

@@ -1,703 +0,0 @@
-CREATE OR REPLACE FUNCTION highway_is_link(highway text) RETURNS boolean AS
-$$
-SELECT highway LIKE '%_link';
-$$ LANGUAGE SQL IMMUTABLE
-                STRICT
-                PARALLEL SAFE;
-
-
--- etldoc: layer_transportation[shape=record fillcolor=lightpink, style="rounded,filled",
--- etldoc:     label="<sql> layer_transportation |<z4> z4 |<z5> z5 |<z6> z6 |<z7> z7 |<z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14_> z14+" ] ;
-CREATE OR REPLACE FUNCTION layer_transportation(bbox geometry, zoom_level int)
-    RETURNS TABLE
-            (
-                osm_id    bigint,
-                geometry  geometry,
-                class     text,
-                subclass  text,
-                ramp      int,
-                oneway    int,
-                brunnel   text,
-                service   text,
-                layer     int,
-                level     int,
-                indoor    int,
-                bicycle   text,
-                foot      text,
-                horse     text,
-                mtb_scale text,
-                surface   text
-            )
-AS
-$$
-SELECT osm_id,
-       geometry,
-       CASE
-           WHEN NULLIF(highway, '') IS NOT NULL OR NULLIF(public_transport, '') IS NOT NULL
-               THEN highway_class(highway, public_transport, construction)
-           WHEN NULLIF(railway, '') IS NOT NULL THEN railway_class(railway)
-           WHEN NULLIF(aerialway, '') IS NOT NULL THEN aerialway
-           WHEN NULLIF(shipway, '') IS NOT NULL THEN shipway
-           WHEN NULLIF(man_made, '') IS NOT NULL THEN man_made
-           END                                AS class,
-       CASE
-           WHEN railway IS NOT NULL THEN railway
-           WHEN (highway IS NOT NULL OR public_transport IS NOT NULL)
-               AND highway_class(highway, public_transport, construction) = 'path'
-               THEN COALESCE(NULLIF(public_transport, ''), highway)
-           END                                AS subclass,
-       -- All links are considered as ramps as well
-       CASE
-           WHEN highway_is_link(highway) OR highway = 'steps'
-               THEN 1
-           ELSE is_ramp::int END              AS ramp,
-       is_oneway::int                         AS oneway,
-       brunnel(is_bridge, is_tunnel, is_ford) AS brunnel,
-       NULLIF(service, '')                    AS service,
-       NULLIF(layer, 0)                       AS layer,
-       "level",
-       CASE WHEN indoor = TRUE THEN 1 END     AS indoor,
-       NULLIF(bicycle, '')                    AS bicycle,
-       NULLIF(foot, '')                       AS foot,
-       NULLIF(horse, '')                      AS horse,
-       NULLIF(mtb_scale, '')                  AS mtb_scale,
-       NULLIF(surface, '')                    AS surface
-FROM (
-         -- etldoc: osm_transportation_merge_linestring_gen7 -> layer_transportation:z4
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                NULL::int     AS layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_transportation_merge_linestring_gen7
-         WHERE zoom_level = 4
-         UNION ALL
-
-         -- etldoc: osm_transportation_merge_linestring_gen6 -> layer_transportation:z5
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                NULL::int     AS layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_transportation_merge_linestring_gen6
-         WHERE zoom_level = 5
-         UNION ALL
-
-         -- etldoc: osm_transportation_merge_linestring_gen5 -> layer_transportation:z6
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                NULL::int     AS layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_transportation_merge_linestring_gen5
-         WHERE zoom_level = 6
-         UNION ALL
-
-         -- etldoc: osm_transportation_merge_linestring_gen4  ->  layer_transportation:z7
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                NULL::int     AS layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_transportation_merge_linestring_gen4
-         WHERE zoom_level = 7
-         UNION ALL
-
-         -- etldoc: osm_transportation_merge_linestring_gen3  ->  layer_transportation:z8
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                NULL::int     AS layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_transportation_merge_linestring_gen3
-         WHERE zoom_level = 8
-         UNION ALL
-
-         -- etldoc: osm_highway_linestring_gen2  ->  layer_transportation:z9
-         -- etldoc: osm_highway_linestring_gen2  ->  layer_transportation:z10
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                bicycle,
-                foot,
-                horse,
-                mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_highway_linestring_gen2
-         WHERE zoom_level BETWEEN 9 AND 10
-           AND st_length(geometry) > zres(11)
-         UNION ALL
-
-         -- etldoc: osm_highway_linestring_gen1  ->  layer_transportation:z11
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                NULL          AS public_transport,
-                NULL          AS service,
-                NULL::boolean AS is_bridge,
-                NULL::boolean AS is_tunnel,
-                NULL::boolean AS is_ford,
-                NULL::boolean AS is_ramp,
-                NULL::int     AS is_oneway,
-                NULL          AS man_made,
-                layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                bicycle,
-                foot,
-                horse,
-                mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_highway_linestring_gen1
-         WHERE zoom_level = 11
-           AND st_length(geometry) > zres(12)
-         UNION ALL
-
-         -- etldoc: osm_highway_linestring       ->  layer_transportation:z12
-         -- etldoc: osm_highway_linestring       ->  layer_transportation:z13
-         -- etldoc: osm_highway_linestring       ->  layer_transportation:z14_
-         SELECT osm_id,
-                geometry,
-                highway,
-                construction,
-                NULL                                                       AS railway,
-                NULL                                                       AS aerialway,
-                NULL                                                       AS shipway,
-                public_transport,
-                service_value(service)                                     AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                man_made,
-                layer,
-                CASE WHEN highway IN ('footway', 'steps') THEN "level" END AS "level",
-                CASE WHEN highway IN ('footway', 'steps') THEN indoor END  AS indoor,
-                bicycle,
-                foot,
-                horse,
-                mtb_scale,
-                surface_value(surface)                                     AS "surface",
-                z_order
-         FROM osm_highway_linestring
-         WHERE NOT is_area
-           AND (
-                     zoom_level = 12 AND (
-                             highway_class(highway, public_transport, construction) NOT IN ('track', 'path', 'minor')
-                         OR highway IN ('unclassified', 'residential')
-                     ) AND man_made <> 'pier'
-                 OR zoom_level = 13
-                         AND (
-                                    highway_class(highway, public_transport, construction) NOT IN ('track', 'path') AND
-                                    man_made <> 'pier'
-                            OR
-                                    man_made = 'pier' AND NOT ST_IsClosed(geometry)
-                        )
-                 OR zoom_level >= 14
-                         AND (
-                            man_made <> 'pier'
-                            OR
-                            NOT ST_IsClosed(geometry)
-                        )
-             )
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring_gen5  ->  layer_transportation:z8
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                NULL::boolean          AS is_bridge,
-                NULL::boolean          AS is_tunnel,
-                NULL::boolean          AS is_ford,
-                NULL::boolean          AS is_ramp,
-                NULL::int              AS is_oneway,
-                NULL                   AS man_made,
-                NULL::int              AS layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring_gen5
-         WHERE zoom_level = 8
-           AND railway = 'rail'
-           AND service = ''
-           AND usage = 'main'
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring_gen4  ->  layer_transportation:z9
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                NULL::boolean          AS is_bridge,
-                NULL::boolean          AS is_tunnel,
-                NULL::boolean          AS is_ford,
-                NULL::boolean          AS is_ramp,
-                NULL::int              AS is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring_gen4
-         WHERE zoom_level = 9
-           AND railway = 'rail'
-           AND service = ''
-           AND usage = 'main'
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring_gen3  ->  layer_transportation:z10
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring_gen3
-         WHERE zoom_level = 10
-           AND railway IN ('rail', 'narrow_gauge')
-           AND service = ''
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring_gen2  ->  layer_transportation:z11
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring_gen2
-         WHERE zoom_level = 11
-           AND railway IN ('rail', 'narrow_gauge', 'light_rail')
-           AND service = ''
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring_gen1  ->  layer_transportation:z12
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring_gen1
-         WHERE zoom_level = 12
-           AND railway IN ('rail', 'narrow_gauge', 'light_rail')
-           AND service = ''
-         UNION ALL
-
-         -- etldoc: osm_railway_linestring       ->  layer_transportation:z13
-         -- etldoc: osm_railway_linestring       ->  layer_transportation:z14_
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                railway,
-                NULL                   AS aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_railway_linestring
-         WHERE zoom_level = 13
-             AND railway IN ('rail', 'narrow_gauge', 'light_rail') AND service = ''
-            OR zoom_level >= 14
-         UNION ALL
-
-         -- etldoc: osm_aerialway_linestring_gen1  ->  layer_transportation:z12
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                NULL                   AS railway,
-                aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_aerialway_linestring_gen1
-         WHERE zoom_level = 12
-         UNION ALL
-
-         -- etldoc: osm_aerialway_linestring       ->  layer_transportation:z13
-         -- etldoc: osm_aerialway_linestring       ->  layer_transportation:z14_
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                NULL                   AS railway,
-                aerialway,
-                NULL                   AS shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_aerialway_linestring
-         WHERE zoom_level >= 13
-         UNION ALL
-
-         -- etldoc: osm_shipway_linestring_gen2  ->  layer_transportation:z11
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                NULL                   AS railway,
-                NULL                   AS aerialway,
-                shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_shipway_linestring_gen2
-         WHERE zoom_level = 11
-         UNION ALL
-
-         -- etldoc: osm_shipway_linestring_gen1  ->  layer_transportation:z12
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                NULL                   AS railway,
-                NULL                   AS aerialway,
-                shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_shipway_linestring_gen1
-         WHERE zoom_level = 12
-         UNION ALL
-
-         -- etldoc: osm_shipway_linestring       ->  layer_transportation:z13
-         -- etldoc: osm_shipway_linestring       ->  layer_transportation:z14_
-         SELECT osm_id,
-                geometry,
-                NULL                   AS highway,
-                NULL                   AS construction,
-                NULL                   AS railway,
-                NULL                   AS aerialway,
-                shipway,
-                NULL                   AS public_transport,
-                service_value(service) AS service,
-                is_bridge,
-                is_tunnel,
-                is_ford,
-                is_ramp,
-                is_oneway,
-                NULL                   AS man_made,
-                layer,
-                NULL::int              AS level,
-                NULL::boolean          AS indoor,
-                NULL                   AS bicycle,
-                NULL                   AS foot,
-                NULL                   AS horse,
-                NULL                   AS mtb_scale,
-                NULL                   AS surface,
-                z_order
-         FROM osm_shipway_linestring
-         WHERE zoom_level >= 13
-         UNION ALL
-
-         -- NOTE: We limit the selection of polys because we need to be
-         -- careful to net get false positives here because
-         -- it is possible that closed linestrings appear both as
-         -- highway linestrings and as polygon
-         -- etldoc: osm_highway_polygon          ->  layer_transportation:z13
-         -- etldoc: osm_highway_polygon          ->  layer_transportation:z14_
-         SELECT osm_id,
-                geometry,
-                highway,
-                NULL          AS construction,
-                NULL          AS railway,
-                NULL          AS aerialway,
-                NULL          AS shipway,
-                public_transport,
-                NULL          AS service,
-                CASE
-                    WHEN man_made IN ('bridge') THEN TRUE
-                    ELSE FALSE
-                    END       AS is_bridge,
-                FALSE         AS is_tunnel,
-                FALSE         AS is_ford,
-                FALSE         AS is_ramp,
-                FALSE::int    AS is_oneway,
-                man_made,
-                layer,
-                NULL::int     AS level,
-                NULL::boolean AS indoor,
-                NULL          AS bicycle,
-                NULL          AS foot,
-                NULL          AS horse,
-                NULL          AS mtb_scale,
-                NULL          AS surface,
-                z_order
-         FROM osm_highway_polygon
-              -- We do not want underground pedestrian areas for now
-         WHERE zoom_level >= 13
-           AND (
-                 man_made IN ('bridge', 'pier')
-                 OR (is_area AND COALESCE(layer, 0) >= 0)
-             )
-     ) AS zoom_levels
-WHERE geometry && bbox
-ORDER BY z_order ASC;
-$$ LANGUAGE SQL STABLE
-                -- STRICT
-                PARALLEL SAFE;

layers/transportation/mapping.yaml

@@ -1,55 +1,61 @@
 generalized_tables:
-# etldoc: imposm3 -> osm_railway_linestring_gen5
+# etldoc: osm_railway_linestring_gen_z9 -> osm_railway_linestring_gen_z8
-  railway_linestring_gen5:
+  railway_linestring_gen_z8:
-    source: railway_linestring_gen4
+    source: railway_linestring_gen_z9
     tolerance: ZRES9
 
-# etldoc: imposm3 -> osm_railway_linestring_gen4
+# etldoc: osm_railway_linestring_gen_z10 -> osm_railway_linestring_gen_z9
-  railway_linestring_gen4:
+  railway_linestring_gen_z9:
-    source: railway_linestring_gen3
+    source: railway_linestring_gen_z10
     tolerance: ZRES10
 
-# etldoc: imposm3 -> osm_railway_linestring_gen3
+# etldoc: osm_railway_linestring_gen_z11 -> osm_railway_linestring_gen_z10
-  railway_linestring_gen3:
+  railway_linestring_gen_z10:
-    source: railway_linestring_gen2
+    source: railway_linestring_gen_z11
     tolerance: ZRES11
 
-# etldoc: imposm3 -> osm_railway_linestring_gen2
+# etldoc: osm_railway_linestring_gen_z12 -> osm_railway_linestring_gen_z11
-  railway_linestring_gen2:
+  railway_linestring_gen_z11:
-    source: railway_linestring_gen1
+    source: railway_linestring_gen_z12
     tolerance: ZRES12
 
-# etldoc: imposm3 -> osm_railway_linestring_gen1
+# etldoc: osm_railway_linestring -> osm_railway_linestring_gen_z12
-  railway_linestring_gen1:
+  railway_linestring_gen_z12:
     source: railway_linestring
     sql_filter: railway IN ('rail', 'narrow_gauge', 'light_rail') AND service='' AND ST_IsValid(geometry)
     tolerance: ZRES13
 
-# etldoc: imposm3 -> osm_aerialway_linestring_gen1
+# etldoc: osm_aerialway_linestring -> osm_aerialway_linestring_gen_z12
-  aerialway_linestring_gen1:
+  aerialway_linestring_gen_z12:
     source: aerialway_linestring
     sql_filter: ST_IsValid(geometry)
     tolerance: ZRES13
 
-# etldoc: imposm3 -> osm_shipway_linestring_gen2
+# etldoc: osm_shipway_linestring_gen_z12 -> osm_shipway_linestring_gen_z11
-  shipway_linestring_gen2:
+  shipway_linestring_gen_z11:
-    source: shipway_linestring_gen1
+    source: shipway_linestring_gen_z12
     tolerance: ZRES12
 
-# etldoc: imposm3 -> osm_shipway_linestring_gen1
+# etldoc: osm_shipway_linestring -> osm_shipway_linestring_gen_z12
-  shipway_linestring_gen1:
+  shipway_linestring_gen_z12:
     source: shipway_linestring
     sql_filter: ST_IsValid(geometry)
     tolerance: ZRES13
 
-# etldoc: imposm3 -> osm_highway_linestring_gen2
+# etldoc: osm_highway_linestring_gen_z10 -> osm_highway_linestring_gen_z9
-  highway_linestring_gen2:
+  highway_linestring_gen_z9:
-    source: highway_linestring_gen1
+    source: highway_linestring_gen_z10
+    sql_filter: (highway IN ('motorway', 'trunk', 'primary', 'secondary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link') OR highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary', 'secondary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link')) AND NOT is_area
+    tolerance: ZRES10
+
+# etldoc: osm_highway_linestring_gen_z11 -> osm_highway_linestring_gen_z10
+  highway_linestring_gen_z10:
+    source: highway_linestring_gen_z11
     sql_filter: (highway IN ('motorway', 'trunk', 'primary', 'secondary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link') OR highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary', 'secondary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link')) AND NOT is_area
     tolerance: ZRES11
 
-# etldoc: imposm3 -> osm_highway_linestring_gen1
+# etldoc: osm_highway_linestring -> osm_highway_linestring_gen_z11
-  highway_linestring_gen1:
+  highway_linestring_gen_z11:
     source: highway_linestring
     sql_filter: (highway IN ('motorway', 'trunk', 'primary', 'secondary', 'tertiary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link', 'tertiary_link') OR highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary', 'secondary', 'tertiary', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link', 'tertiary_link')) AND NOT is_area AND ST_IsValid(geometry)
     tolerance: ZRES12

layers/transportation/transportation.sql

@@ -0,0 +1,734 @@
+CREATE OR REPLACE FUNCTION highway_is_link(highway text) RETURNS boolean AS
+$$
+SELECT highway LIKE '%_link';
+$$ LANGUAGE SQL IMMUTABLE
+                STRICT
+                PARALLEL SAFE;
+
+
+-- etldoc: layer_transportation[shape=record fillcolor=lightpink, style="rounded,filled",
+-- etldoc:     label="<sql> layer_transportation |<z4> z4 |<z5> z5 |<z6> z6 |<z7> z7 |<z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14_> z14+" ] ;
+CREATE OR REPLACE FUNCTION layer_transportation(bbox geometry, zoom_level int)
+    RETURNS TABLE
+            (
+                osm_id    bigint,
+                geometry  geometry,
+                class     text,
+                subclass  text,
+                ramp      int,
+                oneway    int,
+                brunnel   text,
+                service   text,
+                layer     int,
+                level     int,
+                indoor    int,
+                bicycle   text,
+                foot      text,
+                horse     text,
+                mtb_scale text,
+                surface   text
+            )
+AS
+$$
+SELECT osm_id,
+       geometry,
+       CASE
+           WHEN NULLIF(highway, '') IS NOT NULL OR NULLIF(public_transport, '') IS NOT NULL
+               THEN highway_class(highway, public_transport, construction)
+           WHEN NULLIF(railway, '') IS NOT NULL THEN railway_class(railway)
+           WHEN NULLIF(aerialway, '') IS NOT NULL THEN 'aerialway'
+           WHEN NULLIF(shipway, '') IS NOT NULL THEN shipway
+           WHEN NULLIF(man_made, '') IS NOT NULL THEN man_made
+           END AS class,
+       CASE
+           WHEN railway IS NOT NULL THEN railway
+           WHEN (highway IS NOT NULL OR public_transport IS NOT NULL)
+               AND highway_class(highway, public_transport, construction) = 'path'
+               THEN COALESCE(NULLIF(public_transport, ''), highway)
+           WHEN aerialway IS NOT NULL THEN aerialway
+           END AS subclass,
+       -- All links are considered as ramps as well
+       CASE
+           WHEN highway_is_link(highway) OR highway = 'steps'
+               THEN 1
+           ELSE is_ramp::int END AS ramp,
+       is_oneway::int AS oneway,
+       brunnel(is_bridge, is_tunnel, is_ford) AS brunnel,
+       NULLIF(service, '') AS service,
+       NULLIF(layer, 0) AS layer,
+       "level",
+       CASE WHEN indoor = TRUE THEN 1 END AS indoor,
+       NULLIF(bicycle, '') AS bicycle,
+       NULLIF(foot, '') AS foot,
+       NULLIF(horse, '') AS horse,
+       NULLIF(mtb_scale, '') AS mtb_scale,
+       NULLIF(surface, '') AS surface
+FROM (
+         -- etldoc: osm_transportation_merge_linestring_gen_z4 -> layer_transportation:z4
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_transportation_merge_linestring_gen_z4
+         WHERE zoom_level = 4
+         UNION ALL
+
+         -- etldoc: osm_transportation_merge_linestring_gen_z5 -> layer_transportation:z5
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_transportation_merge_linestring_gen_z5
+         WHERE zoom_level = 5
+         UNION ALL
+
+         -- etldoc: osm_transportation_merge_linestring_gen_z6 -> layer_transportation:z6
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_transportation_merge_linestring_gen_z6
+         WHERE zoom_level = 6
+         UNION ALL
+
+         -- etldoc: osm_transportation_merge_linestring_gen_z7  ->  layer_transportation:z7
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_transportation_merge_linestring_gen_z7
+         WHERE zoom_level = 7
+         UNION ALL
+
+         -- etldoc: osm_transportation_merge_linestring_gen_z8  ->  layer_transportation:z8
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_transportation_merge_linestring_gen_z8
+         WHERE zoom_level = 8
+         UNION ALL
+
+         -- etldoc: osm_highway_linestring_gen_z9  ->  layer_transportation:z9
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                bicycle,
+                foot,
+                horse,
+                mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_highway_linestring_gen_z9
+         WHERE zoom_level = 9
+           AND ST_Length(geometry) > ZRes(11)
+         UNION ALL
+
+         -- etldoc: osm_highway_linestring_gen_z10  ->  layer_transportation:z10
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                bicycle,
+                foot,
+                horse,
+                mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_highway_linestring_gen_z10
+         WHERE zoom_level = 10
+           AND ST_Length(geometry) > ZRes(11)
+         UNION ALL
+
+         -- etldoc: osm_highway_linestring_gen_z11  ->  layer_transportation:z11
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                NULL AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                bicycle,
+                foot,
+                horse,
+                mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_highway_linestring_gen_z11
+         WHERE zoom_level = 11
+           AND ST_Length(geometry) > ZRes(12)
+         UNION ALL
+
+         -- etldoc: osm_highway_linestring  ->  layer_transportation:z12
+         -- etldoc: osm_highway_linestring  ->  layer_transportation:z13
+         -- etldoc: osm_highway_linestring  ->  layer_transportation:z14_
+         SELECT osm_id,
+                geometry,
+                highway,
+                construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                man_made,
+                layer,
+                CASE WHEN highway IN ('footway', 'steps') THEN "level" END AS "level",
+                CASE WHEN highway IN ('footway', 'steps') THEN indoor END AS indoor,
+                bicycle,
+                foot,
+                horse,
+                mtb_scale,
+                surface_value(surface) AS "surface",
+                z_order
+         FROM osm_highway_linestring
+         WHERE NOT is_area
+           AND (
+                     zoom_level = 12 AND (
+                             highway_class(highway, public_transport, construction) NOT IN ('track', 'path', 'minor')
+                         OR highway IN ('unclassified', 'residential')
+                     ) AND man_made <> 'pier'
+                 OR zoom_level = 13
+                         AND (
+                                    highway_class(highway, public_transport, construction) NOT IN ('track', 'path') AND
+                                    man_made <> 'pier'
+                            OR
+                                    man_made = 'pier' AND NOT ST_IsClosed(geometry)
+                        )
+                 OR zoom_level >= 14
+                         AND (
+                            man_made <> 'pier'
+                            OR
+                            NOT ST_IsClosed(geometry)
+                        )
+             )
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring_gen_z8  ->  layer_transportation:z8
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                NULL::boolean AS is_bridge,
+                NULL::boolean AS is_tunnel,
+                NULL::boolean AS is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                NULL::int AS layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring_gen_z8
+         WHERE zoom_level = 8
+           AND railway = 'rail'
+           AND service = ''
+           AND usage = 'main'
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring_gen_z9  ->  layer_transportation:z9
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                NULL::boolean AS is_bridge,
+                NULL::boolean AS is_tunnel,
+                NULL::boolean AS is_ford,
+                NULL::boolean AS is_ramp,
+                NULL::int AS is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring_gen_z9
+         WHERE zoom_level = 9
+           AND railway = 'rail'
+           AND service = ''
+           AND usage = 'main'
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring_gen_z10  ->  layer_transportation:z10
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring_gen_z10
+         WHERE zoom_level = 10
+           AND railway IN ('rail', 'narrow_gauge')
+           AND service = ''
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring_gen_z11  ->  layer_transportation:z11
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring_gen_z11
+         WHERE zoom_level = 11
+           AND railway IN ('rail', 'narrow_gauge', 'light_rail')
+           AND service = ''
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring_gen_z12  ->  layer_transportation:z12
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring_gen_z12
+         WHERE zoom_level = 12
+           AND railway IN ('rail', 'narrow_gauge', 'light_rail')
+           AND service = ''
+         UNION ALL
+
+         -- etldoc: osm_railway_linestring ->  layer_transportation:z13
+         -- etldoc: osm_railway_linestring ->  layer_transportation:z14_
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_railway_linestring
+         WHERE zoom_level = 13
+           AND railway IN ('rail', 'narrow_gauge', 'light_rail')
+           AND service = ''
+           OR zoom_level >= 14
+         UNION ALL
+
+         -- etldoc: osm_aerialway_linestring_gen_z12  ->  layer_transportation:z12
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                NULL AS railway,
+                aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_aerialway_linestring_gen_z12
+         WHERE zoom_level = 12
+         UNION ALL
+
+         -- etldoc: osm_aerialway_linestring ->  layer_transportation:z13
+         -- etldoc: osm_aerialway_linestring ->  layer_transportation:z14_
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                NULL AS railway,
+                aerialway,
+                NULL AS shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_aerialway_linestring
+         WHERE zoom_level >= 13
+         UNION ALL
+
+         -- etldoc: osm_shipway_linestring_gen_z11  ->  layer_transportation:z11
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_shipway_linestring_gen_z11
+         WHERE zoom_level = 11
+         UNION ALL
+
+         -- etldoc: osm_shipway_linestring_gen_z12  ->  layer_transportation:z12
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_shipway_linestring_gen_z12
+         WHERE zoom_level = 12
+         UNION ALL
+
+         -- etldoc: osm_shipway_linestring ->  layer_transportation:z13
+         -- etldoc: osm_shipway_linestring ->  layer_transportation:z14_
+         SELECT osm_id,
+                geometry,
+                NULL AS highway,
+                NULL AS construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                shipway,
+                NULL AS public_transport,
+                service_value(service) AS service,
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                is_ramp,
+                is_oneway,
+                NULL AS man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_shipway_linestring
+         WHERE zoom_level >= 13
+         UNION ALL
+
+         -- NOTE: We limit the selection of polys because we need to be
+         -- careful to net get false positives here because
+         -- it is possible that closed linestrings appear both as
+         -- highway linestrings and as polygon
+         -- etldoc: osm_highway_polygon ->  layer_transportation:z13
+         -- etldoc: osm_highway_polygon ->  layer_transportation:z14_
+         SELECT osm_id,
+                geometry,
+                highway,
+                NULL AS construction,
+                NULL AS railway,
+                NULL AS aerialway,
+                NULL AS shipway,
+                public_transport,
+                NULL AS service,
+                CASE
+                    WHEN man_made IN ('bridge') THEN TRUE
+                    ELSE FALSE
+                    END AS is_bridge,
+                FALSE AS is_tunnel,
+                FALSE AS is_ford,
+                FALSE AS is_ramp,
+                FALSE::int AS is_oneway,
+                man_made,
+                layer,
+                NULL::int AS level,
+                NULL::boolean AS indoor,
+                NULL AS bicycle,
+                NULL AS foot,
+                NULL AS horse,
+                NULL AS mtb_scale,
+                NULL AS surface,
+                z_order
+         FROM osm_highway_polygon
+              -- We do not want underground pedestrian areas for now
+         WHERE zoom_level >= 13
+           AND (
+                 man_made IN ('bridge', 'pier')
+                 OR (is_area AND COALESCE(layer, 0) >= 0)
+             )
+     ) AS zoom_levels
+WHERE geometry && bbox
+ORDER BY z_order ASC;
+$$ LANGUAGE SQL STABLE
+                -- STRICT
+                PARALLEL SAFE;

layers/transportation/transportation.yaml

@@ -178,7 +178,7 @@ layer:
 schema:
   - ./class.sql
   - ./update_transportation_merge.sql
-  - ./layer.sql
+  - ./transportation.sql
 datasources:
   - type: imposm3
     mapping_file: ./mapping.yaml

layers/transportation/update_transportation_merge.sql

@@ -1,11 +1,3 @@
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring CASCADE;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen3 CASCADE;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen4 CASCADE;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen5 CASCADE;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen6 CASCADE;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen7 CASCADE;
-
-
 DROP TRIGGER IF EXISTS trigger_flag_transportation ON osm_highway_linestring;
 DROP TRIGGER IF EXISTS trigger_refresh ON transportation.updates;
 
@@ -16,107 +8,135 @@ DROP TRIGGER IF EXISTS trigger_refresh ON transportation.updates;
 
 
 -- Improve performance of the sql in transportation_name/network_type.sql
-CREATE INDEX IF NOT EXISTS osm_highway_linestring_highway_idx
-    ON osm_highway_linestring (highway);
-
--- Improve performance of the sql below
 CREATE INDEX IF NOT EXISTS osm_highway_linestring_highway_partial_idx
     ON osm_highway_linestring (highway)
     WHERE highway IN ('motorway', 'trunk', 'primary', 'construction');
 
 -- etldoc: osm_highway_linestring ->  osm_transportation_merge_linestring
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring CASCADE;
 CREATE MATERIALIZED VIEW osm_transportation_merge_linestring AS
 (
 SELECT (ST_Dump(geometry)).geom AS geometry,
-       NULL::bigint             AS osm_id,
+       NULL::bigint AS osm_id,
        highway,
        construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
        z_order
 FROM (
          SELECT ST_LineMerge(ST_Collect(geometry)) AS geometry,
                 highway,
                 construction,
-                min(z_order)                       AS z_order
+                is_bridge,
+                is_tunnel,
+                is_ford,
+                min(z_order) AS z_order
          FROM osm_highway_linestring
          WHERE (highway IN ('motorway', 'trunk', 'primary') OR
                 highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary'))
            AND ST_IsValid(geometry)
-         GROUP BY highway, construction
+         GROUP BY highway, construction, is_bridge, is_tunnel, is_ford
      ) AS highway_union
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
 CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_geometry_idx
     ON osm_transportation_merge_linestring USING gist (geometry);
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_highway_partial_idx
-    ON osm_transportation_merge_linestring (highway, construction)
-    WHERE highway IN ('motorway', 'trunk', 'primary', 'construction');
 
--- etldoc: osm_transportation_merge_linestring -> osm_transportation_merge_linestring_gen3
+-- etldoc: osm_transportation_merge_linestring -> osm_transportation_merge_linestring_gen_z8
-CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen3 AS
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen_z8 CASCADE;
+CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z8 AS
 (
-SELECT ST_Simplify(geometry, 120) AS geometry, osm_id, highway, construction, z_order
+SELECT ST_Simplify(geometry, ZRes(10)) AS geometry,
+       osm_id,
+       highway,
+       construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
+       z_order
 FROM osm_transportation_merge_linestring
 WHERE highway IN ('motorway', 'trunk', 'primary')
    OR highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary')
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen3_geometry_idx
+CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen_z8_geometry_idx
-    ON osm_transportation_merge_linestring_gen3 USING gist (geometry);
+    ON osm_transportation_merge_linestring_gen_z8 USING gist (geometry);
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen3_highway_partial_idx
-    ON osm_transportation_merge_linestring_gen3 (highway, construction)
-    WHERE highway IN ('motorway', 'trunk', 'primary', 'construction');
 
--- etldoc: osm_transportation_merge_linestring_gen3 -> osm_transportation_merge_linestring_gen4
+-- etldoc: osm_transportation_merge_linestring_gen_z8 -> osm_transportation_merge_linestring_gen_z7
-CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen4 AS
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen_z7 CASCADE;
+CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z7 AS
 (
-SELECT ST_Simplify(geometry, 200) AS geometry, osm_id, highway, construction, z_order
+SELECT ST_Simplify(geometry, ZRes(9)) AS geometry,
-FROM osm_transportation_merge_linestring_gen3
+       osm_id,
+       highway,
+       construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
+       z_order
+FROM osm_transportation_merge_linestring_gen_z8
 WHERE (highway IN ('motorway', 'trunk', 'primary') OR
        highway = 'construction' AND construction IN ('motorway', 'trunk', 'primary'))
   AND ST_Length(geometry) > 50
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen4_geometry_idx
+CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen_z7_geometry_idx
-    ON osm_transportation_merge_linestring_gen4 USING gist (geometry);
+    ON osm_transportation_merge_linestring_gen_z7 USING gist (geometry);
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen4_highway_partial_idx
-    ON osm_transportation_merge_linestring_gen4 (highway, construction)
-    WHERE highway IN ('motorway', 'trunk', 'primary', 'construction');
 
--- etldoc: osm_transportation_merge_linestring_gen4 -> osm_transportation_merge_linestring_gen5
+-- etldoc: osm_transportation_merge_linestring_gen_z7 -> osm_transportation_merge_linestring_gen_z6
-CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen5 AS
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen_z6 CASCADE;
+CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z6 AS
 (
-SELECT ST_Simplify(geometry, 500) AS geometry, osm_id, highway, construction, z_order
+SELECT ST_Simplify(geometry, ZRes(8)) AS geometry,
-FROM osm_transportation_merge_linestring_gen4
+       osm_id,
+       highway,
+       construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
+       z_order
+FROM osm_transportation_merge_linestring_gen_z7
 WHERE (highway IN ('motorway', 'trunk') OR highway = 'construction' AND construction IN ('motorway', 'trunk'))
   AND ST_Length(geometry) > 100
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen5_geometry_idx
+CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen_z6_geometry_idx
-    ON osm_transportation_merge_linestring_gen5 USING gist (geometry);
+    ON osm_transportation_merge_linestring_gen_z6 USING gist (geometry);
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen5_highway_partial_idx
-    ON osm_transportation_merge_linestring_gen5 (highway, construction)
-    WHERE highway IN ('motorway', 'trunk', 'construction');
 
--- etldoc: osm_transportation_merge_linestring_gen5 -> osm_transportation_merge_linestring_gen6
+-- etldoc: osm_transportation_merge_linestring_gen_z6 -> osm_transportation_merge_linestring_gen_z5
-CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen6 AS
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z5 AS
 (
-SELECT ST_Simplify(geometry, 1000) AS geometry, osm_id, highway, construction, z_order
+SELECT ST_Simplify(geometry, ZRes(7)) AS geometry,
-FROM osm_transportation_merge_linestring_gen5
+       osm_id,
+       highway,
+       construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
+       z_order
+FROM osm_transportation_merge_linestring_gen_z6
 WHERE (highway IN ('motorway', 'trunk') OR highway = 'construction' AND construction IN ('motorway', 'trunk'))
   AND ST_Length(geometry) > 500
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen6_geometry_idx
+CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen_z5_geometry_idx
-    ON osm_transportation_merge_linestring_gen6 USING gist (geometry);
+    ON osm_transportation_merge_linestring_gen_z5 USING gist (geometry);
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen6_highway_partial_idx
-    ON osm_transportation_merge_linestring_gen6 (highway, construction)
-    WHERE highway IN ('motorway', 'trunk', 'construction');
 
--- etldoc: osm_transportation_merge_linestring_gen6 -> osm_transportation_merge_linestring_gen7
+-- etldoc: osm_transportation_merge_linestring_gen_z5 -> osm_transportation_merge_linestring_gen_z4
-CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen7 AS
+DROP MATERIALIZED VIEW IF EXISTS osm_transportation_merge_linestring_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z4 AS
 (
-SELECT ST_Simplify(geometry, 2000) AS geometry, osm_id, highway, construction, z_order
+SELECT ST_Simplify(geometry, ZRes(6)) AS geometry,
-FROM osm_transportation_merge_linestring_gen6
+       osm_id,
+       highway,
+       construction,
+       is_bridge,
+       is_tunnel,
+       is_ford,
+       z_order
+FROM osm_transportation_merge_linestring_gen_z5
 WHERE (highway = 'motorway' OR highway = 'construction' AND construction = 'motorway')
   AND ST_Length(geometry) > 1000
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
-CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen7_geometry_idx
+CREATE INDEX IF NOT EXISTS osm_transportation_merge_linestring_gen_z4_geometry_idx
-    ON osm_transportation_merge_linestring_gen7 USING gist (geometry);
+    ON osm_transportation_merge_linestring_gen_z4 USING gist (geometry);
 
 
 -- Handle updates
@@ -126,7 +146,7 @@ CREATE SCHEMA IF NOT EXISTS transportation;
 CREATE TABLE IF NOT EXISTS transportation.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION transportation.flag() RETURNS trigger AS
@@ -139,16 +159,20 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION transportation.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
-    RAISE NOTICE 'Refresh transportation';
+    RAISE LOG 'Refresh transportation';
     REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring;
-    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen3;
+    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z8;
-    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen4;
+    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z7;
-    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen5;
+    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z6;
-    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen6;
+    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z5;
-    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen7;
+    REFRESH MATERIALIZED VIEW osm_transportation_merge_linestring_gen_z4;
     -- noinspection SqlWithoutWhere
     DELETE FROM transportation.updates;
+
+    RAISE LOG 'Refresh transportation done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
@@ -164,4 +188,4 @@ CREATE CONSTRAINT TRIGGER trigger_refresh
     ON transportation.updates
     INITIALLY DEFERRED
     FOR EACH ROW
-EXECUTE PROCEDURE transportation.refresh();
+EXECUTE PROCEDURE transportation.refresh();

layers/transportation_name/network_type.sql

@@ -1,9 +1,11 @@
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_network CASCADE;
+DROP TRIGGER IF EXISTS trigger_store_transportation_route_member ON osm_route_member;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_linestring CASCADE;
+DROP TRIGGER IF EXISTS trigger_store_transportation_highway_linestring ON osm_highway_linestring;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_linestring_gen1 CASCADE;
+DROP TRIGGER IF EXISTS trigger_flag_transportation_name ON transportation_name.network_changes;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_linestring_gen2 CASCADE;
+DROP TRIGGER IF EXISTS trigger_refresh_network ON transportation_name.updates_network;
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_linestring_gen3 CASCADE;
+
-DROP MATERIALIZED VIEW IF EXISTS osm_transportation_name_linestring_gen4 CASCADE;
+DROP TRIGGER IF EXISTS trigger_store_transportation_name_network ON osm_transportation_name_network;
+DROP TRIGGER IF EXISTS trigger_flag_name ON transportation_name.name_changes;
+DROP TRIGGER IF EXISTS trigger_refresh_name ON transportation_name.updates_name;
 
 DO
 $$

layers/transportation_name/transportation_name.sql

@@ -15,6 +15,7 @@ CREATE OR REPLACE FUNCTION layer_transportation_name(bbox geometry, zoom_level i
                 network    text,
                 class      text,
                 subclass   text,
+                brunnel    text,
                 layer      int,
                 level      int,
                 indoor     int
@@ -23,33 +24,34 @@ AS
 $$
 SELECT osm_id,
        geometry,
-       NULLIF(name, '')                             AS name,
+       name,
-       COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+       COALESCE(name_en, name) AS name_en,
-       COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
+       COALESCE(name_de, name, name_en) AS name_de,
        tags,
-       NULLIF(ref, ''),
+       ref,
-       NULLIF(LENGTH(ref), 0)                       AS ref_length,
+       NULLIF(LENGTH(ref), 0) AS ref_length,
        --TODO: The road network of the road is not yet implemented
        CASE
            WHEN network IS NOT NULL
                THEN network::text
            WHEN length(coalesce(ref, '')) > 0
                THEN 'road'
-           END                                      AS network,
+           END AS network,
-       highway_class(highway, '', construction)     AS class,
+       highway_class(highway, '', construction) AS class,
        CASE
            WHEN highway IS NOT NULL AND highway_class(highway, '', construction) = 'path'
                THEN highway
-           END                                      AS subclass,
+           END AS subclass,
-       NULLIF(layer, 0)                             AS layer,
+       brunnel,
+       NULLIF(layer, 0) AS layer,
        "level",
-       CASE WHEN indoor = TRUE THEN 1 END           AS indoor
+       CASE WHEN indoor = TRUE THEN 1 END AS indoor
 FROM (
 
          -- etldoc: osm_transportation_name_linestring_gen4 ->  layer_transportation_name:z6
          SELECT *,
-                NULL::int     AS layer,
+                NULL::int AS layer,
-                NULL::int     AS level,
+                NULL::int AS level,
                 NULL::boolean AS indoor
          FROM osm_transportation_name_linestring_gen4
          WHERE zoom_level = 6
@@ -57,8 +59,8 @@ FROM (
 
          -- etldoc: osm_transportation_name_linestring_gen3 ->  layer_transportation_name:z7
          SELECT *,
-                NULL::int     AS layer,
+                NULL::int AS layer,
-                NULL::int     AS level,
+                NULL::int AS level,
                 NULL::boolean AS indoor
          FROM osm_transportation_name_linestring_gen3
          WHERE zoom_level = 7
@@ -66,8 +68,8 @@ FROM (
 
          -- etldoc: osm_transportation_name_linestring_gen2 ->  layer_transportation_name:z8
          SELECT *,
-                NULL::int     AS layer,
+                NULL::int AS layer,
-                NULL::int     AS level,
+                NULL::int AS level,
                 NULL::boolean AS indoor
          FROM osm_transportation_name_linestring_gen2
          WHERE zoom_level = 8
@@ -77,8 +79,8 @@ FROM (
          -- etldoc: osm_transportation_name_linestring_gen1 ->  layer_transportation_name:z10
          -- etldoc: osm_transportation_name_linestring_gen1 ->  layer_transportation_name:z11
          SELECT *,
-                NULL::int     AS layer,
+                NULL::int AS layer,
-                NULL::int     AS level,
+                NULL::int AS level,
                 NULL::boolean AS indoor
          FROM osm_transportation_name_linestring_gen1
          WHERE zoom_level BETWEEN 9 AND 11
@@ -94,6 +96,7 @@ FROM (
                 ref,
                 highway,
                 construction,
+                brunnel,
                 network,
                 z_order,
                 layer,
@@ -101,7 +104,7 @@ FROM (
                 indoor
          FROM osm_transportation_name_linestring
          WHERE zoom_level = 12
-           AND LineLabel(zoom_level, COALESCE(NULLIF(name, ''), ref), geometry)
+           AND LineLabel(zoom_level, COALESCE(name, ref), geometry)
            AND highway_class(highway, '', construction) NOT IN ('minor', 'track', 'path')
            AND NOT highway_is_link(highway)
          UNION ALL
@@ -116,6 +119,7 @@ FROM (
                 ref,
                 highway,
                 construction,
+                brunnel,
                 network,
                 z_order,
                 layer,
@@ -123,7 +127,7 @@ FROM (
                 indoor
          FROM osm_transportation_name_linestring
          WHERE zoom_level = 13
-           AND LineLabel(zoom_level, COALESCE(NULLIF(name, ''), ref), geometry)
+           AND LineLabel(zoom_level, COALESCE(name, ref), geometry)
            AND highway_class(highway, '', construction) NOT IN ('track', 'path')
          UNION ALL
 
@@ -137,6 +141,7 @@ FROM (
                 ref,
                 highway,
                 construction,
+                brunnel,
                 network,
                 z_order,
                 layer,

layers/transportation_name/transportation_name.yaml

@@ -69,6 +69,13 @@ layer:
       - bridleway
       - corridor
       - platform
+    brunnel:
+      description: |
+          Mark whether way is a bridge, a tunnel or a ford.
+      values:
+      - bridge
+      - tunnel
+      - ford
     level:
       description: |
           Experimental feature! Filled only for steps and footways. Original
@@ -86,12 +93,12 @@ layer:
   datasource:
     geometry_field: geometry
     srid: 900913
-    query: (SELECT geometry, name, name_en, name_de, {name_languages}, ref, ref_length, network::text, class::text, subclass, layer, level, indoor FROM layer_transportation_name(!bbox!, z(!scale_denominator!))) AS t
+    query: (SELECT geometry, name, name_en, name_de, {name_languages}, ref, ref_length, network::text, class::text, subclass, brunnel, layer, level, indoor FROM layer_transportation_name(!bbox!, z(!scale_denominator!))) AS t
 schema:
   - ./network_type.sql
   - ./update_route_member.sql
   - ./update_transportation_name.sql
-  - ./layer.sql
+  - ./transportation_name.sql
 datasources:
   - type: imposm3
     mapping_file: ../transportation/mapping.yaml

layers/transportation_name/update_route_member.sql

@@ -1,62 +1,87 @@
-DROP TRIGGER IF EXISTS trigger_flag_transportation_name ON osm_route_member;
+CREATE TABLE IF NOT EXISTS ne_10m_admin_0_bg_buffer AS
+SELECT ST_Buffer(geometry, 10000)
+FROM ne_10m_admin_0_countries
+WHERE iso_a2 = 'GB';
 
+CREATE OR REPLACE VIEW gbr_route_members_view AS
+SELECT 0,
+       osm_id,
+       substring(ref FROM E'^[AM][0-9AM()]+'),
+       CASE WHEN highway = 'motorway' THEN 'omt-gb-motorway' ELSE 'omt-gb-trunk' END
+FROM osm_highway_linestring
+WHERE length(ref) > 0
+  AND ST_Intersects(geometry, (SELECT * FROM ne_10m_admin_0_bg_buffer))
+  AND highway IN ('motorway', 'trunk')
+;
+-- Create GBR relations (so we can use it in the same way as other relations)
+DELETE
+FROM osm_route_member
+WHERE network IN ('omt-gb-motorway', 'omt-gb-trunk');
+-- etldoc:  osm_highway_linestring ->  osm_route_member
+INSERT INTO osm_route_member (osm_id, member, ref, network)
+SELECT *
+FROM gbr_route_members_view;
 
--- create GBR relations (so we can use it in the same way as other relations)
+CREATE OR REPLACE FUNCTION osm_route_member_network_type(network text, name text, ref text) RETURNS route_network_type AS
-CREATE OR REPLACE FUNCTION update_gbr_route_members() RETURNS void AS
 $$
-DECLARE
+SELECT CASE
-    gbr_geom geometry;
+           WHEN network = 'US:I' THEN 'us-interstate'::route_network_type
-BEGIN
+           WHEN network = 'US:US' THEN 'us-highway'::route_network_type
-    SELECT st_buffer(geometry, 10000) INTO gbr_geom FROM ne_10m_admin_0_countries WHERE iso_a2 = 'GB';
+           WHEN network LIKE 'US:__' THEN 'us-state'::route_network_type
-    DELETE FROM osm_route_member WHERE network IN ('omt-gb-motorway', 'omt-gb-trunk');
+           -- https://en.wikipedia.org/wiki/Trans-Canada_Highway
-
+           -- TODO: improve hierarchical queries using
-    INSERT INTO osm_route_member (osm_id, member, ref, network)
+           --    http://www.openstreetmap.org/relation/1307243
-    SELECT 0,
+           --    however the relation does not cover the whole Trans-Canada_Highway
-           osm_id,
+           WHEN
-           substring(ref FROM E'^[AM][0-9AM()]+'),
+                   (network = 'CA:transcanada') OR
-           CASE WHEN highway = 'motorway' THEN 'omt-gb-motorway' ELSE 'omt-gb-trunk' END
+                   (network = 'CA:BC:primary' AND ref IN ('16')) OR
-    FROM osm_highway_linestring
+                   (name = 'Yellowhead Highway (AB)' AND ref IN ('16')) OR
-    WHERE length(ref) > 0
+                   (network = 'CA:SK:primary' AND ref IN ('16')) OR
-      AND ST_Intersects(geometry, gbr_geom)
+                   (network = 'CA:ON:primary' AND ref IN ('17', '417')) OR
-      AND highway IN ('motorway', 'trunk');
+                   (name = 'Route Transcanadienne') OR
-END;
+                   (network = 'CA:NB:primary' AND ref IN ('2', '16')) OR
-$$ LANGUAGE plpgsql;
+                   (network = 'CA:PE' AND ref IN ('1')) OR
-
+                   (network = 'CA:NS' AND ref IN ('104', '105')) OR
+                   (network = 'CA:NL:R' AND ref IN ('1')) OR
+                   (name = 'Trans-Canada Highway')
+               THEN 'ca-transcanada'::route_network_type
+           WHEN network = 'omt-gb-motorway' THEN 'gb-motorway'::route_network_type
+           WHEN network = 'omt-gb-trunk' THEN 'gb-trunk'::route_network_type
+           END;
+$$ LANGUAGE sql IMMUTABLE
+                PARALLEL SAFE;
 
 -- etldoc:  osm_route_member ->  osm_route_member
+-- see http://wiki.openstreetmap.org/wiki/Relation:route#Road_routes
+UPDATE osm_route_member
+SET network_type = osm_route_member_network_type(network, name, ref)
+WHERE network != ''
+  AND network_type IS DISTINCT FROM osm_route_member_network_type(network, name, ref)
+;
+
 CREATE OR REPLACE FUNCTION update_osm_route_member() RETURNS void AS
 $$
 BEGIN
-    PERFORM update_gbr_route_members();
+    DELETE
+    FROM osm_route_member AS r
+        USING
+            transportation_name.network_changes AS c
+    WHERE network IN ('omt-gb-motorway', 'omt-gb-trunk')
+      AND r.osm_id = c.osm_id;
 
-    -- see http://wiki.openstreetmap.org/wiki/Relation:route#Road_routes
+    INSERT INTO osm_route_member (osm_id, member, ref, network)
-    UPDATE osm_route_member
+    SELECT r.*
-    SET network_type =
+    FROM gbr_route_members_view AS r
-            CASE
+             JOIN transportation_name.network_changes AS c ON
-                WHEN network = 'US:I' THEN 'us-interstate'::route_network_type
+        r.osm_id = c.osm_id;
-                WHEN network = 'US:US' THEN 'us-highway'::route_network_type
-                WHEN network LIKE 'US:__' THEN 'us-state'::route_network_type
-                -- https://en.wikipedia.org/wiki/Trans-Canada_Highway
-                -- TODO: improve hierarchical queries using
-                --    http://www.openstreetmap.org/relation/1307243
-                --    however the relation does not cover the whole Trans-Canada_Highway
-                WHEN
-                        (network = 'CA:transcanada') OR
-                        (network = 'CA:BC:primary' AND ref IN ('16')) OR
-                        (name = 'Yellowhead Highway (AB)' AND ref IN ('16')) OR
-                        (network = 'CA:SK:primary' AND ref IN ('16')) OR
-                        (network = 'CA:ON:primary' AND ref IN ('17', '417')) OR
-                        (name = 'Route Transcanadienne') OR
-                        (network = 'CA:NB:primary' AND ref IN ('2', '16')) OR
-                        (network = 'CA:PE' AND ref IN ('1')) OR
-                        (network = 'CA:NS' AND ref IN ('104', '105')) OR
-                        (network = 'CA:NL:R' AND ref IN ('1')) OR
-                        (name = 'Trans-Canada Highway')
-                    THEN 'ca-transcanada'::route_network_type
-                WHEN network = 'omt-gb-motorway' THEN 'gb-motorway'::route_network_type
-                WHEN network = 'omt-gb-trunk' THEN 'gb-trunk'::route_network_type
-                END;
 
+    UPDATE
+        osm_route_member AS r
+    SET network_type = osm_route_member_network_type(network, name, ref)
+    FROM transportation_name.network_changes AS c
+    WHERE network != ''
+      AND network_type IS DISTINCT FROM osm_route_member_network_type(network, name, ref)
+      AND r.member = c.osm_id;
 END;
 $$ LANGUAGE plpgsql;
 
@@ -65,6 +90,4 @@ CREATE INDEX IF NOT EXISTS osm_route_member_member_idx ON osm_route_member ("mem
 CREATE INDEX IF NOT EXISTS osm_route_member_name_idx ON osm_route_member ("name");
 CREATE INDEX IF NOT EXISTS osm_route_member_ref_idx ON osm_route_member ("ref");
 
-SELECT update_osm_route_member();
-
 CREATE INDEX IF NOT EXISTS osm_route_member_network_type_idx ON osm_route_member ("network_type");

layers/transportation_name/update_transportation_name.sql

@@ -1,6 +1,3 @@
-DROP TRIGGER IF EXISTS trigger_flag_transportation_name ON osm_highway_linestring;
-DROP TRIGGER IF EXISTS trigger_refresh ON transportation_name.updates;
-
 -- Instead of using relations to find out the road names we
 -- stitch together the touching ways with the same name
 -- to allow for nice label rendering
@@ -9,39 +6,61 @@ DROP TRIGGER IF EXISTS trigger_refresh ON transportation_name.updates;
 
 -- etldoc: osm_highway_linestring ->  osm_transportation_name_network
 -- etldoc: osm_route_member ->  osm_transportation_name_network
-CREATE MATERIALIZED VIEW osm_transportation_name_network AS
+CREATE TABLE IF NOT EXISTS osm_transportation_name_network AS
-(
+SELECT
-SELECT hl.geometry,
+    geometry,
-       hl.osm_id,
+    osm_id,
-       CASE WHEN length(hl.name) > 15 THEN osml10n_street_abbrev_all(hl.name) ELSE hl.name END         AS "name",
+    name,
-       CASE WHEN length(hl.name_en) > 15 THEN osml10n_street_abbrev_en(hl.name_en) ELSE hl.name_en END AS "name_en",
+    name_en,
-       CASE WHEN length(hl.name_de) > 15 THEN osml10n_street_abbrev_de(hl.name_de) ELSE hl.name_de END AS "name_de",
+    name_de,
-       hl.tags,
+    tags,
-       rm.network_type,
+    ref,
-       CASE
+    highway,
-           WHEN (rm.network_type IS NOT NULL AND nullif(rm.ref::text, '') IS NOT NULL)
+    construction,
-               THEN rm.ref::text
+    brunnel,
-           ELSE hl.ref
+    "level",
-           END                                                                                         AS ref,
+    layer,
-       hl.highway,
+    indoor,
-       hl.construction,
+    network_type,
-       CASE WHEN highway IN ('footway', 'steps') THEN layer END                                        AS layer,
+    z_order
-       CASE WHEN highway IN ('footway', 'steps') THEN "level" END                                      AS "level",
+FROM (
-       CASE WHEN highway IN ('footway', 'steps') THEN indoor END                                       AS indoor,
+    SELECT hl.geometry,
-       ROW_NUMBER() OVER (PARTITION BY hl.osm_id
+        hl.osm_id,
-           ORDER BY rm.network_type)                                                                   AS "rank",
+        CASE WHEN length(hl.name) > 15 THEN osml10n_street_abbrev_all(hl.name) ELSE NULLIF(hl.name, '') END AS "name",
-       hl.z_order
+        CASE WHEN length(hl.name_en) > 15 THEN osml10n_street_abbrev_en(hl.name_en) ELSE NULLIF(hl.name_en, '') END AS "name_en",
-FROM osm_highway_linestring hl
+        CASE WHEN length(hl.name_de) > 15 THEN osml10n_street_abbrev_de(hl.name_de) ELSE NULLIF(hl.name_de, '') END AS "name_de",
-         LEFT JOIN osm_route_member rm ON (rm.member = hl.osm_id)
+        slice_language_tags(hl.tags) AS tags,
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+        rm.network_type,
+        CASE
+            WHEN rm.network_type IS NOT NULL AND nullif(rm.ref::text, '') IS NOT NULL
+                THEN rm.ref::text
+            ELSE NULLIF(hl.ref, '')
+            END AS ref,
+        hl.highway,
+        hl.construction,
+        brunnel(hl.is_bridge, hl.is_tunnel, hl.is_ford) AS brunnel,
+        CASE WHEN highway IN ('footway', 'steps') THEN layer END AS layer,
+        CASE WHEN highway IN ('footway', 'steps') THEN level END AS level,
+        CASE WHEN highway IN ('footway', 'steps') THEN indoor END AS indoor,
+        ROW_NUMBER() OVER (PARTITION BY hl.osm_id
+            ORDER BY rm.network_type) AS "rank",
+        hl.z_order
+    FROM osm_highway_linestring hl
+            LEFT JOIN osm_route_member rm ON
+        rm.member = hl.osm_id
+    WHERE (hl.name <> '' OR hl.ref <> '')
+      AND NULLIF(hl.highway, '') IS NOT NULL
+) AS t
+WHERE ("rank" = 1 OR "rank" IS NULL);
+CREATE INDEX IF NOT EXISTS osm_transportation_name_network_osm_id_idx ON osm_transportation_name_network (osm_id);
+CREATE INDEX IF NOT EXISTS osm_transportation_name_network_name_ref_idx ON osm_transportation_name_network (coalesce(name, ''), coalesce(ref, ''));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_network_geometry_idx ON osm_transportation_name_network USING gist (geometry);
 
 
 -- etldoc: osm_transportation_name_network ->  osm_transportation_name_linestring
-CREATE MATERIALIZED VIEW osm_transportation_name_linestring AS
+CREATE TABLE IF NOT EXISTS osm_transportation_name_linestring AS
-(
+SELECT (ST_Dump(geometry)).geom AS geometry,
-SELECT (ST_Dump(geometry)).geom                AS geometry,
+       NULL::bigint AS osm_id,
-       NULL::bigint                            AS osm_id,
        name,
        name_en,
        name_de,
@@ -49,35 +68,33 @@ SELECT (ST_Dump(geometry)).geom                AS geometry,
        ref,
        highway,
        construction,
+       brunnel,
        "level",
        layer,
        indoor,
-       network_type                            AS network,
+       network_type AS network,
        z_order
 FROM (
          SELECT ST_LineMerge(ST_Collect(geometry)) AS geometry,
                 name,
                 name_en,
                 name_de,
-                hstore(string_agg(nullif(slice_language_tags(tags ||
+                tags || hstore( -- store results of osml10n_street_abbrev_* above
-                                                             hstore(ARRAY ['name', name, 'name:en', name_en, 'name:de', name_de]))::text,
+                               ARRAY ['name', name, 'name:en', name_en, 'name:de', name_de]) AS tags,
-                                         ''), ','))
-                                                   AS "tags",
                 ref,
                 highway,
                 construction,
+                brunnel,
                 "level",
                 layer,
                 indoor,
                 network_type,
-                min(z_order)                       AS z_order
+                min(z_order) AS z_order
          FROM osm_transportation_name_network
-         WHERE ("rank" = 1 OR "rank" IS NULL)
+         GROUP BY name, name_en, name_de, tags, ref, highway, construction, brunnel, "level", layer, indoor, network_type
-           AND (name <> '' OR ref <> '')
-           AND NULLIF(highway, '') IS NOT NULL
-         GROUP BY name, name_en, name_de, ref, highway, construction, "level", layer, indoor, network_type
      ) AS highway_union
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+;
+CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_name_ref_idx ON osm_transportation_name_linestring (coalesce(name, ''), coalesce(ref, ''));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_geometry_idx ON osm_transportation_name_linestring USING gist (geometry);
 
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_highway_partial_idx
@@ -85,8 +102,7 @@ CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_highway_partial_id
     WHERE highway IN ('motorway', 'trunk', 'construction');
 
 -- etldoc: osm_transportation_name_linestring -> osm_transportation_name_linestring_gen1
-CREATE MATERIALIZED VIEW osm_transportation_name_linestring_gen1 AS
+CREATE OR REPLACE VIEW osm_transportation_name_linestring_gen1_view AS
-(
 SELECT ST_Simplify(geometry, 50) AS geometry,
        osm_id,
        name,
@@ -96,12 +112,17 @@ SELECT ST_Simplify(geometry, 50) AS geometry,
        ref,
        highway,
        construction,
+       brunnel,
        network,
        z_order
 FROM osm_transportation_name_linestring
 WHERE (highway IN ('motorway', 'trunk') OR highway = 'construction' AND construction IN ('motorway', 'trunk'))
   AND ST_Length(geometry) > 8000
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+;
+CREATE TABLE IF NOT EXISTS osm_transportation_name_linestring_gen1 AS
+SELECT *
+FROM osm_transportation_name_linestring_gen1_view;
+CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen1_name_ref_idx ON osm_transportation_name_linestring_gen1((coalesce(name, ref)));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen1_geometry_idx ON osm_transportation_name_linestring_gen1 USING gist (geometry);
 
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen1_highway_partial_idx
@@ -109,8 +130,7 @@ CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen1_highway_parti
     WHERE highway IN ('motorway', 'trunk', 'construction');
 
 -- etldoc: osm_transportation_name_linestring_gen1 -> osm_transportation_name_linestring_gen2
-CREATE MATERIALIZED VIEW osm_transportation_name_linestring_gen2 AS
+CREATE OR REPLACE VIEW osm_transportation_name_linestring_gen2_view AS
-(
 SELECT ST_Simplify(geometry, 120) AS geometry,
        osm_id,
        name,
@@ -120,12 +140,17 @@ SELECT ST_Simplify(geometry, 120) AS geometry,
        ref,
        highway,
        construction,
+       brunnel,
        network,
        z_order
 FROM osm_transportation_name_linestring_gen1
 WHERE (highway IN ('motorway', 'trunk') OR highway = 'construction' AND construction IN ('motorway', 'trunk'))
   AND ST_Length(geometry) > 14000
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+;
+CREATE TABLE IF NOT EXISTS osm_transportation_name_linestring_gen2 AS
+SELECT *
+FROM osm_transportation_name_linestring_gen2_view;
+CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen2_name_ref_idx ON osm_transportation_name_linestring_gen2((coalesce(name, ref)));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen2_geometry_idx ON osm_transportation_name_linestring_gen2 USING gist (geometry);
 
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen2_highway_partial_idx
@@ -133,8 +158,7 @@ CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen2_highway_parti
     WHERE highway IN ('motorway', 'trunk', 'construction');
 
 -- etldoc: osm_transportation_name_linestring_gen2 -> osm_transportation_name_linestring_gen3
-CREATE MATERIALIZED VIEW osm_transportation_name_linestring_gen3 AS
+CREATE OR REPLACE VIEW osm_transportation_name_linestring_gen3_view AS
-(
 SELECT ST_Simplify(geometry, 200) AS geometry,
        osm_id,
        name,
@@ -144,12 +168,17 @@ SELECT ST_Simplify(geometry, 200) AS geometry,
        ref,
        highway,
        construction,
+       brunnel,
        network,
        z_order
 FROM osm_transportation_name_linestring_gen2
 WHERE (highway = 'motorway' OR highway = 'construction' AND construction = 'motorway')
   AND ST_Length(geometry) > 20000
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+;
+CREATE TABLE IF NOT EXISTS osm_transportation_name_linestring_gen3 AS
+SELECT *
+FROM osm_transportation_name_linestring_gen3_view;
+CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen3_name_ref_idx ON osm_transportation_name_linestring_gen3((coalesce(name, ref)));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen3_geometry_idx ON osm_transportation_name_linestring_gen3 USING gist (geometry);
 
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen3_highway_partial_idx
@@ -157,8 +186,7 @@ CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen3_highway_parti
     WHERE highway IN ('motorway', 'construction');
 
 -- etldoc: osm_transportation_name_linestring_gen3 -> osm_transportation_name_linestring_gen4
-CREATE MATERIALIZED VIEW osm_transportation_name_linestring_gen4 AS
+CREATE OR REPLACE VIEW osm_transportation_name_linestring_gen4_view AS
-(
 SELECT ST_Simplify(geometry, 500) AS geometry,
        osm_id,
        name,
@@ -168,64 +196,464 @@ SELECT ST_Simplify(geometry, 500) AS geometry,
        ref,
        highway,
        construction,
+       brunnel,
        network,
        z_order
 FROM osm_transportation_name_linestring_gen3
 WHERE (highway = 'motorway' OR highway = 'construction' AND construction = 'motorway')
   AND ST_Length(geometry) > 20000
-    ) /* DELAY_MATERIALIZED_VIEW_CREATION */;
+;
+CREATE TABLE IF NOT EXISTS osm_transportation_name_linestring_gen4 AS
+SELECT *
+FROM osm_transportation_name_linestring_gen4_view;
+CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen4_name_ref_idx ON osm_transportation_name_linestring_gen4((coalesce(name, ref)));
 CREATE INDEX IF NOT EXISTS osm_transportation_name_linestring_gen4_geometry_idx ON osm_transportation_name_linestring_gen4 USING gist (geometry);
 
 -- Handle updates
 
 CREATE SCHEMA IF NOT EXISTS transportation_name;
 
-CREATE TABLE IF NOT EXISTS transportation_name.updates
+-- Trigger to update "osm_transportation_name_network" from "osm_route_member" and "osm_highway_linestring"
+
+CREATE TABLE IF NOT EXISTS transportation_name.network_changes
+(
+    osm_id bigint,
+    UNIQUE (osm_id)
+);
+
+CREATE OR REPLACE FUNCTION transportation_name.route_member_store() RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO transportation_name.network_changes(osm_id)
+    VALUES (CASE WHEN tg_op IN ('DELETE', 'UPDATE') THEN old.member ELSE new.member END)
+    ON CONFLICT(osm_id) DO NOTHING;
+
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION transportation_name.highway_linestring_store() RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO transportation_name.network_changes(osm_id)
+    VALUES (CASE WHEN tg_op IN ('DELETE', 'UPDATE') THEN old.osm_id ELSE new.osm_id END)
+    ON CONFLICT(osm_id) DO NOTHING;
+
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TABLE IF NOT EXISTS transportation_name.updates_network
+(
+    id serial PRIMARY KEY,
+    t text,
+    UNIQUE (t)
+);
+CREATE OR REPLACE FUNCTION transportation_name.flag_network() RETURNS trigger AS
+$$
+BEGIN
+    INSERT INTO transportation_name.updates_network(t) VALUES ('y') ON CONFLICT(t) DO NOTHING;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION transportation_name.refresh_network() RETURNS trigger AS
+$$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
+BEGIN
+    RAISE LOG 'Refresh transportation_name_network';
+    PERFORM update_osm_route_member();
+
+    -- REFRESH osm_transportation_name_network
+    DELETE
+    FROM osm_transportation_name_network AS n
+        USING
+            transportation_name.network_changes AS c
+    WHERE n.osm_id = c.osm_id;
+
+    INSERT INTO osm_transportation_name_network
+    SELECT
+        geometry,
+        osm_id,
+        name,
+        name_en,
+        name_de,
+        tags,
+        ref,
+        highway,
+        construction,
+        brunnel,
+        level,
+        layer,
+        indoor,
+        network_type,
+        z_order
+    FROM (
+        SELECT hl.geometry,
+            hl.osm_id,
+            CASE WHEN length(hl.name) > 15 THEN osml10n_street_abbrev_all(hl.name) ELSE NULLIF(hl.name, '') END AS name,
+            CASE WHEN length(hl.name_en) > 15 THEN osml10n_street_abbrev_en(hl.name_en) ELSE NULLIF(hl.name_en, '') END AS name_en,
+            CASE WHEN length(hl.name_de) > 15 THEN osml10n_street_abbrev_de(hl.name_de) ELSE NULLIF(hl.name_de, '') END AS name_de,
+            slice_language_tags(hl.tags) AS tags,
+            rm.network_type,
+            CASE
+                WHEN rm.network_type IS NOT NULL AND NULLIF(rm.ref::text, '') IS NOT NULL
+                    THEN rm.ref::text
+                ELSE NULLIF(hl.ref, '')
+                END AS ref,
+            hl.highway,
+            hl.construction,
+            brunnel(hl.is_bridge, hl.is_tunnel, hl.is_ford) AS brunnel,
+            CASE WHEN highway IN ('footway', 'steps') THEN layer END AS layer,
+            CASE WHEN highway IN ('footway', 'steps') THEN level END AS level,
+            CASE WHEN highway IN ('footway', 'steps') THEN indoor END AS indoor,
+            ROW_NUMBER() OVER (PARTITION BY hl.osm_id
+                ORDER BY rm.network_type) AS "rank",
+            hl.z_order
+        FROM osm_highway_linestring hl
+                JOIN transportation_name.network_changes AS c ON
+            hl.osm_id = c.osm_id
+                LEFT JOIN osm_route_member rm ON
+            rm.member = hl.osm_id
+        WHERE (hl.name <> '' OR hl.ref <> '')
+          AND NULLIF(hl.highway, '') IS NOT NULL
+    ) AS t
+    WHERE ("rank" = 1 OR "rank" IS NULL);
+
+    -- noinspection SqlWithoutWhere
+    DELETE FROM transportation_name.network_changes;
+    -- noinspection SqlWithoutWhere
+    DELETE FROM transportation_name.updates_network;
+
+    RAISE LOG 'Refresh transportation_name network done in %', age(clock_timestamp(), t);
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+
+CREATE TRIGGER trigger_store_transportation_route_member
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_route_member
+    FOR EACH ROW
+EXECUTE PROCEDURE transportation_name.route_member_store();
+
+CREATE TRIGGER trigger_store_transportation_highway_linestring
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_highway_linestring
+    FOR EACH ROW
+EXECUTE PROCEDURE transportation_name.highway_linestring_store();
+
+CREATE TRIGGER trigger_flag_transportation_name
+    AFTER INSERT
+    ON transportation_name.network_changes
+    FOR EACH STATEMENT
+EXECUTE PROCEDURE transportation_name.flag_network();
+
+CREATE CONSTRAINT TRIGGER trigger_refresh_network
+    AFTER INSERT
+    ON transportation_name.updates_network
+    INITIALLY DEFERRED
+    FOR EACH ROW
+EXECUTE PROCEDURE transportation_name.refresh_network();
+
+-- Trigger to update "osm_transportation_name_linestring" from "osm_transportation_name_network"
+
+CREATE TABLE IF NOT EXISTS transportation_name.name_changes
+(
+    id serial PRIMARY KEY,
+    is_old boolean,
+    osm_id bigint,
+    name character varying,
+    name_en character varying,
+    name_de character varying,
+    ref character varying,
+    highway character varying,
+    construction character varying,
+    brunnel character varying,
+    level integer,
+    layer integer,
+    indoor boolean,
+    network_type route_network_type
+);
+
+CREATE OR REPLACE FUNCTION transportation_name.name_network_store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op IN ('DELETE', 'UPDATE'))
+    THEN
+        INSERT INTO transportation_name.name_changes(is_old, osm_id, name, name_en, name_de, ref, highway, construction,
+                                                     brunnel, level, layer, indoor, network_type)
+        VALUES (TRUE, old.osm_id, old.name, old.name_en, old.name_de, old.ref, old.highway, old.construction,
+                old.brunnel, old.level, old.layer, old.indoor, old.network_type);
+    END IF;
+    IF (tg_op IN ('UPDATE', 'INSERT'))
+    THEN
+        INSERT INTO transportation_name.name_changes(is_old, osm_id, name, name_en, name_de, ref, highway, construction,
+                                                     brunnel, level, layer, indoor, network_type)
+        VALUES (FALSE, new.osm_id, new.name, new.name_en, new.name_de, new.ref, new.highway, new.construction,
+                new.brunnel, new.level, new.layer, new.indoor, new.network_type);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TABLE IF NOT EXISTS transportation_name.updates_name
 (
     id serial PRIMARY KEY,
     t  text,
     UNIQUE (t)
 );
-CREATE OR REPLACE FUNCTION transportation_name.flag() RETURNS trigger AS
+CREATE OR REPLACE FUNCTION transportation_name.flag_name() RETURNS trigger AS
 $$
 BEGIN
-    INSERT INTO transportation_name.updates(t) VALUES ('y') ON CONFLICT(t) DO NOTHING;
+    INSERT INTO transportation_name.updates_name(t) VALUES ('y') ON CONFLICT(t) DO NOTHING;
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION transportation_name.refresh() RETURNS trigger AS
+CREATE OR REPLACE FUNCTION transportation_name.refresh_name() RETURNS trigger AS
-$$
+$BODY$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh transportation_name';
-    PERFORM update_osm_route_member();
+
-    REFRESH MATERIALIZED VIEW osm_transportation_name_network;
+    -- REFRESH osm_transportation_name_linestring
-    REFRESH MATERIALIZED VIEW osm_transportation_name_linestring;
+
-    REFRESH MATERIALIZED VIEW osm_transportation_name_linestring_gen1;
+    -- Compact the change history to keep only the first and last version, and then uniq version of row
-    REFRESH MATERIALIZED VIEW osm_transportation_name_linestring_gen2;
+    CREATE TEMP TABLE name_changes_compact AS
-    REFRESH MATERIALIZED VIEW osm_transportation_name_linestring_gen3;
+    SELECT DISTINCT ON (name, name_en, name_de, ref, highway, construction, brunnel, level, layer, indoor, network_type)
-    REFRESH MATERIALIZED VIEW osm_transportation_name_linestring_gen4;
+        name,
-    -- noinspection SqlWithoutWhere
+        name_en,
-    DELETE FROM transportation_name.updates;
+        name_de,
+        ref,
+        highway,
+        construction,
+        brunnel,
+        level,
+        layer,
+        indoor,
+        network_type,
+        coalesce(name, ref) AS name_ref
+    FROM ((
+              SELECT DISTINCT ON (osm_id) *
+              FROM transportation_name.name_changes
+              WHERE is_old
+              ORDER BY osm_id,
+                       id ASC
+          )
+          UNION ALL
+          (
+              SELECT DISTINCT ON (osm_id) *
+              FROM transportation_name.name_changes
+              WHERE NOT is_old
+              ORDER BY osm_id,
+                       id DESC
+          )) AS t;
+
+    DELETE
+    FROM osm_transportation_name_linestring AS n
+        USING name_changes_compact AS c
+    WHERE coalesce(n.name, '') = coalesce(c.name, '')
+      AND coalesce(n.ref, '') = coalesce(c.ref, '')
+      AND n.name_en IS NOT DISTINCT FROM c.name_en
+      AND n.name_de IS NOT DISTINCT FROM c.name_de
+      AND n.highway IS NOT DISTINCT FROM c.highway
+      AND n.construction IS NOT DISTINCT FROM c.construction
+      AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+      AND n.level IS NOT DISTINCT FROM c.level
+      AND n.layer IS NOT DISTINCT FROM c.layer
+      AND n.indoor IS NOT DISTINCT FROM c.indoor
+      AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    INSERT INTO osm_transportation_name_linestring
+    SELECT (ST_Dump(geometry)).geom AS geometry,
+           NULL::bigint AS osm_id,
+           name,
+           name_en,
+           name_de,
+           tags || get_basic_names(tags, geometry) AS tags,
+           ref,
+           highway,
+           construction,
+           brunnel,
+           level,
+           layer,
+           indoor,
+           network_type AS network,
+           z_order
+    FROM (
+        SELECT ST_LineMerge(ST_Collect(n.geometry)) AS geometry,
+            n.name,
+            n.name_en,
+            n.name_de,
+            hstore(string_agg(nullif(slice_language_tags(tags ||
+                                                         hstore(ARRAY ['name', n.name, 'name:en', n.name_en, 'name:de', n.name_de]))::text,
+                                     ''), ',')) AS tags,
+            n.ref,
+            n.highway,
+            n.construction,
+            n.brunnel,
+            n.level,
+            n.layer,
+            n.indoor,
+            n.network_type,
+            min(n.z_order) AS z_order
+        FROM osm_transportation_name_network AS n
+            JOIN name_changes_compact AS c ON
+                 coalesce(n.name, '') = coalesce(c.name, '')
+             AND coalesce(n.ref, '') = coalesce(c.ref, '')
+             AND n.name_en IS NOT DISTINCT FROM c.name_en
+             AND n.name_de IS NOT DISTINCT FROM c.name_de
+             AND n.highway IS NOT DISTINCT FROM c.highway
+             AND n.construction IS NOT DISTINCT FROM c.construction
+             AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+             AND n.level IS NOT DISTINCT FROM c.level
+             AND n.layer IS NOT DISTINCT FROM c.layer
+             AND n.indoor IS NOT DISTINCT FROM c.indoor
+             AND n.network_type IS NOT DISTINCT FROM c.network_type
+        GROUP BY n.name, n.name_en, n.name_de, n.ref, n.highway, n.construction, n.brunnel, n.level, n.layer, n.indoor, n.network_type
+    ) AS highway_union;
+
+    -- REFRESH osm_transportation_name_linestring_gen1
+    DELETE FROM osm_transportation_name_linestring_gen1 AS n
+    USING name_changes_compact AS c
+    WHERE
+        coalesce(n.name, n.ref) = c.name_ref
+        AND n.name IS NOT DISTINCT FROM c.name
+        AND n.name_en IS NOT DISTINCT FROM c.name_en
+        AND n.name_de IS NOT DISTINCT FROM c.name_de
+        AND n.ref IS NOT DISTINCT FROM c.ref
+        AND n.highway IS NOT DISTINCT FROM c.highway
+        AND n.construction IS NOT DISTINCT FROM c.construction
+        AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+        AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    INSERT INTO osm_transportation_name_linestring_gen1
+    SELECT n.*
+    FROM osm_transportation_name_linestring_gen1_view AS n
+        JOIN name_changes_compact AS c ON
+            coalesce(n.name, n.ref) = c.name_ref
+            AND n.name IS NOT DISTINCT FROM c.name
+            AND n.name_en IS NOT DISTINCT FROM c.name_en
+            AND n.name_de IS NOT DISTINCT FROM c.name_de
+            AND n.ref IS NOT DISTINCT FROM c.ref
+            AND n.highway IS NOT DISTINCT FROM c.highway
+            AND n.construction IS NOT DISTINCT FROM c.construction
+            AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+            AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    -- REFRESH osm_transportation_name_linestring_gen2
+    DELETE FROM osm_transportation_name_linestring_gen2 AS n
+    USING name_changes_compact AS c
+    WHERE
+        coalesce(n.name, n.ref) = c.name_ref
+        AND n.name IS NOT DISTINCT FROM c.name
+        AND n.name_en IS NOT DISTINCT FROM c.name_en
+        AND n.name_de IS NOT DISTINCT FROM c.name_de
+        AND n.ref IS NOT DISTINCT FROM c.ref
+        AND n.highway IS NOT DISTINCT FROM c.highway
+        AND n.construction IS NOT DISTINCT FROM c.construction
+        AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+        AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    INSERT INTO osm_transportation_name_linestring_gen2
+    SELECT n.*
+    FROM osm_transportation_name_linestring_gen2_view AS n
+        JOIN name_changes_compact AS c ON
+            coalesce(n.name, n.ref) = c.name_ref
+            AND n.name IS NOT DISTINCT FROM c.name
+            AND n.name_en IS NOT DISTINCT FROM c.name_en
+            AND n.name_de IS NOT DISTINCT FROM c.name_de
+            AND n.ref IS NOT DISTINCT FROM c.ref
+            AND n.highway IS NOT DISTINCT FROM c.highway
+            AND n.construction IS NOT DISTINCT FROM c.construction
+            AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+            AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    -- REFRESH osm_transportation_name_linestring_gen3
+    DELETE FROM osm_transportation_name_linestring_gen3 AS n
+    USING name_changes_compact AS c
+    WHERE
+        coalesce(n.name, n.ref) = c.name_ref
+        AND n.name IS NOT DISTINCT FROM c.name
+        AND n.name_en IS NOT DISTINCT FROM c.name_en
+        AND n.name_de IS NOT DISTINCT FROM c.name_de
+        AND n.ref IS NOT DISTINCT FROM c.ref
+        AND n.highway IS NOT DISTINCT FROM c.highway
+        AND n.construction IS NOT DISTINCT FROM c.construction
+        AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+        AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    INSERT INTO osm_transportation_name_linestring_gen3
+    SELECT n.*
+    FROM osm_transportation_name_linestring_gen3_view AS n
+        JOIN name_changes_compact AS c ON
+            coalesce(n.name, n.ref) = c.name_ref
+            AND n.name IS NOT DISTINCT FROM c.name
+            AND n.name_en IS NOT DISTINCT FROM c.name_en
+            AND n.name_de IS NOT DISTINCT FROM c.name_de
+            AND n.ref IS NOT DISTINCT FROM c.ref
+            AND n.highway IS NOT DISTINCT FROM c.highway
+            AND n.construction IS NOT DISTINCT FROM c.construction
+            AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+            AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    -- REFRESH osm_transportation_name_linestring_gen4
+    DELETE FROM osm_transportation_name_linestring_gen4 AS n
+    USING name_changes_compact AS c
+    WHERE
+        coalesce(n.name, n.ref) = c.name_ref
+        AND n.name IS NOT DISTINCT FROM c.name
+        AND n.name_en IS NOT DISTINCT FROM c.name_en
+        AND n.name_de IS NOT DISTINCT FROM c.name_de
+        AND n.ref IS NOT DISTINCT FROM c.ref
+        AND n.highway IS NOT DISTINCT FROM c.highway
+        AND n.construction IS NOT DISTINCT FROM c.construction
+        AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+        AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    INSERT INTO osm_transportation_name_linestring_gen4
+    SELECT n.*
+    FROM osm_transportation_name_linestring_gen4_view AS n
+        JOIN name_changes_compact AS c ON
+            coalesce(n.name, n.ref) = c.name_ref
+            AND n.name IS NOT DISTINCT FROM c.name
+            AND n.name_en IS NOT DISTINCT FROM c.name_en
+            AND n.name_de IS NOT DISTINCT FROM c.name_de
+            AND n.ref IS NOT DISTINCT FROM c.ref
+            AND n.highway IS NOT DISTINCT FROM c.highway
+            AND n.construction IS NOT DISTINCT FROM c.construction
+            AND n.brunnel IS NOT DISTINCT FROM c.brunnel
+            AND n.network IS NOT DISTINCT FROM c.network_type;
+
+    DROP TABLE name_changes_compact;
+    DELETE FROM transportation_name.name_changes;
+    DELETE FROM transportation_name.updates_name;
+
+    RAISE LOG 'Refresh transportation_name done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
-$$ LANGUAGE plpgsql;
+$BODY$
+    LANGUAGE plpgsql;
 
-CREATE TRIGGER trigger_flag_transportation_name
+
+CREATE TRIGGER trigger_store_transportation_name_network
     AFTER INSERT OR UPDATE OR DELETE
-    ON osm_route_member
+    ON osm_transportation_name_network
-    FOR EACH STATEMENT
+    FOR EACH ROW
-EXECUTE PROCEDURE transportation_name.flag();
+EXECUTE PROCEDURE transportation_name.name_network_store();
 
-CREATE TRIGGER trigger_flag_transportation_name
+CREATE TRIGGER trigger_flag_name
-    AFTER INSERT OR UPDATE OR DELETE
-    ON osm_highway_linestring
-    FOR EACH STATEMENT
-EXECUTE PROCEDURE transportation_name.flag();
-
-CREATE CONSTRAINT TRIGGER trigger_refresh
     AFTER INSERT
-    ON transportation_name.updates
+    ON transportation_name.name_changes
+    FOR EACH STATEMENT
+EXECUTE PROCEDURE transportation_name.flag_name();
+
+CREATE CONSTRAINT TRIGGER trigger_refresh_name
+    AFTER INSERT
+    ON transportation_name.updates_name
     INITIALLY DEFERRED
     FOR EACH ROW
-EXECUTE PROCEDURE transportation_name.refresh();
+EXECUTE PROCEDURE transportation_name.refresh_name();

layers/water/mapping.yaml

@@ -1,39 +1,38 @@
 generalized_tables:
-
+  # etldoc: osm_water_polygon_gen_z7 -> osm_water_polygon_gen_z6
-  # etldoc: imposm3 -> osm_water_polygon_gen6
+  water_polygon_gen_z6:
-  water_polygon_gen6:
+    source: water_polygon_gen_z7
-    source: water_polygon_gen5
     sql_filter: area>power(ZRES5,2)
     tolerance: ZRES7
 
-  # etldoc: imposm3 -> osm_water_polygon_gen5
+  # etldoc: osm_water_polygon_gen_z8 -> osm_water_polygon_gen_z7
-  water_polygon_gen5:
+  water_polygon_gen_z7:
-    source: water_polygon_gen4
+    source: water_polygon_gen_z8
     sql_filter: area>power(ZRES6,2)
     tolerance: ZRES8
 
-  # etldoc: imposm3 -> osm_water_polygon_gen4
+  # etldoc: osm_water_polygon_gen_z9 -> osm_water_polygon_gen_z8
-  water_polygon_gen4:
+  water_polygon_gen_z8:
-    source: water_polygon_gen3
+    source: water_polygon_gen_z9
     sql_filter: area>power(ZRES7,2)
     tolerance: ZRES9
 
-  # etldoc: imposm3 -> osm_water_polygon_gen3
+  # etldoc: osm_water_polygon_gen_z10 -> osm_water_polygon_gen_z9
-  water_polygon_gen3:
+  water_polygon_gen_z9:
-    source: water_polygon_gen2
+    source: water_polygon_gen_z10
     sql_filter: area>power(ZRES8,2)
     tolerance: ZRES10
 
-  # etldoc: imposm3 -> osm_water_polygon_gen2
+  # etldoc: osm_water_polygon_gen_z11 -> osm_water_polygon_gen_z10
-  water_polygon_gen2:
+  water_polygon_gen_z10:
-    source: water_polygon_gen1
+    source: water_polygon_gen_z11
     sql_filter: area>power(ZRES9,2)
     tolerance: ZRES11
 
-  # etldoc: imposm3 -> osm_water_polygon_gen1
+  # etldoc: osm_water_polygon -> osm_water_polygon_gen_z11
-  water_polygon_gen1:
+  water_polygon_gen_z11:
     source: water_polygon
-    sql_filter: area>power(ZRES10,2) AND ST_IsValid(geometry)
+    sql_filter: area>power(ZRES10,2)
     tolerance: ZRES12
 
 tunnel_field: &tunnel
@@ -88,6 +87,7 @@ tables:
       landuse:
       - reservoir
       - basin
+      - salt_pond
       leisure:
       - swimming_pool
       natural:

layers/water/update_water.sql

@@ -1,78 +1,142 @@
+-- Recreate ocean layer by union regular squares into larger polygons
+-- etldoc: osm_ocean_polygon -> osm_ocean_polygon_union
+CREATE TABLE IF NOT EXISTS osm_ocean_polygon_union AS
+    (
+    SELECT (ST_Dump(ST_Union(ST_MakeValid(geometry)))).geom::geometry(Polygon, 3857) AS geometry 
+    FROM osm_ocean_polygon
+    --for union select just full square (not big triangles)
+    WHERE ST_Area(geometry) > 100000000 AND 
+          ST_NPoints(geometry) = 5
+    UNION ALL
+    SELECT geometry 
+    FROM osm_ocean_polygon
+    -- as 321 records have less then 5 coordinates (triangle)
+    -- bigger then 5 coordinates have squares with holes from island and coastline
+    WHERE ST_NPoints(geometry) <> 5
+    );
+
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_union_geom_idx
+  ON osm_ocean_polygon_union
+  USING GIST (geometry);
+
+--Drop data from original table but keep table as `CREATE TABLE IF NOT EXISTS` still test if query is valid
+TRUNCATE TABLE osm_ocean_polygon;
+
 -- This statement can be deleted after the water importer image stops creating this object as a table
 DO
 $$
     BEGIN
-        DROP TABLE IF EXISTS osm_ocean_polygon_gen1 CASCADE;
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z11 CASCADE;
     EXCEPTION
         WHEN wrong_object_type THEN
     END;
 $$ LANGUAGE plpgsql;
 
--- etldoc: osm_ocean_polygon -> osm_ocean_polygon_gen1
+-- etldoc: osm_ocean_polygon_union -> osm_ocean_polygon_gen_z11
-DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen1 CASCADE;
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z11 CASCADE;
-CREATE MATERIALIZED VIEW osm_ocean_polygon_gen1 AS
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z11 AS
 (
-SELECT ST_Simplify(geometry, 20) AS geometry
+SELECT ST_Simplify(geometry, ZRes(13)) AS geometry
-FROM osm_ocean_polygon
+FROM osm_ocean_polygon_union
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
-CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen1_idx ON osm_ocean_polygon_gen1 USING gist (geometry);
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z11_idx ON osm_ocean_polygon_gen_z11 USING gist (geometry);
 
 
 -- This statement can be deleted after the water importer image stops creating this object as a table
 DO
 $$
     BEGIN
-        DROP TABLE IF EXISTS osm_ocean_polygon_gen2 CASCADE;
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z10 CASCADE;
     EXCEPTION
         WHEN wrong_object_type THEN
     END;
 $$ LANGUAGE plpgsql;
 
--- etldoc: osm_ocean_polygon -> osm_ocean_polygon_gen2
+-- etldoc: osm_ocean_polygon_gen_z11 -> osm_ocean_polygon_gen_z10
-DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen2 CASCADE;
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z10 CASCADE;
-CREATE MATERIALIZED VIEW osm_ocean_polygon_gen2 AS
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z10 AS
 (
-SELECT ST_Simplify(geometry, 40) AS geometry
+SELECT ST_Simplify(geometry, ZRes(12)) AS geometry
-FROM osm_ocean_polygon
+FROM osm_ocean_polygon_gen_z11
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
-CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen2_idx ON osm_ocean_polygon_gen2 USING gist (geometry);
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z10_idx ON osm_ocean_polygon_gen_z10 USING gist (geometry);
 
 
 -- This statement can be deleted after the water importer image stops creating this object as a table
 DO
 $$
     BEGIN
-        DROP TABLE IF EXISTS osm_ocean_polygon_gen3 CASCADE;
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z9 CASCADE;
     EXCEPTION
         WHEN wrong_object_type THEN
     END;
 $$ LANGUAGE plpgsql;
 
--- etldoc: osm_ocean_polygon -> osm_ocean_polygon_gen3
+-- etldoc: osm_ocean_polygon_gen_z10 -> osm_ocean_polygon_gen_z9
-DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen3 CASCADE;
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z9 CASCADE;
-CREATE MATERIALIZED VIEW osm_ocean_polygon_gen3 AS
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z9 AS
 (
-SELECT ST_Simplify(geometry, 80) AS geometry
+SELECT ST_Simplify(geometry, ZRes(11)) AS geometry
-FROM osm_ocean_polygon
+FROM osm_ocean_polygon_gen_z10
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
-CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen3_idx ON osm_ocean_polygon_gen3 USING gist (geometry);
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z9_idx ON osm_ocean_polygon_gen_z9 USING gist (geometry);
 
 
 -- This statement can be deleted after the water importer image stops creating this object as a table
 DO
 $$
     BEGIN
-        DROP TABLE IF EXISTS osm_ocean_polygon_gen4 CASCADE;
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z8 CASCADE;
     EXCEPTION
         WHEN wrong_object_type THEN
     END;
 $$ LANGUAGE plpgsql;
 
--- etldoc: osm_ocean_polygon -> osm_ocean_polygon_gen4
+-- etldoc: osm_ocean_polygon_gen_z9 -> osm_ocean_polygon_gen_z8
-DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen4 CASCADE;
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z8 CASCADE;
-CREATE MATERIALIZED VIEW osm_ocean_polygon_gen4 AS
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z8 AS
 (
-SELECT ST_Simplify(geometry, 160) AS geometry
+SELECT ST_Simplify(geometry, ZRes(10)) AS geometry
-FROM osm_ocean_polygon
+FROM osm_ocean_polygon_gen_z9
     ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
-CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen4_idx ON osm_ocean_polygon_gen4 USING gist (geometry);
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z8_idx ON osm_ocean_polygon_gen_z8 USING gist (geometry);
+
+
+-- This statement can be deleted after the water importer image stops creating this object as a table
+DO
+$$
+    BEGIN
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z7 CASCADE;
+    EXCEPTION
+        WHEN wrong_object_type THEN
+    END;
+$$ LANGUAGE plpgsql;
+
+-- etldoc: osm_ocean_polygon_gen_z8 -> osm_ocean_polygon_gen_z7
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z7 CASCADE;
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z7 AS
+(
+SELECT ST_Simplify(geometry, ZRes(9)) AS geometry
+FROM osm_ocean_polygon_gen_z8
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z7_idx ON osm_ocean_polygon_gen_z7 USING gist (geometry);
+
+
+-- This statement can be deleted after the water importer image stops creating this object as a table
+DO
+$$
+    BEGIN
+        DROP TABLE IF EXISTS osm_ocean_polygon_gen_z6 CASCADE;
+    EXCEPTION
+        WHEN wrong_object_type THEN
+    END;
+$$ LANGUAGE plpgsql;
+
+-- etldoc: osm_ocean_polygon_gen_z7 -> osm_ocean_polygon_gen_z6
+DROP MATERIALIZED VIEW IF EXISTS osm_ocean_polygon_gen_z6 CASCADE;
+CREATE MATERIALIZED VIEW osm_ocean_polygon_gen_z6 AS
+(
+SELECT ST_Simplify(geometry, ZRes(8)) AS geometry
+FROM osm_ocean_polygon_gen_z7
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS osm_ocean_polygon_gen_z6_idx ON osm_ocean_polygon_gen_z6 USING gist (geometry);

layers/water/water.sql

@@ -18,232 +18,419 @@ $$ LANGUAGE SQL IMMUTABLE
                 STRICT
                 PARALLEL SAFE;
 
-
+-- ne_10m_ocean
-
+-- etldoc:  ne_10m_ocean ->  ne_10m_ocean_gen_z5
-CREATE OR REPLACE VIEW water_z0 AS
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_ocean_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_ocean_gen_z5 AS
 (
--- etldoc:  ne_110m_ocean ->  water_z0
+SELECT ST_Simplify(geometry, ZRes(7)) AS geometry,
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_110m_ocean
-UNION ALL
--- etldoc:  ne_110m_lakes ->  water_z0
-SELECT geometry,
-       'lake'::text  AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_110m_lakes
-    );
-
-CREATE OR REPLACE VIEW water_z1 AS
-(
--- etldoc:  ne_110m_ocean ->  water_z1
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_110m_ocean
-UNION ALL
--- etldoc:  ne_110m_lakes ->  water_z1
-SELECT geometry,
-       'lake'::text  AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_110m_lakes
-    );
-
-CREATE OR REPLACE VIEW water_z2 AS
-(
--- etldoc:  ne_50m_ocean ->  water_z2
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_50m_ocean
-UNION ALL
--- etldoc:  ne_50m_lakes ->  water_z2
-SELECT geometry,
-       'lake'::text  AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_50m_lakes
-    );
-
-CREATE OR REPLACE VIEW water_z4 AS
-(
--- etldoc:  ne_50m_ocean ->  water_z4
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_50m_ocean
-UNION ALL
--- etldoc:  ne_10m_lakes ->  water_z4
-SELECT geometry,
-       'lake'::text  AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM ne_10m_lakes
-    );
-
-CREATE OR REPLACE VIEW water_z5 AS
-(
--- etldoc:  ne_10m_ocean ->  water_z5
-SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
 FROM ne_10m_ocean
-UNION ALL
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
--- etldoc:  ne_10m_lakes ->  water_z5
+CREATE INDEX IF NOT EXISTS ne_10m_ocean_gen_z5_idx ON ne_10m_ocean_gen_z5 USING gist (geometry);
-SELECT geometry,
+
-       'lake'::text  AS class,
+-- ne_10m_lakes
+-- etldoc:  ne_10m_lakes ->  ne_10m_lakes_gen_z5
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_lakes_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_lakes_gen_z5 AS
+(
+SELECT ogc_fid,
+       ST_MakeValid(ST_Simplify(geometry, ZRes(7))) AS geometry,
+       'lake'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
 FROM ne_10m_lakes
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_lakes_gen_z5_idx ON ne_10m_lakes_gen_z5 USING gist (geometry);
+
+-- etldoc:  ne_10m_lakes_gen_z5 ->  ne_10m_lakes_gen_z4
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_lakes_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_lakes_gen_z4 AS
+(
+SELECT ogc_fid,
+       ST_MakeValid(ST_Simplify(geometry, ZRes(6))) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_10m_lakes_gen_z5
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_lakes_gen_z4_idx ON ne_10m_lakes_gen_z4 USING gist (geometry);
+
+-- ne_50m_ocean
+-- etldoc:  ne_50m_ocean ->  ne_50m_ocean_gen_z4
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_ocean_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_ocean_gen_z4 AS
+(
+SELECT ST_Simplify(geometry, ZRes(6)) AS geometry,
+       'ocean'::text AS class,
+       NULL::boolean AS is_intermittent,
+       NULL::boolean AS is_bridge,
+       NULL::boolean AS is_tunnel
+FROM ne_50m_ocean
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_ocean_gen_z4_idx ON ne_50m_ocean_gen_z4 USING gist (geometry);
+
+-- etldoc:  ne_50m_ocean_gen_z4 ->  ne_50m_ocean_gen_z3
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_ocean_gen_z3 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_ocean_gen_z3 AS
+(
+SELECT ST_Simplify(geometry, ZRes(5)) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_ocean_gen_z4
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_ocean_gen_z3_idx ON ne_50m_ocean_gen_z3 USING gist (geometry);
+
+-- etldoc:  ne_50m_ocean_gen_z3 ->  ne_50m_ocean_gen_z2
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_ocean_gen_z2 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_ocean_gen_z2 AS
+(
+SELECT ST_Simplify(geometry, ZRes(4)) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_ocean_gen_z3
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_ocean_gen_z2_idx ON ne_50m_ocean_gen_z2 USING gist (geometry);
+
+-- ne_50m_lakes
+-- etldoc:  ne_50m_lakes ->  ne_50m_lakes_gen_z3
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_lakes_gen_z3 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_lakes_gen_z3 AS
+(
+SELECT ogc_fid,
+       ST_MakeValid(ST_Simplify(geometry, ZRes(5))) AS geometry,
+       'lakes'::text AS class,
+       NULL::boolean AS is_intermittent,
+       NULL::boolean AS is_bridge,
+       NULL::boolean AS is_tunnel
+FROM ne_50m_lakes
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_lakes_gen_z3_idx ON ne_50m_lakes_gen_z3 USING gist (geometry);
+
+-- etldoc:  ne_50m_lakes_gen_z3 ->  ne_50m_lakes_gen_z2
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_lakes_gen_z2 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_lakes_gen_z2 AS
+(
+SELECT ogc_fid,
+       ST_MakeValid(ST_Simplify(geometry, ZRes(4))) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_lakes_gen_z3
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_lakes_gen_z2_idx ON ne_50m_lakes_gen_z2 USING gist (geometry);
+
+--ne_110m_ocean
+-- etldoc:  ne_110m_ocean ->  ne_110m_ocean_gen_z1
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_ocean_gen_z1 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_ocean_gen_z1 AS
+(
+SELECT ST_Simplify(geometry, ZRes(3)) AS geometry,
+       'ocean'::text AS class,
+       NULL::boolean AS is_intermittent,
+       NULL::boolean AS is_bridge,
+       NULL::boolean AS is_tunnel
+FROM ne_110m_ocean
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_ocean_gen_z1_idx ON ne_110m_ocean_gen_z1 USING gist (geometry);
+
+-- etldoc:  ne_110m_ocean_gen_z1 ->  ne_110m_ocean_gen_z0
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_ocean_gen_z0 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_ocean_gen_z0 AS
+(
+SELECT ST_Simplify(geometry, ZRes(2)) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_ocean_gen_z1
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_ocean_gen_z0_idx ON ne_110m_ocean_gen_z0 USING gist (geometry);
+
+
+-- ne_110m_lakes
+-- etldoc:  ne_110m_lakes ->  ne_110m_lakes_gen_z1
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_lakes_gen_z1 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_lakes_gen_z1 AS
+(
+SELECT ogc_fid,
+       ST_Simplify(geometry, ZRes(3)) AS geometry,
+       'lakes'::text AS class,
+       NULL::boolean AS is_intermittent,
+       NULL::boolean AS is_bridge,
+       NULL::boolean AS is_tunnel
+FROM ne_110m_lakes
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_lakes_gen_z1_idx ON ne_110m_lakes_gen_z1 USING gist (geometry);
+
+-- etldoc:  ne_110m_lakes_gen_z1 ->  ne_110m_lakes_gen_z0
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_lakes_gen_z0 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_lakes_gen_z0 AS
+(
+SELECT ogc_fid,
+       ST_Simplify(geometry, ZRes(2)) AS geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_lakes_gen_z1
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_lakes_gen_z0_idx ON ne_110m_lakes_gen_z0 USING gist (geometry);
+
+
+CREATE OR REPLACE VIEW water_z0 AS
+(
+-- etldoc:  ne_110m_ocean_gen_z0 ->  water_z0
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_ocean_gen_z0
+UNION ALL
+-- etldoc:  ne_110m_lakes_gen_z0 ->  water_z0
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_lakes_gen_z0
+    );
+
+CREATE OR REPLACE VIEW water_z1 AS
+(
+-- etldoc:  ne_110m_ocean_gen_z1 ->  water_z1
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_ocean_gen_z1
+UNION ALL
+-- etldoc:  ne_110m_lakes_gen_z1 ->  water_z1
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_110m_lakes_gen_z1
+    );
+
+CREATE OR REPLACE VIEW water_z2 AS
+(
+-- etldoc:  ne_50m_ocean_gen_z2 ->  water_z2
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_ocean_gen_z2
+UNION ALL
+-- etldoc:  ne_50m_lakes_gen_z2 ->  water_z2
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_lakes_gen_z2
+    );
+
+CREATE OR REPLACE VIEW water_z3 AS
+(
+-- etldoc:  ne_50m_ocean_gen_z3 ->  water_z3
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_ocean_gen_z3
+UNION ALL
+-- etldoc:  ne_50m_lakes_gen_z3 ->  water_z3
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_lakes_gen_z3
+    );
+
+CREATE OR REPLACE VIEW water_z4 AS
+(
+-- etldoc:  ne_50m_ocean_gen_z4 ->  water_z4
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_50m_ocean_gen_z4
+UNION ALL
+-- etldoc:  ne_10m_lakes_gen_z4 ->  water_z4
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_10m_lakes_gen_z4
+    );
+
+CREATE OR REPLACE VIEW water_z5 AS
+(
+-- etldoc:  ne_10m_ocean_gen_z5 ->  water_z5
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_10m_ocean_gen_z5
+UNION ALL
+-- etldoc:  ne_10m_lakes_gen_z5 ->  water_z5
+SELECT geometry,
+       class,
+       is_intermittent,
+       is_bridge,
+       is_tunnel
+FROM ne_10m_lakes_gen_z5
     );
 
 CREATE OR REPLACE VIEW water_z6 AS
 (
--- etldoc:  osm_ocean_polygon_gen4 ->  water_z6
+-- etldoc:  osm_ocean_polygon_gen_z6 ->  water_z6
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen4
+FROM osm_ocean_polygon_gen_z6
 UNION ALL
--- etldoc:  osm_water_polygon_gen6 ->  water_z6
+-- etldoc:  osm_water_polygon_gen_z6 ->  water_z6
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen6
+FROM osm_water_polygon_gen_z6
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z7 AS
 (
--- etldoc:  osm_ocean_polygon_gen4 ->  water_z7
+-- etldoc:  osm_ocean_polygon_gen_z7 ->  water_z7
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen4
+FROM osm_ocean_polygon_gen_z7
 UNION ALL
--- etldoc:  osm_water_polygon_gen5 ->  water_z7
+-- etldoc:  osm_water_polygon_gen_z7 ->  water_z7
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen5
+FROM osm_water_polygon_gen_z7
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z8 AS
 (
--- etldoc:  osm_ocean_polygon_gen4 ->  water_z8
+-- etldoc:  osm_ocean_polygon_gen_z8 ->  water_z8
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen4
+FROM osm_ocean_polygon_gen_z8
 UNION ALL
--- etldoc:  osm_water_polygon_gen4 ->  water_z8
+-- etldoc:  osm_water_polygon_gen_z8 ->  water_z8
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen4
+FROM osm_water_polygon_gen_z8
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z9 AS
 (
--- etldoc:  osm_ocean_polygon_gen3 ->  water_z9
+-- etldoc:  osm_ocean_polygon_gen_z9 ->  water_z9
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen3
+FROM osm_ocean_polygon_gen_z9
 UNION ALL
--- etldoc:  osm_water_polygon_gen3 ->  water_z9
+-- etldoc:  osm_water_polygon_gen_z9 ->  water_z9
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen3
+FROM osm_water_polygon_gen_z9
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z10 AS
 (
--- etldoc:  osm_ocean_polygon_gen2 ->  water_z10
+-- etldoc:  osm_ocean_polygon_gen_z10 ->  water_z10
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen2
+FROM osm_ocean_polygon_gen_z10
 UNION ALL
--- etldoc:  osm_water_polygon_gen2 ->  water_z10
+-- etldoc:  osm_water_polygon_gen_z10 ->  water_z10
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen2
+FROM osm_water_polygon_gen_z10
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z11 AS
 (
--- etldoc:  osm_ocean_polygon_gen1 ->  water_z11
+-- etldoc:  osm_ocean_polygon_gen_z11 ->  water_z11
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon_gen1
+FROM osm_ocean_polygon_gen_z11
 UNION ALL
--- etldoc:  osm_water_polygon_gen1 ->  water_z11
+-- etldoc:  osm_water_polygon_gen_z11 ->  water_z11
 SELECT geometry,
        water_class(waterway) AS class,
        is_intermittent,
-       NULL::boolean         AS is_bridge,
+       NULL::boolean AS is_bridge,
-       NULL::boolean         AS is_tunnel
+       NULL::boolean AS is_tunnel
-FROM osm_water_polygon_gen1
+FROM osm_water_polygon_gen_z11
 WHERE "natural" != 'bay'
     );
 
 CREATE OR REPLACE VIEW water_z12 AS
 (
--- etldoc:  osm_ocean_polygon_gen1 ->  water_z12
+-- etldoc:  osm_ocean_polygon_union ->  water_z12
 SELECT geometry,
        'ocean'::text AS class,
        NULL::boolean AS is_intermittent,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon
+FROM osm_ocean_polygon_union
 UNION ALL
 -- etldoc:  osm_water_polygon ->  water_z12
 SELECT geometry,
@@ -255,48 +442,8 @@ FROM osm_water_polygon
 WHERE "natural" != 'bay'
     );
 
-CREATE OR REPLACE VIEW water_z13 AS
-(
--- etldoc:  osm_ocean_polygon ->  water_z13
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon
-UNION ALL
--- etldoc:  osm_water_polygon ->  water_z13
-SELECT geometry,
-       water_class(waterway) AS class,
-       is_intermittent,
-       is_bridge,
-       is_tunnel
-FROM osm_water_polygon
-WHERE "natural" != 'bay'
-    );
-
-CREATE OR REPLACE VIEW water_z14 AS
-(
--- etldoc:  osm_ocean_polygon ->  water_z14
-SELECT geometry,
-       'ocean'::text AS class,
-       NULL::boolean AS is_intermittent,
-       NULL::boolean AS is_bridge,
-       NULL::boolean AS is_tunnel
-FROM osm_ocean_polygon
-UNION ALL
--- etldoc:  osm_water_polygon ->  water_z14
-SELECT geometry,
-       water_class(waterway) AS class,
-       is_intermittent,
-       is_bridge,
-       is_tunnel
-FROM osm_water_polygon
-WHERE "natural" != 'bay'
-    );
-
 -- etldoc: layer_water [shape=record fillcolor=lightpink, style="rounded,filled",
--- etldoc:     label="layer_water |<z0> z0|<z1>z1|<z2>z2|<z3>z3 |<z4> z4|<z5>z5|<z6>z6|<z7>z7| <z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14_> z14+" ] ;
+-- etldoc:     label="layer_water |<z0> z0|<z1>z1|<z2>z2|<z3>z3 |<z4> z4|<z5>z5|<z6>z6|<z7>z7| <z8> z8 |<z9> z9 |<z10> z10 |<z11> z11 |<z12> z12+" ] ;
 
 CREATE OR REPLACE FUNCTION layer_water(bbox geometry, zoom_level int)
     RETURNS TABLE
@@ -311,7 +458,7 @@ $$
 SELECT geometry,
        class::text,
        waterway_brunnel(is_bridge, is_tunnel) AS brunnel,
-       is_intermittent::int                   AS intermittent
+       is_intermittent::int AS intermittent
 FROM (
          -- etldoc: water_z0 ->  layer_water:z0
          SELECT *
@@ -324,10 +471,14 @@ FROM (
          WHERE zoom_level = 1
          UNION ALL
          -- etldoc: water_z2 ->  layer_water:z2
-         -- etldoc: water_z2 ->  layer_water:z3
          SELECT *
          FROM water_z2
-         WHERE zoom_level BETWEEN 2 AND 3
+         WHERE zoom_level = 2
+         UNION ALL
+         -- etldoc: water_z3 ->  layer_water:z3
+         SELECT *
+         FROM water_z3
+         WHERE zoom_level = 3
          UNION ALL
          -- etldoc: water_z4 ->  layer_water:z4
          SELECT *
@@ -372,17 +523,7 @@ FROM (
          -- etldoc: water_z12 ->  layer_water:z12
          SELECT *
          FROM water_z12
-         WHERE zoom_level = 12
+         WHERE zoom_level >= 12
-         UNION ALL
-         -- etldoc: water_z13 ->  layer_water:z13
-         SELECT *
-         FROM water_z13
-         WHERE zoom_level = 13
-         UNION ALL
-         -- etldoc: water_z14 ->  layer_water:z14_
-         SELECT *
-         FROM water_z14
-         WHERE zoom_level >= 14
      ) AS zoom_levels
 WHERE geometry && bbox;
 $$ LANGUAGE SQL STABLE

layers/water_name/update_marine_point.sql

@@ -1,49 +1,63 @@
 DROP TRIGGER IF EXISTS trigger_flag ON osm_marine_point;
+DROP TRIGGER IF EXISTS trigger_store ON osm_marine_point;
 DROP TRIGGER IF EXISTS trigger_refresh ON water_name_marine.updates;
 
-CREATE EXTENSION IF NOT EXISTS unaccent;
+CREATE SCHEMA IF NOT EXISTS water_name_marine;
 
-CREATE OR REPLACE FUNCTION update_osm_marine_point() RETURNS void AS
+CREATE TABLE IF NOT EXISTS water_name_marine.osm_ids
+(
+    osm_id bigint
+);
+
+CREATE OR REPLACE FUNCTION update_osm_marine_point(full_update boolean) RETURNS void AS
 $$
-BEGIN
-    -- etldoc: osm_marine_point              -> osm_marine_point
-    UPDATE osm_marine_point AS osm SET "rank" = NULL WHERE "rank" IS NOT NULL;
-
     -- etldoc: ne_10m_geography_marine_polys -> osm_marine_point
     -- etldoc: osm_marine_point              -> osm_marine_point
 
     WITH important_marine_point AS (
-        SELECT osm.geometry, osm.osm_id, osm.name, osm.name_en, ne.scalerank, osm.is_intermittent
+        SELECT osm.osm_id, ne.scalerank
-        FROM ne_10m_geography_marine_polys AS ne,
+        FROM osm_marine_point AS osm
-             osm_marine_point AS osm
+             LEFT JOIN ne_10m_geography_marine_polys AS ne ON
-        WHERE trim(regexp_replace(ne.name, '\\s+', ' ', 'g')) ILIKE osm.name
+              lower(trim(regexp_replace(ne.name, '\\s+', ' ', 'g'))) IN (lower(osm.name), lower(osm.tags->'name:en'), lower(osm.tags->'name:es'))
-           OR trim(regexp_replace(ne.name, '\\s+', ' ', 'g')) ILIKE osm.tags->'name:en'
+           OR substring(lower(trim(regexp_replace(ne.name, '\\s+', ' ', 'g'))) FROM 1 FOR length(lower(osm.name))) = lower(osm.name)
-           OR trim(regexp_replace(ne.name, '\\s+', ' ', 'g')) ILIKE osm.tags->'name:es'
-           OR osm.name ILIKE trim(regexp_replace(ne.name, '\\s+', ' ', 'g')) || ' %'
     )
     UPDATE osm_marine_point AS osm
     SET "rank" = scalerank
     FROM important_marine_point AS ne
-    WHERE osm.osm_id = ne.osm_id;
+    WHERE (full_update OR osm.osm_id IN (SELECT osm_id FROM water_name_marine.osm_ids))
+      AND osm.osm_id = ne.osm_id
+      AND "rank" IS DISTINCT FROM scalerank;
 
     UPDATE osm_marine_point
     SET tags = update_tags(tags, geometry)
-    WHERE COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL;
+    WHERE (full_update OR osm_id IN (SELECT osm_id FROM water_name_marine.osm_ids))
+      AND COALESCE(tags->'name:latin', tags->'name:nonlatin', tags->'name_int') IS NULL
+      AND tags != update_tags(tags, geometry);
 
-END;
+$$ LANGUAGE SQL;
-$$ LANGUAGE plpgsql;
 
-SELECT update_osm_marine_point();
+SELECT update_osm_marine_point(true);
 
 CREATE INDEX IF NOT EXISTS osm_marine_point_rank_idx ON osm_marine_point ("rank");
 
 -- Handle updates
-CREATE SCHEMA IF NOT EXISTS water_name_marine;
+
+CREATE OR REPLACE FUNCTION water_name_marine.store() RETURNS trigger AS
+$$
+BEGIN
+    IF (tg_op = 'DELETE') THEN
+        INSERT INTO water_name_marine.osm_ids VALUES (OLD.osm_id);
+    ELSE
+        INSERT INTO water_name_marine.osm_ids VALUES (NEW.osm_id);
+    END IF;
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
 
 CREATE TABLE IF NOT EXISTS water_name_marine.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION water_name_marine.flag() RETURNS trigger AS
@@ -56,15 +70,27 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION water_name_marine.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh water_name_marine rank';
-    PERFORM update_osm_marine_point();
+    PERFORM update_osm_marine_point(false);
+    -- noinspection SqlWithoutWhere
+    DELETE FROM water_name_marine.osm_ids;
     -- noinspection SqlWithoutWhere
     DELETE FROM water_name_marine.updates;
+
+    RAISE LOG 'Refresh water_name_marine done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 
+CREATE TRIGGER trigger_store
+    AFTER INSERT OR UPDATE OR DELETE
+    ON osm_marine_point
+    FOR EACH ROW
+EXECUTE PROCEDURE water_name_marine.store();
+
 CREATE TRIGGER trigger_flag
     AFTER INSERT OR UPDATE OR DELETE
     ON osm_marine_point

layers/water_name/update_water_lakeline.sql

@@ -4,12 +4,12 @@ DROP TRIGGER IF EXISTS trigger_insert_line ON osm_water_polygon;
 
 CREATE OR REPLACE VIEW osm_water_lakeline_view AS
 SELECT wp.osm_id,
-       ll.wkb_geometry                    AS geometry,
+       ll.wkb_geometry AS geometry,
        name,
        name_en,
        name_de,
        update_tags(tags, ll.wkb_geometry) AS tags,
-       ST_Area(wp.geometry)               AS area,
+       ST_Area(wp.geometry) AS area,
        is_intermittent
 FROM osm_water_polygon AS wp
          INNER JOIN lake_centerline ll ON wp.osm_id = ll.osm_id
@@ -66,7 +66,10 @@ BEGIN
     INSERT INTO osm_water_lakeline
     SELECT *
     FROM osm_water_lakeline_view
-    WHERE osm_water_lakeline_view.osm_id = NEW.osm_id;
+    WHERE osm_water_lakeline_view.osm_id = NEW.osm_id
+    -- May happen in case we replay update
+    ON CONFLICT ON CONSTRAINT osm_water_lakeline_pk
+    DO NOTHING;
 
     RETURN NULL;
 END;

layers/water_name/update_water_point.sql

@@ -4,17 +4,18 @@ DROP TRIGGER IF EXISTS trigger_insert_point ON osm_water_polygon;
 
 CREATE OR REPLACE VIEW osm_water_point_view AS
 SELECT wp.osm_id,
-       ST_PointOnSurface(wp.geometry)                       AS geometry,
+       ST_PointOnSurface(wp.geometry) AS geometry,
        wp.name,
        wp.name_en,
        wp.name_de,
        update_tags(wp.tags, ST_PointOnSurface(wp.geometry)) AS tags,
-       ST_Area(wp.geometry)                                 AS area,
+       ST_Area(wp.geometry) AS area,
        wp.is_intermittent
 FROM osm_water_polygon AS wp
          LEFT JOIN lake_centerline ll ON wp.osm_id = ll.osm_id
 WHERE ll.osm_id IS NULL
-  AND wp.name <> '';
+  AND wp.name <> ''
+  AND ST_IsValid(wp.geometry);
 
 -- etldoc:  osm_water_polygon ->  osm_water_point
 -- etldoc:  lake_centerline ->  osm_water_point
@@ -66,7 +67,10 @@ BEGIN
     INSERT INTO osm_water_point
     SELECT *
     FROM osm_water_point_view
-    WHERE osm_water_point_view.osm_id = NEW.osm_id;
+    WHERE osm_water_point_view.osm_id = NEW.osm_id
+    -- May happen in case we replay update
+    ON CONFLICT ON CONSTRAINT osm_water_point_pk
+    DO NOTHING;
 
     RETURN NULL;
 END;

layers/water_name/water_name.sql

@@ -21,14 +21,14 @@ SELECT
     CASE
         WHEN osm_id < 0 THEN -osm_id * 10 + 4
         ELSE osm_id * 10 + 1
-        END                                      AS osm_id_hash,
+        END AS osm_id_hash,
     geometry,
     name,
-    COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+    COALESCE(NULLIF(name_en, ''), name) AS name_en,
     COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
     tags,
-    'lake'::text                                 AS class,
+    'lake'::text AS class,
-    is_intermittent::int                         AS intermittent
+    is_intermittent::int AS intermittent
 FROM osm_water_lakeline
 WHERE geometry && bbox
   AND ((zoom_level BETWEEN 9 AND 13 AND LineLabel(zoom_level, NULLIF(name, ''), geometry))
@@ -40,14 +40,14 @@ SELECT
     CASE
         WHEN osm_id < 0 THEN -osm_id * 10 + 4
         ELSE osm_id * 10 + 1
-        END                                      AS osm_id_hash,
+        END AS osm_id_hash,
     geometry,
     name,
-    COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+    COALESCE(NULLIF(name_en, ''), name) AS name_en,
     COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
     tags,
-    'lake'::text                                 AS class,
+    'lake'::text AS class,
-    is_intermittent::int                         AS intermittent
+    is_intermittent::int AS intermittent
 FROM osm_water_point
 WHERE geometry && bbox
   AND (
@@ -59,14 +59,14 @@ SELECT
     -- etldoc: osm_marine_point ->  layer_water_name:z0_8
     -- etldoc: osm_marine_point ->  layer_water_name:z9_13
     -- etldoc: osm_marine_point ->  layer_water_name:z14_
-    osm_id * 10                                  AS osm_id_hash,
+    osm_id * 10 AS osm_id_hash,
     geometry,
     name,
-    COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+    COALESCE(NULLIF(name_en, ''), name) AS name_en,
     COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
     tags,
-    place::text                                  AS class,
+    place::text AS class,
-    is_intermittent::int                         AS intermittent
+    is_intermittent::int AS intermittent
 FROM osm_marine_point
 WHERE geometry && bbox
   AND (

layers/water_name/water_name.yaml

@@ -29,7 +29,7 @@ schema:
   - ./update_marine_point.sql
   - ./update_water_lakeline.sql
   - ./update_water_point.sql
-  - ./layer.sql
+  - ./water_name.sql
 datasources:
   - type: imposm3
     mapping_file: ../water/mapping.yaml

layers/waterway/mapping.yaml

@@ -1,20 +1,3 @@
-generalized_tables:
-  # etldoc: imposm3 -> osm_waterway_linestring_gen3
-  waterway_linestring_gen3:
-    source: waterway_linestring_gen2
-    sql_filter: waterway IN ('river')
-    tolerance: ZRES9
-  # etldoc: imposm3 -> osm_waterway_linestring_gen2
-  waterway_linestring_gen2:
-    source: waterway_linestring_gen1
-    sql_filter: waterway IN ('river')
-    tolerance: ZRES10
-  # etldoc: imposm3 -> osm_waterway_linestring_gen1
-  waterway_linestring_gen1:
-    source: waterway_linestring
-    sql_filter: waterway IN ('river') AND ST_IsValid(geometry)
-    tolerance: ZRES11
-
 tunnel_field: &tunnel
   key: tunnel
   name: is_tunnel

layers/waterway/update_important_waterway.sql

@@ -26,7 +26,7 @@ FROM (
                 name,
                 name_en,
                 name_de,
-                slice_language_tags(tags)        AS tags
+                slice_language_tags(tags) AS tags
          FROM osm_waterway_linestring
          WHERE name <> ''
            AND waterway = 'river'
@@ -36,41 +36,50 @@ FROM (
 CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_names ON osm_important_waterway_linestring (name);
 CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_geometry_idx ON osm_important_waterway_linestring USING gist (geometry);
 
--- etldoc: osm_important_waterway_linestring -> osm_important_waterway_linestring_gen1
+-- etldoc: osm_important_waterway_linestring -> osm_important_waterway_linestring_gen_z11
-CREATE OR REPLACE VIEW osm_important_waterway_linestring_gen1_view AS
+DROP MATERIALIZED VIEW IF EXISTS osm_important_waterway_linestring_gen_z11 CASCADE;
-SELECT ST_Simplify(geometry, 60) AS geometry, name, name_en, name_de, tags
+CREATE MATERIALIZED VIEW osm_important_waterway_linestring_gen_z11 AS
+(
+SELECT ST_Simplify(geometry, ZRes(12)) AS geometry,
+       name,
+       name_en,
+       name_de,
+       tags
 FROM osm_important_waterway_linestring
-WHERE ST_Length(geometry) > 1000;
+WHERE ST_Length(geometry) > 1000
+    );
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z11_name_idx ON osm_important_waterway_linestring_gen_z11 (name);
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z11_geometry_idx ON osm_important_waterway_linestring_gen_z11 USING gist (geometry);
 
-CREATE TABLE IF NOT EXISTS osm_important_waterway_linestring_gen1 AS
+-- etldoc: osm_important_waterway_linestring_gen_z11 -> osm_important_waterway_linestring_gen_z10
-SELECT *
+DROP MATERIALIZED VIEW IF EXISTS osm_important_waterway_linestring_gen_z10 CASCADE;
-FROM osm_important_waterway_linestring_gen1_view;
+CREATE MATERIALIZED VIEW osm_important_waterway_linestring_gen_z10 AS
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen1_name_idx ON osm_important_waterway_linestring_gen1 (name);
+(
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen1_geometry_idx ON osm_important_waterway_linestring_gen1 USING gist (geometry);
+SELECT ST_Simplify(geometry, ZRes(11)) AS geometry,
+       name,
+       name_en,
+       name_de,
+       tags
+FROM osm_important_waterway_linestring_gen_z11
+WHERE ST_Length(geometry) > 4000
+    );
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z10_name_idx ON osm_important_waterway_linestring_gen_z10 (name);
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z10_geometry_idx ON osm_important_waterway_linestring_gen_z10 USING gist (geometry);
 
--- etldoc: osm_important_waterway_linestring_gen1 -> osm_important_waterway_linestring_gen2
+-- etldoc: osm_important_waterway_linestring_gen_z10 -> osm_important_waterway_linestring_gen_z9
-CREATE OR REPLACE VIEW osm_important_waterway_linestring_gen2_view AS
+DROP MATERIALIZED VIEW IF EXISTS osm_important_waterway_linestring_gen_z9 CASCADE;
-SELECT ST_Simplify(geometry, 100) AS geometry, name, name_en, name_de, tags
+CREATE MATERIALIZED VIEW osm_important_waterway_linestring_gen_z9 AS
-FROM osm_important_waterway_linestring_gen1
+(
-WHERE ST_Length(geometry) > 4000;
+SELECT ST_Simplify(geometry, ZRes(10)) AS geometry,
-
+       name,
-CREATE TABLE IF NOT EXISTS osm_important_waterway_linestring_gen2 AS
+       name_en,
-SELECT *
+       name_de,
-FROM osm_important_waterway_linestring_gen2_view;
+       tags
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen2_name_idx ON osm_important_waterway_linestring_gen2 (name);
+FROM osm_important_waterway_linestring_gen_z10
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen2_geometry_idx ON osm_important_waterway_linestring_gen2 USING gist (geometry);
+WHERE ST_Length(geometry) > 8000
-
+    );
--- etldoc: osm_important_waterway_linestring_gen2 -> osm_important_waterway_linestring_gen3
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z9_name_idx ON osm_important_waterway_linestring_gen_z9 (name);
-CREATE OR REPLACE VIEW osm_important_waterway_linestring_gen3_view AS
+CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen_z9_geometry_idx ON osm_important_waterway_linestring_gen_z9 USING gist (geometry);
-SELECT ST_Simplify(geometry, 200) AS geometry, name, name_en, name_de, tags
-FROM osm_important_waterway_linestring_gen2
-WHERE ST_Length(geometry) > 8000;
-
-CREATE TABLE IF NOT EXISTS osm_important_waterway_linestring_gen3 AS
-SELECT *
-FROM osm_important_waterway_linestring_gen3_view;
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen3_name_idx ON osm_important_waterway_linestring_gen3 (name);
-CREATE INDEX IF NOT EXISTS osm_important_waterway_linestring_gen3_geometry_idx ON osm_important_waterway_linestring_gen3 USING gist (geometry);
 
 -- Handle updates
 
@@ -78,26 +87,24 @@ CREATE SCHEMA IF NOT EXISTS waterway_important;
 
 CREATE TABLE IF NOT EXISTS waterway_important.changes
 (
-    id      serial PRIMARY KEY,
+    id serial PRIMARY KEY,
-    is_old  boolean,
+    osm_id bigint,
-    name    character varying,
+    is_old boolean,
+    name character varying,
     name_en character varying,
     name_de character varying,
-    tags    hstore,
+    tags hstore
-    UNIQUE (is_old, name, name_en, name_de, tags)
 );
 CREATE OR REPLACE FUNCTION waterway_important.store() RETURNS trigger AS
 $$
 BEGIN
     IF (tg_op IN ('DELETE', 'UPDATE')) AND OLD.name <> '' AND OLD.waterway = 'river' THEN
         INSERT INTO waterway_important.changes(is_old, name, name_en, name_de, tags)
-        VALUES (TRUE, OLD.name, OLD.name_en, OLD.name_de, slice_language_tags(OLD.tags))
+        VALUES (TRUE, OLD.name, OLD.name_en, OLD.name_de, slice_language_tags(OLD.tags));
-        ON CONFLICT(is_old, name, name_en, name_de, tags) DO NOTHING;
     END IF;
     IF (tg_op IN ('UPDATE', 'INSERT')) AND NEW.name <> '' AND NEW.waterway = 'river' THEN
         INSERT INTO waterway_important.changes(is_old, name, name_en, name_de, tags)
-        VALUES (FALSE, NEW.name, NEW.name_en, NEW.name_de, slice_language_tags(NEW.tags))
+        VALUES (FALSE, NEW.name, NEW.name_en, NEW.name_de, slice_language_tags(NEW.tags));
-        ON CONFLICT(is_old, name, name_en, name_de, tags) DO NOTHING;
     END IF;
     RETURN NULL;
 END;
@@ -106,7 +113,7 @@ $$ LANGUAGE plpgsql;
 CREATE TABLE IF NOT EXISTS waterway_important.updates
 (
     id serial PRIMARY KEY,
-    t  text,
+    t text,
     UNIQUE (t)
 );
 CREATE OR REPLACE FUNCTION waterway_important.flag() RETURNS trigger AS
@@ -119,15 +126,40 @@ $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE FUNCTION waterway_important.refresh() RETURNS trigger AS
 $$
+DECLARE
+    t TIMESTAMP WITH TIME ZONE := clock_timestamp();
 BEGIN
     RAISE LOG 'Refresh waterway';
 
     -- REFRESH osm_important_waterway_linestring
+
+    -- Compact the change history to keep only the first and last version, and then uniq version of row
+    CREATE TEMP TABLE changes_compact AS
+    SELECT DISTINCT ON (name, name_en, name_de, tags)
+        name,
+        name_en,
+        name_de,
+        tags
+    FROM ((
+              SELECT DISTINCT ON (osm_id) *
+              FROM waterway_important.changes
+              WHERE is_old
+              ORDER BY osm_id,
+                       id ASC
+          )
+          UNION ALL
+          (
+              SELECT DISTINCT ON (osm_id) *
+              FROM waterway_important.changes
+              WHERE NOT is_old
+              ORDER BY osm_id,
+                       id DESC
+          )) AS t;
+
     DELETE
     FROM osm_important_waterway_linestring AS w
-        USING waterway_important.changes AS c
+        USING changes_compact AS c
-    WHERE c.is_old
+    WHERE w.name = c.name
-      AND w.name = c.name
       AND w.name_en IS NOT DISTINCT FROM c.name_en
       AND w.name_de IS NOT DISTINCT FROM c.name_de
       AND w.tags IS NOT DISTINCT FROM c.tags;
@@ -143,72 +175,34 @@ BEGIN
                     w.name,
                     w.name_en,
                     w.name_de,
-                    slice_language_tags(w.tags)      AS tags
+                    slice_language_tags(w.tags) AS tags
              FROM osm_waterway_linestring AS w
-                      JOIN waterway_important.changes AS c ON
+                      JOIN changes_compact AS c ON
                      w.name = c.name AND w.name_en IS NOT DISTINCT FROM c.name_en AND
                      w.name_de IS NOT DISTINCT FROM c.name_de AND
                      slice_language_tags(w.tags) IS NOT DISTINCT FROM c.tags
              WHERE w.name <> ''
                AND w.waterway = 'river'
                AND ST_IsValid(geometry)
-               AND NOT c.is_old
              GROUP BY w.name, w.name_en, w.name_de, slice_language_tags(w.tags)
          ) AS waterway_union;
 
-    -- REFRESH sm_important_waterway_linestring_gen1
+    -- REFRESH osm_important_waterway_linestring_gen_z11
-    DELETE
+    REFRESH MATERIALIZED VIEW osm_important_waterway_linestring_gen_z11;
-    FROM osm_important_waterway_linestring_gen1 AS w
-        USING waterway_important.changes AS c
-    WHERE c.is_old
-      AND w.name = c.name
-      AND w.name_en IS NOT DISTINCT FROM c.name_en
-      AND w.name_de IS NOT DISTINCT FROM c.name_de
-      AND w.tags IS NOT DISTINCT FROM c.tags;
 
-    INSERT INTO osm_important_waterway_linestring_gen1
+    -- REFRESH osm_important_waterway_linestring_gen_z10
-    SELECT w.*
+    REFRESH MATERIALIZED VIEW osm_important_waterway_linestring_gen_z10;
-    FROM osm_important_waterway_linestring_gen1_view AS w
-             NATURAL JOIN waterway_important.changes AS c
-    WHERE NOT c.is_old;
 
-    -- REFRESH osm_important_waterway_linestring_gen2
+    -- REFRESH osm_important_waterway_linestring_gen_z9
-    DELETE
+    REFRESH MATERIALIZED VIEW osm_important_waterway_linestring_gen_z9;
-    FROM osm_important_waterway_linestring_gen2 AS w
-        USING waterway_important.changes AS c
-    WHERE c.is_old
-      AND w.name = c.name
-      AND w.name_en IS NOT DISTINCT FROM c.name_en
-      AND w.name_de IS NOT DISTINCT FROM c.name_de
-      AND w.tags IS NOT DISTINCT FROM c.tags;
-
-    INSERT INTO osm_important_waterway_linestring_gen2
-    SELECT w.*
-    FROM osm_important_waterway_linestring_gen2_view AS w
-             NATURAL JOIN waterway_important.changes AS c
-    WHERE NOT c.is_old;
-
-    -- REFRESH osm_important_waterway_linestring_gen3
-    DELETE
-    FROM osm_important_waterway_linestring_gen3 AS w
-        USING waterway_important.changes AS c
-    WHERE c.is_old
-      AND w.name = c.name
-      AND w.name_en IS NOT DISTINCT FROM c.name_en
-      AND w.name_de IS NOT DISTINCT FROM c.name_de
-      AND w.tags IS NOT DISTINCT FROM c.tags;
-
-    INSERT INTO osm_important_waterway_linestring_gen3
-    SELECT w.*
-    FROM osm_important_waterway_linestring_gen3_view AS w
-             NATURAL JOIN waterway_important.changes AS c
-    WHERE NOT c.is_old;
 
+    DROP TABLE changes_compact;
     -- noinspection SqlWithoutWhere
     DELETE FROM waterway_important.changes;
     -- noinspection SqlWithoutWhere
     DELETE FROM waterway_important.updates;
 
+    RAISE LOG 'Refresh waterway done in %', age(clock_timestamp(), t);
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;

layers/waterway/update_waterway_linestring.sql

@@ -6,15 +6,6 @@ $$
     BEGIN
         UPDATE osm_waterway_linestring
         SET tags = update_tags(tags, geometry);
-
-        UPDATE osm_waterway_linestring_gen1
-        SET tags = update_tags(tags, geometry);
-
-        UPDATE osm_waterway_linestring_gen2
-        SET tags = update_tags(tags, geometry);
-
-        UPDATE osm_waterway_linestring_gen3
-        SET tags = update_tags(tags, geometry);
     END
 $$;
 

layers/waterway/waterway.sql

@@ -7,56 +7,206 @@ SELECT CASE
 $$ LANGUAGE SQL IMMUTABLE
                 STRICT
                 PARALLEL SAFE;
-
+-- ne_110m_rivers_lake_centerlines
--- etldoc: ne_110m_rivers_lake_centerlines ->  waterway_z3
+-- etldoc: ne_110m_rivers_lake_centerlines ->  ne_110m_rivers_lake_centerlines_gen_z3
-CREATE OR REPLACE VIEW waterway_z3 AS
+DROP MATERIALIZED VIEW IF EXISTS ne_110m_rivers_lake_centerlines_gen_z3 CASCADE;
+CREATE MATERIALIZED VIEW ne_110m_rivers_lake_centerlines_gen_z3 AS
 (
-SELECT geometry,
+SELECT ST_Simplify(geometry, ZRes(5)) as geometry,
        'river'::text AS class,
-       NULL::text    AS name,
+       NULL::text AS name,
-       NULL::text    AS name_en,
+       NULL::text AS name_en,
-       NULL::text    AS name_de,
+       NULL::text AS name_de,
-       NULL::hstore  AS tags,
+       NULL::hstore AS tags,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
 FROM ne_110m_rivers_lake_centerlines
 WHERE featurecla = 'River'
-    );
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_110m_rivers_lake_centerlines_gen_z3_idx ON ne_110m_rivers_lake_centerlines_gen_z3 USING gist (geometry);
 
--- etldoc: ne_50m_rivers_lake_centerlines ->  waterway_z4
+-- ne_50m_rivers_lake_centerlines
-CREATE OR REPLACE VIEW waterway_z4 AS
+-- etldoc: ne_50m_rivers_lake_centerlines ->  ne_50m_rivers_lake_centerlines_gen_z5
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_rivers_lake_centerlines_gen_z5 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_rivers_lake_centerlines_gen_z5 AS
 (
-SELECT geometry,
+SELECT ST_Simplify(geometry, ZRes(7)) as geometry,
        'river'::text AS class,
-       NULL::text    AS name,
+       NULL::text AS name,
-       NULL::text    AS name_en,
+       NULL::text AS name_en,
-       NULL::text    AS name_de,
+       NULL::text AS name_de,
-       NULL::hstore  AS tags,
+       NULL::hstore AS tags,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
 FROM ne_50m_rivers_lake_centerlines
 WHERE featurecla = 'River'
-    );
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_rivers_lake_centerlines_gen_z5_idx ON ne_50m_rivers_lake_centerlines_gen_z5 USING gist (geometry);
 
--- etldoc: ne_10m_rivers_lake_centerlines ->  waterway_z6
+-- etldoc: ne_50m_rivers_lake_centerlines_gen_z5 ->  ne_50m_rivers_lake_centerlines_gen_z4
-CREATE OR REPLACE VIEW waterway_z6 AS
+DROP MATERIALIZED VIEW IF EXISTS ne_50m_rivers_lake_centerlines_gen_z4 CASCADE;
+CREATE MATERIALIZED VIEW ne_50m_rivers_lake_centerlines_gen_z4 AS
 (
-SELECT geometry,
+SELECT ST_Simplify(geometry, ZRes(6)) as geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_50m_rivers_lake_centerlines_gen_z5
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_50m_rivers_lake_centerlines_gen_z4_idx ON ne_50m_rivers_lake_centerlines_gen_z4 USING gist (geometry);
+
+-- ne_10m_rivers_lake_centerlines
+-- etldoc: ne_10m_rivers_lake_centerlines ->  ne_10m_rivers_lake_centerlines_gen_z8
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_rivers_lake_centerlines_gen_z8 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_rivers_lake_centerlines_gen_z8 AS
+(
+SELECT ST_Simplify(geometry, ZRes(10)) as geometry,
        'river'::text AS class,
-       NULL::text    AS name,
+       NULL::text AS name,
-       NULL::text    AS name_en,
+       NULL::text AS name_en,
-       NULL::text    AS name_de,
+       NULL::text AS name_de,
-       NULL::hstore  AS tags,
+       NULL::hstore AS tags,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
 FROM ne_10m_rivers_lake_centerlines
 WHERE featurecla = 'River'
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_rivers_lake_centerlines_gen_z8_idx ON ne_10m_rivers_lake_centerlines_gen_z8 USING gist (geometry);
+
+-- etldoc: ne_10m_rivers_lake_centerlines_gen_z8 ->  ne_10m_rivers_lake_centerlines_gen_z7
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_rivers_lake_centerlines_gen_z7 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_rivers_lake_centerlines_gen_z7 AS
+(
+SELECT ST_Simplify(geometry, ZRes(9)) as geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_10m_rivers_lake_centerlines_gen_z8
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_rivers_lake_centerlines_gen_z7_idx ON ne_10m_rivers_lake_centerlines_gen_z7 USING gist (geometry);
+
+-- etldoc: ne_10m_rivers_lake_centerlines_gen_z7 ->  ne_10m_rivers_lake_centerlines_gen_z6
+DROP MATERIALIZED VIEW IF EXISTS ne_10m_rivers_lake_centerlines_gen_z6 CASCADE;
+CREATE MATERIALIZED VIEW ne_10m_rivers_lake_centerlines_gen_z6 AS
+(
+SELECT ST_Simplify(geometry, ZRes(8)) as geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_10m_rivers_lake_centerlines_gen_z7
+    ) /* DELAY_MATERIALIZED_VIEW_CREATION */ ;
+CREATE INDEX IF NOT EXISTS ne_10m_rivers_lake_centerlines_gen_z6_idx ON ne_10m_rivers_lake_centerlines_gen_z6 USING gist (geometry);
+
+
+-- etldoc: ne_110m_rivers_lake_centerlines_gen_z3 ->  waterway_z3
+CREATE OR REPLACE VIEW waterway_z3 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_110m_rivers_lake_centerlines_gen_z3
     );
 
--- etldoc: osm_important_waterway_linestring_gen3 ->  waterway_z9
+-- etldoc: ne_50m_rivers_lake_centerlines_gen_z4 ->  waterway_z4
+CREATE OR REPLACE VIEW waterway_z4 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_50m_rivers_lake_centerlines_gen_z4
+    );
+
+-- etldoc: ne_50m_rivers_lake_centerlines_gen_z5 ->  waterway_z5
+CREATE OR REPLACE VIEW waterway_z5 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_50m_rivers_lake_centerlines_gen_z5
+    );
+
+-- etldoc: ne_10m_rivers_lake_centerlines_gen_z6 ->  waterway_z6
+CREATE OR REPLACE VIEW waterway_z6 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_10m_rivers_lake_centerlines_gen_z6
+    );
+
+-- etldoc: ne_10m_rivers_lake_centerlines_gen_z7 ->  waterway_z7
+CREATE OR REPLACE VIEW waterway_z7 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_10m_rivers_lake_centerlines_gen_z7
+    );
+
+    -- etldoc: ne_10m_rivers_lake_centerlines_gen_z8 ->  waterway_z8
+CREATE OR REPLACE VIEW waterway_z8 AS
+(
+SELECT geometry,
+       class,
+       name,
+       name_en,
+       name_de,
+       tags,
+       is_bridge,
+       is_tunnel,
+       is_intermittent
+FROM ne_10m_rivers_lake_centerlines_gen_z8
+    );
+
+-- etldoc: osm_important_waterway_linestring_gen_z9 ->  waterway_z9
 CREATE OR REPLACE VIEW waterway_z9 AS
 (
 SELECT geometry,
@@ -68,10 +218,10 @@ SELECT geometry,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
-FROM osm_important_waterway_linestring_gen3
+FROM osm_important_waterway_linestring_gen_z9
     );
 
--- etldoc: osm_important_waterway_linestring_gen2 ->  waterway_z10
+-- etldoc: osm_important_waterway_linestring_gen_z10 ->  waterway_z10
 CREATE OR REPLACE VIEW waterway_z10 AS
 (
 SELECT geometry,
@@ -83,10 +233,10 @@ SELECT geometry,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
-FROM osm_important_waterway_linestring_gen2
+FROM osm_important_waterway_linestring_gen_z10
     );
 
--- etldoc:osm_important_waterway_linestring_gen1 ->  waterway_z11
+-- etldoc:osm_important_waterway_linestring_gen_z11 ->  waterway_z11
 CREATE OR REPLACE VIEW waterway_z11 AS
 (
 SELECT geometry,
@@ -98,7 +248,7 @@ SELECT geometry,
        NULL::boolean AS is_bridge,
        NULL::boolean AS is_tunnel,
        NULL::boolean AS is_intermittent
-FROM osm_important_waterway_linestring_gen1
+FROM osm_important_waterway_linestring_gen_z11
     );
 
 -- etldoc: osm_waterway_linestring ->  waterway_z12
@@ -149,7 +299,7 @@ FROM osm_waterway_linestring
     );
 
 -- etldoc: layer_waterway[shape=record fillcolor=lightpink, style="rounded,filled",
--- etldoc:     label="layer_waterway | <z3> z3 |<z4_5> z4-z5 |<z6_8> z6-8 | <z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14> z14+" ];
+-- etldoc: label="layer_waterway | <z3> z3 |<z4> z4 |<z5> z5 |<z6> z6 |<z7> z7 |<z8> z8 | <z9> z9 |<z10> z10 |<z11> z11 |<z12> z12|<z13> z13|<z14> z14+" ];
 
 CREATE OR REPLACE FUNCTION layer_waterway(bbox geometry, zoom_level int)
     RETURNS TABLE
@@ -167,11 +317,11 @@ AS
 $$
 SELECT geometry,
        class,
-       NULLIF(name, '')                             AS name,
+       NULLIF(name, '') AS name,
-       COALESCE(NULLIF(name_en, ''), name)          AS name_en,
+       COALESCE(NULLIF(name_en, ''), name) AS name_en,
        COALESCE(NULLIF(name_de, ''), name, name_en) AS name_de,
-       waterway_brunnel(is_bridge, is_tunnel)       AS brunnel,
+       waterway_brunnel(is_bridge, is_tunnel) AS brunnel,
-       is_intermittent::int                         AS intermittent,
+       is_intermittent::int AS intermittent,
        tags
 FROM (
          -- etldoc: waterway_z3 ->  layer_waterway:z3
@@ -179,15 +329,30 @@ FROM (
          FROM waterway_z3
          WHERE zoom_level = 3
          UNION ALL
-         -- etldoc: waterway_z4 ->  layer_waterway:z4_5
+         -- etldoc: waterway_z4 ->  layer_waterway:z4
          SELECT *
          FROM waterway_z4
-         WHERE zoom_level BETWEEN 4 AND 5
+         WHERE zoom_level = 4
          UNION ALL
-         -- etldoc: waterway_z6 ->  layer_waterway:z6_8
+         -- etldoc: waterway_z5 ->  layer_waterway:z5
+         SELECT *
+         FROM waterway_z5
+         WHERE zoom_level = 5
+         UNION ALL
+         -- etldoc: waterway_z6 ->  layer_waterway:z6
          SELECT *
          FROM waterway_z6
-         WHERE zoom_level BETWEEN 6 AND 8
+         WHERE zoom_level = 6
+         UNION ALL
+         -- etldoc: waterway_z7 ->  layer_waterway:z7
+         SELECT *
+         FROM waterway_z7
+         WHERE zoom_level = 7
+         UNION ALL
+         -- etldoc: waterway_z8 ->  layer_waterway:z8
+         SELECT *
+         FROM waterway_z8
+         WHERE zoom_level = 8
          UNION ALL
          -- etldoc: waterway_z9 ->  layer_waterway:z9
          SELECT *

openmaptiles.yaml

@@ -18,11 +18,11 @@ tileset:
     - layers/landmarks/landmark.yaml
     - layers/aerodrome_label/aerodrome_label.yaml
   name: OpenMapTiles
-  version: 3.11.0
+  version: 3.12.1
   id: openmaptiles
   description: "A tileset showcasing all layers in OpenMapTiles. https://openmaptiles.org"
   attribution: '<a href="https://www.openmaptiles.org/" target="_blank">&copy; OpenMapTiles</a> <a href="https://www.openstreetmap.org/copyright" target="_blank">&copy; OpenStreetMap contributors</a>'
-  center: [-12.2168, 28.6135, 4]
+  center: [0, 0, 1]
   bounds: [-180.0,-85.0511,180.0,85.0511]
   maxzoom: 14
   minzoom: 0
@@ -53,6 +53,7 @@ tileset:
     - ga # Irish, Latin
     - gd # Scottish Gaelic, Latin
     - he # Hebrew
+    - hi # Hindi
     - hr # Croatian, Latin
     - hu # Hungarian, Latin
     - hy # Armenian
@@ -62,11 +63,13 @@ tileset:
     - ja # Japanese
     - ja_kana # Japanese Kana form
     - ja_rm # romanization of Japanese, Latin
+    - ja-Latn # romanisation of Japanese, Latin since 2018
+    - ja-Hira # Japanese Hiragana form
     - ka # Georgian
     - kk # Kazakh
     - kn # Kannada
     - ko # Korean
-    - ko_rm # romanization of Korean, Latin
+    - ko-Latn # romanization of Korean, Latin
     - ku # Kurdish, Latin
     - la # Latin, Latin
     - lb # Luxembourgish, Latin
@@ -89,6 +92,8 @@ tileset:
     - sr # Serbian, Cyrillic
     - sr-Latn # Serbian, Latin
     - sv # Swedish, Latin
+    - ta # Tamil
+    - te # Telugu
     - th # Thai
     - tr # Turkish, Latin
     - uk # Ukrainian

qa/layer_freq.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-set -o errexit
-set -o pipefail
-set -o nounset
-
-layerid=$1
-classvars=$2
-
-echo "# FREQ - $layerid  group by : $classvars "
-
-for z in {0..15}
-do
-echo " "
-echo "## $layerid z$z  - freq"
-
-SQL=$(docker-compose run --rm openmaptiles-tools generate-sqlquery  layers/${layerid}/${layerid}.yaml $z )
-
-SQLCODE=$(cat <<-END
-select $classvars , count(*) as _count_ from
-( $SQL ) as t
-GROUP BY $classvars
-ORDER BY $classvars
-;
-END
-)
-
-#echo "\`\`\`sql"
-#echo "$SQLCODE"
-#echo "\`\`\`"
-
-docker-compose run --rm import-osm /usr/src/app/psql.sh -q -P pager=off -P border=2 -P footer=off -P null='(null)' -c "$SQLCODE" \
-   | sed '1d;$d'  | sed '$d' | sed 's/+--/|--/g' | sed 's/--+/--|/g'
-
-done
-

qa/layer_numvar_analyze.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-set -o errexit
-set -o pipefail
-set -o nounset
-
-layerid=$1
-var=$2
-
-echo "# NUMVAR-ANALYZE - $layerid  - $var "
-
-for z in {0..15}
-do
-echo " "
-echo "## $layerid z$z - $var "
-
-SQL=$(docker-compose run --rm openmaptiles-tools generate-sqlquery  layers/${layerid}/${layerid}.yaml $z )
-
-SQLCODE=$(cat <<-END
-SELECT
-   count($var)    as count
-  ,min($var)      as min
-  ,max($var)      as max
-  ,avg($var)      as avg
-  ,stddev($var)   as stddev
-  ,variance($var) as variance
-FROM
-( $SQL ) as t
-;
-END
-)
-
-
-#echo "\`\`\`sql"
-#echo "$SQLCODE"
-#echo "\`\`\`"
-
-docker-compose run --rm import-osm /usr/src/app/psql.sh -q -P pager=off -P border=2 -P footer=off -P null='(null)' -c "$SQLCODE" \
-   | sed '1d;$d'  | sed '$d' | sed 's/+--/|--/g' | sed 's/--+/--|/g'
-
-done

qa/layer_toplength.sh

@@ -1,34 +0,0 @@
-#!/bin/bash
-set -o errexit
-set -o pipefail
-set -o nounset
-
-layerid=$1
-classvar=$2
-
-for z in {0..15}
-do
-echo " "
-echo "## $layerid z$z   max length ($classvar)"
-
-SQL=$(docker-compose run --rm openmaptiles-tools generate-sqlquery  layers/${layerid}/${layerid}.yaml $z )
-
-SQLCODE=$(cat <<-END
-SELECT DISTINCT $classvar , length( $classvar ) AS _length_ from
-( $SQL ) as t
-WHERE length( $classvar ) > 0
-ORDER BY length( $classvar ) DESC NULLS LAST
-LIMIT 30
-;
-END
-)
-
-#echo "\`\`\`sql"
-#echo "$SQLCODE"
-#echo "\`\`\`"
-
-docker-compose run --rm import-osm /usr/src/app/psql.sh -q -P pager=off -P border=2 -P footer=off -P null='(null)' -c "$SQLCODE" \
-   | sed '1d;$d'  | sed '$d' | sed 's/+--/|--/g' | sed 's/--+/--|/g'
-
-done
-

qa/run.sh

@@ -1,83 +0,0 @@
-#!/bin/bash
-set -o errexit
-set -o pipefail
-set -o nounset
-
-#  example call from the parent folder :  ./qa/run.sh
-#                                    or    make generate-qareports
-
-# ---- freq ---------------------------------------------------------------
-
-mkdir -p ./build/qareports
-rm -f    ./build/qareports/*.md
-
-# -----
-
-./qa/layer_freq.sh aeroway             "class"                    > ./build/qareports/freq_aeroway__class.md
-
-###Todo:./qa/layer_freq.sh boundary            "admin_level,disputed"     > ./build/qareports/freq_boundary__admin_level_disputed.md
-./qa/layer_freq.sh boundary            "admin_level"              > ./build/qareports/freq_boundary__admin_level.md
-###Todo: ./qa/layer_freq.sh boundary            "disputed"                 > ./build/qareports/freq_boundary__disputed.md
-
-./qa/layer_freq.sh building            "render_min_height"        > ./build/qareports/freq_building__render_min_height.md
-
-#./qa/layer_freq.sh housenumber         "housenumber "        > ./build/qadocfreq_housenumber.md
-./qa/layer_freq.sh landcover           "class, subclass"      > ./build/qareports/freq_landcover__class_subclass.md
-
-./qa/layer_freq.sh landuse             "class "               > ./build/qareports/freq_landuse__class.md
-
-./qa/layer_freq.sh park                "class "               > ./build/qareports/freq_park__class.md
-
-./qa/layer_freq.sh place               "class "               > ./build/qareports/freq_place__class.md
-./qa/layer_freq.sh place               "class,capital "       > ./build/qareports/freq_place__class_capital.md
-./qa/layer_freq.sh place               "capital "             > ./build/qareports/freq_place__capital.md
-./qa/layer_freq.sh place               "class,capital,rank "  > ./build/qareports/freq_place__class_capital_rank.md
-./qa/layer_freq.sh place               "rank "                > ./build/qareports/freq_place__rank.md
-
-./qa/layer_freq.sh poi                 "class    "            > ./build/qareports/freq_poi__class.md
-./qa/layer_freq.sh poi                 "subclass "            > ./build/qareports/freq_poi__subclass.md
-./qa/layer_freq.sh poi                 "rank     "            > ./build/qareports/freq_poi__rank.md
-./qa/layer_freq.sh poi                 "class,subclass "      > ./build/qareports/freq_poi__class_subclass.md
-./qa/layer_freq.sh poi                 "class,subclass,rank"  > ./build/qareports/freq_poi__class_subclass_rank.md
-./qa/layer_freq.sh poi                 "class,rank         "  > ./build/qareports/freq_poi__class_rank.md
-
-./qa/layer_freq.sh transportation      "class, oneway, ramp, brunnel, service"    > ./build/qareports/freq_transportation__class_oneway_ramp_brunnel_service.md
-./qa/layer_freq.sh transportation      "oneway, ramp, brunnel, service "          > ./build/qareports/freq_transportation__oneway_ramp_brunnel_service.md
-./qa/layer_freq.sh transportation      "class "                                   > ./build/qareports/freq_transportation__class.md
-
-./qa/layer_freq.sh transportation_name "class "               > ./build/qareports/freq_transportation_name__class.md
-./qa/layer_freq.sh transportation_name "ref_length"           > ./build/qareports/freq_transportation_name__ref_length.md
-
-./qa/layer_freq.sh water               "class "               > ./build/qareports/freq_water__class.md
-
-./qa/layer_freq.sh water_name          "class "               > ./build/qareports/freq_water_name__class.md
-
-./qa/layer_freq.sh waterway            "class "               > ./build/qareports/freq_waterway__class.md
-
-# ---- toplength -------------------------------------------
-
-./qa/layer_toplength.sh housenumber         "housenumber"   > ./build/qareports/toplength_housenumber__housenumber.md
-
-./qa/layer_toplength.sh place               "name"          > ./build/qareports/toplength_place__name.md
-./qa/layer_toplength.sh place               "name_en"       > ./build/qareports/toplength_place__name_en.md
-
-./qa/layer_toplength.sh poi                 "name"          > ./build/qareports/toplength_poi__name.md
-./qa/layer_toplength.sh poi                 "name_en"       > ./build/qareports/toplength_poi__name_en.md
-
-./qa/layer_toplength.sh transportation_name "name"          > ./build/qareports/toplength_transportation_name__name.md
-./qa/layer_toplength.sh transportation_name "ref"           > ./build/qareports/toplength_transportation_name__ref.md
-###Todo: ./qa/layer_toplength.sh transportation_name "network"       > ./build/qareports/toplength_transportation_name__network.md
-
-./qa/layer_toplength.sh water_name          "name"          > ./build/qareports/toplength_water_name__name.md
-./qa/layer_toplength.sh water_name          "name_en"       > ./build/qareports/toplength_water_name__name_en.md
-
-./qa/layer_toplength.sh waterway            "name"          > ./build/qareports/toplength_waterway__name.md
-
-
-# ---- numvar analyze -------------------------------------
-
-./qa/layer_numvar_analyze.sh building             "render_min_height"  > ./build/qareports/numvara_building__render_min_height.md
-./qa/layer_numvar_analyze.sh building             "render_height"      > ./build/qareports/numvara_building__render_height.md
-
-./qa/layer_numvar_analyze.sh transportation_name  "ref_length"         > ./build/qareports/numvara_transportation_name__ref_length.md
-

qa/table_sizes.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python
-import sys
-import argparse
-import subprocess
-
-parser = argparse.ArgumentParser()
-parser.add_argument('--noan', action='store_true', help='Not to run make psql-analyze')
-
-TOTAL_SIZE_SQL = """SELECT
-  pg_size_pretty(sum(size)) AS size
-FROM (
-  SELECT
-    relname as "Table",
-    pg_total_relation_size(relid) as "size"
-  FROM pg_catalog.pg_statio_user_tables
-  WHERE schemaname='public'
-) a
-;""".replace('\"', '\\\"')
-
-TABLE_SIZES_SQL = """SELECT
-  a.relname as "table",
-  pg_table_size(a.relid) as "size",
-  b.n_live_tup as "rows"
-FROM pg_catalog.pg_statio_user_tables a
-  LEFT JOIN pg_stat_user_tables b ON (a.relid = b.relid)
-WHERE
-  a.schemaname='public'
-ORDER BY a.relname;
-""".replace('\"', '\\\"')
-
-TABLES_SQL = """SELECT
-  a.relname
-FROM pg_catalog.pg_statio_user_tables a
-WHERE
-  a.schemaname='public'
-ORDER BY a.relname;
-"""
-
-COLUMN_NAMES_SQL = """SELECT a.attname
-FROM pg_class As c
-  INNER JOIN pg_attribute As a ON c.oid = a.attrelid
-  LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_tablespace t ON t.oid = c.reltablespace
-WHERE
-  c.relkind IN('r', 'v', 'm') AND
-  a.attnum > 0 AND
-  n.nspname = 'public' AND
-  c.relname = '{0}' AND
-  a.attisdropped = FALSE
-ORDER BY a.attname;
-"""
-
-COLUMNS_SQL = """select
-    sum(pg_column_size(t.*)) as "all",
-    {0}
-from {1} t;
-""".replace('\"', '\\\"')
-
-
-def print_column_sizes(tables):
-    for table in tables:
-        print("Column sizes of table " + table)
-        cmds = [
-            'docker-compose run --rm import-osm',
-            '/usr/src/app/psql.sh -t -A -F\",\" -P pager=off',
-            '-c \"' + COLUMN_NAMES_SQL.format(table).replace('\n', ' ').replace('\r',
-                                                                                '') + '\"'
-        ]
-        # print " ".join(cmds)
-        output = subprocess.check_output(" ".join(cmds), shell=True)
-        columns = filter(lambda c: len(c) > 0,
-                         map(lambda l: l.strip(), output.split('\n')))
-
-        # print columns
-
-        col_sql = ",\n".join(
-            map(lambda c: "sum(pg_column_size(\\\"" + c + "\\\")) as \\\"" + c + "\\\"",
-                columns))
-
-        # print COLUMNS_SQL.format(col_sql, table);
-
-        cmds = [
-            'docker-compose run --rm import-osm',
-            '/usr/src/app/psql.sh -F\",\" --no-align -P pager=off',
-            '-c \"' + COLUMNS_SQL.format(col_sql, table).replace('\n', ' ').replace(
-                '\r', '') + '\"'
-        ]
-        # print " ".join(cmds)
-        col_csv = subprocess.check_output(" ".join(cmds), shell=True)
-        print(col_csv)
-
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-
-    try:
-
-        if not args.noan:
-            print("Running make psql-analyze")
-            subprocess.check_output("make psql-analyze", shell=True)
-
-        print("Total size of tables")
-        cmds = [
-            'docker-compose run --rm import-osm',
-            '/usr/src/app/psql.sh -F\",\" --no-align -P pager=off',
-            '-c \"' + TOTAL_SIZE_SQL.replace('\n', ' ').replace('\r', '') + '\"'
-        ]
-        # print " ".join(cmds)
-        TOTAL_SIZE_CSV = subprocess.check_output(" ".join(cmds), shell=True)
-        print(TOTAL_SIZE_CSV)
-        print("\n")
-
-        print("Table sizes")
-        cmds = [
-            'docker-compose run --rm import-osm',
-            '/usr/src/app/psql.sh -F\",\" --no-align -P pager=off',
-            '-c \"' + TABLE_SIZES_SQL.replace('\n', ' ').replace('\r', '') + '\"'
-        ]
-        # print " ".join(cmds)
-        TABLE_SIZES_CSV = subprocess.check_output(" ".join(cmds), shell=True)
-        print(TABLE_SIZES_CSV)
-        print("\n")
-
-        print("Column sizes")
-        cmds = [
-            'docker-compose run --rm import-osm',
-            '/usr/src/app/psql.sh -t -A -F\",\" -P pager=off',
-            '-c \"' + TABLES_SQL.replace('\n', ' ').replace('\r', '') + '\"'
-        ]
-        # print " ".join(cmds)
-        output = subprocess.check_output(" ".join(cmds), shell=True)
-        tables = filter(lambda t: len(t) > 0,
-                        map(lambda l: l.strip(), output.split('\n')))
-
-        print_column_sizes(tables);
-
-        # print tables
-    except subprocess.CalledProcessError as e:
-        print("Error:\n", e.output)
-    sys.exit(0)

quickstart.sh

@@ -83,7 +83,7 @@ function version { echo "$@" | tr -cs '0-9.' '.' | awk -F. '{ printf("%03d%03d%0
 
 COMPOSE_VER=$(docker-compose version --short)
 if [ "$(version "$COMPOSE_VER")" -lt "$(version "$MIN_COMPOSE_VER")" ]; then
-  echo "ERR: Your Docker-compose version is Known to have bugs , Please Update docker-compose!"
+  echo "ERR: Your Docker-compose version is known to have bugs, please update docker-compose!"
   exit 1
 fi
 
@@ -109,8 +109,8 @@ echo "--------------------------------------------------------------------------
 echo "====> : OpenMapTiles quickstart! [ https://github.com/openmaptiles/openmaptiles ]    "
 echo "      : This will be logged to the $log_file file (for debugging) and to the screen"
 echo "      : Area             : $area "
-echo "      : Download Server  : ${osm_server:-unset (automatic)} "
+echo "      : Download server  : ${osm_server:-unset (automatic)} "
-echo "      : Preloaded Image  : $USE_PRELOADED_IMAGE "
+echo "      : Preloaded image  : $USE_PRELOADED_IMAGE "
 echo "      : Git version      : $(git rev-parse HEAD) "
 echo "      : Started          : $STARTDATE "
 echo "      : Your bash version: $BASH_VERSION"
@@ -132,9 +132,9 @@ if [[ "$OSTYPE" == "linux-gnu" ]]; then
     fi
     echo "      : --- Memory, CPU info ---- "
     mem=$( grep MemTotal /proc/meminfo | awk '{print $2}' | xargs -I {} echo "scale=4; {}/1024^2" | bc )
-    echo "system memory (GB): ${mem}"
+    echo "System memory (GB): ${mem}"
     grep SwapTotal /proc/meminfo
-    echo "cpu number: $(grep -c processor /proc/cpuinfo) x $(grep "bogomips" /proc/cpuinfo | head -1)"
+    echo "CPU number: $(grep -c processor /proc/cpuinfo) x $(grep "bogomips" /proc/cpuinfo | head -1)"
     grep Free /proc/meminfo
 else
     echo " "
@@ -200,7 +200,7 @@ if [[ "$USE_PRELOADED_IMAGE" == true ]]; then
   echo "      :   make import-data"
   echo "      :"
   echo "      : Source code: https://github.com/openmaptiles/openmaptiles-tools/tree/master/docker/postgis-preloaded"
-  echo "      : Thank you: https://www.postgresql.org !  Thank you http://postgis.org !"
+  echo "      : Thank you https://www.postgresql.org !  Thank you http://postgis.org !"
   make start-db-preloaded
 else
   echo "====> : Start PostgreSQL service using empty database and importing all the data:"
@@ -213,7 +213,7 @@ else
   echo "      : Source code: https://github.com/openmaptiles/openmaptiles-tools/tree/master/docker/import-data"
   echo "      :   includes all data from the import-data image"
   echo "      :"
-  echo "      : Thank you: https://www.postgresql.org !  Thank you http://postgis.org !"
+  echo "      : Thank you https://www.postgresql.org !  Thank you http://postgis.org !"
   make start-db
   make import-data
 fi
@@ -233,7 +233,7 @@ echo "--------------------------------------------------------------------------
 echo "====> : Start importing border ${area} data into PostgreSQL using osmborder"
 echo "      : Source code: https://github.com/pnorman/osmborder"
 echo "      : Data license: http://www.openstreetmap.org/copyright"
-echo "      : Thank you: Paul Norman"
+echo "      : Thank you Paul Norman"
 make import-borders
 
 echo " "
@@ -263,11 +263,17 @@ make test-perf-null
 
 echo " "
 echo "-------------------------------------------------------------------------------------"
-if [[ "$area" != "planet" ]]; then
+
-  echo "====> : Compute bounding box for tile generation"
+if [[ "$(source .env ; echo "$BBOX")" = "-180.0,-85.0511,180.0,85.0511" ]]; then
-  make generate-dc-config
+  if [[ "$area" != "planet" ]]; then
+    echo "====> : Compute bounding box for tile generation"
+    make generate-bbox-file ${MIN_ZOOM:+MIN_ZOOM="${MIN_ZOOM}"} ${MAX_ZOOM:+MAX_ZOOM="${MAX_ZOOM}"}
+  else
+    echo "====> : Skipping bbox calculation when generating the entire planet"
+  fi
+
 else
-  echo "====> : Skipping bbox calculation when generating the entire planet"
+  echo "====> : Bounding box is set in .env file"
 fi
 
 echo " "
@@ -322,10 +328,10 @@ ls -la ./data
 echo " "
 echo "-------------------------------------------------------------------------------------"
 echo "The ./quickstart.sh $area  is finished! "
-echo "It takes $((ENDTIME - STARTTIME)) seconds to complete"
+echo "It took $((ENDTIME - STARTTIME)) seconds to complete"
-echo "We saved the log file to $log_file  ( for debugging ) You can compare with the travis log !"
+echo "We saved the log file to $log_file  (for debugging) You can compare with the travis log !"
 echo " "
-echo "Start experimenting! And check the QUICKSTART.MD file!"
+echo "Start experimenting and check the QUICKSTART.MD file!"
 echo " "
 echo "*  Use   make start-maputnik     to explore tile generation on request"
 echo "*  Use   make start-tileserver   to view pre-generated tiles"