1 /***********************************************************************
2  * Copyright (c) 2013-2024 Commonwealth Computer Research, Inc.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Apache License, Version 2.0
5  * which accompanies this distribution and is available at
6  * http://www.opensource.org/licenses/apache2.0.php.
7  ***********************************************************************/
8 
9 package org.locationtech.geomesa.filter.factory
10 
11 import org.geotools.api.feature.`type`.Name
12 import org.geotools.api.feature.simple.SimpleFeatureType
13 import org.geotools.api.filter.MultiValuedFilter.MatchAction
14 import org.geotools.api.filter._
15 import org.geotools.api.filter.expression.{Expression, PropertyName}
16 import org.geotools.api.filter.spatial.DWithin
17 import org.geotools.api.filter.temporal.{After, Before, During}
18 import org.geotools.feature.simple.SimpleFeatureBuilder
19 import org.geotools.filter.text.ecql.ECQL
20 import org.geotools.filter.visitor.DuplicatingFilterVisitor
21 import org.locationtech.geomesa.filter.FilterHelper
22 import org.locationtech.geomesa.filter.expression.AttributeExpression.{FunctionLiteral, PropertyLiteral}
23 import org.locationtech.geomesa.filter.expression.FastDWithin.DWithinLiteral
24 import org.locationtech.geomesa.filter.expression.FastPropertyIsEqualTo.{FastIsEqualTo, FastIsEqualToIgnoreCase, FastListIsEqualToAny}
25 import org.locationtech.geomesa.filter.expression.FastPropertyName.{FastPropertyNameAccessor, FastPropertyNameAttribute}
26 import org.locationtech.geomesa.filter.expression.OrHashEquality.OrHashListEquality
27 import org.locationtech.geomesa.filter.expression.OrSequentialEquality.OrSequentialListEquality
28 import org.locationtech.geomesa.filter.expression._
29 import org.locationtech.geomesa.filter.visitor.QueryPlanFilterVisitor
30 import org.locationtech.geomesa.utils.geotools.SimpleFeaturePropertyAccessor
31 import org.locationtech.jts.geom.Geometry
32 import org.xml.sax.helpers.NamespaceSupport
33 
34 /**
35   * Filter factory that creates optimized filters
36   *
37   * Note: usage expects the sft to be set in FastFilterFactory.sfts
38   * FastFilterFactory.toFilter will handle this for you
39  */
40 class FastFilterFactory private extends org.geotools.filter.FilterFactoryImpl with FilterFactory {
41 
42   import org.locationtech.geomesa.utils.geotools.RichAttributeDescriptors.RichAttributeDescriptor
43 
44   import scala.collection.JavaConverters._
45 
46   override def after(exp1: Expression, exp2: Expression): After = after(exp1, exp2, MatchAction.ANY)
47 
48   override def after(exp1: Expression, exp2: Expression, matchAction: MatchAction): After = {
49     if (matchAction != MatchAction.ANY) {
50       super.after(exp1, exp2, matchAction)
51     } else {
52       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
53         case None =>
54           super.after(exp1, exp2, matchAction)
55 
56         case Some(prop) =>
57           val exp1 = prop match {
58             case p: PropertyLiteral => property(p.name)
59             case p: FunctionLiteral => p.function
60           }
61           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
62           if (descriptor != null && classOf[java.util.Date].isAssignableFrom(descriptor.getType.getBinding)) {
63             if (prop.flipped) {
64               FastTemporalOperator.after(prop.literal, exp1)
65             } else {
66               FastTemporalOperator.after(exp1, prop.literal)
67             }
68           } else {
69             super.after(exp1, exp2, matchAction)
70           }
71       }
72     }
73   }
74 
75   override def before(exp1: Expression, exp2: Expression): Before = before(exp1, exp2, MatchAction.ANY)
76 
77   override def before(exp1: Expression, exp2: Expression, matchAction: MatchAction): Before = {
78     if (matchAction != MatchAction.ANY) {
79       super.before(exp1, exp2, matchAction)
80     } else {
81       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
82         case None =>
83           super.before(exp1, exp2, matchAction)
84 
85         case Some(prop) =>
86           val exp1 = prop match {
87             case p: PropertyLiteral => property(p.name)
88             case p: FunctionLiteral => p.function
89           }
90           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
91           if (descriptor != null && classOf[java.util.Date].isAssignableFrom(descriptor.getType.getBinding)) {
92             if (prop.flipped) {
93               FastTemporalOperator.before(prop.literal, exp1)
94             } else {
95               FastTemporalOperator.before(exp1, prop.literal)
96             }
97           } else {
98             super.before(exp1, exp2, matchAction)
99           }
100       }
101     }
102   }
103 
104   override def greater(exp1: Expression, exp2: Expression): PropertyIsGreaterThan =
105     greater(exp1, exp2, matchCase = false)
106 
107   override def greater(exp1: Expression,
108                        exp2: Expression,
109                        matchCase: Boolean): PropertyIsGreaterThan = greater(exp1, exp2, matchCase, MatchAction.ANY)
110 
111   override def greater(exp1: Expression,
112                        exp2: Expression,
113                        matchCase: Boolean,
114                        matchAction: MatchAction): PropertyIsGreaterThan = {
115     if (matchAction != MatchAction.ANY) {
116       super.greater(exp1, exp2, matchCase, matchAction)
117     } else {
118       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
119         case None =>
120           super.greater(exp1, exp2, matchCase, matchAction)
121 
122         case Some(prop) =>
123           val exp1 = prop match {
124             case p: PropertyLiteral => property(p.name)
125             case p: FunctionLiteral => p.function
126           }
127           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
128           if (descriptor != null && classOf[Comparable[_]].isAssignableFrom(descriptor.getType.getBinding)) {
129             if (prop.flipped) {
130               FastComparisonOperator.greaterThan(prop.literal, exp1)
131             } else {
132               FastComparisonOperator.greaterThan(exp1, prop.literal)
133             }
134           } else {
135             super.greater(exp1, exp2, matchCase, matchAction)
136           }
137       }
138     }
139   }
140 
141   override def greaterOrEqual(exp1: Expression, exp2: Expression): PropertyIsGreaterThanOrEqualTo =
142     greaterOrEqual(exp1, exp2, matchCase = false)
143 
144   override def greaterOrEqual(exp1: Expression,
145                               exp2: Expression,
146                               matchCase: Boolean): PropertyIsGreaterThanOrEqualTo =
147     greaterOrEqual(exp1, exp2, matchCase, MatchAction.ANY)
148 
149   override def greaterOrEqual(exp1: Expression,
150                               exp2: Expression,
151                               matchCase: Boolean,
152                               matchAction: MatchAction): PropertyIsGreaterThanOrEqualTo = {
153     if (matchAction != MatchAction.ANY) {
154       super.greaterOrEqual(exp1, exp2, matchCase, matchAction)
155     } else {
156       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
157         case None =>
158           super.greaterOrEqual(exp1, exp2, matchCase, matchAction)
159 
160         case Some(prop) =>
161           val exp1 = prop match {
162             case p: PropertyLiteral => property(p.name)
163             case p: FunctionLiteral => p.function
164           }
165           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
166           if (descriptor != null && classOf[Comparable[_]].isAssignableFrom(descriptor.getType.getBinding)) {
167             if (prop.flipped) {
168               FastComparisonOperator.greaterThanOrEqual(prop.literal, exp1)
169             } else {
170               FastComparisonOperator.greaterThanOrEqual(exp1, prop.literal)
171             }
172           } else {
173             super.greaterOrEqual(exp1, exp2, matchCase, matchAction)
174           }
175       }
176     }
177   }
178 
179   override def less(exp1: Expression, exp2: Expression): PropertyIsLessThan = less(exp1, exp2, matchCase = false)
180 
181   override def less(exp1: Expression,
182                     exp2: Expression,
183                     matchCase: Boolean): PropertyIsLessThan = less(exp1, exp2, matchCase, MatchAction.ANY)
184 
185   override def less(exp1: Expression,
186                     exp2: Expression,
187                     matchCase: Boolean,
188                     matchAction: MatchAction): PropertyIsLessThan = {
189     if (matchAction != MatchAction.ANY) {
190       super.less(exp1, exp2, matchCase, matchAction)
191     } else {
192       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
193         case None =>
194           super.less(exp1, exp2, matchCase, matchAction)
195 
196         case Some(prop) =>
197           val exp1 = prop match {
198             case p: PropertyLiteral => property(p.name)
199             case p: FunctionLiteral => p.function
200           }
201           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
202           if (descriptor != null && classOf[Comparable[_]].isAssignableFrom(descriptor.getType.getBinding)) {
203             if (prop.flipped) {
204               FastComparisonOperator.lessThan(prop.literal, exp1)
205             } else {
206               FastComparisonOperator.lessThan(exp1, prop.literal)
207             }
208           } else {
209             super.less(exp1, exp2, matchCase, matchAction)
210           }
211       }
212     }
213   }
214 
215   override def lessOrEqual(exp1: Expression, exp2: Expression): PropertyIsLessThanOrEqualTo =
216     lessOrEqual(exp1, exp2, matchCase = false)
217 
218   override def lessOrEqual(exp1: Expression,
219                            exp2: Expression,
220                            matchCase: Boolean): PropertyIsLessThanOrEqualTo =
221     lessOrEqual(exp1, exp2, matchCase, MatchAction.ANY)
222 
223   override def lessOrEqual(exp1: Expression,
224                            exp2: Expression,
225                            matchCase: Boolean,
226                            matchAction: MatchAction): PropertyIsLessThanOrEqualTo = {
227     if (matchAction != MatchAction.ANY) {
228       super.lessOrEqual(exp1, exp2, matchCase, matchAction)
229     } else {
230       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
231         case None =>
232           super.lessOrEqual(exp1, exp2, matchCase, matchAction)
233 
234         case Some(prop) =>
235           val exp1 = prop match {
236             case p: PropertyLiteral => property(p.name)
237             case p: FunctionLiteral => p.function
238           }
239           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
240           if (descriptor != null && classOf[Comparable[_]].isAssignableFrom(descriptor.getType.getBinding)) {
241             if (prop.flipped) {
242               FastComparisonOperator.lessThanOrEqual(prop.literal, exp1)
243             } else {
244               FastComparisonOperator.lessThanOrEqual(exp1, prop.literal)
245             }
246           } else {
247             super.lessOrEqual(exp1, exp2, matchCase, matchAction)
248           }
249       }
250     }
251   }
252 
253   override def property(name: String): PropertyName = {
254     val sft = FastFilterFactory.sfts.get
255     val colon = name.indexOf(":")
256     val local = if (colon == -1) { name } else { name.substring(colon + 1) }
257     val index = sft.indexOf(local)
258     if (index != -1) {
259       new FastPropertyNameAttribute(name, index)
260     } else {
261       val sf = new SimpleFeatureBuilder(sft).buildFeature("")
262       val accessor = SimpleFeaturePropertyAccessor.getAccessor(sf, name).getOrElse {
263         throw new IllegalArgumentException(s"Property '$name' does not exist in feature type ${sft.getTypeName}")
264       }
265       new FastPropertyNameAccessor(name, accessor)
266     }
267   }
268 
269   override def property(name: Name): PropertyName = property(name.getLocalPart)
270 
271   override def property(name: String, namespaceContext: NamespaceSupport): PropertyName = property(name)
272 
273   override def or(f: Filter, g: Filter): Or = or(java.util.Arrays.asList(f, g))
274 
275   override def or(filters: java.util.List[Filter]): Or = {
276     if (filters.isEmpty) {
277       return super.or(filters)
278     }
279 
280     val predicates = FilterHelper.flattenOr(filters.asScala.toSeq)
281 
282     val props = scala.collection.mutable.HashSet.empty[String]
283     val literals = scala.collection.immutable.HashSet.newBuilder[AnyRef]
284     literals.sizeHint(predicates.length)
285 
286     val iter = predicates.iterator
287     while (iter.hasNext) {
288       iter.next() match {
289         case p: PropertyIsEqualTo if p.getMatchAction == MatchAction.ANY && p.isMatchingCase =>
290           org.locationtech.geomesa.filter.checkOrder(p.getExpression1, p.getExpression2) match {
291             case Some(PropertyLiteral(name, lit, _)) if !props.add(name) || props.size == 1 => literals += lit.getValue
292             case _ => return super.or(filters)
293           }
294 
295         case _ => return super.or(filters)
296       }
297     }
298 
299     // if we've reached here, we have verified that all the child filters are equality matches on the same property
300     val prop = property(props.head)
301     val values = literals.result
302     val isListType = Option(FastFilterFactory.sfts.get.getDescriptor(props.head)).exists(_.isList)
303 
304     if (values.size >= OrHashEquality.OrHashThreshold.get.toInt) {
305       if (isListType) {
306         new OrHashListEquality(prop, values)
307       } else {
308         new OrHashEquality(prop, values)
309       }
310     } else if (isListType) {
311       new OrSequentialListEquality(prop, values.toSeq)
312     } else {
313       new OrSequentialEquality(prop, values.toSeq)
314     }
315   }
316 
317   override def equals(exp1: Expression, exp2: Expression): PropertyIsEqualTo =
318     equal(exp1, exp2, matchCase = true, MatchAction.ANY)
319 
320   override def equal(exp1: Expression, exp2: Expression, matchCase: Boolean): PropertyIsEqualTo =
321     equal(exp1, exp2, matchCase, MatchAction.ANY)
322 
323   override def equal(exp1: Expression, exp2: Expression, matchCase: Boolean, matchAction: MatchAction): PropertyIsEqualTo = {
324     if (matchAction != MatchAction.ANY) {
325       super.equal(exp1, exp2, matchCase, matchAction)
326     } else {
327       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
328         case None =>
329           super.equal(exp1, exp2, matchCase, matchAction)
330 
331         case Some(prop) =>
332           val exp1 = prop match {
333             case p: PropertyLiteral => property(p.name)
334             case p: FunctionLiteral => p.function
335           }
336           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
337           if (descriptor != null && descriptor.isList) {
338             new FastListIsEqualToAny(exp1, prop.literal)
339           } else if (matchCase) {
340             new FastIsEqualTo(exp1, prop.literal)
341           } else {
342             new FastIsEqualToIgnoreCase(exp1, prop.literal)
343           }
344       }
345     }
346   }
347 
348   override def during(exp1: Expression, exp2: Expression): During = during(exp1, exp2, MatchAction.ANY)
349 
350   override def during(exp1: Expression, exp2: Expression, matchAction: MatchAction): During = {
351     if (matchAction != MatchAction.ANY) {
352       super.during(exp1, exp2, matchAction)
353     } else {
354       org.locationtech.geomesa.filter.checkOrder(exp1, exp2).filterNot(_.flipped) match {
355         case None =>
356           super.during(exp1, exp2, matchAction)
357 
358         case Some(prop) =>
359           val exp1 = prop match {
360             case p: PropertyLiteral => property(p.name)
361             case p: FunctionLiteral => p.function
362           }
363           val descriptor = FastFilterFactory.sfts.get.getDescriptor(prop.name)
364           if (descriptor != null && classOf[java.util.Date].isAssignableFrom(descriptor.getType.getBinding)) {
365             FastTemporalOperator.during(exp1, prop.literal)
366           } else {
367             super.during(exp1, exp2, matchAction)
368           }
369       }
370     }
371   }
372 
373   override def dwithin(name: String, geom: Geometry, distance: Double, units: String): DWithin =
374     dwithin(property(name), literal(geom), distance, units)
375 
376   override def dwithin(name: String, geom: Geometry, distance: Double, units: String, action: MatchAction): DWithin =
377     dwithin(property(name), literal(geom), distance, units, action)
378 
379   override def dwithin(exp1: Expression, exp2: Expression, distance: Double, units: String): DWithin =
380     dwithin(exp1, exp2, distance, units, MatchAction.ANY)
381 
382   override def dwithin(exp1: Expression, exp2: Expression, distance: Double, units: String, action: MatchAction): DWithin = {
383     if (action != MatchAction.ANY) {
384       super.dwithin(exp1, exp2, distance, units, action)
385     } else {
386       org.locationtech.geomesa.filter.checkOrder(exp1, exp2) match {
387         case Some(PropertyLiteral(name, lit, _))  => new DWithinLiteral(property(name), lit, distance, units)
388         case Some(FunctionLiteral(_, fn, lit, _)) => new DWithinLiteral(fn, lit, distance, units)
389         case _ => super.dwithin(exp1, exp2, distance, units, action)
390       }
391     }
392   }
393 }
394 
395 object FastFilterFactory {
396 
397   val factory = new FastFilterFactory
398 
399   val sfts = new ThreadLocal[SimpleFeatureType]()
400 
401   def toFilter(sft: SimpleFeatureType, ecql: String): Filter = optimize(sft, ECQL.toFilter(ecql))
402 
403   def toExpression(sft: SimpleFeatureType, ecql: String): Expression = {
404     sfts.set(sft)
405     try { ECQL.toExpression(ecql, factory) } finally {
406       sfts.remove()
407     }
408   }
409 
410   def optimize(sft: SimpleFeatureType, filter: Filter): Filter = {
411     sfts.set(sft)
412     try { QueryPlanFilterVisitor(sft, filter, factory) } finally {
413       sfts.remove()
414     }
415   }
416 
417   def copy(sft: SimpleFeatureType, filter: Filter): Filter = {
418     sfts.set(sft)
419     try { filter.accept(new DuplicatingFilterVisitor(factory), null).asInstanceOf[Filter] } finally {
420       sfts.remove()
421     }
422   }
423 }