> newRectangleFilter(S2LatLngRect latLngRect) {
54 | return com.dashlabs.dash.geo.model.filters.GeoFilters.newRectangleFilter(EXTRACTOR, latLngRect);
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/src/main/java/com/amazonaws/geo/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2010-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License").
5 | * You may not use this file except in compliance with the License.
6 | * A copy of the License is located at
7 | *
8 | * http://aws.amazon.com/apache2.0
9 | *
10 | * or in the "license" file accompanying this file. This file is distributed
11 | * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
12 | * express or implied. See the License for the specific language governing
13 | * permissions and limitations under the License.
14 | */
15 | /**
16 | * Geo Library for Amazon DynamoDB
17 | *
18 | * This server library will enable you to create, retrieve, and query for geo-spatial data records in DynamoDB. Geo data
19 | * is popular in mobile apps, and along with this library we have sample mobile projects for iOS which
20 | * demonstrate usage.
21 | *
22 | * Geo-spatial data in a nutshell
23 | *
24 | * A Geo-spatial data record is simply one which is tagged with a latitude and a longitude, which correspond to that
25 | * record's "place" on the planet Earth. Many mobile apps which run on smart phones generate geo data records by
26 | * accessing the GPS to determine the current location, then pass the lat/lng pair to a data storage layer for retrieval
27 | * in the future. Mobile apps also commonly access geo data records which are "nearby". This is done by performing a
28 | * query for all the geo data records which are within a radius or a bounding box around the current location of the
29 | * device.
30 | *
31 | *
32 | * Storing, retrieving, and querying for data records which have a physical location has always been possible with
33 | * DynamoDB, but it required careful design of hash keys, ranges, and indexes, as well as associated code for
34 | * calculating a point's position "inside or outside" a given grid which overlays the globe. Our new library makes it
35 | * very easy.
36 | *
37 | * Major components:
38 | *
39 | * - Geo Library for Amazon DynamoDB: Java library which provides a high-level interface to DynamoDB-backed data
40 | * storage of geo objects. This library can be added to your existing server backend. For more help getting started, we
41 | * include a reference sample Java server for AWS ElasticBeanstalk.
42 | * -
43 | * DynamoDB tables: you create and configure these tables to store your geo records. The library takes care of
44 | * determining the proper hash keys, range keys, and indexes. These keys and indexes are how queries can "find" the
45 | * records which are within a physical distance of a given starting point.
46 | * -
47 | * Client code: interacting with the server library can occur any way you prefer. We have included reference samples of
48 | * mobile apps for iOS and Android which demonstrate how to gather the lat/lng from the device and send it to the
49 | * library, as well as how to query for geo records and display them on a map view.
50 | *
51 | * How does a query work?
52 | *
53 | * We overlay a virtual "grid" over the planet earth. Each grid cell has a corresponding "address", derived by location.
54 | * When geo points are inserted to DynamoDB, a "geohash" is constructed, which locates the data record into the correct
55 | * grid cell. Geohashes also attempt to preserve the proximity of nearby points. Using local secondary indexes, the
56 | * geohash is stored in DynamoDB along with the data record.
57 | *
58 | *
59 | * For querying, you provide either a center point lat/lng and a radial distance, or the coordinates of a bounding box.
60 | * The library uses this input to determine which grid cells are "candidates" for returning geo records from DynamoDB.
61 | * Those cells are queried by geohash - again, a local secondary index on the DynamoDB table - to return the candidate
62 | * geo records. Some cells contain lots of points, some contain none, depending on what points were originally stored in
63 | * the table. Next, the library post-processes those records, filtering out the ones which are outside of the
64 | * originally-provided input (the bounding box or radius). The final list of matching geo records are returned to the
65 | * client.
66 | *
67 | *
68 | * @since 1.0
69 | * @version 1.0
70 | * */
71 | package com.amazonaws.geo;
--------------------------------------------------------------------------------
/src/main/java/com/amazonaws/geo/s2/internal/GeoQueryClient.java:
--------------------------------------------------------------------------------
1 | package com.amazonaws.geo.s2.internal;
2 |
3 | import com.amazonaws.geo.model.GeoQueryRequest;
4 | import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
5 | import com.amazonaws.services.dynamodbv2.model.AttributeValue;
6 | import com.amazonaws.services.dynamodbv2.model.QueryRequest;
7 | import com.amazonaws.services.dynamodbv2.model.QueryResult;
8 | import com.dashlabs.dash.geo.model.filters.GeoFilter;
9 | import com.google.common.collect.ImmutableList;
10 |
11 | import java.util.ArrayList;
12 | import java.util.List;
13 | import java.util.Map;
14 | import java.util.concurrent.Callable;
15 | import java.util.concurrent.ExecutionException;
16 | import java.util.concurrent.ExecutorService;
17 | import java.util.concurrent.Future;
18 |
19 | /**
20 | * Created by mpuri on 3/28/14
21 | */
22 | public class GeoQueryClient {
23 |
24 | /**
25 | * The db client to use when executing the queries
26 | */
27 | private final AmazonDynamoDBClient dbClient;
28 |
29 | /**
30 | * The executor service to use to manage the queries workload
31 | */
32 | private final ExecutorService executorService;
33 |
34 | public GeoQueryClient(AmazonDynamoDBClient dbClient, ExecutorService executorService) {
35 | this.dbClient = dbClient;
36 | this.executorService = executorService;
37 | }
38 |
39 | /**
40 | * A convenience method that executes the queryRequests and applies the resultFilter to the query results.
41 | *
42 | * @return an immutable collection of filtered items
43 | */
44 | public List> execute(final GeoQueryRequest geoQueryRequest)
45 | throws InterruptedException, ExecutionException {
46 | final List> results = new ArrayList>();
47 | List>>> futures;
48 | final List>>> queryCallables =
49 | new ArrayList>>>(geoQueryRequest.getQueryRequests().size());
50 | for (final QueryRequest query : geoQueryRequest.getQueryRequests()) {
51 | queryCallables.add(new Callable>>() {
52 | @Override public List> call() throws Exception {
53 | return executeQuery(query, geoQueryRequest.getResultFilter());
54 | }
55 | });
56 | }
57 | futures = executorService.invokeAll(queryCallables);
58 | if (futures != null) {
59 | for (Future>> future : futures) {
60 | results.addAll(future.get());
61 | }
62 | }
63 | return ImmutableList.copyOf(results);
64 | }
65 |
66 | /**
67 | * Executes the query using the provided db client. The geo filter is applied to the results of the query.
68 | *
69 | * @param queryRequest the query to execute
70 | * @return a collection of filtered result items
71 | */
72 | private List> executeQuery(QueryRequest queryRequest, GeoFilter> resultFilter) {
73 | QueryResult queryResult;
74 | List> resultItems = new ArrayList>();
75 | do {
76 | queryResult = dbClient.query(queryRequest);
77 | List> items = queryResult.getItems();
78 | // filter the results using the geo filter
79 | List> filteredItems = resultFilter.filter(items);
80 | resultItems.addAll(filteredItems);
81 | queryRequest = queryRequest.withExclusiveStartKey(queryResult.getLastEvaluatedKey());
82 | } while ((queryResult.getLastEvaluatedKey() != null));
83 |
84 | return resultItems;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/src/test/java/com/amazonaws/geo/GeoQueryClientTest.java:
--------------------------------------------------------------------------------
1 | package com.amazonaws.geo;
2 |
3 | import com.amazonaws.geo.model.GeoQueryRequest;
4 | import com.amazonaws.geo.s2.internal.GeoQueryClient;
5 | import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
6 | import com.amazonaws.services.dynamodbv2.model.AttributeValue;
7 | import com.amazonaws.services.dynamodbv2.model.QueryRequest;
8 | import com.amazonaws.services.dynamodbv2.model.QueryResult;
9 | import com.dashlabs.dash.geo.model.filters.GeoFilter;
10 | import org.junit.Test;
11 |
12 | import java.util.*;
13 | import java.util.concurrent.ExecutionException;
14 | import java.util.concurrent.ExecutorService;
15 | import java.util.concurrent.Executors;
16 |
17 | import static org.junit.Assert.assertEquals;
18 | import static org.junit.Assert.assertNotNull;
19 | import static org.junit.Assert.fail;
20 | import static org.mockito.Mockito.mock;
21 | import static org.mockito.Mockito.when;
22 |
23 | /**
24 | * Created by mpuri on 3/26/14
25 | */
26 | public class GeoQueryClientTest {
27 |
28 | @Test @SuppressWarnings("unchecked")
29 | public void execute() {
30 | AmazonDynamoDBClient dbClient = mock(AmazonDynamoDBClient.class);
31 | GeoFilter> geoFilter = mock(GeoFilter.class);
32 | ExecutorService executorService = Executors.newFixedThreadPool(2);
33 | GeoQueryClient geoQueryClient = new GeoQueryClient(dbClient,executorService);
34 |
35 | //Mock queries that get fired by the execute method
36 | List queryRequests = new ArrayList();
37 | QueryRequest query1 = new QueryRequest().withLimit(5);
38 | QueryRequest query2 = new QueryRequest().withLimit(10);
39 | queryRequests.add(query1);
40 | queryRequests.add(query2);
41 |
42 | //Mock results of the first query
43 | QueryResult result1 = new QueryResult();
44 | List> resultItems1 = new ArrayList>();
45 | Map item1 = new HashMap();
46 | item1.put("title", new AttributeValue().withS("Milk Bar"));
47 | item1.put("tag", new AttributeValue().withS("cafe:breakfast:american"));
48 |
49 | Map item2 = new HashMap();
50 | item2.put("title", new AttributeValue().withS("Chuko"));
51 | item2.put("tag", new AttributeValue().withS("restaurant:noodles:japanese"));
52 | resultItems1.add(item1);
53 | resultItems1.add(item2);
54 | result1.setItems(resultItems1);
55 |
56 | //Mock results of the second query
57 | QueryResult result2 = new QueryResult();
58 | List> resultItems2 = new ArrayList>();
59 | Map item3 = new HashMap();
60 | item3.put("title", new AttributeValue().withS("Al Di La"));
61 | item3.put("tag", new AttributeValue().withS("restaurant:italian"));
62 |
63 | Map item4 = new HashMap();
64 | item4.put("title", new AttributeValue().withS("Blue Print"));
65 | item4.put("tag", new AttributeValue().withS("bar:cocktails"));
66 | resultItems2.add(item3);
67 | resultItems2.add(item4);
68 | result2.setItems(resultItems2);
69 |
70 | when(dbClient.query(query1)).thenReturn(result1);
71 | when(dbClient.query(query2)).thenReturn(result2);
72 | when(geoFilter.filter(resultItems1)).thenReturn(resultItems1);
73 | List> filteredList = new ArrayList>();
74 | filteredList.add(resultItems2.get(0));
75 | when(geoFilter.filter(resultItems2)).thenReturn(filteredList);
76 |
77 | GeoQueryRequest geoQueryRequest = new GeoQueryRequest(queryRequests, geoFilter);
78 | try {
79 | List> results = geoQueryClient.execute(geoQueryRequest);
80 | assertNotNull(results);
81 | assertEquals(results.size(), 3);
82 | } catch (InterruptedException | ExecutionException ie) {
83 | fail("error occurred while executing the queries");
84 | } finally {
85 | executorService.shutdown();
86 | }
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/test/java/com/amazonaws/geo/GeoTest.java:
--------------------------------------------------------------------------------
1 | package com.amazonaws.geo;
2 |
3 | import com.amazonaws.geo.model.GeoQueryRequest;
4 | import com.amazonaws.services.dynamodbv2.model.*;
5 | import com.dashlabs.dash.geo.s2.internal.S2Manager;
6 | import com.google.common.base.Optional;
7 | import com.google.common.geometry.S2LatLng;
8 | import com.google.common.geometry.S2LatLngRect;
9 | import org.junit.Test;
10 |
11 | import java.util.ArrayList;
12 | import java.util.HashMap;
13 | import java.util.List;
14 | import java.util.Map;
15 |
16 | import static org.junit.Assert.*;
17 | import static org.mockito.Mockito.*;
18 |
19 | /**
20 | * Created by mpuri on 3/26/14
21 | */
22 | public class GeoTest {
23 |
24 | @Test
25 | public void putItemRequestInvalidFields() {
26 | Geo geo = new Geo();
27 | try {
28 | List configs = new ArrayList();
29 | configs.add(new GeoConfig(null, null, null, 0, Optional.absent(), null));
30 | geo.putItemRequest(new PutItemRequest(), 0.0, 0.0, configs);
31 | fail("Should have failed as there are invalid fields");
32 | } catch (IllegalArgumentException e) {
33 | //expected
34 | }
35 | }
36 |
37 | @Test
38 | public void putItemRequest() {
39 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
40 | S2Manager s2Manager = mock(S2Manager.class);
41 | Geo geo = new Geo(s2Manager, geoQueryHelper);
42 | double lat = 5.0;
43 | double longitude = -5.5;
44 | long geohash = System.currentTimeMillis();
45 | long geohashKey = 12345;
46 | List configs = new ArrayList();
47 | GeoConfig config = createTestConfig(false, null);
48 | configs.add(config);
49 | String tableName = "TableWithSomeData";
50 | Map populatedItem = new HashMap();
51 | populatedItem.put("title", new AttributeValue().withS("Ippudo"));
52 | PutItemRequest request = new PutItemRequest().withTableName(tableName).withItem(populatedItem);
53 | when(s2Manager.generateGeohash(lat, longitude)).thenReturn(geohash);
54 | when(s2Manager.generateHashKey(geohash, config.getGeoHashKeyLength())).thenReturn(geohashKey);
55 |
56 | PutItemRequest withGeoProperties = geo.putItemRequest(request, lat, longitude, configs);
57 | assertNotNull(withGeoProperties);
58 | assertEquals(request.getTableName(), withGeoProperties.getTableName());
59 | assertEquals(request.getItem().get("title"), withGeoProperties.getItem().get("title"));
60 | assertEquals(withGeoProperties.getItem().get(config.getGeoHashColumn()).getN(), String.valueOf(geohash));
61 | assertEquals(withGeoProperties.getItem().get(config.getGeoHashKeyColumn()).getN(), String.valueOf(geohashKey));
62 | verify(s2Manager, times(1)).generateGeohash(lat, longitude);
63 | verify(s2Manager, times(1)).generateHashKey(geohash, config.getGeoHashKeyLength());
64 | verifyNoMoreInteractions(s2Manager);
65 | }
66 |
67 | @Test
68 | public void putItemRequestWithCompositeColumn() {
69 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
70 | S2Manager s2Manager = mock(S2Manager.class);
71 | Geo geo = new Geo(s2Manager, geoQueryHelper);
72 | double lat = 5.0;
73 | double longitude = -5.5;
74 | long geohash = System.currentTimeMillis();
75 | long geohashKey = 12345;
76 | List configs = new ArrayList();
77 | GeoConfig config = createTestConfig(true, "venueCategory");
78 | configs.add(config);
79 | String tableName = "TableWithSomeData";
80 | Map populatedItem = new HashMap();
81 | populatedItem.put("title", new AttributeValue().withS("Ippudo"));
82 | populatedItem.put("venueCategory", new AttributeValue().withS("restaurant"));
83 | PutItemRequest request = new PutItemRequest().withTableName(tableName).withItem(populatedItem);
84 | when(s2Manager.generateGeohash(lat, longitude)).thenReturn(geohash);
85 | when(s2Manager.generateHashKey(geohash, config.getGeoHashKeyLength())).thenReturn(geohashKey);
86 |
87 | PutItemRequest withGeoProperties = geo.putItemRequest(request, lat, longitude, configs);
88 | assertNotNull(withGeoProperties);
89 | assertEquals(request.getTableName(), withGeoProperties.getTableName());
90 | assertEquals(request.getItem().get("title"), withGeoProperties.getItem().get("title"));
91 | assertEquals(withGeoProperties.getItem().get(config.getGeoHashColumn()).getN(), String.valueOf(geohash));
92 | assertEquals(withGeoProperties.getItem().get(config.getGeoHashKeyColumn()).getS(), new DefaultHashKeyDecorator().decorate("restaurant", geohashKey));
93 | verify(s2Manager, times(1)).generateGeohash(lat, longitude);
94 | verify(s2Manager, times(1)).generateHashKey(geohash, config.getGeoHashKeyLength());
95 | verifyNoMoreInteractions(s2Manager);
96 |
97 | reset(s2Manager);
98 |
99 | // test where the composite value is null, the composite GSI should not be added to the put-item request
100 | populatedItem.clear();
101 | populatedItem.put("title", new AttributeValue().withS("Ippudo"));
102 | request = new PutItemRequest().withTableName(tableName).withItem(populatedItem);
103 | when(s2Manager.generateGeohash(lat, longitude)).thenReturn(geohash);
104 | when(s2Manager.generateHashKey(geohash, config.getGeoHashKeyLength())).thenReturn(geohashKey);
105 |
106 | withGeoProperties = geo.putItemRequest(request, lat, longitude, configs);
107 | assertNotNull(withGeoProperties);
108 | assertEquals(request.getTableName(), withGeoProperties.getTableName());
109 | assertEquals(request.getItem().get("title"), withGeoProperties.getItem().get("title"));
110 | assertEquals(withGeoProperties.getItem().get(config.getGeoHashColumn()).getN(), String.valueOf(geohash));
111 | assertNull(withGeoProperties.getItem().get(config.getGeoHashKeyColumn()));
112 | verify(s2Manager, times(1)).generateGeohash(lat, longitude);
113 | verify(s2Manager, times(1)).generateHashKey(geohash, config.getGeoHashKeyLength());
114 | verifyNoMoreInteractions(s2Manager);
115 |
116 | }
117 |
118 | @Test
119 | public void getItemQueryInvalidFields() {
120 | Geo geo = new Geo();
121 | try {
122 | geo.getItemQuery(new QueryRequest(), 0.0, 0.0, null, null, null, 0, Optional.absent());
123 | fail("Should have failed as there are invalid fields");
124 | } catch (IllegalArgumentException e) {
125 | //expected
126 | }
127 | }
128 |
129 | @Test
130 | public void getItemQuery() {
131 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
132 | S2Manager s2Manager = mock(S2Manager.class);
133 | Geo geo = new Geo(s2Manager, geoQueryHelper);
134 | double lat = 5.0;
135 | double longitude = -5.5;
136 | long geohash = System.currentTimeMillis();
137 | long geohashKey = 12345;
138 | Condition expectedGeoHashKeyCondition = new Condition().withComparisonOperator(ComparisonOperator.EQ)
139 | .withAttributeValueList(new AttributeValue().withN(String.valueOf(geohashKey)));
140 | Condition expectedGeoHashCondition = new Condition().withComparisonOperator(ComparisonOperator.EQ)
141 | .withAttributeValueList(new AttributeValue().withN(String.valueOf(geohash)));
142 |
143 | GeoConfig config = createTestConfig(false, null);
144 | String tableName = "TableWithSomeData";
145 | QueryRequest query = new QueryRequest().withTableName(tableName);
146 | when(s2Manager.generateGeohash(lat, longitude)).thenReturn(geohash);
147 | when(s2Manager.generateHashKey(geohash, config.getGeoHashKeyLength())).thenReturn(geohashKey);
148 |
149 | QueryRequest withGeoProperties = geo.getItemQuery(query, lat, longitude, config, Optional.absent());
150 | assertNotNull(withGeoProperties);
151 | assertEquals(query.getTableName(), withGeoProperties.getTableName());
152 | assertEquals(withGeoProperties.getKeyConditions().get(config.getGeoHashKeyColumn()), expectedGeoHashKeyCondition);
153 | assertEquals(withGeoProperties.getKeyConditions().get(config.getGeoHashColumn()), expectedGeoHashCondition);
154 | verify(s2Manager, times(1)).generateGeohash(lat, longitude);
155 | verify(s2Manager, times(1)).generateHashKey(geohash, config.getGeoHashKeyLength());
156 | verifyNoMoreInteractions(s2Manager);
157 | }
158 |
159 | @Test
160 | public void getItemQueryWithCompositeKey() {
161 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
162 | S2Manager s2Manager = mock(S2Manager.class);
163 | Geo geo = new Geo(s2Manager, geoQueryHelper);
164 | double lat = 5.0;
165 | double longitude = -5.5;
166 | long geohash = System.currentTimeMillis();
167 | long geohashKey = 12345;
168 | String category = "restaurant";
169 | Condition expectedGeoHashKeyCondition = new Condition().withComparisonOperator(ComparisonOperator.EQ)
170 | .withAttributeValueList(new AttributeValue().withS(String.format("%s:%d", category, geohashKey)));
171 | Condition expectedGeoHashCondition = new Condition().withComparisonOperator(ComparisonOperator.EQ)
172 | .withAttributeValueList(new AttributeValue().withN(String.valueOf(geohash)));
173 |
174 | GeoConfig config = createTestConfig(true, "category");
175 | String tableName = "TableWithSomeData";
176 | QueryRequest query = new QueryRequest().withTableName(tableName);
177 | when(s2Manager.generateGeohash(lat, longitude)).thenReturn(geohash);
178 | when(s2Manager.generateHashKey(geohash, config.getGeoHashKeyLength())).thenReturn(geohashKey);
179 |
180 | QueryRequest withGeoProperties = geo.getItemQuery(query, lat, longitude, config, Optional.of(category));
181 | assertNotNull(withGeoProperties);
182 | assertEquals(query.getTableName(), withGeoProperties.getTableName());
183 | assertEquals(withGeoProperties.getKeyConditions().get(config.getGeoHashKeyColumn()), expectedGeoHashKeyCondition);
184 | assertEquals(withGeoProperties.getKeyConditions().get(config.getGeoHashColumn()), expectedGeoHashCondition);
185 | verify(s2Manager, times(1)).generateGeohash(lat, longitude);
186 | verify(s2Manager, times(1)).generateHashKey(geohash, config.getGeoHashKeyLength());
187 | verifyNoMoreInteractions(s2Manager);
188 | }
189 |
190 | @Test
191 | public void radiusQueryInvalidRadius() {
192 | Geo geo = new Geo();
193 | try {
194 | geo.radiusQuery(new QueryRequest(), 0.0, 0.0, -5.0, null, null, null, 0, Optional.absent());
195 | fail("Should have failed as there are invalid fields");
196 | } catch (IllegalArgumentException e) {
197 | //expected
198 | }
199 | }
200 |
201 | @Test
202 | public void radiusQuery() {
203 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
204 | S2Manager s2Manager = mock(S2Manager.class);
205 | Geo geo = new Geo(s2Manager, geoQueryHelper);
206 | double lat = 5.0;
207 | double longitude = -5.5;
208 | double radius = 50;
209 | String category = "restaurant";
210 | GeoConfig config = createTestConfig(true, "category");
211 | String tableName = "TableWithSomeData";
212 | QueryRequest query = new QueryRequest().withTableName(tableName);
213 | List geoQueries = new ArrayList();
214 | geoQueries.add(new QueryRequest().withLimit(100));
215 | S2LatLngRect latLngRect = new S2LatLngRect(S2LatLng.fromDegrees(lat, longitude), S2LatLng.fromDegrees(lat + 10, longitude + 10));
216 | when(s2Manager.getBoundingBoxForRadiusQuery(lat, longitude, radius)).thenReturn(latLngRect);
217 | when(geoQueryHelper.generateGeoQueries(query, latLngRect, config, Optional.of(category))).thenReturn(geoQueries);
218 | GeoQueryRequest geoQueryRequest = geo.radiusQuery(query, lat, longitude, radius, config, Optional.of(category));
219 | assertNotNull(geoQueryRequest);
220 | assertNotNull(geoQueryRequest.getResultFilter());
221 | assertNotNull(geoQueryRequest.getQueryRequests());
222 | assertEquals(geoQueryRequest.getQueryRequests(), geoQueries);
223 | verify(s2Manager, times(1)).getBoundingBoxForRadiusQuery(lat, longitude, radius);
224 | verify(geoQueryHelper, times(1)).generateGeoQueries(query, latLngRect, config, Optional.of(category));
225 | verifyNoMoreInteractions(s2Manager, geoQueryHelper);
226 | }
227 |
228 | @Test
229 | public void rectangleQueryInvalidFields() {
230 | Geo geo = new Geo();
231 | try {
232 | geo.rectangleQuery(new QueryRequest(), 0.0, 0.0, 0.0, 0.0, null, null, null, 0, Optional.absent());
233 | fail("Should have failed as there are invalid fields");
234 | } catch (IllegalArgumentException e) {
235 | //expected
236 | }
237 | }
238 |
239 | @Test
240 | public void rectangleQuery() {
241 | GeoQueryHelper geoQueryHelper = mock(GeoQueryHelper.class);
242 | S2Manager s2Manager = mock(S2Manager.class);
243 | Geo geo = new Geo(s2Manager, geoQueryHelper);
244 | double minLat = 5.0;
245 | double minLongitude = -5.5;
246 | double maxLat = 15.0;
247 | double maxLongitude = -25.5;
248 | GeoConfig config = createTestConfig(false, null);
249 | String tableName = "TableWithSomeData";
250 | QueryRequest query = new QueryRequest().withTableName(tableName);
251 | List geoQueries = new ArrayList();
252 | geoQueries.add(new QueryRequest().withLimit(100));
253 | S2LatLngRect latLngRect = new S2LatLngRect(S2LatLng.fromDegrees(minLat, minLongitude), S2LatLng.fromDegrees(maxLat, maxLongitude));
254 | when(s2Manager.getBoundingBoxForRectangleQuery(minLat, minLongitude, maxLat, maxLongitude)).thenReturn(latLngRect);
255 | when(geoQueryHelper.generateGeoQueries(query, latLngRect, config, Optional.absent())).thenReturn(geoQueries);
256 | GeoQueryRequest geoQueryRequest = geo.rectangleQuery(query, minLat, minLongitude, maxLat, maxLongitude, config, Optional.absent());
257 | assertNotNull(geoQueryRequest);
258 | assertNotNull(geoQueryRequest.getResultFilter());
259 | assertNotNull(geoQueryRequest.getQueryRequests());
260 | assertEquals(geoQueryRequest.getQueryRequests(), geoQueries);
261 | verify(s2Manager, times(1)).getBoundingBoxForRectangleQuery(minLat, minLongitude, maxLat, maxLongitude);
262 | verify(geoQueryHelper, times(1)).generateGeoQueries(query, latLngRect, config, Optional.absent());
263 | verifyNoMoreInteractions(s2Manager, geoQueryHelper);
264 | }
265 |
266 | private GeoConfig createTestConfig(boolean withKeyDecorator, String compositeColumnName) {
267 | int hashKeyLength = 3;
268 | String geoIndexName = "VenueGeoIndex";
269 | String geoHashKeyColumn = "geoHashKey";
270 | String geoHashColumn = "geohash";
271 |
272 | GeoConfig.Builder builder = new GeoConfig.Builder().geoIndexName(geoIndexName).geoHashKeyLength(hashKeyLength)
273 | .geoHashKeyColumn(geoHashKeyColumn).geoHashColumn(geoHashColumn);
274 | if(withKeyDecorator) {
275 | HashKeyDecorator decorator = new DefaultHashKeyDecorator();
276 | builder.hashKeyDecorator(Optional.of(decorator));
277 | builder.compositeHashKeyColumn(Optional.of(compositeColumnName));
278 | }else{
279 | builder.hashKeyDecorator(Optional.absent());
280 | }
281 | return builder.build();
282 | }
283 |
284 | }
285 |
--------------------------------------------------------------------------------