@Test public void testTimePlusDayTimeInterval() { final Period period = new Period("P1DT1H1M"); testExpression( rexBuilder.makeCall( SqlStdOperatorTable.DATETIME_PLUS, inputRef("t"), rexBuilder.makeIntervalLiteral( new BigDecimal(period.toStandardDuration().getMillis()), // DAY-TIME literals value is millis new SqlIntervalQualifier(TimeUnit.DAY, TimeUnit.MINUTE, SqlParserPos.ZERO) ) ), DruidExpression.of( null, "(\"t\" + 90060000)" ), DateTimes.of("2000-02-03T04:05:06").plus(period).getMillis() ); }
final RelDataTypeSystem typeSystem = typeFactory.getTypeSystem(); final int startPrecision = qualifier.getStartPrecision(typeSystem); final int fracPrecision = qualifier.getFractionalSecondPrecision(typeSystem); final int maxPrecision = typeSystem.getMaxPrecision(qualifier.typeName()); final int minPrecision = qualifier.typeName().getMinPrecision(); final int minScale = qualifier.typeName().getMinScale(); final int maxScale = typeSystem.getMaxScale(qualifier.typeName()); if (qualifier.isYearMonth()) { if (startPrecision < minPrecision || startPrecision > maxPrecision) { startPrecisionOutOfRange = true;
getFractionalSecondPrecision(typeSystem); String intervalPatternWithFracSec = "(\\d+) (\\d{1,2}):(\\d{1,2}):(\\d{1,2})\\.(\\d{1," day = parseField(m, 1); hour = parseField(m, 2); minute = parseField(m, 3); second = parseField(m, 4); } catch (NumberFormatException e) { throw invalidValueException(pos, originalValue); secondFrac = normalizeSecondFraction(m.group(5)); } else { secondFrac = ZERO; checkLeadFieldInRange(typeSystem, sign, day, TimeUnit.DAY, pos); if (!(isSecondaryFieldInRange(hour, TimeUnit.HOUR)) || !(isSecondaryFieldInRange(minute, TimeUnit.MINUTE)) || !(isSecondaryFieldInRange(second, TimeUnit.SECOND)) || !(isFractionalSecondFieldInRange(secondFrac))) { throw invalidValueException(pos, originalValue); return fillIntervalValueArray( sign, day, secondFrac); } else { throw invalidValueException(pos, originalValue);
relDataType .getIntervalQualifier() .getFractionalSecondPrecision( RelDataTypeSystemImpl.REL_DATA_TYPE_SYSTEM); break; relDataType .getIntervalQualifier() .getStartPrecision(RelDataTypeSystemImpl.REL_DATA_TYPE_SYSTEM); final TimeUnit start = relDataType.getIntervalQualifier().getStartUnit(); final TimeUnit end = MoreObjects.firstNonNull(relDataType.getIntervalQualifier().getEndUnit(), start); if ( start == end ) { this.INTERVAL_TYPE = start.name();
public static long intervalToMonths( String literal, SqlIntervalQualifier intervalQualifier) { Preconditions.checkArgument(intervalQualifier.isYearMonth(), "interval must be year month"); int[] ret; try { ret = intervalQualifier.evaluateIntervalLiteral(literal, intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT); assert ret != null; } catch (CalciteContextException e) { throw new RuntimeException("Error while parsing year-to-month interval " + literal, e); } long l = 0; long[] conv = new long[2]; conv[1] = 1; // months conv[0] = conv[1] * 12; // years for (int i = 1; i < ret.length; i++) { l += conv[i - 1] * ret[i]; } return ret[0] * l; }
final String start = qualifier.timeUnitRange.startUnit.name(); final int fractionalSecondPrecision = qualifier.getFractionalSecondPrecision(typeSystem); final int startPrecision = qualifier.getStartPrecision(typeSystem); if (qualifier.timeUnitRange.startUnit == TimeUnit.SECOND) { if (!qualifier.useDefaultFractionalSecondPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); writer.sep(",", true); writer.print(qualifier.getFractionalSecondPrecision(typeSystem)); writer.endList(frame); } else if (!qualifier.useDefaultStartPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); if (!qualifier.useDefaultStartPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); final String end = qualifier.timeUnitRange.endUnit.name(); if ((TimeUnit.SECOND == qualifier.timeUnitRange.endUnit) && (!qualifier.useDefaultFractionalSecondPrecision())) { final SqlWriter.Frame frame = writer.startFunCall(end); writer.print(fractionalSecondPrecision);
public static int combineFractionalSecondPrecisionPreservingDefault( RelDataTypeSystem typeSystem, SqlIntervalQualifier qual1, SqlIntervalQualifier qual2) { final int p1 = qual1.getFractionalSecondPrecision(typeSystem); final int p2 = qual2.getFractionalSecondPrecision(typeSystem); if (p1 > p2) { // qual1 is more precise, but if it has the default indicator // set, we need to return that indicator so result will also // use default return qual1.getFractionalSecondPrecisionPreservingDefault(); } else if (p1 < p2) { // qual2 is more precise, but if it has the default indicator // set, we need to return that indicator so result will also // use default return qual2.getFractionalSecondPrecisionPreservingDefault(); } else { // they are equal. return default if both are default, // otherwise return exact precision if (qual1.useDefaultFractionalSecondPrecision() && qual2.useDefaultFractionalSecondPrecision()) { return qual1.getFractionalSecondPrecisionPreservingDefault(); } else { return p1; } } }
public static int combineStartPrecisionPreservingDefault( RelDataTypeSystem typeSystem, SqlIntervalQualifier qual1, SqlIntervalQualifier qual2) { final int start1 = qual1.getStartPrecision(typeSystem); final int start2 = qual2.getStartPrecision(typeSystem); if (start1 > start2) { // qual1 is more precise, but if it has the default indicator // set, we need to return that indicator so result will also // use default return qual1.getStartPrecisionPreservingDefault(); } else if (start1 < start2) { // qual2 is more precise, but if it has the default indicator // set, we need to return that indicator so result will also // use default return qual2.getStartPrecisionPreservingDefault(); } else { // they are equal. return default if both are default, // otherwise return exact precision if (qual1.useDefaultStartPrecision() && qual2.useDefaultStartPrecision()) { return qual1.getStartPrecisionPreservingDefault(); } else { return start1; } } }
/** * Gets the time range start unit of the type qualifier of the interval data * type descriptor of this field (<i>iff</i> interval type). */ public TimeUnit getStartUnit() { return null == intervalQualifier ? null : intervalQualifier.getStartUnit(); }
/** * Converts a chained string literals into regular literals; returns regular * literals unchanged. * @throws IllegalArgumentException if {@code node} is not a string literal * and cannot be unchained. */ public static SqlLiteral unchain(SqlNode node) { if (node instanceof SqlLiteral) { return (SqlLiteral) node; } else if (SqlUtil.isLiteralChain(node)) { return SqlLiteralChainOperator.concatenateOperands((SqlCall) node); } else if (node instanceof SqlIntervalQualifier) { final SqlIntervalQualifier q = (SqlIntervalQualifier) node; return new SqlLiteral( new SqlIntervalLiteral.IntervalValue(q, 1, q.toString()), q.typeName(), q.pos); } else { throw new IllegalArgumentException("invalid literal: " + node); } }
private void checkLeadFieldInRange(RelDataTypeSystem typeSystem, int sign, BigDecimal value, TimeUnit unit, SqlParserPos pos) { if (!isLeadFieldInRange(typeSystem, value, unit)) { throw fieldExceedsPrecisionException( pos, sign, value, unit, getStartPrecision(typeSystem)); } }
@Override public int getPrecision() { return intervalQualifier.getStartPrecision(typeSystem); }
@Override public int getScale() { return intervalQualifier.getFractionalSecondPrecision(typeSystem); } }
public void checkIntervalConv(String sql, String expected) { SqlValidator validator = getValidator(); final SqlCall n = (SqlCall) parseAndValidate(validator, sql); SqlNode node = null; for (int i = 0; i < n.operandCount(); i++) { node = stripAs(n.operand(i)); if (node instanceof SqlCall) { node = ((SqlCall) node).operand(0); break; } } assertNotNull(node); SqlIntervalLiteral intervalLiteral = (SqlIntervalLiteral) node; SqlIntervalLiteral.IntervalValue interval = (SqlIntervalLiteral.IntervalValue) intervalLiteral.getValue(); long l = interval.getIntervalQualifier().isYearMonth() ? SqlParserUtil.intervalToMonths(interval) : SqlParserUtil.intervalToMillis(interval); String actual = l + ""; assertEquals(expected, actual); }
/** * Gets the fractional second precision of the type qualifier of the interval * data type descriptor of this field (<i>iff</i> interval type). * Gets the interval type descriptor's fractional second precision * (<i>iff</i> interval type). */ public Integer getFractionalSecondPrecision() { return null == intervalQualifier ? null : intervalQualifier.getFractionalSecondPrecisionPreservingDefault(); }
getFractionalSecondPrecision(typeSystem); String intervalPatternWithFracSec = "(\\d+):(\\d{1,2}):(\\d{1,2})\\.(\\d{1," hour = parseField(m, 1); minute = parseField(m, 2); second = parseField(m, 3); } catch (NumberFormatException e) { throw invalidValueException(pos, originalValue); secondFrac = normalizeSecondFraction(m.group(4)); } else { secondFrac = ZERO; checkLeadFieldInRange(typeSystem, sign, hour, TimeUnit.HOUR, pos); if (!(isSecondaryFieldInRange(minute, TimeUnit.MINUTE)) || !(isSecondaryFieldInRange(second, TimeUnit.SECOND)) || !(isFractionalSecondFieldInRange(secondFrac))) { throw invalidValueException(pos, originalValue); return fillIntervalValueArray( sign, ZERO, secondFrac); } else { throw invalidValueException(pos, originalValue);
relDataType .getIntervalQualifier() .getFractionalSecondPrecision( DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM ); break; relDataType .getIntervalQualifier() .getStartPrecision(DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM); final TimeUnit start = relDataType.getIntervalQualifier().getStartUnit(); final TimeUnit end = MoreObjects.firstNonNull(relDataType.getIntervalQualifier().getEndUnit(), start); if ( start == end ) { this.INTERVAL_TYPE = start.name();
public static long intervalToMonths( String literal, SqlIntervalQualifier intervalQualifier) { Preconditions.checkArgument(intervalQualifier.isYearMonth(), "interval must be year month"); int[] ret; try { ret = intervalQualifier.evaluateIntervalLiteral(literal, intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT); assert ret != null; } catch (CalciteContextException e) { throw new RuntimeException("Error while parsing year-to-month interval " + literal, e); } long l = 0; long[] conv = new long[2]; conv[1] = 1; // months conv[0] = conv[1] * 12; // years for (int i = 1; i < ret.length; i++) { l += conv[i - 1] * ret[i]; } return ret[0] * l; }
final String start = qualifier.timeUnitRange.startUnit.name(); final int fractionalSecondPrecision = qualifier.getFractionalSecondPrecision(typeSystem); final int startPrecision = qualifier.getStartPrecision(typeSystem); if (qualifier.timeUnitRange.startUnit == TimeUnit.SECOND) { if (!qualifier.useDefaultFractionalSecondPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); writer.sep(",", true); writer.print(qualifier.getFractionalSecondPrecision(typeSystem)); writer.endList(frame); } else if (!qualifier.useDefaultStartPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); if (!qualifier.useDefaultStartPrecision()) { final SqlWriter.Frame frame = writer.startFunCall(start); writer.print(startPrecision); final String end = qualifier.timeUnitRange.endUnit.name(); if ((TimeUnit.SECOND == qualifier.timeUnitRange.endUnit) && (!qualifier.useDefaultFractionalSecondPrecision())) { final SqlWriter.Frame frame = writer.startFunCall(end); writer.print(fractionalSecondPrecision);