From 940b64c006fdafb59a549fa7479c6ada5fee3c9b Mon Sep 17 00:00:00 2001 From: Xiaobing Zhou Date: Fri, 27 Feb 2015 10:44:57 -0800 Subject: [PATCH] HIVE-9518: Implement MONTHS_BETWEEN aligned with Oracle one --- .../hadoop/hive/ql/exec/FunctionRegistry.java | 1 + .../hive/ql/udf/generic/GenericUDFDateDiff.java | 137 ++------ .../ql/udf/generic/GenericUDFDateDiffBase.java | 148 +++++++++ .../ql/udf/generic/GenericUDFMonthsBetween.java | 111 +++++++ .../hive/ql/udf/TestGenericUDFMonthsBetween.java | 261 +++++++++++++++ .../queries/clientnegative/udf_datediff_error1.q | 1 + .../queries/clientnegative/udf_datediff_error2.q | 1 + .../clientnegative/udf_months_between_error1.q | 1 + .../clientnegative/udf_months_between_error2.q | 1 + ql/src/test/queries/clientpositive/udf_datediff.q | 107 +++++- .../queries/clientpositive/udf_months_between.q | 103 ++++++ .../clientnegative/udf_datediff_error1.q.out | 1 + .../clientnegative/udf_datediff_error2.q.out | 1 + .../clientnegative/udf_months_between_error1.q.out | 1 + .../clientnegative/udf_months_between_error2.q.out | 1 + .../results/clientpositive/show_functions.q.out | 2 + .../clientpositive/show_functions.q.out.orig | 367 --------------------- .../test/results/clientpositive/udf_datediff.q.out | 315 +++++++++++++++++- .../clientpositive/udf_months_between.q.out | 317 ++++++++++++++++++ 19 files changed, 1386 insertions(+), 491 deletions(-) create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiffBase.java create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFMonthsBetween.java create mode 100644 ql/src/test/org/apache/hadoop/hive/ql/udf/TestGenericUDFMonthsBetween.java create mode 100644 ql/src/test/queries/clientnegative/udf_datediff_error1.q create mode 100644 ql/src/test/queries/clientnegative/udf_datediff_error2.q create mode 100644 ql/src/test/queries/clientnegative/udf_months_between_error1.q create mode 100644 ql/src/test/queries/clientnegative/udf_months_between_error2.q create mode 100644 ql/src/test/queries/clientpositive/udf_months_between.q create mode 100644 ql/src/test/results/clientnegative/udf_datediff_error1.q.out create mode 100644 ql/src/test/results/clientnegative/udf_datediff_error2.q.out create mode 100644 ql/src/test/results/clientnegative/udf_months_between_error1.q.out create mode 100644 ql/src/test/results/clientnegative/udf_months_between_error2.q.out delete mode 100644 ql/src/test/results/clientpositive/show_functions.q.out.orig create mode 100644 ql/src/test/results/clientpositive/udf_months_between.q.out diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java index bfeb33c..cfd094f 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/FunctionRegistry.java @@ -265,6 +265,7 @@ system.registerGenericUDF("date_add", GenericUDFDateAdd.class); system.registerGenericUDF("date_sub", GenericUDFDateSub.class); system.registerGenericUDF("datediff", GenericUDFDateDiff.class); + system.registerGenericUDF("months_between", GenericUDFMonthsBetween.class); system.registerGenericUDF("add_months", GenericUDFAddMonths.class); system.registerUDF("get_json_object", UDFJson.class, false); diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiff.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiff.java index 403cf11..9c7d1c3 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiff.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiff.java @@ -17,31 +17,18 @@ */ package org.apache.hadoop.hive.ql.udf.generic; -import java.sql.Timestamp; -import java.text.ParseException; -import java.text.SimpleDateFormat; import java.util.Date; -import java.util.TimeZone; import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDFArgumentException; -import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; -import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException; import org.apache.hadoop.hive.ql.exec.vector.VectorizedExpressions; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffColCol; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffColScalar; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffScalarCol; -import org.apache.hadoop.hive.ql.metadata.HiveException; -import org.apache.hadoop.hive.serde2.io.DateWritable; -import org.apache.hadoop.hive.serde2.io.TimestampWritable; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters; -import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters.Converter; -import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; -import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorConverter.TimestampConverter; import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.WritableComparable; /** * UDFDateDiff. @@ -60,122 +47,42 @@ + " > SELECT _FUNC_('2009-07-30', '2009-07-31') FROM src LIMIT 1;\n" + " 1") @VectorizedExpressions({VectorUDFDateDiffColScalar.class, VectorUDFDateDiffColCol.class, VectorUDFDateDiffScalarCol.class}) -public class GenericUDFDateDiff extends GenericUDF { - private transient SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); - private transient Converter inputConverter1; - private transient Converter inputConverter2; - private IntWritable output = new IntWritable(); - private transient PrimitiveCategory inputType1; - private transient PrimitiveCategory inputType2; - private IntWritable result = new IntWritable(); +public class GenericUDFDateDiff extends GenericUDFDateDiffBase { + + private transient IntWritable output; public GenericUDFDateDiff() { - formatter.setTimeZone(TimeZone.getTimeZone("UTC")); + udfName = "datediff"; } @Override public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { - if (arguments.length != 2) { - throw new UDFArgumentLengthException( - "datediff() requires 2 argument, got " + arguments.length); - } - inputConverter1 = checkArguments(arguments, 0); - inputConverter2 = checkArguments(arguments, 1); - inputType1 = ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory(); - inputType2 = ((PrimitiveObjectInspector) arguments[1]).getPrimitiveCategory(); - ObjectInspector outputOI = PrimitiveObjectInspectorFactory.writableIntObjectInspector; - return outputOI; + output = new IntWritable(); + return super.initialize(arguments); } @Override - public IntWritable evaluate(DeferredObject[] arguments) throws HiveException { - output = evaluate(convertToDate(inputType1, inputConverter1, arguments[0]), - convertToDate(inputType2, inputConverter2, arguments[1])); - return output; + protected ObjectInspector getOutputOI() { + return PrimitiveObjectInspectorFactory.writableIntObjectInspector; } @Override - public String getDisplayString(String[] children) { - return getStandardDisplayString("datediff", children); - } - - private Date convertToDate(PrimitiveCategory inputType, Converter converter, DeferredObject argument) - throws HiveException { - assert(converter != null); - assert(argument != null); - if (argument.get() == null) { - return null; - } - Date date = new Date(); - switch (inputType) { - case STRING: - case VARCHAR: - case CHAR: - String dateString = converter.convert(argument.get()).toString(); - try { - date = formatter.parse(dateString); - } catch (ParseException e) { - return null; - } - break; - case TIMESTAMP: - Timestamp ts = ((TimestampWritable) converter.convert(argument.get())) - .getTimestamp(); - date.setTime(ts.getTime()); - break; - case DATE: - DateWritable dw = (DateWritable) converter.convert(argument.get()); - date = dw.get(); - break; - default: - throw new UDFArgumentException( - "TO_DATE() only takes STRING/TIMESTAMP/DATEWRITABLE types, got " + inputType); - } - return date; - } - - private Converter checkArguments(ObjectInspector[] arguments, int i) throws UDFArgumentException { - if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { - throw new UDFArgumentTypeException(0, - "Only primitive type arguments are accepted but " - + arguments[i].getTypeName() + " is passed. as first arguments"); - } - PrimitiveCategory inputType = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); - Converter converter; - switch (inputType) { - case STRING: - case VARCHAR: - case CHAR: - converter = ObjectInspectorConverters.getConverter( - (PrimitiveObjectInspector) arguments[i], - PrimitiveObjectInspectorFactory.writableStringObjectInspector); - break; - case TIMESTAMP: - converter = new TimestampConverter((PrimitiveObjectInspector) arguments[i], - PrimitiveObjectInspectorFactory.writableTimestampObjectInspector); - break; - case DATE: - converter = ObjectInspectorConverters.getConverter((PrimitiveObjectInspector)arguments[i], - PrimitiveObjectInspectorFactory.writableDateObjectInspector); - break; - default: - throw new UDFArgumentException( - " DATEDIFF() only takes STRING/TIMESTAMP/DATEWRITABLE types as " + (i + 1) - + "-th argument, got " + inputType); - } - return converter; - } - - private IntWritable evaluate(Date date, Date date2) { - - if (date == null || date2 == null) { + protected WritableComparable eval(Date date1, Date date2) { + if (date1 == null || date2 == null) { return null; } + // NOTE: This implementation avoids the extra-second problem - // by comparing with UTC epoch and integer division. + // by comparing with UTC epoch and integer divisionj. // 86400 is the number of seconds in a day - long diffInMilliSeconds = date.getTime() - date2.getTime(); - result.set((int) (diffInMilliSeconds / (86400 * 1000))); - return result; + + long diffInMilliSeconds = date1.getTime() - date2.getTime(); + output.set((int) (diffInMilliSeconds / (86400 * 1000))); + return output; + } + + @Override + public String getDisplayString(String[] children) { + return getStandardDisplayString(udfName, children); } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiffBase.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiffBase.java new file mode 100644 index 0000000..e6cdc17 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateDiffBase.java @@ -0,0 +1,148 @@ +/** + * 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.hadoop.hive.ql.udf.generic; + +import java.sql.Timestamp; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.TimeZone; + +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedExpressions; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffColCol; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffColScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFDateDiffScalarCol; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.io.DateWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorConverters.Converter; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorConverter.TimestampConverter; +import org.apache.hadoop.io.WritableComparable; + +@VectorizedExpressions({VectorUDFDateDiffColScalar.class, VectorUDFDateDiffColCol.class, VectorUDFDateDiffScalarCol.class}) +public abstract class GenericUDFDateDiffBase extends GenericUDF { + private transient SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); + private transient Converter inputConverter1; + private transient Converter inputConverter2; + private transient PrimitiveCategory inputType1; + private transient PrimitiveCategory inputType2; + protected String udfName = ""; + + public GenericUDFDateDiffBase() { + formatter.setTimeZone(TimeZone.getTimeZone("UTC")); + } + + @Override + public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { + if (arguments.length != 2) { + throw new UDFArgumentLengthException(udfName + "() requires 2 arguments, got " + + arguments.length); + } + inputConverter1 = checkArguments(arguments, 0); + inputConverter2 = checkArguments(arguments, 1); + inputType1 = ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory(); + inputType2 = ((PrimitiveObjectInspector) arguments[1]).getPrimitiveCategory(); + return getOutputOI(); + } + + protected abstract ObjectInspector getOutputOI(); + + @Override + public WritableComparable evaluate(DeferredObject[] arguments) throws HiveException { + WritableComparable output = eval( + convertToDate(0, inputType1, inputConverter1, arguments[0]), + convertToDate(1, inputType2, inputConverter2, arguments[1])); + return output; + } + + protected abstract WritableComparable eval(Date date1, Date date2); + + private Date convertToDate(int argIdx, PrimitiveCategory inputType, Converter converter, DeferredObject argument) + throws HiveException { + assert(converter != null); + assert(argument != null); + if (argument.get() == null) { + return null; + } + Date date = new Date(); + switch (inputType) { + case STRING: + case VARCHAR: + case CHAR: + String dateString = converter.convert(argument.get()).toString(); + try { + date = formatter.parse(dateString); + } catch (ParseException e) { + return null; + } + break; + case TIMESTAMP: + Timestamp ts = ((TimestampWritable) converter.convert(argument.get())).getTimestamp(); + date.setTime(ts.getTime()); + break; + case DATE: + DateWritable dw = (DateWritable) converter.convert(argument.get()); + date = dw.get(); + break; + default: + throw new UDFArgumentTypeException(argIdx, + "TO_DATE() only takes STRING/TIMESTAMP/DATEWRITABLE types, got " + inputType); + } + return date; + } + + private Converter checkArguments(ObjectInspector[] arguments, int i) throws UDFArgumentTypeException { + if (arguments[i].getCategory() != ObjectInspector.Category.PRIMITIVE) { + throw new UDFArgumentTypeException(0, + "Only primitive type arguments are accepted but " + + arguments[i].getTypeName() + " is passed. as first arguments"); + } + PrimitiveCategory inputType = ((PrimitiveObjectInspector) arguments[i]).getPrimitiveCategory(); + Converter converter; + switch (inputType) { + case STRING: + case VARCHAR: + case CHAR: + converter = ObjectInspectorConverters.getConverter( + (PrimitiveObjectInspector) arguments[i], + PrimitiveObjectInspectorFactory.writableStringObjectInspector); + break; + case TIMESTAMP: + converter = new TimestampConverter((PrimitiveObjectInspector) arguments[i], + PrimitiveObjectInspectorFactory.writableTimestampObjectInspector); + break; + case DATE: + converter = ObjectInspectorConverters.getConverter((PrimitiveObjectInspector)arguments[i], + PrimitiveObjectInspectorFactory.writableDateObjectInspector); + break; + default: + throw new UDFArgumentTypeException(i, + udfName.toUpperCase() + "() only takes STRING/TIMESTAMP/DATEWRITABLE types as " + (i + 1) + + "-th argument, got " + inputType); + } + return converter; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFMonthsBetween.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFMonthsBetween.java new file mode 100644 index 0000000..9b862af --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFMonthsBetween.java @@ -0,0 +1,111 @@ +/** + * 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.hadoop.hive.ql.udf.generic; + +import java.math.BigDecimal; +import java.util.Calendar; +import java.util.Date; +import java.util.TimeZone; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.io.WritableComparable; + +/** + * UDFMonthsBetween. + * + * Calculate number of months between dates date1 and date2. The time part of + * the string will be ignored. If dateString1 is earlier than dateString2, then + * the result can be negative. + * + */ +@Description(name = "months_between", +value = "_FUNC_(date1, date2) - returns number of months between dates date1 and date2", +extended = "If date1 is later than date2, then the result is positive. " + + "If date1 is earlier than date2, then the result is negative." + + "If date1 and date2 are either the same days of the month or both last days of months, " + + "then the result is always an integer." + + "otherwise, it will calculate the fractional portion of the result based on a 31-day " + + "month and considers the difference in time components date1 and date2.\n" + + "date1 and date2 are strings in the format " + + "'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd'. The time parts are ignored.\n" + + "Example:\n " + + " > SELECT _FUNC_('02-02-1995', '01-01-1995');\n" + "OK\n" + "1.03225806") +public class GenericUDFMonthsBetween extends GenericUDFDateDiffBase { + private transient DoubleWritable output; + + public GenericUDFMonthsBetween() { + udfName = "months_between"; + } + + @Override + public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { + output = new DoubleWritable(); + return super.initialize(arguments); + } + + @Override + protected ObjectInspector getOutputOI() { + return PrimitiveObjectInspectorFactory.writableDoubleObjectInspector; + } + + @Override + protected WritableComparable eval(Date date1, Date date2) { + + if (date1 == null || date2 == null) { + return null; + } + + Calendar cal1 = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + cal1.setTime(date1); + + Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + cal2.setTime(date2); + + double monthsBetween = 0; + // difference in month for years + monthsBetween = (cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR)) * 12; + // difference in month for months + monthsBetween += cal1.get(Calendar.MONTH) - cal2.get(Calendar.MONTH); + + // difference in month for days + //if both date1 and date2 are the same days or the last days of the month + if (cal1.get(Calendar.DAY_OF_MONTH) == cal2.get(Calendar.DAY_OF_MONTH) || + (cal1.get(Calendar.DAY_OF_MONTH) == cal1.getActualMaximum(Calendar.DAY_OF_MONTH) + && cal2.get(Calendar.DAY_OF_MONTH) == cal2.getActualMaximum(Calendar.DAY_OF_MONTH))) { + monthsBetween += 0; + } else { + int dayDiff = cal1.get(Calendar.DAY_OF_MONTH) - cal2.get(Calendar.DAY_OF_MONTH); + monthsBetween += (dayDiff / 31d); + } + + Double result = new BigDecimal(monthsBetween).setScale(8, BigDecimal.ROUND_HALF_UP) + .doubleValue(); + output.set(result); + return output; + } + + @Override + public String getDisplayString(String[] children) { + return getStandardDisplayString(udfName, children); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/udf/TestGenericUDFMonthsBetween.java ql/src/test/org/apache/hadoop/hive/ql/udf/TestGenericUDFMonthsBetween.java new file mode 100644 index 0000000..19f245e --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/udf/TestGenericUDFMonthsBetween.java @@ -0,0 +1,261 @@ +/** + * 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.hadoop.hive.ql.udf; + +import java.sql.Date; +import java.sql.Timestamp; + +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF.DeferredJavaObject; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF.DeferredObject; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFMonthsBetween; +import org.apache.hadoop.hive.serde2.io.DateWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.DoubleWritable; +import org.apache.hadoop.io.Text; + +import junit.framework.TestCase; + +public class TestGenericUDFMonthsBetween extends TestCase { + public void testStringToDate() throws HiveException { + GenericUDFMonthsBetween udf = new GenericUDFMonthsBetween(); + ObjectInspector valueOI1 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; + ObjectInspector valueOI2 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; + ObjectInspector[] arguments = { valueOI1, valueOI2 }; + + // test month diff with fraction considering time components + udf.initialize(arguments); + DeferredObject valueObj1 = new DeferredJavaObject(new Text("1995-02-02")); + DeferredObject valueObj2 = new DeferredJavaObject(new Text("1995-01-01")); + DeferredObject[] args = { valueObj1, valueObj2 }; + DoubleWritable output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "1.03225806", output.toString()); + + valueObj1 = new DeferredJavaObject(new Text("2003-07-17")); + valueObj2 = new DeferredJavaObject(new Text("2005-07-06")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "-23.64516129", output.toString()); + + // test the last day of month + valueObj1 = new DeferredJavaObject(new Text("2001-06-30")); + valueObj2 = new DeferredJavaObject(new Text("2000-05-31")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "13.0", output.toString()); + + // test the same day of month + valueObj1 = new DeferredJavaObject(new Text("2000-06-01")); + valueObj2 = new DeferredJavaObject(new Text("2004-07-01")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "-49.0", output.toString()); + + // test february of non-leap year, 2/28 + valueObj1 = new DeferredJavaObject(new Text("2002-02-28")); + valueObj2 = new DeferredJavaObject(new Text("2002-03-01")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "-0.12903226", output.toString()); + + // test february of non-leap year, 2/31 is viewd as 3/3 due to 3 days diff + // from 2/31 to 2/28 + valueObj1 = new DeferredJavaObject(new Text("2002-02-31")); + valueObj2 = new DeferredJavaObject(new Text("2002-03-01")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "0.06451613", output.toString()); + + // test Feb of leap year, 2/29 + valueObj1 = new DeferredJavaObject(new Text("2012-02-29")); + valueObj2 = new DeferredJavaObject(new Text("2012-03-01")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "-0.09677419", output.toString()); + + // test february of leap year, 2/31 is viewed as 3/2 due to 2 days diff from + // 2/31 to 2/29 + valueObj1 = new DeferredJavaObject(new Text("2012-02-31")); + valueObj2 = new DeferredJavaObject(new Text("2012-03-01")); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for STRING failed ", "0.03225806", output.toString()); + + // Test with null args + args = new DeferredObject[] { new DeferredJavaObject(null), valueObj2 }; + assertNull("months_between() 1st arg null", udf.evaluate(args)); + + args = new DeferredObject[] { valueObj1, new DeferredJavaObject(null) }; + assertNull("months_between() 2nd arg null", udf.evaluate(args)); + + args = new DeferredObject[] { new DeferredJavaObject(null), new DeferredJavaObject(null) }; + assertNull("months_between() both args null", udf.evaluate(args)); + } + + public void testTimestampToDate() throws HiveException { + GenericUDFMonthsBetween udf = new GenericUDFMonthsBetween(); + ObjectInspector valueOI1 = PrimitiveObjectInspectorFactory.writableTimestampObjectInspector; + ObjectInspector valueOI2 = PrimitiveObjectInspectorFactory.writableTimestampObjectInspector; + ObjectInspector[] arguments = { valueOI1, valueOI2 }; + + // test month diff with fraction considering time components + udf.initialize(arguments); + DeferredObject valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("1995-02-02 00:00:00"))); + DeferredObject valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("1995-01-01 00:00:00"))); + DeferredObject[] args = { valueObj1, valueObj2 }; + DoubleWritable output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "1.03225806", output.toString()); + + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2003-07-17 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2005-07-06 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-23.64516129", output.toString()); + + // test the last day of month + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2001-06-30 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2000-05-31 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "13.0", output.toString()); + + // test the same day of month + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2000-06-01 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2004-07-01 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-49.0", output.toString()); + + // test february of non-leap year, 2/28 + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2002-02-28 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2002-03-01 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-0.12903226", output.toString()); + + // test february of non-leap year, 2/31 is viewd as 3/3 due to 3 days diff + // from 2/31 to 2/28 + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2002-02-31 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2002-03-01 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "0.06451613", output.toString()); + + // test Feb of leap year, 2/29 + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2012-02-29 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2012-03-01 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-0.09677419", output.toString()); + + // test february of leap year, 2/31 is viewed as 3/2 due to 2 days diff from + // 2/31 to 2/29 + valueObj1 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2012-02-31 00:00:00"))); + valueObj2 = new DeferredJavaObject(new TimestampWritable(Timestamp.valueOf("2012-03-01 00:00:00"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "0.03225806", output.toString()); + + // Test with null args + args = new DeferredObject[] { new DeferredJavaObject(null), valueObj2 }; + assertNull("months_between() 1st arg null", udf.evaluate(args)); + + args = new DeferredObject[] { valueObj1, new DeferredJavaObject(null) }; + assertNull("months_between() 2nd arg null", udf.evaluate(args)); + + args = new DeferredObject[] { new DeferredJavaObject(null), new DeferredJavaObject(null) }; + assertNull("months_between() both args null", udf.evaluate(args)); + } + + public void testDateWritablepToDate() throws HiveException { + GenericUDFMonthsBetween udf = new GenericUDFMonthsBetween(); + ObjectInspector valueOI1 = PrimitiveObjectInspectorFactory.writableDateObjectInspector; + ObjectInspector valueOI2 = PrimitiveObjectInspectorFactory.writableDateObjectInspector; + ObjectInspector[] arguments = { valueOI1, valueOI2 }; + + // test month diff with fraction considering time components + udf.initialize(arguments); + DeferredObject valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("1995-02-02"))); + DeferredObject valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("1995-01-01"))); + DeferredObject[] args = { valueObj1, valueObj2 }; + DoubleWritable output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "1.03225806", output.toString()); + + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2003-07-17"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2005-07-06"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-23.64516129", output.toString()); + + // test the last day of month + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2001-06-30"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2000-05-31"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "13.0", output.toString()); + + // test the same day of month + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2000-06-01"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2004-07-01"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-49.0", output.toString()); + + // test february of non-leap year, 2/28 + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2002-02-28"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2002-03-01"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-0.12903226", output.toString()); + + // test february of non-leap year, 2/31 is viewd as 3/3 due to 3 days diff + // from 2/31 to 2/28 + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2002-02-31"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2002-03-01"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "0.06451613", output.toString()); + + // test Feb of leap year, 2/29 + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2012-02-29"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2012-03-01"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "-0.09677419", output.toString()); + + // test february of leap year, 2/31 is viewed as 3/2 due to 2 days diff from + // 2/31 to 2/29 + valueObj1 = new DeferredJavaObject(new DateWritable(Date.valueOf("2012-02-31"))); + valueObj2 = new DeferredJavaObject(new DateWritable(Date.valueOf("2012-03-01"))); + args = new DeferredObject[] { valueObj1, valueObj2 }; + output = (DoubleWritable) udf.evaluate(args); + assertEquals("months_between() test for TIMESTAMP failed ", "0.03225806", output.toString()); + + // Test with null args + args = new DeferredObject[] { new DeferredJavaObject(null), valueObj2 }; + assertNull("months_between() 1st arg null", udf.evaluate(args)); + + args = new DeferredObject[] { valueObj1, new DeferredJavaObject(null) }; + assertNull("months_between() 2nd arg null", udf.evaluate(args)); + + args = new DeferredObject[] { new DeferredJavaObject(null), new DeferredJavaObject(null) }; + assertNull("months_between() both args null", udf.evaluate(args)); + } +} diff --git ql/src/test/queries/clientnegative/udf_datediff_error1.q ql/src/test/queries/clientnegative/udf_datediff_error1.q new file mode 100644 index 0000000..c369258 --- /dev/null +++ ql/src/test/queries/clientnegative/udf_datediff_error1.q @@ -0,0 +1 @@ +SELECT DATEDIFF(1, '2001-01-01'); diff --git ql/src/test/queries/clientnegative/udf_datediff_error2.q ql/src/test/queries/clientnegative/udf_datediff_error2.q new file mode 100644 index 0000000..b164cf1 --- /dev/null +++ ql/src/test/queries/clientnegative/udf_datediff_error2.q @@ -0,0 +1 @@ +SELECT DATEDIFF(1.0, 2); diff --git ql/src/test/queries/clientnegative/udf_months_between_error1.q ql/src/test/queries/clientnegative/udf_months_between_error1.q new file mode 100644 index 0000000..df9ccb2 --- /dev/null +++ ql/src/test/queries/clientnegative/udf_months_between_error1.q @@ -0,0 +1 @@ +SELECT MONTHS_BETWEEN(1, '2001-01-01'); diff --git ql/src/test/queries/clientnegative/udf_months_between_error2.q ql/src/test/queries/clientnegative/udf_months_between_error2.q new file mode 100644 index 0000000..d0a7ec8 --- /dev/null +++ ql/src/test/queries/clientnegative/udf_months_between_error2.q @@ -0,0 +1 @@ +SELECT MONTHS_BETWEEN(1.0, 2); \ No newline at end of file diff --git ql/src/test/queries/clientpositive/udf_datediff.q ql/src/test/queries/clientpositive/udf_datediff.q index 30718fe..8bf6b94 100644 --- ql/src/test/queries/clientpositive/udf_datediff.q +++ ql/src/test/queries/clientpositive/udf_datediff.q @@ -1,2 +1,105 @@ -DESCRIBE FUNCTION datediff; -DESCRIBE FUNCTION EXTENDED datediff; +DESCRIBE FUNCTION DATEDIFF; +DESCRIBE FUNCTION EXTENDED DATEDIFF; + + + +--test STRING format +EXPLAIN +SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01'); + + +SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01'); + +--test timestamp format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)); + + +SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)); + +--test date format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)); + +SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)); + +--test misc with null +EXPLAIN +SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)); + + +SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)); \ No newline at end of file diff --git ql/src/test/queries/clientpositive/udf_months_between.q ql/src/test/queries/clientpositive/udf_months_between.q new file mode 100644 index 0000000..1d2640d --- /dev/null +++ ql/src/test/queries/clientpositive/udf_months_between.q @@ -0,0 +1,103 @@ +DESCRIBE FUNCTION MONTHS_BETWEEN; +DESCRIBE FUNCTION EXTENDED MONTHS_BETWEEN; + +--test string format +EXPLAIN +SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01'); + + +SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01'); + +--test timestamp format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)); + + +SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)); + +--test date format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)); + +SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)); + +--test misc with null +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)); + + +SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)); \ No newline at end of file diff --git ql/src/test/results/clientnegative/udf_datediff_error1.q.out ql/src/test/results/clientnegative/udf_datediff_error1.q.out new file mode 100644 index 0000000..e87fba3 --- /dev/null +++ ql/src/test/results/clientnegative/udf_datediff_error1.q.out @@ -0,0 +1 @@ +FAILED: SemanticException [Error 10016]: Line 1:16 Argument type mismatch '1': DATEDIFF() only takes STRING/TIMESTAMP/DATEWRITABLE types as 1-th argument, got INT diff --git ql/src/test/results/clientnegative/udf_datediff_error2.q.out ql/src/test/results/clientnegative/udf_datediff_error2.q.out new file mode 100644 index 0000000..8b93306 --- /dev/null +++ ql/src/test/results/clientnegative/udf_datediff_error2.q.out @@ -0,0 +1 @@ +FAILED: SemanticException [Error 10016]: Line 1:16 Argument type mismatch '1.0': DATEDIFF() only takes STRING/TIMESTAMP/DATEWRITABLE types as 1-th argument, got DOUBLE diff --git ql/src/test/results/clientnegative/udf_months_between_error1.q.out ql/src/test/results/clientnegative/udf_months_between_error1.q.out new file mode 100644 index 0000000..cbaec34 --- /dev/null +++ ql/src/test/results/clientnegative/udf_months_between_error1.q.out @@ -0,0 +1 @@ +FAILED: SemanticException [Error 10016]: Line 1:22 Argument type mismatch '1': MONTHS_BETWEEN() only takes STRING/TIMESTAMP/DATEWRITABLE types as 1-th argument, got INT diff --git ql/src/test/results/clientnegative/udf_months_between_error2.q.out ql/src/test/results/clientnegative/udf_months_between_error2.q.out new file mode 100644 index 0000000..cc27940 --- /dev/null +++ ql/src/test/results/clientnegative/udf_months_between_error2.q.out @@ -0,0 +1 @@ +FAILED: SemanticException [Error 10016]: Line 1:22 Argument type mismatch '1.0': MONTHS_BETWEEN() only takes STRING/TIMESTAMP/DATEWRITABLE types as 1-th argument, got DOUBLE diff --git ql/src/test/results/clientpositive/show_functions.q.out ql/src/test/results/clientpositive/show_functions.q.out index d4b0650..471498e 100644 --- ql/src/test/results/clientpositive/show_functions.q.out +++ ql/src/test/results/clientpositive/show_functions.q.out @@ -123,6 +123,7 @@ max min minute month +months_between named_struct negative next_day @@ -318,6 +319,7 @@ max min minute month +months_between xpath xpath_boolean xpath_double diff --git ql/src/test/results/clientpositive/show_functions.q.out.orig ql/src/test/results/clientpositive/show_functions.q.out.orig deleted file mode 100644 index d79106f..0000000 --- ql/src/test/results/clientpositive/show_functions.q.out.orig +++ /dev/null @@ -1,367 +0,0 @@ -PREHOOK: query: SHOW FUNCTIONS -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS -POSTHOOK: type: SHOWFUNCTIONS -! -!= -% -& -* -+ -- -/ -< -<= -<=> -<> -= -== -> ->= -^ -abs -acos -add_months -and -array -array_contains -ascii -asin -assert_true -atan -avg -base64 -between -bin -case -ceil -ceiling -coalesce -collect_list -collect_set -compute_stats -concat -concat_ws -context_ngrams -conv -corr -cos -count -covar_pop -covar_samp -create_union -cume_dist -current_database -current_date -current_timestamp -current_user -date_add -date_sub -datediff -day -dayofmonth -decode -default.qtest_get_java_boolean -degrees -dense_rank -div -e -elt -encode -ewah_bitmap -ewah_bitmap_and -ewah_bitmap_empty -ewah_bitmap_or -exp -explode -field -find_in_set -first_value -floor -format_number -from_unixtime -from_utc_timestamp -get_json_object -greatest -hash -hex -histogram_numeric -hour -if -in -in_file -index -initcap -inline -instr -isnotnull -isnull -java_method -json_tuple -lag -last_day -last_value -lcase -lead -least -length -like -ln -locate -log -log10 -log2 -lower -lpad -ltrim -map -map_keys -map_values -matchpath -max -min -minute -month -named_struct -negative -ngrams -noop -noopstreaming -noopwithmap -noopwithmapstreaming -not -ntile -nvl -or -parse_url -parse_url_tuple -percent_rank -percentile -percentile_approx -pi -pmod -posexplode -positive -pow -power -printf -radians -rand -rank -reflect -reflect2 -regexp -regexp_extract -regexp_replace -repeat -reverse -rlike -round -row_number -rpad -rtrim -second -sentences -sign -sin -size -sort_array -space -split -sqrt -stack -std -stddev -stddev_pop -stddev_samp -str_to_map -struct -substr -substring -sum -tan -to_date -to_unix_timestamp -to_utc_timestamp -translate -trim -ucase -unbase64 -unhex -unix_timestamp -upper -var_pop -var_samp -variance -weekofyear -when -windowingtablefunction -xpath -xpath_boolean -xpath_double -xpath_float -xpath_int -xpath_long -xpath_number -xpath_short -xpath_string -year -| -~ -PREHOOK: query: SHOW FUNCTIONS '^c.*' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS '^c.*' -POSTHOOK: type: SHOWFUNCTIONS -case -ceil -ceiling -coalesce -collect_list -collect_set -compute_stats -concat -concat_ws -context_ngrams -conv -corr -cos -count -covar_pop -covar_samp -create_union -cume_dist -current_database -current_date -current_timestamp -current_user -PREHOOK: query: SHOW FUNCTIONS '.*e$' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS '.*e$' -POSTHOOK: type: SHOWFUNCTIONS -assert_true -case -coalesce -current_database -current_date -decode -e -encode -explode -first_value -from_unixtime -in_file -inline -json_tuple -last_value -lcase -like -locate -minute -negative -ntile -parse_url_tuple -percentile -posexplode -positive -regexp_replace -reverse -rlike -size -space -to_date -translate -ucase -variance -xpath_double -PREHOOK: query: SHOW FUNCTIONS 'log.*' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS 'log.*' -POSTHOOK: type: SHOWFUNCTIONS -log -log10 -log2 -PREHOOK: query: SHOW FUNCTIONS '.*date.*' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS '.*date.*' -POSTHOOK: type: SHOWFUNCTIONS -current_date -date_add -date_sub -datediff -to_date -PREHOOK: query: SHOW FUNCTIONS '***' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS '***' -POSTHOOK: type: SHOWFUNCTIONS -PREHOOK: query: SHOW FUNCTIONS LIKE 'When' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'When' -POSTHOOK: type: SHOWFUNCTIONS -when -PREHOOK: query: SHOW FUNCTIONS LIKE 'max|min' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'max|min' -POSTHOOK: type: SHOWFUNCTIONS -max -min -PREHOOK: query: SHOW FUNCTIONS LIKE 'xpath*|m*' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'xpath*|m*' -POSTHOOK: type: SHOWFUNCTIONS -map -map_keys -map_values -matchpath -max -min -minute -month -xpath -xpath_boolean -xpath_double -xpath_float -xpath_int -xpath_long -xpath_number -xpath_short -xpath_string -PREHOOK: query: SHOW FUNCTIONS LIKE 'nomatch' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'nomatch' -POSTHOOK: type: SHOWFUNCTIONS -PREHOOK: query: SHOW FUNCTIONS LIKE "log" -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE "log" -POSTHOOK: type: SHOWFUNCTIONS -log -PREHOOK: query: SHOW FUNCTIONS LIKE 'log' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'log' -POSTHOOK: type: SHOWFUNCTIONS -log -PREHOOK: query: SHOW FUNCTIONS LIKE `log` -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE `log` -POSTHOOK: type: SHOWFUNCTIONS -log -PREHOOK: query: SHOW FUNCTIONS LIKE 'log*' -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE 'log*' -POSTHOOK: type: SHOWFUNCTIONS -log -log10 -log2 -PREHOOK: query: SHOW FUNCTIONS LIKE "log*" -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE "log*" -POSTHOOK: type: SHOWFUNCTIONS -log -log10 -log2 -PREHOOK: query: SHOW FUNCTIONS LIKE `log*` -PREHOOK: type: SHOWFUNCTIONS -POSTHOOK: query: SHOW FUNCTIONS LIKE `log*` -POSTHOOK: type: SHOWFUNCTIONS -log -log10 -log2 diff --git ql/src/test/results/clientpositive/udf_datediff.q.out ql/src/test/results/clientpositive/udf_datediff.q.out index 86f30f6..38f1f2e 100644 --- ql/src/test/results/clientpositive/udf_datediff.q.out +++ ql/src/test/results/clientpositive/udf_datediff.q.out @@ -1,14 +1,315 @@ -PREHOOK: query: DESCRIBE FUNCTION datediff +PREHOOK: query: DESCRIBE FUNCTION DATEDIFF PREHOOK: type: DESCFUNCTION -POSTHOOK: query: DESCRIBE FUNCTION datediff +POSTHOOK: query: DESCRIBE FUNCTION DATEDIFF POSTHOOK: type: DESCFUNCTION -datediff(date1, date2) - Returns the number of days between date1 and date2 -PREHOOK: query: DESCRIBE FUNCTION EXTENDED datediff +DATEDIFF(date1, date2) - Returns the number of days between date1 and date2 +PREHOOK: query: DESCRIBE FUNCTION EXTENDED DATEDIFF PREHOOK: type: DESCFUNCTION -POSTHOOK: query: DESCRIBE FUNCTION EXTENDED datediff +POSTHOOK: query: DESCRIBE FUNCTION EXTENDED DATEDIFF POSTHOOK: type: DESCFUNCTION -datediff(date1, date2) - Returns the number of days between date1 and date2 +DATEDIFF(date1, date2) - Returns the number of days between date1 and date2 +Synonyms: datediff date1 and date2 are strings in the format 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd'. The time parts are ignored.If date1 is earlier than date2, the result is negative. Example: - > SELECT datediff('2009-07-30', '2009-07-31') FROM src LIMIT 1; + > SELECT DATEDIFF('2009-07-30', '2009-07-31') FROM src LIMIT 1; 1 +PREHOOK: query: --test STRING format +EXPLAIN +SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01') +PREHOOK: type: QUERY +POSTHOOK: query: --test STRING format +EXPLAIN +SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01') +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 32 (type: int), -720 (type: int), 395 (type: int), -1491 (type: int), -1 (type: int), 2 (type: int), -1 (type: int), 1 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01') +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + DATEDIFF('1995-02-02', '1995-01-01'), + DATEDIFF('2003-07-17', '2005-07-06'), + DATEDIFF('2001-06-30', '2000-05-31'), + DATEDIFF('2000-06-01', '2004-07-01'), + DATEDIFF('2002-02-28', '2002-03-01'), + DATEDIFF('2002-02-31', '2002-03-01'), + DATEDIFF('2012-02-29', '2012-03-01'), + DATEDIFF('2012-02-31', '2012-03-01') +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +32 -720 395 -1491 -1 2 -1 1 +PREHOOK: query: --test timestamp format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +PREHOOK: type: QUERY +POSTHOOK: query: --test timestamp format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 32 (type: int), -720 (type: int), 395 (type: int), -1491 (type: int), -1 (type: int), 2 (type: int), -1 (type: int), 1 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + DATEDIFF(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +32 -720 395 -1491 -1 2 -1 1 +PREHOOK: query: --test date format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +PREHOOK: type: QUERY +POSTHOOK: query: --test date format +EXPLAIN +SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 32 (type: int), -720 (type: int), 395 (type: int), -1491 (type: int), -1 (type: int), 2 (type: int), -1 (type: int), 1 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + DATEDIFF(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + DATEDIFF(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + DATEDIFF(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + DATEDIFF(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + DATEDIFF(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +32 -720 395 -1491 -1 2 -1 1 +PREHOOK: query: --test misc with null +EXPLAIN +SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +PREHOOK: type: QUERY +POSTHOOK: query: --test misc with null +EXPLAIN +SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: datediff(UDFToString(null), '2012-03-01') (type: int), datediff('2012-02-31', CAST( null AS TIMESTAMP)) (type: int), datediff(CAST( null AS TIMESTAMP), CAST( null AS DATE)) (type: int), datediff(UDFToString(null), 2012-03-01 00:00:00.0) (type: int), datediff(2012-03-02 00:00:00.0, UDFToString(null)) (type: int), datediff(CAST( null AS TIMESTAMP), '2012-03-01') (type: int), datediff(2012-03-02, UDFToString(null)) (type: int), datediff('2012-02-10', UDFToString(null)) (type: int), datediff(UDFToString(null), '2012-02-10') (type: int), datediff(UDFToString(null), UDFToString(null)) (type: int), datediff('2012-02-10', CAST( null AS TIMESTAMP)) (type: int), datediff(CAST( null AS TIMESTAMP), '2012-02-10') (type: int), datediff(CAST( null AS TIMESTAMP), CAST( null AS TIMESTAMP)) (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + DATEDIFF(CAST(null AS STRING), '2012-03-01'), + DATEDIFF('2012-02-31', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + DATEDIFF(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + DATEDIFF(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + DATEDIFF(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + DATEDIFF(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS STRING)), + DATEDIFF(CAST(null AS STRING), '2012-02-10'), + DATEDIFF(CAST(null AS STRING), CAST(null AS STRING)), + DATEDIFF('2012-02-10', CAST(null AS TIMESTAMP)), + DATEDIFF(CAST(null AS TIMESTAMP), '2012-02-10'), + DATEDIFF(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL diff --git ql/src/test/results/clientpositive/udf_months_between.q.out ql/src/test/results/clientpositive/udf_months_between.q.out new file mode 100644 index 0000000..2702b69 --- /dev/null +++ ql/src/test/results/clientpositive/udf_months_between.q.out @@ -0,0 +1,317 @@ +PREHOOK: query: DESCRIBE FUNCTION MONTHS_BETWEEN +PREHOOK: type: DESCFUNCTION +POSTHOOK: query: DESCRIBE FUNCTION MONTHS_BETWEEN +POSTHOOK: type: DESCFUNCTION +MONTHS_BETWEEN(date1, date2) - returns number of months between dates date1 and date2 +PREHOOK: query: DESCRIBE FUNCTION EXTENDED MONTHS_BETWEEN +PREHOOK: type: DESCFUNCTION +POSTHOOK: query: DESCRIBE FUNCTION EXTENDED MONTHS_BETWEEN +POSTHOOK: type: DESCFUNCTION +MONTHS_BETWEEN(date1, date2) - returns number of months between dates date1 and date2 +Synonyms: months_between +If date1 is later than date2, then the result is positive. If date1 is earlier than date2, then the result is negative.If date1 and date2 are either the same days of the month or both last days of months, then the result is always an integer.otherwise, it will calculate the fractional portion of the result based on a 31-day month and considers the difference in time components date1 and date2. +date1 and date2 are strings in the format 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd'. The time parts are ignored. +Example: + > SELECT MONTHS_BETWEEN('02-02-1995', '01-01-1995'); +OK +1.03225806 +PREHOOK: query: --test string format +EXPLAIN +SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01') +PREHOOK: type: QUERY +POSTHOOK: query: --test string format +EXPLAIN +SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01') +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 1.03225806 (type: double), -23.64516129 (type: double), 13.0 (type: double), -49.0 (type: double), -0.12903226 (type: double), 0.06451613 (type: double), -0.09677419 (type: double), 0.03225806 (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01') +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + MONTHS_BETWEEN('1995-02-02', '1995-01-01'), + MONTHS_BETWEEN('2003-07-17', '2005-07-06'), + MONTHS_BETWEEN('2001-06-30', '2000-05-31'), + MONTHS_BETWEEN('2000-06-01', '2004-07-01'), + MONTHS_BETWEEN('2002-02-28', '2002-03-01'), + MONTHS_BETWEEN('2002-02-31', '2002-03-01'), + MONTHS_BETWEEN('2012-02-29', '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', '2012-03-01') +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +1.03225806 -23.64516129 13.0 -49.0 -0.12903226 0.06451613 -0.09677419 0.03225806 +PREHOOK: query: --test timestamp format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +PREHOOK: type: QUERY +POSTHOOK: query: --test timestamp format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 1.03225806 (type: double), -23.64516129 (type: double), 13.0 (type: double), -49.0 (type: double), -0.12903226 (type: double), 0.06451613 (type: double), -0.09677419 (type: double), 0.03225806 (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + MONTHS_BETWEEN(CAST('1995-02-02 00:00:00' AS TIMESTAMP), CAST('1995-01-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2003-07-17 00:00:00' AS TIMESTAMP), CAST('2005-07-06 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2001-06-30 00:00:00' AS TIMESTAMP), CAST('2000-05-31 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2000-06-01 00:00:00' AS TIMESTAMP), CAST('2004-07-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-28 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2002-02-31 00:00:00' AS TIMESTAMP), CAST('2002-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-29 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST('2012-03-01 00:00:00' AS TIMESTAMP)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +1.03225806 -23.64516129 13.0 -49.0 -0.12903226 0.06451613 -0.09677419 0.03225806 +PREHOOK: query: --test date format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +PREHOOK: type: QUERY +POSTHOOK: query: --test date format +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: 1.03225806 (type: double), -23.64516129 (type: double), 13.0 (type: double), -49.0 (type: double), -0.12903226 (type: double), 0.06451613 (type: double), -0.09677419 (type: double), 0.03225806 (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + ListSink + +PREHOOK: query: SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + MONTHS_BETWEEN(CAST('1995-02-02' AS DATE), CAST('1995-01-01' AS DATE)), + MONTHS_BETWEEN(CAST('2003-07-17' AS DATE), CAST('2005-07-06' AS DATE)), + MONTHS_BETWEEN(CAST('2001-06-30' AS DATE), CAST('2000-05-31' AS DATE)), + MONTHS_BETWEEN(CAST('2000-06-01' AS DATE), CAST('2004-07-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-28' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2002-02-31' AS DATE), CAST('2002-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-29' AS DATE), CAST('2012-03-01' AS DATE)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST('2012-03-01' AS DATE)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +1.03225806 -23.64516129 13.0 -49.0 -0.12903226 0.06451613 -0.09677419 0.03225806 +PREHOOK: query: --test misc with null +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +PREHOOK: type: QUERY +POSTHOOK: query: --test misc with null +EXPLAIN +SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: _dummy_table + Row Limit Per Split: 1 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + Select Operator + expressions: months_between(UDFToString(null), '2012-03-01') (type: double), months_between('2012-02-31', CAST( null AS TIMESTAMP)) (type: double), months_between(CAST( null AS TIMESTAMP), CAST( null AS DATE)) (type: double), months_between(UDFToString(null), 2012-03-01 00:00:00.0) (type: double), months_between(2012-03-02 00:00:00.0, UDFToString(null)) (type: double), months_between(CAST( null AS TIMESTAMP), '2012-03-01') (type: double), months_between(2012-03-02, UDFToString(null)) (type: double), months_between('2012-02-10', UDFToString(null)) (type: double), months_between(UDFToString(null), '2012-02-10') (type: double), months_between(UDFToString(null), UDFToString(null)) (type: double), months_between('2012-02-10', CAST( null AS TIMESTAMP)) (type: double), months_between(CAST( null AS TIMESTAMP), '2012-02-10') (type: double), months_between(CAST( null AS TIMESTAMP), CAST( null AS TIMESTAMP)) (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12 + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 0 Data size: 1 Basic stats: PARTIAL Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: SELECT + MONTHS_BETWEEN(CAST(null AS STRING), '2012-03-01'), + MONTHS_BETWEEN('2012-02-31', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS DATE)), + MONTHS_BETWEEN(CAST(null AS STRING), CAST('2012-03-01 00:00:00' AS TIMESTAMP)), + MONTHS_BETWEEN(CAST('2012-02-31 00:00:00' AS TIMESTAMP), CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST('2012-03-01' AS STRING)), + MONTHS_BETWEEN(CAST('2012-02-31' AS DATE), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS STRING)), + MONTHS_BETWEEN(CAST(null AS STRING), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS STRING), CAST(null AS STRING)), + MONTHS_BETWEEN('2012-02-10', CAST(null AS TIMESTAMP)), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), '2012-02-10'), + MONTHS_BETWEEN(CAST(null AS TIMESTAMP), CAST(null AS TIMESTAMP)) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL NULL -- 1.9.3 (Apple Git-50)