]> git.openstreetmap.org Git - nominatim.git/blob - sql/partition-functions.src.sql
remove unused columns in search_name_* and use right index
[nominatim.git] / sql / partition-functions.src.sql
1 DROP TYPE IF EXISTS nearfeaturecentr CASCADE;
2 CREATE TYPE nearfeaturecentr AS (
3   place_id BIGINT,
4   keywords int[],
5   rank_address smallint,
6   rank_search smallint,
7   distance float,
8   isguess boolean,
9   postcode TEXT,
10   centroid GEOMETRY
11 );
12
13 -- feature intersects geoemtry
14 -- for areas and linestrings they must touch at least along a line
15 CREATE OR REPLACE FUNCTION is_relevant_geometry(de9im TEXT, geom_type TEXT)
16 RETURNS BOOLEAN
17 AS $$
18 BEGIN
19   IF substring(de9im from 1 for 2) != 'FF' THEN
20     RETURN TRUE;
21   END IF;
22
23   IF geom_type = 'ST_Point' THEN
24     RETURN substring(de9im from 4 for 1) = '0';
25   END IF;
26
27   IF geom_type in ('ST_LineString', 'ST_MultiLineString') THEN
28     RETURN substring(de9im from 4 for 1) = '1';
29   END IF;
30
31   RETURN substring(de9im from 4 for 1) = '2';
32 END
33 $$ LANGUAGE plpgsql IMMUTABLE;
34
35 create or replace function getNearFeatures(in_partition INTEGER, feature GEOMETRY, maxrank INTEGER) RETURNS setof nearfeaturecentr AS $$
36 DECLARE
37   r nearfeaturecentr%rowtype;
38 BEGIN
39
40 -- start
41   IF in_partition = -partition- THEN
42     FOR r IN
43       SELECT place_id, keywords, rank_address, rank_search,
44              min(ST_Distance(feature, centroid)) as distance,
45              isguess, postcode, centroid
46       FROM location_area_large_-partition-
47       WHERE geometry && feature
48         AND is_relevant_geometry(ST_Relate(geometry, feature), ST_GeometryType(feature))
49         AND rank_address < maxrank
50       GROUP BY place_id, keywords, rank_address, rank_search, isguess, postcode, centroid
51     LOOP
52       RETURN NEXT r;
53     END LOOP;
54     RETURN;
55   END IF;
56 -- end
57
58   RAISE EXCEPTION 'Unknown partition %', in_partition;
59 END
60 $$
61 LANGUAGE plpgsql STABLE;
62
63 CREATE OR REPLACE FUNCTION get_places_for_addr_tags(in_partition SMALLINT,
64                                                     feature GEOMETRY,
65                                                     address HSTORE, country TEXT)
66   RETURNS SETOF nearfeaturecentr
67   AS $$
68 DECLARE
69   r nearfeaturecentr%rowtype;
70   item RECORD;
71 BEGIN
72   FOR item IN
73     SELECT (get_addr_tag_rank(key, country)).*, key, name FROM
74       (SELECT skeys(address) as key, svals(address) as name) x
75   LOOP
76    IF item.from_rank is null THEN
77      CONTINUE;
78    END IF;
79
80 -- start
81     IF in_partition = -partition- THEN
82         SELECT place_id, keywords, rank_address, rank_search,
83                min(ST_Distance(feature, centroid)) as distance,
84                isguess, postcode, centroid INTO r
85         FROM location_area_large_-partition-
86         WHERE geometry && ST_Expand(feature, item.extent)
87           AND rank_address between item.from_rank and item.to_rank
88           AND word_ids_from_name(item.name) && keywords
89         GROUP BY place_id, keywords, rank_address, rank_search, isguess, postcode, centroid
90         ORDER BY ST_Intersects(ST_Collect(geometry), feature), distance LIMIT 1;
91       IF r.place_id is null THEN
92         -- If we cannot find a place for the term, just return the
93         -- search term for the given name. That ensures that the address
94         -- element can still be searched for, even though it will not be
95         -- displayed.
96         RETURN NEXT ROW(null, addr_ids_from_name(item.name), null, null,
97                         null, null, null, null)::nearfeaturecentr;
98       ELSE
99         RETURN NEXT r;
100       END IF;
101       CONTINUE;
102     END IF;
103 -- end
104
105     RAISE EXCEPTION 'Unknown partition %', in_partition;
106   END LOOP;
107 END;
108 $$
109 LANGUAGE plpgsql STABLE;
110
111 create or replace function deleteLocationArea(in_partition INTEGER, in_place_id BIGINT, in_rank_search INTEGER) RETURNS BOOLEAN AS $$
112 DECLARE
113 BEGIN
114
115   IF in_rank_search <= 4 THEN
116     DELETE from location_area_country WHERE place_id = in_place_id;
117     RETURN TRUE;
118   END IF;
119
120 -- start
121   IF in_partition = -partition- THEN
122     DELETE from location_area_large_-partition- WHERE place_id = in_place_id;
123     RETURN TRUE;
124   END IF;
125 -- end
126
127   RAISE EXCEPTION 'Unknown partition %', in_partition;
128
129   RETURN FALSE;
130 END
131 $$
132 LANGUAGE plpgsql;
133
134 create or replace function insertLocationAreaLarge(
135   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_keywords INTEGER[],
136   in_rank_search INTEGER, in_rank_address INTEGER, in_estimate BOOLEAN, postcode TEXT,
137   in_centroid GEOMETRY, in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
138 DECLARE
139 BEGIN
140   IF in_rank_address = 0 THEN
141     RETURN TRUE;
142   END IF;
143
144   IF in_rank_search <= 4 and not in_estimate THEN
145     INSERT INTO location_area_country (place_id, country_code, geometry)
146       values (in_place_id, in_country_code, in_geometry);
147     RETURN TRUE;
148   END IF;
149
150 -- start
151   IF in_partition = -partition- THEN
152     INSERT INTO location_area_large_-partition- (partition, place_id, country_code, keywords, rank_search, rank_address, isguess, postcode, centroid, geometry)
153       values (in_partition, in_place_id, in_country_code, in_keywords, in_rank_search, in_rank_address, in_estimate, postcode, in_centroid, in_geometry);
154     RETURN TRUE;
155   END IF;
156 -- end
157
158   RAISE EXCEPTION 'Unknown partition %', in_partition;
159   RETURN FALSE;
160 END
161 $$
162 LANGUAGE plpgsql;
163
164 CREATE OR REPLACE FUNCTION getNearestNamedRoadPlaceId(in_partition INTEGER,
165                                                       point GEOMETRY,
166                                                       isin_token INTEGER[])
167   RETURNS BIGINT
168   AS $$
169 DECLARE
170   parent BIGINT;
171 BEGIN
172
173 -- start
174   IF in_partition = -partition- THEN
175     SELECT place_id FROM search_name_-partition-
176       INTO parent
177       WHERE name_vector && isin_token
178             AND centroid && ST_Expand(point, 0.015)
179             AND address_rank between 26 and 27
180       ORDER BY ST_Distance(centroid, point) ASC limit 1;
181     RETURN parent;
182   END IF;
183 -- end
184
185   RAISE EXCEPTION 'Unknown partition %', in_partition;
186 END
187 $$
188 LANGUAGE plpgsql STABLE;
189
190 CREATE OR REPLACE FUNCTION getNearestNamedPlacePlaceId(in_partition INTEGER,
191                                                        point GEOMETRY,
192                                                        isin_token INTEGER[])
193   RETURNS BIGINT
194   AS $$
195 DECLARE
196   parent BIGINT;
197 BEGIN
198
199 -- start
200   IF in_partition = -partition- THEN
201     SELECT place_id
202       INTO parent
203       FROM search_name_-partition-
204       WHERE name_vector && isin_token
205             AND centroid && ST_Expand(point, 0.04)
206             AND address_rank between 16 and 25
207       ORDER BY ST_Distance(centroid, point) ASC limit 1;
208     RETURN parent;
209   END IF;
210 -- end
211
212   RAISE EXCEPTION 'Unknown partition %', in_partition;
213 END
214 $$
215 LANGUAGE plpgsql STABLE;
216
217 create or replace function insertSearchName(
218   in_partition INTEGER, in_place_id BIGINT, in_name_vector INTEGER[],
219   in_rank_search INTEGER, in_rank_address INTEGER, in_geometry GEOMETRY)
220 RETURNS BOOLEAN AS $$
221 DECLARE
222 BEGIN
223 -- start
224   IF in_partition = -partition- THEN
225     DELETE FROM search_name_-partition- values WHERE place_id = in_place_id;
226     IF in_rank_address > 0 THEN
227       INSERT INTO search_name_-partition- (place_id, address_rank, name_vector, centroid)
228         values (in_place_id, in_rank_address, in_name_vector, in_geometry);
229     END IF;
230     RETURN TRUE;
231   END IF;
232 -- end
233
234   RAISE EXCEPTION 'Unknown partition %', in_partition;
235   RETURN FALSE;
236 END
237 $$
238 LANGUAGE plpgsql;
239
240 create or replace function deleteSearchName(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
241 DECLARE
242 BEGIN
243 -- start
244   IF in_partition = -partition- THEN
245     DELETE from search_name_-partition- WHERE place_id = in_place_id;
246     RETURN TRUE;
247   END IF;
248 -- end
249
250   RAISE EXCEPTION 'Unknown partition %', in_partition;
251
252   RETURN FALSE;
253 END
254 $$
255 LANGUAGE plpgsql;
256
257 create or replace function insertLocationRoad(
258   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
259 DECLARE
260 BEGIN
261
262 -- start
263   IF in_partition = -partition- THEN
264     DELETE FROM location_road_-partition- where place_id = in_place_id;
265     INSERT INTO location_road_-partition- (partition, place_id, country_code, geometry)
266       values (in_partition, in_place_id, in_country_code, in_geometry);
267     RETURN TRUE;
268   END IF;
269 -- end
270
271   RAISE EXCEPTION 'Unknown partition %', in_partition;
272   RETURN FALSE;
273 END
274 $$
275 LANGUAGE plpgsql;
276
277 create or replace function deleteRoad(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
278 DECLARE
279 BEGIN
280
281 -- start
282   IF in_partition = -partition- THEN
283     DELETE FROM location_road_-partition- where place_id = in_place_id;
284     RETURN TRUE;
285   END IF;
286 -- end
287
288   RAISE EXCEPTION 'Unknown partition %', in_partition;
289
290   RETURN FALSE;
291 END
292 $$
293 LANGUAGE plpgsql;
294
295 CREATE OR REPLACE FUNCTION getNearestRoadPlaceId(in_partition INTEGER, point GEOMETRY)
296   RETURNS BIGINT
297   AS $$
298 DECLARE
299   r RECORD;
300   search_diameter FLOAT;
301 BEGIN
302
303 -- start
304   IF in_partition = -partition- THEN
305     search_diameter := 0.00005;
306     WHILE search_diameter < 0.1 LOOP
307       FOR r IN
308         SELECT place_id FROM location_road_-partition-
309           WHERE ST_DWithin(geometry, point, search_diameter)
310           ORDER BY ST_Distance(geometry, point) ASC limit 1
311       LOOP
312         RETURN r.place_id;
313       END LOOP;
314       search_diameter := search_diameter * 2;
315     END LOOP;
316     RETURN NULL;
317   END IF;
318 -- end
319
320   RAISE EXCEPTION 'Unknown partition %', in_partition;
321 END
322 $$
323 LANGUAGE plpgsql STABLE;
324
325 CREATE OR REPLACE FUNCTION getNearestParallelRoadFeature(in_partition INTEGER,
326                                                          line GEOMETRY)
327   RETURNS BIGINT
328   AS $$
329 DECLARE
330   r RECORD;
331   search_diameter FLOAT;
332   p1 GEOMETRY;
333   p2 GEOMETRY;
334   p3 GEOMETRY;
335 BEGIN
336
337   IF ST_GeometryType(line) not in ('ST_LineString') THEN
338     RETURN NULL;
339   END IF;
340
341   p1 := ST_LineInterpolatePoint(line,0);
342   p2 := ST_LineInterpolatePoint(line,0.5);
343   p3 := ST_LineInterpolatePoint(line,1);
344
345 -- start
346   IF in_partition = -partition- THEN
347     search_diameter := 0.0005;
348     WHILE search_diameter < 0.01 LOOP
349       FOR r IN
350         SELECT place_id FROM location_road_-partition-
351           WHERE ST_DWithin(line, geometry, search_diameter)
352           ORDER BY (ST_distance(geometry, p1)+
353                     ST_distance(geometry, p2)+
354                     ST_distance(geometry, p3)) ASC limit 1
355       LOOP
356         RETURN r.place_id;
357       END LOOP;
358       search_diameter := search_diameter * 2;
359     END LOOP;
360     RETURN NULL;
361   END IF;
362 -- end
363
364   RAISE EXCEPTION 'Unknown partition %', in_partition;
365 END
366 $$
367 LANGUAGE plpgsql STABLE;