Method to construct the greater than expression for date

@param value the date value
@return Expression
322875
public Expression<java.util.Date> gt(java.util.Date value) {
		SimpleDateFormat formatter = getDateTimeFormatter();
		String valueString = "'" + formatter.format(value).concat("Z") + "'";
		return new Expression<java.util.Date>(this, Operation.gt, valueString);
	}
1133367
def GreaterThanOrEqualTo(self, value):
    
    self._awql = self._CreateSingleValueCondition(value, '>=')
    return self._query_builder
310918
public static Expression constant(final long value) {
    return new Expression(Type.LONG_TYPE, Feature.CHEAP) {
      @Override
      protected void doGen(CodeBuilder mv) {
        mv.pushLong(value);
      }
    };
  }
1248339
public static String formatDate(long value) {
        synchronized (HttpDateFormat.class) {
            Date dateValue = new Date(value);
            return FORMAT.format(dateValue);
        }
    }
308527
@SuppressWarnings("unchecked")
	@Override
	public T greaterEqual(final String col, final Object value) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new GreaterEqual(col, value));
		this.useOperator = true;
		return (T) this;
	}
926282
public Expression<Double> gt(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.gt, valueString);
	}
732273
public Expression<Float> gt(float value) {
		String valueString = "'" + value + "'";
		return new Expression<Float>(this, Operation.gt, valueString);
	}
557848
private static DateTime getDateValue(String value) {
		return DateUtil.date(org.apache.poi.ss.usermodel.DateUtil.getJavaDate(Double.parseDouble(value), false));
	}
619668
public Expression<Long> lte(long value) {
		String valueString = "'" + value + "'";
		return new Expression<Long>(this, Operation.lte, valueString);
	}
850716
@SuppressWarnings("unchecked")
	@Override
	public T greaterThan(final String col, final Object value) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new GreaterThan(col, value));
		this.useOperator = true;
		return (T) this;
	}
870341
public Expression<Byte> eq(byte value) {
		String valueString = "'" + value + "'";
		return new Expression<Byte>(this, Operation.eq, valueString);
	}
286356
private static Calendar valueAsCalendar(Object value) {
		Date date = (Date) value;
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal;
	}
760896
public static AcceptDatetime valueOf(final String value) {
        final Optional<Instant> datetime = parseDatetime(value);
        if (datetime.isPresent()) {
            return new AcceptDatetime(datetime.get());
        }
        return null;
    }
597603
public Expression<String> eq(String value) {
		String valueString = "'" + value + "'";
		return new Expression<String>(this, Operation.eq, valueString);
	}
813127
public static <T extends Comparable<?>> DateExpression<T> asDate(Expression<T> expr) {
        Expression<T> underlyingMixin = ExpressionUtils.extract(expr);
        if (underlyingMixin instanceof PathImpl) {
            return new DatePath<T>((PathImpl<T>) underlyingMixin);
        } else if (underlyingMixin instanceof OperationImpl) {
            return new DateOperation<T>((OperationImpl<T>) underlyingMixin);
        } else if (underlyingMixin instanceof TemplateExpressionImpl) {
            return new DateTemplate<T>((TemplateExpressionImpl<T>) underlyingMixin);
        } else {
            return new DateExpression<T>(underlyingMixin) {

                private static final long serialVersionUID = 389920618099394430L;

                @Override
                public <R, C> R accept(Visitor<R, C> v, C context) {
                    return this.mixin.accept(v, context);
                }

            };
        }

    }
749739
function( value, comparator ) {
			var error;
			if ( value <= parseFloat( comparator ) ) {
				error = {
					"rule": "greater_than",
					"message": "ERROR:provided value [" + value + "] is not greater than " + parseFloat( comparator )
				};
				return [ error ];
			}
			return;
		}
987422
public Expression<Long> gte(long value) {
		String valueString = "'" + value + "'";
		return new Expression<Long>(this, Operation.gte, valueString);
	}