query = QueryUpdateBuilder.builderFor(entity).build();
169 | String queryStr = queryTranslator.translate(query);
170 | if (showSQL) {
171 | log.info("Query String {}", queryStr);
172 | }
173 | if (preparedStatement == null) {
174 | preparedStatement = createPreparedStatement(conn, queryStr);
175 | }
176 | preparedStatement.addBatch(queryStr);
177 | }
178 | return preparedStatement;
179 | }
180 |
181 | private Statement createStatement(final Connection conn) throws SQLException {
182 | Statement statement = conn.createStatement();
183 | if(statementProperties.containsKey(QUERY_TIMEOUT_SEC)) {
184 | String queryTimeOutValue = statementProperties.get(QUERY_TIMEOUT_SEC);
185 | try {
186 | statement.setQueryTimeout(Integer.valueOf(queryTimeOutValue));
187 | } catch(Exception ig) {
188 | log.warn("Ignoring invalid queryTimeout {}", queryTimeOutValue, ig);
189 | }
190 | }
191 | return statement;
192 |
193 | }
194 |
195 | private PreparedStatement createPreparedStatement(final Connection conn, final String queryStr) throws SQLException {
196 | PreparedStatement statement = conn.prepareStatement(queryStr);
197 | if(statementProperties.containsKey(QUERY_TIMEOUT_SEC)) {
198 | String queryTimeOutValue = statementProperties.get(QUERY_TIMEOUT_SEC);
199 | try {
200 | statement.setQueryTimeout(Integer.valueOf(queryTimeOutValue));
201 | } catch(Exception ig) {
202 | log.warn("Ignoring invalid queryTimeout {}", queryTimeOutValue, ig);
203 | }
204 | }
205 | return statement;
206 |
207 | }
208 |
209 | protected PhoenixProjectedResultMapper getMapper() {
210 | return resultMapper;
211 | }
212 |
213 | public boolean isShowSQL() {
214 | return showSQL;
215 | }
216 |
217 | public void setShowSQL(boolean showSQL) {
218 | this.showSQL = showSQL;
219 | }
220 |
221 | }
222 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/translator/MorphiaEntityResolver.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.translator;
2 |
3 | import org.apache.commons.lang.StringUtils;
4 |
5 | import com.eharmony.pho.translator.EntityResolver;
6 | import com.google.code.morphia.annotations.Entity;
7 |
8 | /**
9 | * Resolve the collection name of an entity class using Morphia's mapper.
10 | */
11 | public class MorphiaEntityResolver implements EntityResolver {
12 |
13 | @Override
14 | public String resolve(Class entityClass) {
15 | Entity entity = entityClass.getAnnotation(Entity.class);
16 | String mappedName = entityClass.getSimpleName();
17 | if (entity != null && StringUtils.isNotBlank(entity.value())) {
18 | mappedName = entity.value();
19 | }
20 | return mappedName;
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/translator/PhoenixHBaseAggregate.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.translator;
2 |
3 | import com.eharmony.pho.query.criterion.Symbolic;
4 |
5 | public enum PhoenixHBaseAggregate implements Symbolic {
6 |
7 | GROUP_BY("GROUP BY"),
8 | COUNT("COUNT"),
9 | AVG("AVG"),
10 | SUM("SUM"),
11 | MAX("MAX"),
12 | MIN("MIN");
13 |
14 | private final String symbol;
15 |
16 | PhoenixHBaseAggregate(String symbol) {
17 | this.symbol = symbol;
18 | }
19 |
20 | @Override
21 | public String symbol() {
22 | return symbol;
23 | }
24 |
25 |
26 | @Override
27 | public String toString() {
28 | return symbol();
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/translator/PhoenixHBaseClauses.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.translator;
2 |
3 | import com.eharmony.pho.query.criterion.Symbolic;
4 |
5 | /**
6 | * Mappings for Apache Phoenix HBase Clauses
7 | */
8 | public enum PhoenixHBaseClauses implements Symbolic {
9 | FROM("FROM"),
10 | WHERE("WHERE"),
11 | HAVING("HAVING"),
12 | ORDER_BY("ORDER BY"),
13 | LIMIT("LIMIT");
14 |
15 | private final String symbol;
16 |
17 | private PhoenixHBaseClauses(String symbol) {
18 | this.symbol = symbol;
19 | }
20 |
21 | @Override
22 | public String symbol() {
23 | return symbol;
24 | }
25 |
26 | @Override
27 | public String toString() {
28 | return symbol();
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/translator/PhoenixHBaseOperator.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.translator;
2 |
3 | import com.eharmony.pho.query.criterion.Symbolic;
4 |
5 | /**
6 | * Mappings for Apache Phoenix HBase query operators
7 | */
8 | public enum PhoenixHBaseOperator implements Symbolic {
9 | EQUAL("="),
10 | NOT_EQUAL("!="),
11 | GREATER_THAN(">"),
12 | GREATER_THAN_OR_EQUAL(">="),
13 | LESS_THAN("<"),
14 | LESS_THAN_OR_EQUAL("<="),
15 |
16 | OR("OR"),
17 | AND("AND"),
18 |
19 | LIKE("LIKE"),
20 | LIKE_CASE_INSENSITIVE("ILIKE"),
21 |
22 | IS_NULL("IS NULL"),
23 | IS_NOT_NULL("IS NOT NULL");
24 |
25 | private final String symbol;
26 |
27 | private PhoenixHBaseOperator(String symbol) {
28 | this.symbol = symbol;
29 | }
30 |
31 | @Override
32 | public String symbol() {
33 | return symbol;
34 | }
35 |
36 | @Override
37 | public String toString() {
38 | return symbol();
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/translator/PhoenixHBaseQueryTranslator.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.translator;
2 |
3 | import java.lang.reflect.InvocationTargetException;
4 | import java.util.ArrayList;
5 | import java.util.Arrays;
6 | import java.util.Date;
7 | import java.util.LinkedList;
8 | import java.util.List;
9 | import java.util.Map;
10 | import java.util.Set;
11 |
12 | import com.eharmony.pho.query.criterion.expression.Expression;
13 | import com.eharmony.pho.query.criterion.projection.AggregateProjection;
14 | import com.eharmony.pho.query.criterion.projection.GroupProjection;
15 | import com.eharmony.pho.query.criterion.projection.Projection;
16 | import com.google.common.base.Strings;
17 | import org.apache.commons.beanutils.PropertyUtils;
18 | import org.apache.commons.collections.CollectionUtils;
19 | import org.apache.commons.collections.MapUtils;
20 | import org.apache.commons.lang.StringUtils;
21 | import org.slf4j.Logger;
22 | import org.slf4j.LoggerFactory;
23 |
24 | import com.eharmony.pho.api.DataStoreException;
25 | import com.eharmony.pho.hbase.util.PhoenixDateFormatUtil;
26 | import com.eharmony.pho.mapper.EntityPropertiesResolver;
27 | import com.eharmony.pho.mapper.EntityPropertyBinding;
28 | import com.eharmony.pho.mapper.EntityPropertyValueBinding;
29 | import com.eharmony.pho.query.QuerySelect;
30 | import com.eharmony.pho.query.QueryUpdate;
31 | import com.eharmony.pho.query.criterion.Criterion;
32 | import com.eharmony.pho.query.criterion.Ordering;
33 | import com.eharmony.pho.query.criterion.Orderings;
34 | import com.eharmony.pho.query.criterion.Ordering.NullOrdering;
35 | import com.eharmony.pho.query.criterion.Ordering.Order;
36 | import com.eharmony.pho.query.criterion.expression.NativeExpression;
37 | import com.eharmony.pho.translator.AbstractQueryTranslator;
38 | import com.eharmony.pho.translator.QueryTranslator;
39 | import com.google.common.base.Function;
40 | import com.google.common.base.Joiner;
41 | import com.google.common.collect.Lists;
42 |
43 | import static com.eharmony.pho.hbase.translator.PhoenixHBaseAggregate.*;
44 |
45 | /**
46 | * Translates the entity to Phoenix query to execute on HBase.
47 | *
48 | * 1. Entity classes must be registered through constructor. 2. SELECT, DELETE and UPSERT queries supported. 3.
49 | * provided support to escape the special characters while querying and inserting the data ("'", "/" etc..) 4. No
50 | * support for joins and sub-queries are not tested
51 | *
52 | * @author vvangapandu
53 | */
54 | public class PhoenixHBaseQueryTranslator extends AbstractQueryTranslator implements
55 | QueryTranslator {
56 |
57 | private final MorphiaEntityResolver entityResolver = new MorphiaEntityResolver();
58 | private EntityPropertiesResolver entityPropertiesResolver;
59 | private static final String PROJECTION_ALL = "*";
60 | private static final String SELECT = "SELECT";
61 | private static final String STRING_OPERAND_WITH_WILDCARD = "%%%s%%";
62 |
63 | private static final Logger logger = LoggerFactory.getLogger(PhoenixHBaseQueryTranslator.class);
64 |
65 | private static final int ORDER_EXPRESSION_SUFFIX_MAX_LENGTH = "DESC NULLS FIRST".length();
66 |
67 | public PhoenixHBaseQueryTranslator(Class queryClass, Class orderClass,
68 | EntityPropertiesResolver propertyResolver) {
69 | super(queryClass, orderClass, propertyResolver);
70 | this.entityPropertiesResolver = propertyResolver;
71 | }
72 |
73 | public PhoenixHBaseQueryTranslator(final EntityPropertiesResolver propertyResolver) {
74 | super(String.class, String.class, propertyResolver);
75 | this.entityPropertiesResolver = propertyResolver;
76 | }
77 |
78 | /**
79 | * translates given QuerySelect object to select query string
80 | *
81 | * @param query QuerySelect
82 | * @return String
83 | */
84 | @Override
85 | public String translate(QuerySelect query) {
86 | return translateSelectQuery(query);
87 | }
88 |
89 | private String translateSelectQuery(QuerySelect query) {
90 | List fields = query.getReturnFields();
91 | Criterion rootCriterion = query.getCriteria();
92 | Criterion groupCriterion = query.getGroupCriteria();
93 | Orderings orders = query.getOrder();
94 | Integer maxResults = query.getMaxResults();
95 | Class entityClass = query.getEntityClass();
96 | Joiner spaceJoiner = Joiner.on(" ");
97 |
98 | List projections = query.getProjection();
99 |
100 | String projection = PROJECTION_ALL;
101 | if (CollectionUtils.isNotEmpty(fields)) {
102 | projection = Joiner.on(", ").join(
103 | entityPropertiesResolver.resolveEntityMappingPropertyNames(fields, entityClass));
104 | }
105 |
106 | if (projections != null && CollectionUtils.isNotEmpty(projections)) {
107 | List properties = new ArrayList<>();
108 | for (Projection p : projections) {
109 | if (p instanceof AggregateProjection) {
110 | properties.add(translate((AggregateProjection) p,
111 | entityPropertiesResolver.resolve(p.getPropertyNames().get(0), entityClass)));
112 | } else {
113 | properties.addAll(p.getPropertyNames());
114 | }
115 | projection = Joiner.on(", ").join(
116 | entityPropertiesResolver.resolveEntityMappingPropertyNames(properties, entityClass));
117 | }
118 | }
119 | //Add query hint if available
120 | projection = Strings.isNullOrEmpty(query.getQueryHint()) ? projection : spaceJoiner.join(query.getQueryHint(), PROJECTION_ALL);
121 | String queryString = spaceJoiner.join(new String[]{SELECT, projection, PhoenixHBaseClauses.FROM.symbol(),
122 | entityResolver.resolve(entityClass)});
123 |
124 | if (rootCriterion != null) {
125 | queryString = spaceJoiner.join(queryString, PhoenixHBaseClauses.WHERE.symbol(), translate(rootCriterion, entityClass));
126 | }
127 |
128 | if (orders != null && CollectionUtils.isNotEmpty(orders.get())) {
129 | queryString = spaceJoiner.join(queryString, PhoenixHBaseClauses.ORDER_BY.symbol(), translateOrder(query));
130 | }
131 |
132 | if (maxResults != null && maxResults > 0) {
133 | queryString = spaceJoiner.join(queryString, PhoenixHBaseClauses.LIMIT.symbol(), maxResults);
134 | }
135 | if (projections != null && CollectionUtils.isNotEmpty(projections)) {
136 | for (Projection p : projections) {
137 | if (p instanceof GroupProjection) {
138 | queryString = spaceJoiner.join(queryString, translate(p, entityClass));
139 | }
140 | }
141 | }
142 | if (groupCriterion != null) {
143 | if (groupCriterion instanceof Expression) {
144 | queryString = spaceJoiner.join(queryString, PhoenixHBaseClauses.HAVING.symbol(),
145 | translate(groupCriterion, entityClass, ((Expression) groupCriterion).getAggregateProjection()));
146 | } else {
147 | queryString = spaceJoiner.join(queryString, PhoenixHBaseClauses.HAVING.symbol(),
148 | translate(groupCriterion, entityClass));
149 | }
150 | }
151 | return queryString;
152 | }
153 |
154 | private String resolveMappingName(String fieldName) {
155 | return fieldName;
156 | }
157 |
158 | private String resolveMappingNames(String... fieldNames) {
159 | return Joiner.on(", ").join(Arrays.asList(fieldNames));
160 | }
161 |
162 | @Override
163 | public String eq(String fieldName, Object value) {
164 |
165 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.EQUAL, value);
166 | }
167 |
168 | @Override
169 | public String ne(String fieldName, Object value) {
170 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.NOT_EQUAL, value);
171 | }
172 |
173 | @Override
174 | public String lt(String fieldName, Object value) {
175 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.LESS_THAN, value);
176 | }
177 |
178 | @Override
179 | public String lte(String fieldName, Object value) {
180 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.LESS_THAN_OR_EQUAL, value);
181 | }
182 |
183 | @Override
184 | public String gt(String fieldName, Object value) {
185 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.GREATER_THAN, value);
186 | }
187 |
188 | @Override
189 | public String gte(String fieldName, Object value) {
190 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.GREATER_THAN_OR_EQUAL, value);
191 | }
192 |
193 | @Override
194 | public String insensitiveLike(String fieldName, Object value) {
195 | return join(resolveMappingName(fieldName),
196 | PhoenixHBaseOperator.LIKE_CASE_INSENSITIVE,
197 | String.format(STRING_OPERAND_WITH_WILDCARD, value));
198 | }
199 |
200 | @Override
201 | public String like(String fieldName, Object value) {
202 | return join(resolveMappingName(fieldName),
203 | PhoenixHBaseOperator.LIKE,
204 | String.format(STRING_OPERAND_WITH_WILDCARD, value));
205 | }
206 |
207 | @Override
208 | public String between(String fieldName, Object from, Object to) {
209 | throw new UnsupportedOperationException("BETWEEN operator is not supported in phoenix hbase library...");
210 | }
211 |
212 | @Override
213 | public String in(String fieldName, Object[] values) {
214 | throw new UnsupportedOperationException("IN operator is not supported in phoenix hbase library...");
215 | }
216 |
217 | @Override
218 | public String notIn(String fieldName, Object[] values) {
219 | throw new UnsupportedOperationException("NOTIN operator is not supported in phoenix hbase library...");
220 | }
221 |
222 | @Override
223 | public String contains(String fieldName, Object[] values) {
224 | throw new UnsupportedOperationException("CONTAINS operator is not supported in phoenix hbase library...");
225 | }
226 |
227 | @Override
228 | public String isNull(String fieldName) {
229 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.IS_NULL);
230 | }
231 |
232 | @Override
233 | public String notNull(String fieldName) {
234 | return join(resolveMappingName(fieldName), PhoenixHBaseOperator.IS_NOT_NULL);
235 | }
236 |
237 | @Override
238 | public String isEmpty(String fieldName) {
239 | throw new UnsupportedOperationException("ISEMPTY operator is not supported in phoenix hbase library...");
240 | }
241 |
242 | @Override
243 | public String notEmpty(String fieldName) {
244 | throw new UnsupportedOperationException("NOTEMPTY operator is not supported in phoenix hbase library...");
245 | }
246 |
247 | @Override
248 | protected String translate(NativeExpression e, Class entityClass) {
249 | return e.getExpression().toString();
250 | }
251 |
252 | @Override
253 | public String order(String... orders) {
254 | return Joiner.on(", ").join(orders);
255 | }
256 |
257 | @Override
258 | public String order(String fieldName, Ordering ordering) {
259 | if (ordering == null || StringUtils.isBlank(ordering.getPropertyName())) {
260 | return StringUtils.EMPTY;
261 | }
262 | StringBuilder orderExpressionBuilder = new StringBuilder(fieldName.length() + ORDER_EXPRESSION_SUFFIX_MAX_LENGTH);
263 | orderExpressionBuilder.append(fieldName);
264 | Order order = ordering.getOrder();
265 | if (order != null) {
266 | orderExpressionBuilder.append(' ');
267 | orderExpressionBuilder
268 | .append(Order.ASCENDING.equals(order) ? "ASC"
269 | : "DESC");
270 | NullOrdering nullOrdering = ordering.getNullOrdering();
271 | if (nullOrdering != null) {
272 | orderExpressionBuilder.append(" NULLS ");
273 | orderExpressionBuilder.append(nullOrdering.name());
274 | }
275 | }
276 | return orderExpressionBuilder.toString();
277 |
278 | }
279 |
280 | @Override
281 | public String translateProjection(QuerySelect query) {
282 | return query.getReturnFields().size() > 0 ? Joiner.on(",").join(query.getReturnFields()) : null;
283 | }
284 |
285 | protected String join(String fieldName, Object... parts) {
286 | return fieldName + " " + Joiner.on(" ").join(Lists.transform(Arrays.asList(parts), toString));
287 | }
288 |
289 | protected String joinAggregateFunc(PhoenixHBaseAggregate function, String... fieldNames) {
290 | return function + "(" + resolveMappingNames(fieldNames) + ")";
291 | }
292 |
293 | private final Function toString = new Function() {
294 | @Override
295 | public String apply(Object o) {
296 | return string(o);
297 | }
298 | };
299 |
300 | protected String string(Object o) {
301 | if (o instanceof Object[]) {
302 | return "[" + Joiner.on(",").join(Lists.transform(Arrays.asList((Object[]) o), toString)) + "]";
303 | } else if (o instanceof String) {
304 | return "'" + sanitizeString((String) o) + "'";
305 | } else if (o instanceof Character) {
306 | logger.debug("Converting char type, value {}", o);
307 | return "'" + sanitizeString(o.toString()) + "'";
308 | } else if (o instanceof Date) {
309 | return PhoenixDateFormatUtil.formatDate((Date) o);
310 | } else if (o != null) {
311 | return o.toString();
312 | }
313 | logger.warn("Can't convert null object to String");
314 | return null;
315 |
316 | }
317 |
318 | private String sanitizeString(String stringValue) {
319 | if (stringValue.contains("'")) {
320 | stringValue = stringValue.replace("'", "''");
321 | }
322 | if (stringValue.contains("\\")) {
323 | stringValue = stringValue.replace("\\", "\\\\");
324 | }
325 | return stringValue;
326 | }
327 |
328 | @Override
329 | public String translate(QueryUpdate updateQuery) {
330 | T entity = updateQuery.getEntity();
331 | List selectedFields = updateQuery.getSelectedFields();
332 | try {
333 | List entityPropertyValueBindings = buildParameterBindings(entity,
334 | selectedFields);
335 |
336 | if (CollectionUtils.isEmpty(entityPropertyValueBindings)) {
337 | throw new DataStoreException("Invalid Entity to save :"
338 | + (updateQuery.getEntity() != null ? updateQuery.getEntity().getClass() : ""));
339 | }
340 | String columnsList = "";
341 | String valuesList = "";
342 | Joiner joiner = Joiner.on(", ");
343 | for (EntityPropertyValueBinding propertyValueBinding : entityPropertyValueBindings) {
344 | if (propertyValueBinding.getValue() != null) {
345 | try {
346 | if (StringUtils.isEmpty(columnsList)) {
347 | columnsList = propertyValueBinding.getEntityPropertyBinding().getStoreFieldName();
348 | valuesList = string(propertyValueBinding.getValue());
349 | } else {
350 | columnsList = joiner.join(columnsList, propertyValueBinding.getEntityPropertyBinding()
351 | .getStoreFieldName());
352 | valuesList = joiner.join(valuesList, string(propertyValueBinding.getValue()));
353 | }
354 | } catch (Exception ex) {
355 | logger.warn("Exception while translating the update query for property {} and value {}",
356 | propertyValueBinding.getEntityPropertyBinding().getName(),
357 | propertyValueBinding.getValue(), ex);
358 | throw new RuntimeException(ex);
359 | }
360 |
361 | } else {
362 | logger.info("There is no binding value for property {} and skipping the translation.",
363 | propertyValueBinding.getEntityPropertyBinding().getNameFullPath());
364 | continue;
365 | }
366 | }
367 | String tableName = entityResolver.resolve(entity.getClass());
368 | StringBuilder finalQuery = new StringBuilder("UPSERT INTO ");
369 | finalQuery.append(tableName).append("(").append(columnsList).append(")").append(" values ").append("(")
370 | .append(valuesList).append(")");
371 |
372 | return finalQuery.toString();
373 |
374 | } catch (Exception ex) {
375 | throw new RuntimeException(ex);
376 | }
377 |
378 | }
379 |
380 | private List buildParameterBindings(T entity, List selectedFields)
381 | throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
382 |
383 | try {
384 |
385 | Map entityPropertyBindings = entityPropertiesResolver
386 | .getEntityPropertyNamePropertyBindingMap(entity.getClass());
387 | if (MapUtils.isEmpty(entityPropertyBindings)) {
388 | throw new DataStoreException("Invalid Entity class " + entity.getClass().getSimpleName());
389 | }
390 | List entityPropertyValueBindings = new LinkedList();
391 | int position = 1;
392 | Set entityFields = entityPropertyBindings.keySet();
393 | if (CollectionUtils.isEmpty(selectedFields)) {
394 | selectedFields = new ArrayList(entityFields);
395 | }
396 | for (String beanPropertyName : selectedFields) {
397 | EntityPropertyBinding entityPropertyBinding = entityPropertyBindings.get(beanPropertyName);
398 | if (entityPropertyBinding == null) {
399 | String errorMessage = "Invalid bean property " + beanPropertyName + " for bean "
400 | + entity.getClass().getSimpleName();
401 | throw new DataStoreException(errorMessage);
402 | }
403 | Object value = PropertyUtils.getProperty(entity, entityPropertyBinding.getNameFullPath());
404 | EntityPropertyValueBinding entityPropertyValueBinding = new EntityPropertyValueBinding(
405 | entityPropertyBinding);
406 | entityPropertyValueBinding.setValue(value);
407 | entityPropertyValueBinding.setPosition(position++);
408 | entityPropertyValueBindings.add(entityPropertyValueBinding);
409 | }
410 | return entityPropertyValueBindings;
411 | } catch (Exception ex) {
412 | logger.warn("Exceotion while building parameter bindings for entity {}", entity.getClass(), ex);
413 | throw new DataStoreException(ex);
414 | }
415 |
416 | }
417 |
418 | @Override
419 | public String and(String... subqueries) {
420 | return junction(PhoenixHBaseOperator.AND, subqueries);
421 | }
422 |
423 | @Override
424 | public String or(String... subqueries) {
425 | return junction(PhoenixHBaseOperator.OR, subqueries);
426 | }
427 |
428 | protected String junction(PhoenixHBaseOperator operator, String... subqueries) {
429 | if (subqueries.length < 1) {
430 | return "";
431 | } else if (subqueries.length == 1) {
432 | return subqueries[0];
433 | } else {
434 | return "(" + Joiner.on(") " + operator.symbol() + " (").join(subqueries) + ")";
435 | }
436 | }
437 |
438 | @Override
439 | public String limit(Integer value) {
440 |
441 | if (value != null && value > 0) {
442 | return "LIMIT " + value;
443 | }
444 | return "";
445 |
446 | }
447 |
448 | @Override
449 | public String groupBy(String... fieldNames) {
450 | return joinAggregateFunc(GROUP_BY, fieldNames);
451 | }
452 |
453 | @Override
454 | public String count(String fieldName) {
455 | return joinAggregateFunc(COUNT, fieldName);
456 | }
457 |
458 | @Override
459 | public String countAll() {
460 | return joinAggregateFunc(COUNT, "*");
461 | }
462 |
463 | @Override
464 | public String sum(String fieldName) {
465 | return joinAggregateFunc(SUM, fieldName);
466 | }
467 |
468 | @Override
469 | public String avg(String fieldName) {
470 | return joinAggregateFunc(AVG, fieldName);
471 | }
472 |
473 | @Override
474 | public String max(String fieldName) {
475 | return joinAggregateFunc(MAX, resolveMappingName(fieldName));
476 | }
477 |
478 | @Override
479 | public String min(String fieldName) {
480 | return joinAggregateFunc(MIN, fieldName);
481 | }
482 |
483 | }
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/util/PhoenixConnectionManager.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.util;
2 |
3 | import java.sql.Connection;
4 | import java.sql.DriverManager;
5 | /**
6 | * Manages the phoenix connections based on JDBC driver
7 | *
8 | * @author vvangapandu
9 | *
10 | */
11 | public class PhoenixConnectionManager {
12 |
13 | public static Connection getConnection(final String connectionString) throws Exception {
14 | Class.forName("org.apache.phoenix.jdbc.PhoenixDriver");
15 | return DriverManager.getConnection(connectionString);
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/hbase/util/PhoenixDateFormatUtil.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.hbase.util;
2 |
3 | import java.text.SimpleDateFormat;
4 | import java.util.Date;
5 |
6 | import com.google.common.base.Preconditions;
7 | /**
8 | * Utility class to convert the java.util.Date to apache phoenix date format to insert into hbase.
9 | *
10 | * Note: this class is using simpledateformat, but should be
11 | * switched to org.apache.commons.lang3.time.FastDateFormat if there are any performance issues
12 | *
13 | * @author vvangapandu
14 | *
15 | */
16 | public class PhoenixDateFormatUtil {
17 |
18 | public static final String TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mm:ss z";
19 |
20 | public static final String formatDate(Date date) {
21 | Preconditions.checkNotNull(date, "date must not be null");
22 | String formattedDate = new SimpleDateFormat(TIMESTAMP_FORMAT).format(date);
23 | StringBuffer dateFormatBuilder = new StringBuffer("TO_DATE('");
24 | dateFormatBuilder.append(formattedDate).append("', 'yyyy-MM-dd HH:mm:ss z')");
25 | return dateFormatBuilder.toString();
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/mapper/EntityPropertiesMappingContext.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.mapper;
2 |
3 | import java.lang.reflect.Field;
4 | import java.util.HashMap;
5 | import java.util.HashSet;
6 | import java.util.LinkedList;
7 | import java.util.List;
8 | import java.util.Map;
9 | import java.util.Set;
10 |
11 | import org.apache.commons.lang.StringUtils;
12 |
13 | import com.google.code.morphia.annotations.Embedded;
14 | import com.google.code.morphia.annotations.Property;
15 |
16 | /**
17 | * Provides the mappings between entity properties and datastore mapping columns.
18 | *
19 | * Entity mappings will be resolved for configured classes on instantiation of this class.
20 | *
21 | * @author vvangapandu
22 | *
23 | */
24 | public class EntityPropertiesMappingContext {
25 |
26 | private Map> storeFieldToEntityPropertyBindingMap = new HashMap>();
27 | private Map> entityPropertyToStoreFieldBindingMap = new HashMap>();
28 |
29 | private static final String PROPERTY_SEPARATOR = ".";
30 |
31 | public EntityPropertiesMappingContext(List classNames) throws ClassNotFoundException {
32 | if (classNames != null) {
33 | for (String clzName : classNames) {
34 | Class clz = getClass().getClassLoader().loadClass(clzName);
35 | populateMappings(clz);
36 | }
37 |
38 | }
39 | }
40 |
41 | public void populateMappings(Class clz) {
42 |
43 | String className = clz.getSimpleName();
44 | Set entityPropertiesSet = buildEntityPropertiesSet(clz, null);
45 | Map entityMappingPropertiesMap = populateEntityMappingPropertiesMap(
46 | entityPropertiesSet, clz);
47 | storeFieldToEntityPropertyBindingMap.put(className, entityMappingPropertiesMap);
48 |
49 | Map entityFieldPropertiesMap = populateEntityFieldPropertiesMap(
50 | entityPropertiesSet, clz);
51 | entityPropertyToStoreFieldBindingMap.put(className, entityFieldPropertiesMap);
52 |
53 | }
54 |
55 | private Map populateEntityMappingPropertiesMap(
56 | Set entityPropertiesSetInternal, Class clz) {
57 | Map propertiesMap = new HashMap();
58 | for (EntityPropertyBinding entityProperty : entityPropertiesSetInternal) {
59 | propertiesMap.put(entityProperty.getStoreFieldName().toUpperCase(), entityProperty);
60 | }
61 | return propertiesMap;
62 | }
63 |
64 | private Map populateEntityFieldPropertiesMap(
65 | Set entityPropertiesSetInternal, Class clz) {
66 | Map propertiesMap = new HashMap();
67 | for (EntityPropertyBinding entityProperty : entityPropertiesSetInternal) {
68 | propertiesMap.put(entityProperty.getName(), entityProperty);
69 | // should the property resolved by complete path?
70 | // propertiesMap.put(entityProperty.getMappingNameFullPath(), entityProperty);
71 | }
72 | return propertiesMap;
73 | }
74 |
75 | public EntityPropertyBinding resolveEntityPropertyBindingByStoreMappingName(Class clz, String mappingName) {
76 | Map entityProperties = storeFieldToEntityPropertyBindingMap.get(clz
77 | .getSimpleName());
78 |
79 | if (entityProperties == null || entityProperties.size() == 0) {
80 | return null;
81 | }
82 | return entityProperties.get(mappingName.toUpperCase());
83 | }
84 |
85 | public EntityPropertyBinding resolveEntityPropertyBindingByEntityFieldName(Class clz, String fieldName) {
86 | Map entityProperties = storeFieldToEntityPropertyBindingMap.get(clz
87 | .getSimpleName());
88 | if (entityProperties == null || entityProperties.size() == 0) {
89 | return null;
90 | }
91 | EntityPropertyBinding entityProperty = entityProperties.get(fieldName);
92 | if (entityProperty != null && StringUtils.isNotBlank(entityProperty.getStoreFieldName())) {
93 | return entityProperty;
94 | }
95 | return null;
96 | }
97 |
98 | public String resolveEntityMappingPropertyName(Class clz, String fieldName) {
99 | Map entityProperties = entityPropertyToStoreFieldBindingMap.get(clz
100 | .getSimpleName());
101 | if (entityProperties == null || entityProperties.size() == 0) {
102 | return fieldName;
103 | }
104 | EntityPropertyBinding entityProperty = entityProperties.get(fieldName);
105 | if (entityProperty != null && StringUtils.isNotBlank(entityProperty.getStoreFieldName())) {
106 | return entityProperty.getStoreFieldName();
107 | }
108 | return fieldName;
109 | }
110 |
111 | public List resolveEntityMappingPropertyNames(Class clz, List fieldPropertyNames) {
112 | Map entityProperties = entityPropertyToStoreFieldBindingMap.get(clz
113 | .getSimpleName());
114 |
115 | if (entityProperties == null || entityProperties.size() == 0) {
116 | throw new IllegalArgumentException("Invalid Entity Class:" + clz.getSimpleName());
117 | }
118 | List mappingProperties = new LinkedList();
119 | for (String fieldPropertyName : fieldPropertyNames) {
120 | EntityPropertyBinding entityProperty = entityProperties.get(fieldPropertyName);
121 | String mappingName = fieldPropertyName;
122 | if (entityProperty != null && StringUtils.isNotBlank(entityProperty.getStoreFieldName())) {
123 | mappingName = entityProperty.getStoreFieldName();
124 | }
125 | mappingProperties.add(mappingName);
126 | }
127 | return mappingProperties;
128 | }
129 |
130 | private Set buildEntityPropertiesSet(Class clz, String parentProperty) {
131 |
132 | Set entityPropertiesSet = new HashSet();
133 | Field[] fields = clz.getDeclaredFields();
134 | if (fields == null || fields.length == 0) {
135 | return entityPropertiesSet;
136 | }
137 | for (Field field : fields) {
138 | if (field.isAnnotationPresent(Embedded.class)) {
139 | StringBuilder nameBuilder = new StringBuilder();
140 | if (StringUtils.isNotEmpty(parentProperty)) {
141 | nameBuilder.append(parentProperty).append(PROPERTY_SEPARATOR);
142 | }
143 | nameBuilder.append(field.getName());
144 | entityPropertiesSet.addAll(buildEntityPropertiesSet(field.getType(), nameBuilder.toString()));
145 | } else {
146 | EntityPropertyBinding entityProperty = buildEntityProperty(field, parentProperty);
147 | if (entityProperty != null) {
148 | entityPropertiesSet.add(entityProperty);
149 | }
150 | }
151 |
152 | }
153 | return entityPropertiesSet;
154 | }
155 |
156 | private EntityPropertyBinding buildEntityProperty(Field simpleField, String parentProperty) {
157 |
158 | EntityPropertyBinding entityProperty = new EntityPropertyBinding();
159 | Property propertyAnnotation = simpleField.getAnnotation(Property.class);
160 | if (propertyAnnotation == null) {
161 | // Mapping store column doesn't exist for field, consider it as non store property.
162 | // should we consider property name as store field name in absence of annotation????
163 | // entityProperty.setStoreFieldName(simpleField.getName());
164 | return null;
165 | }
166 |
167 | entityProperty.setStoreFieldName(propertyAnnotation.value());
168 | entityProperty.setName(simpleField.getName());
169 | entityProperty.setType(simpleField.getType());
170 | StringBuilder nameBuilder = new StringBuilder();
171 | if (StringUtils.isNotEmpty(parentProperty)) {
172 | nameBuilder.append(parentProperty).append(PROPERTY_SEPARATOR);
173 | }
174 | nameBuilder.append(simpleField.getName());
175 | entityProperty.setNameFullPath(nameBuilder.toString());
176 | return entityProperty;
177 | }
178 |
179 | public String resolve(String fieldName, Class entityClass) {
180 | Map propertiesMap = entityPropertyToStoreFieldBindingMap.get(entityClass
181 | .getSimpleName());
182 |
183 | if (propertiesMap == null) {
184 | throw new IllegalArgumentException("Invalid Entity class:" + entityClass.getSimpleName());
185 | }
186 |
187 | EntityPropertyBinding entityProperty = propertiesMap.get(fieldName);
188 | if (entityProperty != null && StringUtils.isNotBlank(entityProperty.getStoreFieldName())) {
189 | return entityProperty.getStoreFieldName();
190 | }
191 | return fieldName;
192 | }
193 |
194 | public Map getStoreFieldNamePropertyBindingMap(Class clz) {
195 | return storeFieldToEntityPropertyBindingMap.get(clz.getSimpleName());
196 | }
197 |
198 | public Map getEntityPropertyNamePropertyBindingMap(Class clz) {
199 | return entityPropertyToStoreFieldBindingMap.get(clz.getSimpleName());
200 | }
201 |
202 | }
203 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/mapper/EntityPropertiesResolver.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.mapper;
2 |
3 | import java.util.List;
4 | import java.util.Map;
5 |
6 | import com.eharmony.pho.translator.PropertyResolver;
7 |
8 | public class EntityPropertiesResolver implements PropertyResolver {
9 |
10 | private final EntityPropertiesMappingContext entityPropertiesMappingContext;
11 |
12 | public EntityPropertiesResolver(final EntityPropertiesMappingContext entityPropertiesMappingContext) {
13 | this.entityPropertiesMappingContext = entityPropertiesMappingContext;
14 | }
15 |
16 | @Override
17 | public EntityPropertyBinding resolveEntityPropertyBindingByStoreMappingName(String mappingName, Class clz) {
18 | return entityPropertiesMappingContext.resolveEntityPropertyBindingByStoreMappingName(clz, mappingName);
19 | }
20 |
21 | @Override
22 | public EntityPropertyBinding resolveEntityPropertyBindingByEntityFieldName(String entityFieldName,
23 | Class entityClass) {
24 | return entityPropertiesMappingContext.resolveEntityPropertyBindingByEntityFieldName(entityClass,
25 | entityFieldName);
26 | }
27 |
28 | @Override
29 | public List resolveEntityMappingPropertyNames(List fieldPropertyNames, Class clz) {
30 | return entityPropertiesMappingContext.resolveEntityMappingPropertyNames(clz, fieldPropertyNames);
31 | }
32 |
33 | @Override
34 | public String resolve(String fieldPropertyName, Class entityClass) {
35 | return entityPropertiesMappingContext.resolveEntityMappingPropertyName(entityClass, fieldPropertyName);
36 | }
37 |
38 | @Override
39 | public Map getStoreFieldNamePropertyBindingMap(Class clz) {
40 | return entityPropertiesMappingContext.getStoreFieldNamePropertyBindingMap(clz);
41 | }
42 |
43 | @Override
44 | public Map getEntityPropertyNamePropertyBindingMap(Class clz) {
45 | return entityPropertiesMappingContext.getEntityPropertyNamePropertyBindingMap(clz);
46 | }
47 |
48 | }
49 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/mapper/EntityPropertyBinding.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.mapper;
2 |
3 | import java.lang.reflect.Type;
4 |
5 | /**
6 | * Contains the information about entity property to store property mapping
7 | *
8 | * @author vvangapandu
9 | *
10 | */
11 | public class EntityPropertyBinding {
12 |
13 | private String name;
14 | private Type type;
15 | private String storeFieldName;
16 | private String nameFullPath;
17 |
18 | public String getName() {
19 | return name;
20 | }
21 |
22 | public void setName(String name) {
23 | this.name = name;
24 | }
25 |
26 | public Type getType() {
27 | return type;
28 | }
29 |
30 | public void setType(Type type) {
31 | this.type = type;
32 | }
33 |
34 | public String getStoreFieldName() {
35 | return storeFieldName;
36 | }
37 |
38 | public void setStoreFieldName(String storeFieldName) {
39 | this.storeFieldName = storeFieldName;
40 | }
41 |
42 | public String getNameFullPath() {
43 | return nameFullPath;
44 | }
45 |
46 | public void setNameFullPath(String nameFullPath) {
47 | this.nameFullPath = nameFullPath;
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/mapper/EntityPropertyValueBinding.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.mapper;
2 |
3 | /**
4 | * Contains the information about entity property to store property mapping and value of the property
5 | *
6 | * @author vvangapandu
7 | *
8 | */
9 | public class EntityPropertyValueBinding {
10 |
11 | private final EntityPropertyBinding entityPropertyBinding;
12 | private int position;
13 | private Object value;
14 |
15 | public EntityPropertyValueBinding(EntityPropertyBinding entityPropertyBinding) {
16 | this.entityPropertyBinding = entityPropertyBinding;
17 | }
18 |
19 | public EntityPropertyBinding getEntityPropertyBinding() {
20 | return entityPropertyBinding;
21 | }
22 |
23 | public int getPosition() {
24 | return position;
25 | }
26 |
27 | public void setPosition(int position) {
28 | this.position = position;
29 | }
30 |
31 | public Object getValue() {
32 | return value;
33 | }
34 |
35 | public void setValue(Object value) {
36 | this.value = value;
37 | }
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/mapper/ProjectedResultMapper.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.mapper;
2 |
3 | import java.util.Map;
4 |
5 | import org.codehaus.jackson.map.ObjectMapper;
6 |
7 | import com.google.common.collect.Maps;
8 |
9 | /**
10 | * Map an array of properties and an array of associated property names to an
11 | * Object of a specified type.
12 | */
13 | public class ProjectedResultMapper {
14 |
15 | private final ObjectMapper mapper;
16 |
17 | public ProjectedResultMapper(ObjectMapper mapper) {
18 | this.mapper = mapper;
19 | }
20 |
21 | public ProjectedResultMapper() {
22 | this(new ObjectMapper());
23 | }
24 |
25 | protected Map propertyMap(Object[] properties,
26 | String[] propertyNames) {
27 | if (properties.length != propertyNames.length) {
28 | throw new IllegalArgumentException("The number of properties ("
29 | + properties.length
30 | + ") must match the number of property names ("
31 | + propertyNames.length + ")");
32 | }
33 | int n = properties.length;
34 | Map map = Maps.newHashMapWithExpectedSize(n);
35 | for (int i = 0; i < n; i++) {
36 | map.put(propertyNames[i], properties[i]);
37 | }
38 | return map;
39 | }
40 |
41 | /**
42 | * Map an Object or an Object array with an associated array of property
43 | * names to the provided type.
44 | * @param return type
45 | * @param resultClass
46 | * the desired mapped type
47 | * @param properties
48 | * the property or properties to be mapped
49 | * @param propertyNames
50 | * an array of associated property names
51 | * @return the mapped object of type R
52 | */
53 | public R mapTo(Class resultClass, Object properties,
54 | String[] propertyNames) {
55 | return propertyNames.length == 1
56 | ? resultClass.cast(properties)
57 | : mapper.convertValue(propertyMap((Object[]) properties, propertyNames), resultClass);
58 | }
59 |
60 | }
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/QueryOperationType.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query;
2 |
3 |
4 | public enum QueryOperationType {
5 |
6 | SELECT, UPDATE, INSERT, DELETE;
7 |
8 | }
9 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/QuerySelect.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query;
2 |
3 | import java.util.List;
4 |
5 | import com.eharmony.pho.query.criterion.Criterion;
6 | import com.eharmony.pho.query.criterion.GroupCriterion;
7 | import com.eharmony.pho.query.criterion.Orderings;
8 | import com.eharmony.pho.query.criterion.projection.Projection;
9 |
10 | /**
11 | * A generic, object oriented representation of a query
12 | *
13 | * @param
14 | * the entity type being queried
15 | * @param
16 | * the desired return type
17 | */
18 | public interface QuerySelect {
19 |
20 | /**
21 | * Get the queried entity type.
22 | *
23 | * @return the entity class being queried
24 | */
25 | public Class getEntityClass();
26 |
27 | /**
28 | * Get the return entity type.
29 | *
30 | * @return the class of the desired return type
31 | */
32 | public Class getReturnType();
33 |
34 | /**
35 | * The list of properties to return. An empty collection means all properties.
36 | *
37 | * @return the fields to be returned from the query
38 | */
39 | public List getReturnFields();
40 |
41 | /**
42 | * Get the query criteria. The top level object can either be a single Criterion or a Junction of multiple nested
43 | * Criterion objects.
44 | *
45 | * @return the root criterion node
46 | */
47 | public Criterion getCriteria();
48 |
49 | Criterion getGroupCriteria();
50 |
51 | /**
52 | * Get the Order clauses.
53 | *
54 | * @return the ordering clauses
55 | */
56 | public Orderings getOrder();
57 |
58 | public List getProjection();
59 |
60 | /**
61 | * Get the max desired results. Null signifies no maximum.
62 | *
63 | * @return the maximum number of results or null if no maximum
64 | *
65 | */
66 | public Integer getMaxResults();
67 |
68 | /**
69 | * Getter method for Query Operation type
70 | *
71 | * @return QueryOperationType
72 | */
73 | public QueryOperationType getQueryOperationType();
74 |
75 | /**
76 | * Getter method for Query Hint
77 | *
78 | * @return String
79 | */
80 | public String getQueryHint();
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/QuerySelectImpl.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query;
2 |
3 | import java.util.List;
4 |
5 | import com.eharmony.pho.query.criterion.Criterion;
6 | import com.eharmony.pho.query.criterion.GroupCriterion;
7 | import com.eharmony.pho.query.criterion.Orderings;
8 | import com.eharmony.pho.query.criterion.projection.Projection;
9 |
10 | /**
11 | * The default implementation of the generic Query interface
12 | *
13 | * @param
14 | * the entity type being queried
15 | * @param
16 | * the desired return type
17 | */
18 | public class QuerySelectImpl implements QuerySelect {
19 |
20 | private final Class entityClass;
21 | private final Class returnType;
22 | private final Criterion criteria;
23 | private final Criterion groupCriterion;
24 | private final Orderings orderings;
25 | private final Integer maxResults;
26 | private final List returnFields;
27 | private final List projections;
28 | private final QueryOperationType queryOperationType;
29 | private final String queryHint;
30 |
31 | public QuerySelectImpl(Class entityClass, Class returnType, Criterion criteria, Criterion groupCriterion, Orderings orderings,
32 | Integer maxResults, List returnFields, List projections, QueryOperationType queryOperationType, String queryHint) {
33 | this.entityClass = entityClass;
34 | this.returnType = returnType;
35 | this.criteria = criteria;
36 | this.groupCriterion = groupCriterion;
37 | this.returnFields = returnFields;
38 | this.orderings = orderings;
39 | this.maxResults = maxResults;
40 | this.projections = projections;
41 | this.queryOperationType = queryOperationType;
42 | this.queryHint = queryHint;
43 | }
44 |
45 | @Override
46 | public QueryOperationType getQueryOperationType() {
47 | return queryOperationType;
48 | }
49 |
50 | @Override
51 | public String getQueryHint() {
52 | return queryHint;
53 | }
54 |
55 | /*
56 | * (non-Javadoc)
57 | *
58 | * @see com.eharmony.matching.seeking.query.Query#getEntityClass()
59 | */
60 | @Override
61 | public Class getEntityClass() {
62 | return entityClass;
63 | }
64 |
65 | /*
66 | * (non-Javadoc)
67 | *
68 | * @see com.eharmony.matching.seeking.query.Query#getReturnType()
69 | */
70 | @Override
71 | public Class getReturnType() {
72 | return returnType;
73 | }
74 |
75 | /*
76 | * (non-Javadoc)
77 | *
78 | * @see com.eharmony.matching.seeking.query.Query#getReturnFields()
79 | */
80 | @Override
81 | public List getReturnFields() {
82 | return returnFields;
83 | }
84 |
85 | /*
86 | * (non-Javadoc)
87 | *
88 | * @see com.eharmony.matching.seeking.query.Query#getCriteria()
89 | */
90 | @Override
91 | public Criterion getCriteria() {
92 | return criteria;
93 | }
94 |
95 | @Override
96 | public Criterion getGroupCriteria() {
97 | return groupCriterion;
98 | }
99 |
100 | /*
101 | * (non-Javadoc)
102 | *
103 | * @see com.eharmony.matching.seeking.query.Query#getOrder()
104 | */
105 | @Override
106 | public Orderings getOrder() {
107 | return orderings;
108 | }
109 |
110 | @Override
111 | public List getProjection() {
112 | return this.projections;
113 | }
114 |
115 | /*
116 | * (non-Javadoc)
117 | *
118 | * @see com.eharmony.matching.seeking.query.Query#getMaxResults()
119 | */
120 | @Override
121 | public Integer getMaxResults() {
122 | return maxResults;
123 | }
124 |
125 | /*
126 | * (non-Javadoc)
127 | *
128 | * @see java.lang.Object#toString()
129 | */
130 | @Override
131 | public String toString() {
132 | return "QueryImpl [entityClass=" + entityClass + ", criteria=" + criteria + ", orderings=" + orderings
133 | + ", maxResults=" + maxResults + "]";
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/QueryUpdate.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query;
2 |
3 | import java.util.List;
4 |
5 | import com.eharmony.pho.query.criterion.Criterion;
6 |
7 | /**
8 | * A generic, object oriented representation of update query
9 | *
10 | * @param
11 | * the entity type being saved
12 | */
13 | public interface QueryUpdate {
14 |
15 | /**
16 | * The list of properties to return. An empty collection means all properties.
17 | *
18 | * @return the fields to be updated
19 | */
20 | public List getSelectedFields();
21 |
22 | /**
23 | * Get the query criteria. The top level object can either be a single Criterion or a Junction of multiple nested
24 | * Criterion objects.
25 | *
26 | * @return the root criterion node
27 | */
28 | public Criterion getCriteria();
29 |
30 | /**
31 | * Getter method for Query Operation type for update
32 | *
33 | * @return QueryOperationType
34 | */
35 | public QueryOperationType getQueryOperationType();
36 |
37 | /**
38 | * Get the entity, which is set to persist
39 | * @return T
40 | */
41 | public T getEntity();
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/QueryUpdateImpl.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query;
2 |
3 | import java.util.List;
4 |
5 | import com.eharmony.pho.query.criterion.Criterion;
6 |
7 | /**
8 | * The default implementation of the generic Query interface
9 | *
10 | * @param
11 | * the entity type being queried
12 | */
13 | public class QueryUpdateImpl implements QueryUpdate {
14 |
15 | private final T entity;
16 | private Criterion criteria;
17 | private final List selectedFields;
18 | private final QueryOperationType queryOperationType;
19 |
20 | public QueryUpdateImpl(final T entity, Criterion criteria, List selectedFields,
21 | QueryOperationType queryOperationType) {
22 | this.entity = entity;
23 | this.criteria = criteria;
24 | this.selectedFields = selectedFields;
25 | this.queryOperationType = queryOperationType;
26 | }
27 |
28 | @Override
29 | public QueryOperationType getQueryOperationType() {
30 | return queryOperationType;
31 | }
32 |
33 | @Override
34 | public String toString() {
35 | return "QueryImpl [entityClass=" + entity.getClass() + ", criteria=" + criteria + "]";
36 | }
37 |
38 | @Override
39 | public List getSelectedFields() {
40 | return this.selectedFields;
41 | }
42 |
43 | @Override
44 | public Criterion getCriteria() {
45 | return this.criteria;
46 | }
47 |
48 | @Override
49 | public T getEntity() {
50 | return this.entity;
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/java/com/eharmony/pho/query/builder/QueryBuilder.java:
--------------------------------------------------------------------------------
1 | package com.eharmony.pho.query.builder;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Arrays;
5 | import java.util.Collections;
6 | import java.util.List;
7 |
8 | import com.eharmony.pho.query.QueryOperationType;
9 | import com.eharmony.pho.query.QuerySelect;
10 | import com.eharmony.pho.query.QuerySelectImpl;
11 | import com.eharmony.pho.query.criterion.*;
12 | import com.eharmony.pho.query.criterion.projection.AggregateProjection;
13 | import com.eharmony.pho.query.criterion.projection.Projection;
14 |
15 | /**
16 | * Builder for Query objects
17 | *
18 | * @param the entity type being queried
19 | * @param the desired return type
20 | */
21 | public class QueryBuilder {
22 |
23 | private final Class entityClass;
24 | private final Class returnType;
25 | private List criteria = new ArrayList<>();
26 | private List groupCriteria = new ArrayList<>();
27 | private Orderings orderings = new Orderings();
28 | private List projections = new ArrayList<>();
29 | private Integer maxResults;
30 | private List returnFields = Collections.emptyList();
31 | private QueryOperationType queryOperationType;
32 | private String queryHint;
33 |
34 | public QueryBuilder(Class entityClass, Class returnType) {
35 | this.entityClass = entityClass;
36 | this.returnType = returnType;
37 | }
38 |
39 | public static QueryBuilder builderFor(Class entityClass, Class returnType,
40 | String... returnFields) {
41 | return new QueryBuilder(entityClass, returnType).setReturnFields(returnFields);
42 | }
43 |
44 | public static QueryBuilder builderFor(Class entityClass) {
45 | return new QueryBuilder(entityClass, entityClass);
46 | }
47 |
48 | public QueryBuilder select() {
49 | queryOperationType = QueryOperationType.SELECT;
50 | return this;
51 | }
52 |
53 | public QueryBuilder select(List returnFields) {
54 | queryOperationType = QueryOperationType.SELECT;
55 | this.returnFields = returnFields;
56 | return this;
57 | }
58 |
59 | public QueryBuilder update() {
60 | queryOperationType = QueryOperationType.UPDATE;
61 | return this;
62 | }
63 |
64 | public QueryBuilder update(List selectedFields) {
65 | queryOperationType = QueryOperationType.UPDATE;
66 | this.returnFields = selectedFields;
67 | return this;
68 | }
69 |
70 | public QueryBuilder create() {
71 | queryOperationType = QueryOperationType.INSERT;
72 | return this;
73 | }
74 |
75 | public QueryBuilder create(List fields) {
76 | queryOperationType = QueryOperationType.INSERT;
77 | this.returnFields = fields;
78 | return this;
79 | }
80 |
81 | public QueryBuilder delete() {
82 | queryOperationType = QueryOperationType.DELETE;
83 | return this;
84 | }
85 |
86 | public QueryBuilder add(Criterion criterion) {
87 | criteria.add(criterion);
88 | return this;
89 | }
90 |
91 | /**
92 | * Add an ordering to the list of orderings
93 | *
94 | * @param orders the list of orderings to add
95 | * @return the builder
96 | */
97 | public QueryBuilder addOrder(Ordering... orders) {
98 |
99 | return addOrder(Arrays.asList(orders));
100 |
101 | }
102 |
103 | /**
104 | * Add an ordering to the list of orderings
105 | *
106 | * @param orders the list of orderings to add
107 | * @return the builder
108 | */
109 | public QueryBuilder addOrder(Iterable orders) {
110 | for (Ordering order : orders) {
111 | orderings.add(order);
112 | }
113 | return this;
114 | }
115 |
116 | public QueryBuilder addProjection(Projection... projections) {
117 | this.projections.addAll(Arrays.asList(projections));
118 | return this;
119 | }
120 |
121 | public QueryBuilder addGroupCriterion(Criterion groupCriterion) {
122 | groupCriteria.add(groupCriterion);
123 | return this;
124 | }
125 |
126 | public QueryBuilder setReturnFields(String... returnFields) {
127 | this.returnFields = Arrays.asList(returnFields);
128 | return this;
129 | }
130 |
131 | public QueryBuilder setMaxResults(int maxResults) {
132 | this.maxResults = maxResults;
133 | return this;
134 | }
135 |
136 | public QueryBuilder setQueryOperationType(QueryOperationType queryOperationType) {
137 | this.queryOperationType = queryOperationType;
138 | return this;
139 | }
140 |
141 | public QueryBuilder setQueryHint(String queryHint) {
142 | this.queryHint = queryHint;
143 | return this;
144 | }
145 |
146 | public QuerySelect
3 |