Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.tajo.datum; import com.google.common.primitives.Longs; import org.apache.tajo.common.TajoDataTypes; import org.apache.tajo.exception.InvalidOperationException; import org.apache.tajo.util.datetime.DateTimeUtil; import org.apache.tajo.util.datetime.TimeMeta; import java.text.DecimalFormat; import java.util.HashMap; import java.util.Map; import static org.apache.tajo.type.Type.Interval; public class IntervalDatum extends Datum { public static final long MINUTE_MILLIS = 60 * 1000; public static final long HOUR_MILLIS = 60 * MINUTE_MILLIS; public static final long DAY_MILLIS = 24 * HOUR_MILLIS; public static final long MONTH_MILLIS = 30 * DAY_MILLIS; static enum DATE_UNIT { CENTURY, DECADE, YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, MICROSEC, MILLISEC, TIMEZONE, } static Map<String, DATE_UNIT> DATE_FORMAT_LITERAL = new HashMap<>(); static { Object[][] dateFormatLiterals = new Object[][] { { DATE_UNIT.CENTURY, "c,cent,centuries,century" }, { DATE_UNIT.DAY, "d,day,days" }, { DATE_UNIT.DECADE, "dec,decade,decades,decs" }, { DATE_UNIT.HOUR, "h,hour,hours,hr,hrs" }, { DATE_UNIT.MILLISEC, "millisecon,ms,msec,msecond,mseconds,msecs" }, { DATE_UNIT.MINUTE, "m,min,mins,minute,minutes" }, { DATE_UNIT.MONTH, "mon,mons,month,months" }, { DATE_UNIT.SECOND, "s,sec,second,seconds,secs" }, { DATE_UNIT.TIMEZONE, "timezone" }, { DATE_UNIT.MICROSEC, "microsecon,us,usec,microsecond,useconds,usecs" }, { DATE_UNIT.YEAR, "y,year,years,yr,yrs" } }; for (Object[] eachLiteral : dateFormatLiterals) { String[] tokens = ((String) eachLiteral[1]).split(","); DATE_UNIT unit = (DATE_UNIT) eachLiteral[0]; for (String eachToken : tokens) { DATE_FORMAT_LITERAL.put(eachToken, unit); } } } final int months; final long milliseconds; public IntervalDatum(long milliseconds) { this(0, milliseconds); } public IntervalDatum(int months, long milliseconds) { super(Interval); this.months = months; this.milliseconds = milliseconds; } public IntervalDatum(String intervalStr) { super(Interval); intervalStr = intervalStr.trim(); if (intervalStr.isEmpty()) { throw new InvalidOperationException("interval expression is empty"); } try { int year = 0; int month = 0; int day = 0; int hour = 0; int minute = 0; int second = 0; int microsecond = 0; int millisecond = 0; long time = 0; int length = intervalStr.getBytes().length; StringBuilder digitChars = new StringBuilder(); StringBuilder unitChars = new StringBuilder(); for (int i = 0; i < length; i++) { char c = intervalStr.charAt(i); if (Character.isDigit(c) || c == ':' || c == '.' || c == '-') { digitChars.append(c); } else if (c == ' ') { if (digitChars.length() > 0) { if (unitChars.length() > 0) { String unitName = unitChars.toString(); DATE_UNIT foundUnit = DATE_FORMAT_LITERAL.get(unitName); if (foundUnit == null) { throw new InvalidOperationException( "invalid input syntax for type interval: " + intervalStr); } int digit = Integer.parseInt(digitChars.toString()); switch (foundUnit) { case YEAR: year = digit; break; case MONTH: month = digit; break; case DAY: day = digit; break; case HOUR: hour = digit; break; case MINUTE: minute = digit; break; case SECOND: second = digit; break; case MICROSEC: microsecond = digit; break; case MILLISEC: millisecond = digit; break; default: throw new InvalidOperationException("Unknown datetime unit: " + foundUnit); } digitChars.setLength(0); unitChars.setLength(0); } else if (digitChars.indexOf(":") >= 0) { time = parseTime(digitChars.toString()); digitChars.setLength(0); } } } else { unitChars.append(c); } } if (digitChars.length() > 0) { if (unitChars.length() > 0) { String unitName = unitChars.toString(); DATE_UNIT foundUnit = DATE_FORMAT_LITERAL.get(unitName); if (foundUnit == null) { throw new InvalidOperationException( "invalid input syntax for type interval: " + intervalStr); } int digit = Integer.parseInt(digitChars.toString()); switch (foundUnit) { case YEAR: year = digit; break; case MONTH: month = digit; break; case DAY: day = digit; break; case HOUR: hour = digit; break; case MINUTE: minute = digit; break; case SECOND: second = digit; break; case MICROSEC: microsecond = digit; break; case MILLISEC: millisecond = digit; break; default: throw new InvalidOperationException("Unknown datetime unit: " + foundUnit); } } else if (digitChars.indexOf(":") >= 0) { time = parseTime(digitChars.toString()); digitChars.setLength(0); } } if (time > 0 && (hour != 0 || minute != 0 || second != 0 || microsecond != 0 || millisecond != 0)) { throw new InvalidOperationException("invalid input syntax for type interval: " + intervalStr); } this.milliseconds = time + day * DAY_MILLIS + hour * HOUR_MILLIS + minute * 60 * 1000L + second * 1000L + microsecond * 100L + millisecond; this.months = year * 12 + month; } catch (InvalidOperationException e) { throw e; } catch (Throwable t) { throw new InvalidOperationException(t.getMessage() + ": " + intervalStr); } } public static long parseTime(String timeStr) { //parse HH:mm:ss.SSS int hour = 0; int minute = 0; int second = 0; int millisecond = 0; String[] timeTokens = timeStr.split(":"); if (timeTokens.length == 1) { //sec String[] secondTokens = timeTokens[0].split("\\."); if (secondTokens.length == 1) { second = Integer.parseInt(secondTokens[0]); } else if (secondTokens.length == 2) { millisecond = Integer.parseInt(secondTokens[1]); } else { throw new InvalidOperationException("invalid input syntax for type interval: " + timeStr); } } else { if (timeTokens.length > 3) { throw new InvalidOperationException("invalid input syntax for type interval: " + timeStr); } for (int i = 0; i < timeTokens.length - 1; i++) { if (i == 0) hour = Integer.parseInt(timeTokens[i]); if (i == 1) minute = Integer.parseInt(timeTokens[i]); } if (timeTokens.length == 3) { //sec String[] secondTokens = timeTokens[2].split("\\."); if (secondTokens.length == 1) { second = Integer.parseInt(secondTokens[0]); } else if (secondTokens.length == 2) { second = Integer.parseInt(secondTokens[0]); millisecond = Integer.parseInt(secondTokens[1]); } else { throw new InvalidOperationException("invalid input syntax for type interval: " + timeStr); } } } return hour * HOUR_MILLIS + minute * MINUTE_MILLIS + second * 1000 + millisecond; } public int getMonths() { return this.months; } public long getMilliSeconds() { return milliseconds; } @Override public Datum plus(Datum datum) { switch (datum.kind()) { case INTERVAL: IntervalDatum other = (IntervalDatum) datum; return new IntervalDatum(months + other.months, milliseconds + other.milliseconds); case DATE: { DateDatum dateDatum = (DateDatum) datum; TimeMeta tm = dateDatum.asTimeMeta(); tm.plusInterval(months, milliseconds); return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm)); } case TIME: { TimeMeta tm = datum.asTimeMeta(); tm.plusInterval(months, milliseconds); return new TimeDatum(DateTimeUtil.toTime(tm)); } case TIMESTAMP: { TimeMeta tm = new TimeMeta(); DateTimeUtil.toJulianTimeMeta(datum.asInt8(), tm); tm.plusInterval(months, milliseconds); return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm)); } default: throw new InvalidOperationException("operator does not exist: " + type() + " + " + datum.type()); } } @Override public Datum minus(Datum datum) { if (datum.kind() == TajoDataTypes.Type.INTERVAL) { IntervalDatum other = (IntervalDatum) datum; return new IntervalDatum(months - other.months, milliseconds - other.milliseconds); } else { throw new InvalidOperationException("operator does not exist: " + type() + " - " + datum.type()); } } @Override public Datum multiply(Datum datum) { switch (datum.kind()) { case INT2: case INT4: case INT8: long int8Val = datum.asInt8(); return createIntervalDatum((double) months * int8Val, (double) milliseconds * int8Val); case FLOAT4: case FLOAT8: double float8Val = datum.asFloat8(); return createIntervalDatum((double) months * float8Val, (double) milliseconds * float8Val); default: throw new InvalidOperationException("operator does not exist: " + type() + " * " + datum.type()); } } @Override public Datum divide(Datum datum) { switch (datum.kind()) { case INT2: case INT4: case INT8: long paramValueI8 = datum.asInt8(); if (!validateDivideZero(paramValueI8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueI8, (double) milliseconds / paramValueI8); case FLOAT4: case FLOAT8: double paramValueF8 = datum.asFloat8(); if (!validateDivideZero(paramValueF8)) { return NullDatum.get(); } return createIntervalDatum((double) months / paramValueF8, (double) milliseconds / paramValueF8); default: throw new InvalidOperationException("operator does not exist: " + type() + " / " + datum.type()); } } private IntervalDatum createIntervalDatum(double monthValue, double millisValue) { int month = (int) (monthValue); return new IntervalDatum(month, Math.round((monthValue - (double) month) * (double) MONTH_MILLIS + millisValue)); } @Override public long asInt8() { return (months * 30) * DAY_MILLIS + milliseconds; } @Override public String toString() { return asChars(); } static DecimalFormat df = new DecimalFormat("00"); static DecimalFormat df2 = new DecimalFormat("000"); @Override public String asChars() { try { StringBuilder sb = new StringBuilder(); String prefix = ""; if (months != 0) { int positiveNum = Math.abs(months); int year = positiveNum / 12; int remainMonth = positiveNum - year * 12; if (year > 0) { sb.append(months < 0 ? "-" : ""); sb.append(year).append(year == 1 ? " year" : " years"); prefix = " "; } sb.append(prefix).append(months < 0 ? "-" : "").append(remainMonth) .append(months == 1 ? " month" : " months"); prefix = " "; } formatMillis(sb, prefix, milliseconds); return sb.toString(); } catch (Exception e) { return ""; } } public static String formatMillis(long millis) { StringBuilder sb = new StringBuilder(); formatMillis(sb, "", millis); return sb.toString(); } public static void formatMillis(StringBuilder sb, String prefix, long millis) { if (millis != 0) { long positiveNum = Math.abs(millis); int days = (int) (positiveNum / DAY_MILLIS); long remainInterval = positiveNum - days * DAY_MILLIS; if (days != 0) { sb.append(prefix).append(millis < 0 ? "-" : "").append(days).append(days == 1 ? " day" : " days"); prefix = " "; } if (remainInterval != 0) { int hour = (int) (remainInterval / HOUR_MILLIS); int minutes = (int) (remainInterval - hour * HOUR_MILLIS) / (60 * 1000); long sec = (int) (remainInterval - hour * HOUR_MILLIS - minutes * (60 * 1000L)) / 1000L; long millisecond = (int) (remainInterval - hour * HOUR_MILLIS - minutes * (60 * 1000L) - sec * 1000L); sb.append(prefix).append(millis < 0 ? "-" : "").append(df.format(hour)).append(":") .append(df.format(minutes)).append(":").append(df.format(sec)); if (millisecond > 0) { sb.append(".").append(df2.format(millisecond)); } } } else { sb.append(prefix).append(df.format(0)).append(":").append(df.format(0)).append(":") .append(df.format(0)); } } @Override public int size() { return 0; } @Override public int compareTo(Datum datum) { if (datum.kind() == TajoDataTypes.Type.INTERVAL) { return Longs.compare(asInt8(), datum.asInt8()); } else if (datum instanceof NullDatum || datum.isNull()) { return -1; } else { throw new InvalidOperationException(datum.type()); } } @Override public Datum equalsTo(Datum datum) { if (datum.kind() == TajoDataTypes.Type.INTERVAL) { return DatumFactory.createBool(asInt8() == datum.asInt8()); } else if (datum.isNull()) { return datum; } else { throw new InvalidOperationException(datum.type()); } } @Override public boolean equals(Object obj) { if (obj instanceof IntervalDatum) { return asInt8() == ((IntervalDatum) obj).asInt8(); } else { return false; } } @Override public int hashCode() { return Longs.hashCode(asInt8()); } }