Support the literal expression for the following data types

- Byte
- Boolean
- BigDecimal
- BigInteger
- Double
- Float
- LocalDate
- LocalDateTime
- LocalTime
- Long
- Short

Author: nakamura-to

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/expression/AggregateFunction.java

@@ -89,7 +89,7 @@ public Class<?> asClass() {
 
     @Override
     public EntityPropertyType<?, Long> asType() {
-      return LongPropertyType.INSTANCE;
+      return new LongPropertyType(null);
     }
 
     @Override
@@ -161,7 +161,7 @@ public Class<?> asClass() {
 
     @Override
     public EntityPropertyType<?, ?> asType() {
-      return LongPropertyType.INSTANCE;
+      return new LongPropertyType(null);
     }
 
     @Override

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/expression/BasicPropertyTypes.java

@@ -1,5 +1,10 @@
 package org.seasar.doma.jdbc.criteria.expression;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.BiFunction;
@@ -11,13 +16,29 @@
 import org.seasar.doma.jdbc.entity.EntityPropertyType;
 import org.seasar.doma.jdbc.entity.NamingType;
 import org.seasar.doma.jdbc.entity.Property;
+import org.seasar.doma.wrapper.BigDecimalWrapper;
+import org.seasar.doma.wrapper.BigIntegerWrapper;
+import org.seasar.doma.wrapper.BooleanWrapper;
+import org.seasar.doma.wrapper.ByteWrapper;
+import org.seasar.doma.wrapper.DoubleWrapper;
+import org.seasar.doma.wrapper.FloatWrapper;
 import org.seasar.doma.wrapper.IntegerWrapper;
+import org.seasar.doma.wrapper.LocalDateTimeWrapper;
+import org.seasar.doma.wrapper.LocalDateWrapper;
+import org.seasar.doma.wrapper.LocalTimeWrapper;
 import org.seasar.doma.wrapper.LongWrapper;
+import org.seasar.doma.wrapper.ShortWrapper;
 import org.seasar.doma.wrapper.StringWrapper;
 import org.seasar.doma.wrapper.Wrapper;
 
 abstract class BasicPropertyType<BASIC> implements EntityPropertyType<Object, BASIC> {
 
+  protected final BASIC value;
+
+  protected BasicPropertyType(BASIC value) {
+    this.value = value;
+  }
+
   @Override
   public String getName() {
     throw new UnsupportedOperationException();
@@ -119,53 +140,249 @@ public Optional<Class<?>> getDomainClass() {
   }
 }
 
-class StringPropertyType extends BasicPropertyType<String> {
+class BigDecimalPropertyType extends BasicPropertyType<BigDecimal> {
 
-  static final StringPropertyType INSTANCE = new StringPropertyType();
+  BigDecimalPropertyType(BigDecimal value) {
+    super(value);
+  }
 
   @Override
-  public Property<Object, String> createProperty() {
-    return new StringProperty();
+  public Property<Object, BigDecimal> createProperty() {
+    return new BigDecimalProperty(value);
   }
 
-  static class StringProperty extends BasicProperty<String> {
+  static class BigDecimalProperty extends BasicProperty<BigDecimal> {
+
+    BigDecimalProperty(BigDecimal value) {
+      super(new BasicScalar<>(new BigDecimalWrapper(value)));
+    }
+  }
+}
+
+class BigIntegerPropertyType extends BasicPropertyType<BigInteger> {
+
+  BigIntegerPropertyType(BigInteger value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, BigInteger> createProperty() {
+    return new BigIntegerProperty(value);
+  }
+
+  static class BigIntegerProperty extends BasicProperty<BigInteger> {
+
+    BigIntegerProperty(BigInteger value) {
+      super(new BasicScalar<>(new BigIntegerWrapper(value)));
+    }
+  }
+}
+
+class BooleanPropertyType extends BasicPropertyType<Boolean> {
+
+  BooleanPropertyType(Boolean value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, Boolean> createProperty() {
+    return new BooleanProperty(value);
+  }
+
+  static class BooleanProperty extends BasicProperty<Boolean> {
+
+    BooleanProperty(Boolean value) {
+      super(new BasicScalar<>(new BooleanWrapper(value)));
+    }
+  }
+}
+
+class BytePropertyType extends BasicPropertyType<Byte> {
+
+  BytePropertyType(Byte value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, Byte> createProperty() {
+    return new ByteProperty(value);
+  }
+
+  static class ByteProperty extends BasicProperty<Byte> {
+
+    ByteProperty(Byte value) {
+      super(new BasicScalar<>(new ByteWrapper(value)));
+    }
+  }
+}
+
+class DoublePropertyType extends BasicPropertyType<Double> {
+
+  DoublePropertyType(Double value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, Double> createProperty() {
+    return new DoubleProperty(value);
+  }
+
+  static class DoubleProperty extends BasicProperty<Double> {
+
+    DoubleProperty(Double value) {
+      super(new BasicScalar<>(new DoubleWrapper(value)));
+    }
+  }
+}
+
+class FloatPropertyType extends BasicPropertyType<Float> {
+
+  FloatPropertyType(Float value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, Float> createProperty() {
+    return new FloatProperty(value);
+  }
 
-    protected StringProperty() {
-      super(new BasicScalar<>(new StringWrapper()));
+  static class FloatProperty extends BasicProperty<Float> {
+
+    FloatProperty(Float value) {
+      super(new BasicScalar<>(new FloatWrapper(value)));
     }
   }
 }
 
 class IntegerPropertyType extends BasicPropertyType<Integer> {
 
-  static final IntegerPropertyType INSTANCE = new IntegerPropertyType();
+  IntegerPropertyType(Integer value) {
+    super(value);
+  }
 
   @Override
   public Property<Object, Integer> createProperty() {
-    return new IntegerProperty();
+    return new IntegerProperty(value);
   }
 
   static class IntegerProperty extends BasicProperty<Integer> {
 
-    protected IntegerProperty() {
-      super(new BasicScalar<>(new IntegerWrapper()));
+    IntegerProperty(Integer value) {
+      super(new BasicScalar<>(new IntegerWrapper(value)));
+    }
+  }
+}
+
+class LocalDatePropertyType extends BasicPropertyType<LocalDate> {
+
+  LocalDatePropertyType(LocalDate value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, LocalDate> createProperty() {
+    return new LocalDateProperty(value);
+  }
+
+  static class LocalDateProperty extends BasicProperty<LocalDate> {
+
+    LocalDateProperty(LocalDate value) {
+      super(new BasicScalar<>(new LocalDateWrapper(value)));
+    }
+  }
+}
+
+class LocalDateTimePropertyType extends BasicPropertyType<LocalDateTime> {
+
+  LocalDateTimePropertyType(LocalDateTime value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, LocalDateTime> createProperty() {
+    return new LocalDateTimeProperty(value);
+  }
+
+  static class LocalDateTimeProperty extends BasicProperty<LocalDateTime> {
+
+    LocalDateTimeProperty(LocalDateTime value) {
+      super(new BasicScalar<>(new LocalDateTimeWrapper(value)));
+    }
+  }
+}
+
+class LocalTimePropertyType extends BasicPropertyType<LocalTime> {
+
+  LocalTimePropertyType(LocalTime value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, LocalTime> createProperty() {
+    return new LocalTimeProperty(value);
+  }
+
+  static class LocalTimeProperty extends BasicProperty<LocalTime> {
+
+    LocalTimeProperty(LocalTime value) {
+      super(new BasicScalar<>(new LocalTimeWrapper(value)));
     }
   }
 }
 
 class LongPropertyType extends BasicPropertyType<Long> {
 
-  static final LongPropertyType INSTANCE = new LongPropertyType();
+  LongPropertyType(Long value) {
+    super(value);
+  }
 
   @Override
   public Property<Object, Long> createProperty() {
-    return new LongProperty();
+    return new LongProperty(value);
   }
 
   static class LongProperty extends BasicProperty<Long> {
 
-    protected LongProperty() {
-      super(new BasicScalar<>(new LongWrapper()));
+    LongProperty(Long value) {
+      super(new BasicScalar<>(new LongWrapper(value)));
+    }
+  }
+}
+
+class ShortPropertyType extends BasicPropertyType<Short> {
+
+  ShortPropertyType(Short value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, Short> createProperty() {
+    return new ShortProperty(value);
+  }
+
+  static class ShortProperty extends BasicProperty<Short> {
+
+    ShortProperty(Short value) {
+      super(new BasicScalar<>(new ShortWrapper(value)));
+    }
+  }
+}
+
+class StringPropertyType extends BasicPropertyType<String> {
+
+  StringPropertyType(String value) {
+    super(value);
+  }
+
+  @Override
+  public Property<Object, String> createProperty() {
+    return new StringProperty(value);
+  }
+
+  static class StringProperty extends BasicProperty<String> {
+
+    StringProperty(String value) {
+      super(new BasicScalar<>(new StringWrapper(value)));
     }
   }
 }