@Override
public int compareTo(Datum datum) {
switch (datum.type()) {
case STRING:
return this.val.compareTo(((StringDatum) datum).val);
default:
throw new InvalidOperationException(datum.type());
}
}
@Override
public BoolDatum equalsTo(Datum datum) {
switch (datum.type()) {
case STRING:
return DatumFactory.createBool(this.val.equals(((StringDatum) datum).val));
default:
throw new InvalidOperationException(datum.type());
}
}
@Override
public Datum equalsTo(Datum datum) {
switch (datum.type()) {
case BLOB:
return DatumFactory.createBool(Arrays.equals(this.val, ((BlobDatum) datum).val));
case NULL_TYPE:
return datum;
default:
throw new InvalidOperationException(datum.type());
}
}
@Override
public int compareTo(Datum datum) {
switch (datum.type()) {
case BLOB:
initFromBytes();
((BlobDatum) datum).initFromBytes();
return bb.compareTo(((BlobDatum) datum).bb);
case NULL_TYPE:
return -1;
default:
throw new InvalidOperationException(datum.type());
}
}
public static Datum cast(Datum operandDatum, DataType target, @Nullable TimeZone tz) {
switch (target.getType()) {
case BOOLEAN:
return DatumFactory.createBool(operandDatum.asBool());
case CHAR:
return DatumFactory.createChar(operandDatum.asChar());
case INT1:
case INT2:
return DatumFactory.createInt2(operandDatum.asInt2());
case INT4:
return DatumFactory.createInt4(operandDatum.asInt4());
case INT8:
return DatumFactory.createInt8(operandDatum.asInt8());
case FLOAT4:
return DatumFactory.createFloat4(operandDatum.asFloat4());
case FLOAT8:
return DatumFactory.createFloat8(operandDatum.asFloat8());
case VARCHAR:
case TEXT:
switch (operandDatum.type()) {
case TIMESTAMP:
{
TimestampDatum timestampDatum = (TimestampDatum) operandDatum;
if (tz != null) {
return DatumFactory.createText(
TimestampDatum.asChars(operandDatum.asTimeMeta(), tz, false));
} else {
return DatumFactory.createText(timestampDatum.asChars());
}
}
default:
return DatumFactory.createText(operandDatum.asTextBytes());
}
case DATE:
return DatumFactory.createDate(operandDatum);
case TIME:
return DatumFactory.createTime(operandDatum);
case TIMESTAMP:
return DatumFactory.createTimestamp(operandDatum, tz);
case BLOB:
return DatumFactory.createBlob(operandDatum.asByteArray());
case INET4:
return DatumFactory.createInet4(operandDatum.asByteArray());
case ANY:
return DatumFactory.createAny(operandDatum);
default:
throw new TajoRuntimeException(
new InvalidValueForCastException(operandDatum.type(), target.getType()));
}
}
public static DateDatum createDate(Datum datum) {
switch (datum.type()) {
case INT4:
return new DateDatum(datum.asInt4());
case INT8:
return new DateDatum(datum.asInt4());
case TEXT:
return createDate(datum.asChars());
case DATE:
return (DateDatum) datum;
default:
throw new TajoRuntimeException(new InvalidValueForCastException(datum.type(), Type.DATE));
}
}
public static TimeDatum createTime(Datum datum) {
switch (datum.type()) {
case INT8:
return new TimeDatum(datum.asInt8());
case CHAR:
case VARCHAR:
case TEXT:
TimeMeta tm = DateTimeFormat.parseDateTime(datum.asChars(), "HH24:MI:SS.MS");
return new TimeDatum(DateTimeUtil.toTime(tm));
case TIME:
return (TimeDatum) datum;
default:
throw new TajoRuntimeException(new InvalidValueForCastException(datum.type(), Type.TIME));
}
}
@Override
public int compareTo(Datum datum) {
switch (datum.type()) {
case SHORT:
if (val < datum.asShort()) {
return -1;
} else if (datum.asShort() < val) {
return 1;
} else {
return 0;
}
case INT:
if (val < datum.asInt()) {
return -1;
} else if (datum.asInt() < val) {
return 1;
} else {
return 0;
}
case LONG:
if (val < datum.asLong()) {
return -1;
} else if (datum.asLong() < val) {
return 1;
} else {
return 0;
}
case FLOAT:
if (val < datum.asFloat()) {
return -1;
} else if (datum.asFloat() < val) {
return 1;
} else {
return 0;
}
case DOUBLE:
if (val < datum.asDouble()) {
return -1;
} else if (datum.asDouble() < val) {
return 1;
} else {
return 0;
}
default:
throw new InvalidOperationException(datum.type());
}
}
@Override
public Datum modular(Datum datum) {
switch (datum.type()) {
case SHORT:
return DatumFactory.createShort((short) (val % datum.asShort()));
case INT:
return DatumFactory.createInt(val % datum.asInt());
case LONG:
return DatumFactory.createLong(val % datum.asLong());
case FLOAT:
return DatumFactory.createFloat(val % datum.asFloat());
case DOUBLE:
return DatumFactory.createDouble(val % datum.asDouble());
default:
throw new InvalidOperationException(datum.type());
}
}
@Override
public BoolDatum equalsTo(Datum datum) {
switch (datum.type()) {
case SHORT:
return DatumFactory.createBool(val == datum.asShort());
case INT:
return DatumFactory.createBool(val == datum.asInt());
case LONG:
return DatumFactory.createBool(val == datum.asLong());
case FLOAT:
return DatumFactory.createBool(val == datum.asFloat());
case DOUBLE:
return DatumFactory.createBool(val == datum.asDouble());
default:
throw new InvalidOperationException(datum.type());
}
}
public static TimestampDatum createTimestamp(Datum datum, @Nullable TimeZone tz) {
switch (datum.type()) {
case CHAR:
case VARCHAR:
case TEXT:
return parseTimestamp(datum.asChars(), tz);
case TIMESTAMP:
return (TimestampDatum) datum;
case DATE:
{
TimeMeta tm = datum.asTimeMeta();
if (tz != null) {
DateTimeUtil.toUTCTimezone(tm, tz);
}
return new TimestampDatum(DateTimeUtil.toJulianTimestamp(tm));
}
default:
throw new TajoRuntimeException(
new InvalidValueForCastException(datum.type(), Type.TIMESTAMP));
}
}
