Fixed 'year' function for Intervals.

FraunhoferIOSB · Jun 19, 2018 · 580c4bf · 580c4bf
1 parent dd0f8bb
commit 580c4bf
Show file tree

Hide file tree

Showing 6 changed files with 83 additions and 38 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,7 @@ Version 1.7 is not released yet.
 **Bugfixes**
 * Fixed #53: Query parser not Unicode aware.
 * Fixed #52: Generating FeatureOfInterest did not work for Things with multiple Location entities when some of these entities were not geoJSON.
+* Fixed the 'year' function not working on interval properties.
 
 
 # Release Version 1.6

diff --git a/...QL/src/main/java/de/fraunhofer/iosb/ilt/sta/persistence/postgres/PgExpressionHandler.java b/...QL/src/main/java/de/fraunhofer/iosb/ilt/sta/persistence/postgres/PgExpressionHandler.java
@@ -40,19 +40,19 @@
 import de.fraunhofer.iosb.ilt.sta.path.NavigationProperty;
 import de.fraunhofer.iosb.ilt.sta.path.Property;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ConstantDateExpression;
-import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaDateTimeExpression;
-import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaDurationExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ConstantGeometryExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ConstantNumberExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ConstantStringExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ConstantTimeExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.JsonExpressionFactory;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.ListExpression;
-import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StringCastExpressionFactory;
-import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.TimeExpression;
+import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaDateTimeExpression;
+import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaDurationExpression;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaTimeIntervalExpression;
 import static de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaTimeIntervalExpression.KEY_TIME_INTERVAL_END;
 import static de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StaTimeIntervalExpression.KEY_TIME_INTERVAL_START;
+import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.StringCastExpressionFactory;
+import de.fraunhofer.iosb.ilt.sta.persistence.postgres.expression.TimeExpression;
 import de.fraunhofer.iosb.ilt.sta.query.OrderBy;
 import de.fraunhofer.iosb.ilt.sta.query.expression.ExpressionVisitor;
 import de.fraunhofer.iosb.ilt.sta.query.expression.Path;
@@ -93,15 +93,15 @@
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.date.Time;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.date.TotalOffsetMinutes;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.date.Year;
-import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoDistance;
-import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoIntersects;
-import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoLength;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.logical.And;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.logical.Not;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.logical.Or;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.math.Ceiling;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.math.Floor;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.math.Round;
+import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoDistance;
+import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoIntersects;
+import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.GeoLength;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.STContains;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.STCrosses;
 import de.fraunhofer.iosb.ilt.sta.query.expression.function.spatialrelation.STDisjoint;
@@ -201,7 +201,7 @@ public void addOrderbyToQuery(OrderBy orderBy, SQLQuery<Tuple> sqlQuery) {
         }
         if (resultExpression instanceof StaDateTimeExpression) {
             StaDateTimeExpression dateTime = (StaDateTimeExpression) resultExpression;
-            addToQuery(orderBy, dateTime.getExpression(), sqlQuery);
+            addToQuery(orderBy, dateTime.getDateTime(), sqlQuery);
         }
         if (resultExpression instanceof ListExpression) {
             for (Expression<?> sqlExpression : ((ListExpression) resultExpression).getExpressionsForOrder().values()) {
@@ -795,33 +795,33 @@ public Expression<?> visit(NotEqual node) {
     public Expression<?> visit(Date node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        DateExpression date = SQLExpressions.date(inExp.getExpression());
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        DateExpression date = SQLExpressions.date(inExp.getDateTime());
         return date;
     }
 
     @Override
     public Expression<?> visit(Day node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().dayOfMonth();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().dayOfMonth();
     }
 
     @Override
     public Expression<?> visit(FractionalSeconds node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().milliSecond();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().milliSecond();
     }
 
     @Override
     public Expression<?> visit(Hour node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().hour();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().hour();
     }
 
     @Override
@@ -838,16 +838,16 @@ public Expression<?> visit(MinDateTime node) {
     public Expression<?> visit(Minute node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().minute();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().minute();
     }
 
     @Override
     public Expression<?> visit(Month node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().month();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().month();
     }
 
     @Override
@@ -859,37 +859,37 @@ public Expression<?> visit(Now node) {
     public Expression<?> visit(Second node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().second();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().second();
     }
 
     @Override
     public Expression<?> visit(Time node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
         if (!inExp.isUtc()) {
             throw new IllegalArgumentException("Constants passed to the time() function have to be in UTC.");
         }
-        TimeTemplate<java.sql.Time> time = Expressions.timeTemplate(java.sql.Time.class, "pg_catalog.time({0})", inExp.getExpression());
+        TimeTemplate<java.sql.Time> time = Expressions.timeTemplate(java.sql.Time.class, "pg_catalog.time({0})", inExp.getDateTime());
         return time;
     }
 
     @Override
     public Expression<?> visit(TotalOffsetMinutes node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        NumberExpression<Integer> offset = Expressions.numberTemplate(Integer.class, "timezone({0})", inExp.getExpression()).divide(60);
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        NumberExpression<Integer> offset = Expressions.numberTemplate(Integer.class, "timezone({0})", inExp.getDateTime()).divide(60);
         return offset;
     }
 
     @Override
     public Expression<?> visit(Year node) {
         de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
         Expression<?> input = param.accept(this);
-        StaDateTimeExpression inExp = getSingleOfType(StaDateTimeExpression.class, input);
-        return inExp.getExpression().year();
+        TimeExpression inExp = getSingleOfType(TimeExpression.class, input);
+        return inExp.getDateTime().year();
     }
 
     @Override

diff --git a/...ava/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaDateTimeExpression.java b/...ava/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaDateTimeExpression.java
@@ -24,6 +24,7 @@
 import com.querydsl.core.types.dsl.DateTimeExpression;
 import com.querydsl.core.types.dsl.DateTimeTemplate;
 import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.core.types.dsl.NumberExpression;
 import com.querydsl.core.types.dsl.StringTemplate;
 import de.fraunhofer.iosb.ilt.sta.persistence.postgres.PgExpressionHandler;
 import de.fraunhofer.iosb.ilt.sta.query.expression.constant.DurationConstant;
@@ -66,11 +67,13 @@ public StaDateTimeExpression(DateTimeExpression mixin) {
     /**
      * @return Flag indicating that the original time given was in utc.
      */
+    @Override
     public boolean isUtc() {
         return utc;
     }
 
-    public DateTimeExpression<Timestamp> getExpression() {
+    @Override
+    public DateTimeExpression<Timestamp> getDateTime() {
         return mixin;
     }
 
@@ -101,7 +104,7 @@ private Expression<?> specificOp(String op, StaDateTimeExpression other) {
         switch (op) {
             case "-":
                 String template = "(({0})::timestamp " + op + " ({1})::timestamp)";
-                StringTemplate expression = Expressions.stringTemplate(template, mixin, other.getExpression());
+                StringTemplate expression = Expressions.stringTemplate(template, mixin, other.getDateTime());
                 return new StaDurationExpression(expression);
 
             default:
@@ -222,4 +225,9 @@ public BooleanExpression simpleOpBool(String op, Expression<?> other) {
         throw new UnsupportedOperationException("Can not compare between Duration and " + other.getClass().getName());
     }
 
+    @Override
+    public NumberExpression<Integer> year() {
+        return getDateTime().year();
+    }
+
 }
diff --git a/...ava/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaDurationExpression.java b/...ava/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaDurationExpression.java
@@ -47,6 +47,17 @@ public StaDurationExpression(final StringExpression duration) {
         this.duration = duration;
     }
 
+    @Override
+    public DateTimeExpression<Timestamp> getDateTime() {
+        throw new UnsupportedOperationException("Can not convert duration to DateTime.");
+    }
+
+    @Override
+    public boolean isUtc() {
+        // durations are always utc.
+        return true;
+    }
+
     public StringExpression getDuration() {
         return duration;
     }

diff --git a/...de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaTimeIntervalExpression.java b/...de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/StaTimeIntervalExpression.java
@@ -38,12 +38,16 @@ public class StaTimeIntervalExpression implements TimeExpression {
     public static final String KEY_TIME_INTERVAL_START = "tStart";
     public static final String KEY_TIME_INTERVAL_END = "tEnd";
 
-    final Expression<?> start;
-    final Expression<?> end;
+    /**
+     * Flag indicating that the original time given was in utc.
+     */
+    private boolean utc = true;
+    final DateTimeExpression<Timestamp> start;
+    final DateTimeExpression<Timestamp> end;
 
     public StaTimeIntervalExpression(Map<String, Expression<?>> expressions) {
-        this.start = expressions.get(KEY_TIME_INTERVAL_START);
-        this.end = expressions.get(KEY_TIME_INTERVAL_END);
+        this.start = (DateTimeExpression) expressions.get(KEY_TIME_INTERVAL_START);
+        this.end = (DateTimeExpression) expressions.get(KEY_TIME_INTERVAL_END);
     }
 
     public StaTimeIntervalExpression(DateTimeExpression<Timestamp> start, DateTimeExpression<Timestamp> end) {
@@ -56,14 +60,24 @@ public StaTimeIntervalExpression(Timestamp start, Timestamp end) {
         this.end = StaDateTimeExpression.createDateTimeExpression(ConstantImpl.create(end));
     }
 
-    public Expression<?> getStart() {
+    public DateTimeExpression<Timestamp> getStart() {
         return start;
     }
 
-    public Expression<?> getEnd() {
+    public DateTimeExpression<Timestamp> getEnd() {
         return end;
     }
 
+    @Override
+    public DateTimeExpression<Timestamp> getDateTime() {
+        return start;
+    }
+
+    @Override
+    public boolean isUtc() {
+        return utc;
+    }
+
     @Override
     public Object accept(Visitor vstr, Object c) {
         throw new UnsupportedOperationException("visit on TimeIntervalExpression not supported.");
@@ -97,7 +111,7 @@ private Expression<?> specificOp(String op, StaDateTimeExpression other) {
                 // We calculate with the start time and return a duration.
                 DateTimeExpression dtStart = PgExpressionHandler.checkType(DateTimeExpression.class, start, false);
                 String template = "(({0})::timestamp - ({1})::timestamp)";
-                return new StaDurationExpression(Expressions.stringTemplate(template, dtStart, other.getExpression()));
+                return new StaDurationExpression(Expressions.stringTemplate(template, dtStart, other.getDateTime()));
 
             default:
                 throw new UnsupportedOperationException("Can not '" + op + "' with Interval and " + other.getClass().getName());
@@ -137,7 +151,7 @@ public Expression<?> simpleOp(String op, Expression<?> other) {
     private BooleanExpression specificOpBool(String op, StaDateTimeExpression other) {
         DateTimeExpression s1 = PgExpressionHandler.checkType(DateTimeExpression.class, start, false);
         DateTimeExpression e1 = PgExpressionHandler.checkType(DateTimeExpression.class, end, false);
-        DateTimeExpression t2 = other.getExpression();
+        DateTimeExpression t2 = other.getDateTime();
         switch (op) {
             case "=":
                 return s1.eq(t2).and(e1.eq(t2));

diff --git a/.../main/java/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/TimeExpression.java b/.../main/java/de/fraunhofer/iosb/ilt/sta/persistence/postgres/expression/TimeExpression.java
@@ -19,13 +19,20 @@
 
 import com.querydsl.core.types.Expression;
 import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.DateTimeExpression;
+import com.querydsl.core.types.dsl.NumberExpression;
+import java.sql.Timestamp;
 
 /**
  *
  * @author scf
  */
 public interface TimeExpression extends Expression {
 
+    public DateTimeExpression<Timestamp> getDateTime();
+
+    public boolean isUtc();
+
     public default BooleanExpression eq(Expression<?> other) {
         return simpleOpBool("=", other);
     }
@@ -97,4 +104,8 @@ public default Expression<?> div(Expression<?> other) {
     public Expression<?> simpleOp(String op, Expression<?> other);
 
     public BooleanExpression simpleOpBool(String op, Expression<?> other);
+
+    public default NumberExpression<Integer> year() {
+        return getDateTime().year();
+    }
 }