You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by br...@apache.org on 2014/09/08 06:38:26 UTC
svn commit: r1623263 [2/28] - in /hive/branches/spark: ./
accumulo-handler/src/java/org/apache/hadoop/hive/accumulo/predicate/
ant/src/org/apache/hadoop/hive/ant/ beeline/src/java/org/apache/hive/beeline/
beeline/src/test/org/apache/hive/beeline/ bin/ ...
Modified: hive/branches/spark/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java (original)
+++ hive/branches/spark/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java Mon Sep 8 04:38:17 2014
@@ -232,29 +232,98 @@ public class GenVectorCode extends Task
{"FilterScalarCompareColumn", "GreaterEqual", "long", "long", ">="},
{"FilterScalarCompareColumn", "GreaterEqual", "double", "long", ">="},
- {"FilterStringColumnCompareScalar", "Equal", "=="},
- {"FilterStringColumnCompareScalar", "NotEqual", "!="},
- {"FilterStringColumnCompareScalar", "Less", "<"},
- {"FilterStringColumnCompareScalar", "LessEqual", "<="},
- {"FilterStringColumnCompareScalar", "Greater", ">"},
- {"FilterStringColumnCompareScalar", "GreaterEqual", ">="},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "Equal", "=="},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "NotEqual", "!="},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "Less", "<"},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "LessEqual", "<="},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "Greater", ">"},
+ {"FilterStringGroupColumnCompareStringGroupScalarBase", "GreaterEqual", ">="},
+
+ {"FilterStringGroupColumnCompareStringScalar", "Equal", "=="},
+ {"FilterStringGroupColumnCompareStringScalar", "NotEqual", "!="},
+ {"FilterStringGroupColumnCompareStringScalar", "Less", "<"},
+ {"FilterStringGroupColumnCompareStringScalar", "LessEqual", "<="},
+ {"FilterStringGroupColumnCompareStringScalar", "Greater", ">"},
+ {"FilterStringGroupColumnCompareStringScalar", "GreaterEqual", ">="},
+
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "Equal", "=="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "NotEqual", "!="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "Less", "<"},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "LessEqual", "<="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "Greater", ">"},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "VarChar", "GreaterEqual", ">="},
+
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "Equal", "=="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "NotEqual", "!="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "Less", "<"},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "LessEqual", "<="},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "Greater", ">"},
+ {"FilterStringGroupColumnCompareTruncStringScalar", "Char", "GreaterEqual", ">="},
{"FilterStringColumnBetween", ""},
{"FilterStringColumnBetween", "!"},
- {"StringColumnCompareScalar", "Equal", "=="},
- {"StringColumnCompareScalar", "NotEqual", "!="},
- {"StringColumnCompareScalar", "Less", "<"},
- {"StringColumnCompareScalar", "LessEqual", "<="},
- {"StringColumnCompareScalar", "Greater", ">"},
- {"StringColumnCompareScalar", "GreaterEqual", ">="},
-
- {"FilterStringScalarCompareColumn", "Equal", "=="},
- {"FilterStringScalarCompareColumn", "NotEqual", "!="},
- {"FilterStringScalarCompareColumn", "Less", "<"},
- {"FilterStringScalarCompareColumn", "LessEqual", "<="},
- {"FilterStringScalarCompareColumn", "Greater", ">"},
- {"FilterStringScalarCompareColumn", "GreaterEqual", ">="},
+ {"FilterTruncStringColumnBetween", "VarChar", ""},
+ {"FilterTruncStringColumnBetween", "VarChar", "!"},
+
+ {"FilterTruncStringColumnBetween", "Char", ""},
+ {"FilterTruncStringColumnBetween", "Char", "!"},
+
+ {"StringGroupColumnCompareStringGroupScalarBase", "Equal", "=="},
+ {"StringGroupColumnCompareStringGroupScalarBase", "NotEqual", "!="},
+ {"StringGroupColumnCompareStringGroupScalarBase", "Less", "<"},
+ {"StringGroupColumnCompareStringGroupScalarBase", "LessEqual", "<="},
+ {"StringGroupColumnCompareStringGroupScalarBase", "Greater", ">"},
+ {"StringGroupColumnCompareStringGroupScalarBase", "GreaterEqual", ">="},
+
+ {"StringGroupColumnCompareStringScalar", "Equal", "=="},
+ {"StringGroupColumnCompareStringScalar", "NotEqual", "!="},
+ {"StringGroupColumnCompareStringScalar", "Less", "<"},
+ {"StringGroupColumnCompareStringScalar", "LessEqual", "<="},
+ {"StringGroupColumnCompareStringScalar", "Greater", ">"},
+ {"StringGroupColumnCompareStringScalar", "GreaterEqual", ">="},
+
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "Equal", "=="},
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "NotEqual", "!="},
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "Less", "<"},
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "LessEqual", "<="},
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "Greater", ">"},
+ {"StringGroupColumnCompareTruncStringScalar", "VarChar", "GreaterEqual", ">="},
+
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "Equal", "=="},
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "NotEqual", "!="},
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "Less", "<"},
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "LessEqual", "<="},
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "Greater", ">"},
+ {"StringGroupColumnCompareTruncStringScalar", "Char", "GreaterEqual", ">="},
+
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "Equal", "=="},
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "NotEqual", "!="},
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "Less", "<"},
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "LessEqual", "<="},
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "Greater", ">"},
+ {"FilterStringGroupScalarCompareStringGroupColumnBase", "GreaterEqual", ">="},
+
+ {"FilterStringScalarCompareStringGroupColumn", "Equal", "=="},
+ {"FilterStringScalarCompareStringGroupColumn", "NotEqual", "!="},
+ {"FilterStringScalarCompareStringGroupColumn", "Less", "<"},
+ {"FilterStringScalarCompareStringGroupColumn", "LessEqual", "<="},
+ {"FilterStringScalarCompareStringGroupColumn", "Greater", ">"},
+ {"FilterStringScalarCompareStringGroupColumn", "GreaterEqual", ">="},
+
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "Equal", "=="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "NotEqual", "!="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "Less", "<"},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "LessEqual", "<="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "Greater", ">"},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "VarChar", "GreaterEqual", ">="},
+
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "Equal", "=="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "NotEqual", "!="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "Less", "<"},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "LessEqual", "<="},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "Greater", ">"},
+ {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "GreaterEqual", ">="},
{"FilterDecimalColumnCompareScalar", "Equal", "=="},
{"FilterDecimalColumnCompareScalar", "NotEqual", "!="},
@@ -277,26 +346,47 @@ public class GenVectorCode extends Task
{"FilterDecimalColumnCompareColumn", "Greater", ">"},
{"FilterDecimalColumnCompareColumn", "GreaterEqual", ">="},
- {"StringScalarCompareColumn", "Equal", "=="},
- {"StringScalarCompareColumn", "NotEqual", "!="},
- {"StringScalarCompareColumn", "Less", "<"},
- {"StringScalarCompareColumn", "LessEqual", "<="},
- {"StringScalarCompareColumn", "Greater", ">"},
- {"StringScalarCompareColumn", "GreaterEqual", ">="},
-
- {"FilterStringColumnCompareColumn", "Equal", "=="},
- {"FilterStringColumnCompareColumn", "NotEqual", "!="},
- {"FilterStringColumnCompareColumn", "Less", "<"},
- {"FilterStringColumnCompareColumn", "LessEqual", "<="},
- {"FilterStringColumnCompareColumn", "Greater", ">"},
- {"FilterStringColumnCompareColumn", "GreaterEqual", ">="},
-
- {"StringColumnCompareColumn", "Equal", "=="},
- {"StringColumnCompareColumn", "NotEqual", "!="},
- {"StringColumnCompareColumn", "Less", "<"},
- {"StringColumnCompareColumn", "LessEqual", "<="},
- {"StringColumnCompareColumn", "Greater", ">"},
- {"StringColumnCompareColumn", "GreaterEqual", ">="},
+ {"StringGroupScalarCompareStringGroupColumnBase", "Equal", "=="},
+ {"StringGroupScalarCompareStringGroupColumnBase", "NotEqual", "!="},
+ {"StringGroupScalarCompareStringGroupColumnBase", "Less", "<"},
+ {"StringGroupScalarCompareStringGroupColumnBase", "LessEqual", "<="},
+ {"StringGroupScalarCompareStringGroupColumnBase", "Greater", ">"},
+ {"StringGroupScalarCompareStringGroupColumnBase", "GreaterEqual", ">="},
+
+ {"StringScalarCompareStringGroupColumn", "Equal", "=="},
+ {"StringScalarCompareStringGroupColumn", "NotEqual", "!="},
+ {"StringScalarCompareStringGroupColumn", "Less", "<"},
+ {"StringScalarCompareStringGroupColumn", "LessEqual", "<="},
+ {"StringScalarCompareStringGroupColumn", "Greater", ">"},
+ {"StringScalarCompareStringGroupColumn", "GreaterEqual", ">="},
+
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "Equal", "=="},
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "NotEqual", "!="},
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "Less", "<"},
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "LessEqual", "<="},
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "Greater", ">"},
+ {"TruncStringScalarCompareStringGroupColumn", "VarChar", "GreaterEqual", ">="},
+
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "Equal", "=="},
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "NotEqual", "!="},
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "Less", "<"},
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "LessEqual", "<="},
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "Greater", ">"},
+ {"TruncStringScalarCompareStringGroupColumn", "Char", "GreaterEqual", ">="},
+
+ {"FilterStringGroupColumnCompareStringGroupColumn", "Equal", "=="},
+ {"FilterStringGroupColumnCompareStringGroupColumn", "NotEqual", "!="},
+ {"FilterStringGroupColumnCompareStringGroupColumn", "Less", "<"},
+ {"FilterStringGroupColumnCompareStringGroupColumn", "LessEqual", "<="},
+ {"FilterStringGroupColumnCompareStringGroupColumn", "Greater", ">"},
+ {"FilterStringGroupColumnCompareStringGroupColumn", "GreaterEqual", ">="},
+
+ {"StringGroupColumnCompareStringGroupColumn", "Equal", "=="},
+ {"StringGroupColumnCompareStringGroupColumn", "NotEqual", "!="},
+ {"StringGroupColumnCompareStringGroupColumn", "Less", "<"},
+ {"StringGroupColumnCompareStringGroupColumn", "LessEqual", "<="},
+ {"StringGroupColumnCompareStringGroupColumn", "Greater", ">"},
+ {"StringGroupColumnCompareStringGroupColumn", "GreaterEqual", ">="},
{"FilterColumnCompareColumn", "Equal", "long", "double", "=="},
{"FilterColumnCompareColumn", "Equal", "double", "double", "=="},
@@ -359,58 +449,58 @@ public class GenVectorCode extends Task
{"ColumnCompareColumn", "GreaterEqual", "double", "long", ">="},
// template, <ClassNamePrefix>, <ReturnType>, <OperandType>, <FuncName>, <OperandCast>,
- // <ResultCast>, <Cleanup>
- {"ColumnUnaryFunc", "FuncRound", "double", "double", "MathExpr.round", "", "", ""},
+ // <ResultCast>, <Cleanup> <VectorExprArgType>
+ {"ColumnUnaryFunc", "FuncRound", "double", "double", "MathExpr.round", "", "", "", ""},
// round(longCol) returns a long and is a no-op. So it will not be implemented here.
// round(Col, N) is a special case and will be implemented separately from this template
- {"ColumnUnaryFunc", "FuncFloor", "long", "double", "Math.floor", "", "(long)", ""},
+ {"ColumnUnaryFunc", "FuncFloor", "long", "double", "Math.floor", "", "(long)", "", ""},
// Floor on an integer argument is a noop, but it is less code to handle it this way.
- {"ColumnUnaryFunc", "FuncFloor", "long", "long", "Math.floor", "", "(long)", ""},
- {"ColumnUnaryFunc", "FuncCeil", "long", "double", "Math.ceil", "", "(long)", ""},
+ {"ColumnUnaryFunc", "FuncFloor", "long", "long", "Math.floor", "", "(long)", "", ""},
+ {"ColumnUnaryFunc", "FuncCeil", "long", "double", "Math.ceil", "", "(long)", "", ""},
// Ceil on an integer argument is a noop, but it is less code to handle it this way.
- {"ColumnUnaryFunc", "FuncCeil", "long", "long", "Math.ceil", "", "(long)", ""},
- {"ColumnUnaryFunc", "FuncExp", "double", "double", "Math.exp", "", "", ""},
- {"ColumnUnaryFunc", "FuncExp", "double", "long", "Math.exp", "(double)", "", ""},
+ {"ColumnUnaryFunc", "FuncCeil", "long", "long", "Math.ceil", "", "(long)", "", ""},
+ {"ColumnUnaryFunc", "FuncExp", "double", "double", "Math.exp", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncExp", "double", "long", "Math.exp", "(double)", "", "", ""},
{"ColumnUnaryFunc", "FuncLn", "double", "double", "Math.log", "", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
{"ColumnUnaryFunc", "FuncLn", "double", "long", "Math.log", "(double)", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
{"ColumnUnaryFunc", "FuncLog10", "double", "double", "Math.log10", "", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
{"ColumnUnaryFunc", "FuncLog10", "double", "long", "Math.log10", "(double)", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
// The MathExpr class contains helper functions for cases when existing library
// routines can't be used directly.
{"ColumnUnaryFunc", "FuncLog2", "double", "double", "MathExpr.log2", "", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
{"ColumnUnaryFunc", "FuncLog2", "double", "long", "MathExpr.log2", "(double)", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n, true);", ""},
// Log(base, Col) is a special case and will be implemented separately from this template
// Pow(col, P) and Power(col, P) are special cases implemented separately from this template
{"ColumnUnaryFunc", "FuncSqrt", "double", "double", "Math.sqrt", "", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n);"},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n);", ""},
{"ColumnUnaryFunc", "FuncSqrt", "double", "long", "Math.sqrt", "(double)", "",
- "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n);"},
- {"ColumnUnaryFunc", "FuncAbs", "double", "double", "Math.abs", "", "", ""},
- {"ColumnUnaryFunc", "FuncAbs", "long", "long", "MathExpr.abs", "", "", ""},
- {"ColumnUnaryFunc", "FuncSin", "double", "double", "Math.sin", "", "", ""},
- {"ColumnUnaryFunc", "FuncSin", "double", "long", "Math.sin", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncASin", "double", "double", "Math.asin", "", "", ""},
- {"ColumnUnaryFunc", "FuncASin", "double", "long", "Math.asin", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncCos", "double", "double", "Math.cos", "", "", ""},
- {"ColumnUnaryFunc", "FuncCos", "double", "long", "Math.cos", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncACos", "double", "double", "Math.acos", "", "", ""},
- {"ColumnUnaryFunc", "FuncACos", "double", "long", "Math.acos", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncTan", "double", "double", "Math.tan", "", "", ""},
- {"ColumnUnaryFunc", "FuncTan", "double", "long", "Math.tan", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncATan", "double", "double", "Math.atan", "", "", ""},
- {"ColumnUnaryFunc", "FuncATan", "double", "long", "Math.atan", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncDegrees", "double", "double", "Math.toDegrees", "", "", ""},
- {"ColumnUnaryFunc", "FuncDegrees", "double", "long", "Math.toDegrees", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncRadians", "double", "double", "Math.toRadians", "", "", ""},
- {"ColumnUnaryFunc", "FuncRadians", "double", "long", "Math.toRadians", "(double)", "", ""},
- {"ColumnUnaryFunc", "FuncSign", "double", "double", "MathExpr.sign", "", "", ""},
- {"ColumnUnaryFunc", "FuncSign", "double", "long", "MathExpr.sign", "(double)", "", ""},
+ "MathExpr.NaNToNull(outputColVector, sel, batch.selectedInUse, n);", ""},
+ {"ColumnUnaryFunc", "FuncAbs", "double", "double", "Math.abs", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncAbs", "long", "long", "MathExpr.abs", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncSin", "double", "double", "Math.sin", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncSin", "double", "long", "Math.sin", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncASin", "double", "double", "Math.asin", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncASin", "double", "long", "Math.asin", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncCos", "double", "double", "Math.cos", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncCos", "double", "long", "Math.cos", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncACos", "double", "double", "Math.acos", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncACos", "double", "long", "Math.acos", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncTan", "double", "double", "Math.tan", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncTan", "double", "long", "Math.tan", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncATan", "double", "double", "Math.atan", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncATan", "double", "long", "Math.atan", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncDegrees", "double", "double", "Math.toDegrees", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncDegrees", "double", "long", "Math.toDegrees", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncRadians", "double", "double", "Math.toRadians", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncRadians", "double", "long", "Math.toRadians", "(double)", "", "", ""},
+ {"ColumnUnaryFunc", "FuncSign", "double", "double", "MathExpr.sign", "", "", "", ""},
+ {"ColumnUnaryFunc", "FuncSign", "double", "long", "MathExpr.sign", "(double)", "", "", ""},
{"DecimalColumnUnaryFunc", "FuncFloor", "decimal", "DecimalUtil.floor"},
{"DecimalColumnUnaryFunc", "FuncCeil", "decimal", "DecimalUtil.ceiling"},
@@ -420,20 +510,24 @@ public class GenVectorCode extends Task
{"DecimalColumnUnaryFunc", "FuncNegate", "decimal", "DecimalUtil.negate"},
// Casts
- {"ColumnUnaryFunc", "Cast", "long", "double", "", "", "(long)", ""},
- {"ColumnUnaryFunc", "Cast", "double", "long", "", "", "(double)", ""},
+ {"ColumnUnaryFunc", "Cast", "long", "double", "", "", "(long)", "", ""},
+ {"ColumnUnaryFunc", "Cast", "double", "long", "", "", "(double)", "", ""},
{"ColumnUnaryFunc", "CastTimestampToLongVia", "long", "long", "MathExpr.fromTimestamp", "",
- "", ""},
+ "", "", "timestamp"},
{"ColumnUnaryFunc", "CastTimestampToDoubleVia", "double", "long",
- "MathExpr.fromTimestampToDouble", "", "", ""},
+ "MathExpr.fromTimestampToDouble", "", "", "", "timestamp"},
{"ColumnUnaryFunc", "CastDoubleToBooleanVia", "long", "double", "MathExpr.toBool", "",
- "", ""},
+ "", "", ""},
{"ColumnUnaryFunc", "CastLongToBooleanVia", "long", "long", "MathExpr.toBool", "",
- "", ""},
+ "", "", ""},
+ {"ColumnUnaryFunc", "CastDateToBooleanVia", "long", "long", "MathExpr.toBool", "",
+ "", "", "date"},
+ {"ColumnUnaryFunc", "CastTimestampToBooleanVia", "long", "long", "MathExpr.toBool", "",
+ "", "", "timestamp"},
{"ColumnUnaryFunc", "CastLongToTimestampVia", "long", "long", "MathExpr.longToTimestamp", "",
- "", ""},
+ "", "", ""},
{"ColumnUnaryFunc", "CastDoubleToTimestampVia", "long", "double",
- "MathExpr.doubleToTimestamp", "", "", ""},
+ "MathExpr.doubleToTimestamp", "", "", "", ""},
// Boolean to long is done with an IdentityExpression
// Boolean to double is done with standard Long to Double cast
@@ -658,22 +752,40 @@ public class GenVectorCode extends Task
generateVectorUDAFVar(tdesc);
} else if (tdesc[0].equals("VectorUDAFVarDecimal")) {
generateVectorUDAFVarDecimal(tdesc);
- } else if (tdesc[0].equals("FilterStringColumnCompareScalar")) {
- generateFilterStringColumnCompareScalar(tdesc);
+ } else if (tdesc[0].equals("FilterStringGroupColumnCompareStringGroupScalarBase")) {
+ generateFilterStringGroupColumnCompareStringGroupScalarBase(tdesc);
+ } else if (tdesc[0].equals("FilterStringGroupColumnCompareStringScalar")) {
+ generateFilterStringGroupColumnCompareStringScalar(tdesc);
+ } else if (tdesc[0].equals("FilterStringGroupColumnCompareTruncStringScalar")) {
+ generateFilterStringGroupColumnCompareTruncStringScalar(tdesc);
} else if (tdesc[0].equals("FilterStringColumnBetween")) {
generateFilterStringColumnBetween(tdesc);
+ } else if (tdesc[0].equals("FilterTruncStringColumnBetween")) {
+ generateFilterTruncStringColumnBetween(tdesc);
} else if (tdesc[0].equals("FilterDecimalColumnBetween")) {
generateFilterDecimalColumnBetween(tdesc);
- } else if (tdesc[0].equals("StringColumnCompareScalar")) {
- generateStringColumnCompareScalar(tdesc);
- } else if (tdesc[0].equals("FilterStringScalarCompareColumn")) {
- generateFilterStringScalarCompareColumn(tdesc);
- } else if (tdesc[0].equals("StringScalarCompareColumn")) {
- generateStringScalarCompareColumn(tdesc);
- } else if (tdesc[0].equals("FilterStringColumnCompareColumn")) {
- generateFilterStringColumnCompareColumn(tdesc);
- } else if (tdesc[0].equals("StringColumnCompareColumn")) {
- generateStringColumnCompareColumn(tdesc);
+ } else if (tdesc[0].equals("StringGroupColumnCompareStringGroupScalarBase")) {
+ generateStringGroupColumnCompareStringGroupScalarBase(tdesc);
+ } else if (tdesc[0].equals("StringGroupColumnCompareStringScalar")) {
+ generateStringGroupColumnCompareStringScalar(tdesc);
+ } else if (tdesc[0].equals("StringGroupColumnCompareTruncStringScalar")) {
+ generateStringGroupColumnCompareTruncStringScalar(tdesc);
+ } else if (tdesc[0].equals("FilterStringGroupScalarCompareStringGroupColumnBase")) {
+ generateFilterStringGroupScalarCompareStringGroupColumnBase(tdesc);
+ } else if (tdesc[0].equals("FilterStringScalarCompareStringGroupColumn")) {
+ generateFilterStringScalarCompareStringGroupColumn(tdesc);
+ } else if (tdesc[0].equals("FilterTruncStringScalarCompareStringGroupColumn")) {
+ generateFilterTruncStringScalarCompareStringGroupColumn(tdesc);
+ } else if (tdesc[0].equals("StringGroupScalarCompareStringGroupColumnBase")) {
+ generateStringGroupScalarCompareStringGroupColumnBase(tdesc);
+ } else if (tdesc[0].equals("StringScalarCompareStringGroupColumn")) {
+ generateStringScalarCompareStringGroupColumn(tdesc);
+ } else if (tdesc[0].equals("TruncStringScalarCompareStringGroupColumn")) {
+ generateTruncStringScalarCompareStringGroupColumn(tdesc);
+ } else if (tdesc[0].equals("FilterStringGroupColumnCompareStringGroupColumn")) {
+ generateFilterStringGroupColumnCompareStringGroupColumn(tdesc);
+ } else if (tdesc[0].equals("StringGroupColumnCompareStringGroupColumn")) {
+ generateStringGroupColumnCompareStringGroupColumn(tdesc);
} else if (tdesc[0].equals("IfExprColumnColumn")) {
generateIfExprColumnColumn(tdesc);
} else if (tdesc[0].equals("IfExprColumnScalar")) {
@@ -710,6 +822,35 @@ public class GenVectorCode extends Task
className, templateString);
}
+ private void generateFilterTruncStringColumnBetween(String[] tdesc) throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String truncStringHiveType;
+ String truncStringHiveGetBytes;
+ if (truncStringTypeName == "Char") {
+ truncStringHiveType = "HiveChar";
+ truncStringHiveGetBytes = "getStrippedValue().getBytes()";
+ } else if (truncStringTypeName == "VarChar") {
+ truncStringHiveType = "HiveVarchar";
+ truncStringHiveGetBytes = "getValue().getBytes()";
+ } else {
+ throw new Error("Unsupported string type: " + truncStringTypeName);
+ }
+ String optionalNot = tdesc[2];
+ String className = "Filter" + truncStringTypeName + "Column" + (optionalNot.equals("!") ? "Not" : "")
+ + "Between";
+ // Read the template into a string, expand it, and write it.
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ templateString = templateString.replaceAll("<TruncStringTypeName>", truncStringTypeName);
+ templateString = templateString.replaceAll("<TruncStringHiveType>", truncStringHiveType);
+ templateString = templateString.replaceAll("<TruncStringHiveGetBytes>", truncStringHiveGetBytes);
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<OptionalNot>", optionalNot);
+
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
private void generateFilterDecimalColumnBetween(String[] tdesc) throws IOException {
String optionalNot = tdesc[1];
String className = "FilterDecimalColumn" + (optionalNot.equals("!") ? "Not" : "")
@@ -745,14 +886,12 @@ public class GenVectorCode extends Task
}
private void generateColumnCompareColumn(String[] tdesc) throws Exception {
- //The variables are all same as ColumnCompareScalar except that
- //this template doesn't need a return type. Pass anything as return type.
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
String className = getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Column";
- generateColumnBinaryOperatorColumn(tdesc, "long", className);
+ generateColumnCompareOperatorColumn(tdesc, false, className);
}
private void generateVectorUDAFMinMax(String[] tdesc) throws Exception {
@@ -886,45 +1025,147 @@ public class GenVectorCode extends Task
writeFile(templateFile.lastModified(), udafOutputDirectory, udafClassesDirectory,
className, templateString);
}
-
-
- private void generateFilterStringScalarCompareColumn(String[] tdesc) throws IOException {
+
+ private void generateFilterStringGroupScalarCompareStringGroupColumnBase(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "FilterStringScalar" + operatorName + "StringColumn";
+ String className = "FilterStringGroupScalar" + operatorName + "StringGroupColumnBase";
// Template expansion logic is the same for both column-scalar and scalar-column cases.
generateStringColumnCompareScalar(tdesc, className);
}
- private void generateStringScalarCompareColumn(String[] tdesc) throws IOException {
+ private void generateFilterStringScalarCompareStringGroupColumn(String[] tdesc) throws IOException {
+ String operatorName = tdesc[1];
+ String className = "FilterStringScalar" + operatorName + "StringGroupColumn";
+ String baseClassName = "FilterStringGroupScalar" + operatorName + "StringGroupColumnBase";
+ String operatorSymbol = tdesc[2];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
+ private void generateFilterTruncStringScalarCompareStringGroupColumn(String[] tdesc) throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String operatorName = tdesc[2];
+ String className = "Filter" + truncStringTypeName + "Scalar" + operatorName + "StringGroupColumn";
+ String baseClassName = "FilterStringGroupScalar" + operatorName + "StringGroupColumnBase";
+ generateStringCompareTruncStringScalar(tdesc, className, baseClassName);
+ }
+
+ private void generateStringGroupScalarCompareStringGroupColumnBase(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "StringScalar" + operatorName + "StringColumn";
+ String className = "StringGroupScalar" + operatorName + "StringGroupColumnBase";
// Template expansion logic is the same for both column-scalar and scalar-column cases.
generateStringColumnCompareScalar(tdesc, className);
}
- private void generateFilterStringColumnCompareScalar(String[] tdesc) throws IOException {
+ private void generateStringScalarCompareStringGroupColumn(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "FilterStringCol" + operatorName + "StringScalar";
- generateStringColumnCompareScalar(tdesc, className);
+ String className = "StringScalar" + operatorName + "StringGroupColumn";
+ String baseClassName = "StringGroupScalar" + operatorName + "StringGroupColumnBase";
+ String operatorSymbol = tdesc[2];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString); }
+
+ private void generateTruncStringScalarCompareStringGroupColumn(String[] tdesc) throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String operatorName = tdesc[2];
+ String className = truncStringTypeName + "Scalar" + operatorName + "StringGroupColumn";
+ String baseClassName = "StringGroupScalar" + operatorName + "StringGroupColumnBase";
+ generateStringCompareTruncStringScalar(tdesc, className, baseClassName);
}
- private void generateStringColumnCompareScalar(String[] tdesc) throws IOException {
+ private void generateFilterStringGroupColumnCompareStringGroupScalarBase(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "StringCol" + operatorName + "StringScalar";
+ String className = "FilterStringGroupCol" + operatorName + "StringGroupScalarBase";
generateStringColumnCompareScalar(tdesc, className);
}
- private void generateFilterStringColumnCompareColumn(String[] tdesc) throws IOException {
+ private void generateFilterStringGroupColumnCompareStringScalar(String[] tdesc) throws IOException {
+ String operatorName = tdesc[1];
+ String className = "FilterStringGroupCol" + operatorName + "StringScalar";
+ String baseClassName = "FilterStringGroupCol" + operatorName + "StringGroupScalarBase";
+ String operatorSymbol = tdesc[2];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
+ private void generateFilterStringGroupColumnCompareTruncStringScalar(String[] tdesc) throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String operatorName = tdesc[2];
+ String className = "FilterStringGroupCol" + operatorName + truncStringTypeName + "Scalar";
+ String baseClassName = "FilterStringGroupCol" + operatorName + "StringGroupScalarBase";
+ generateStringCompareTruncStringScalar(tdesc, className, baseClassName);
+ }
+
+ private void generateStringGroupColumnCompareStringGroupScalarBase(String[] tdesc) throws IOException {
+ String operatorName = tdesc[1];
+ String className = "StringGroupCol" + operatorName + "StringGroupScalarBase";
+ String operatorSymbol = tdesc[2];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
+ private void generateStringGroupColumnCompareStringScalar(String[] tdesc) throws IOException {
+ String operatorName = tdesc[1];
+ String className = "StringGroupCol" + operatorName + "StringScalar";
+ String baseClassName = "StringGroupCol" + operatorName + "StringGroupScalarBase";
+ String operatorSymbol = tdesc[2];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
+ private void generateStringGroupColumnCompareTruncStringScalar(String[] tdesc) throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String operatorName = tdesc[2];
+ String className = "StringGroupCol" + operatorName + truncStringTypeName + "Scalar";
+ String baseClassName = "StringGroupCol" + operatorName + "StringGroupScalarBase";
+ generateStringCompareTruncStringScalar(tdesc, className, baseClassName);
+ }
+
+ private void generateFilterStringGroupColumnCompareStringGroupColumn(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "FilterStringCol" + operatorName + "StringColumn";
+ String className = "FilterStringGroupCol" + operatorName + "StringGroupColumn";
generateStringColumnCompareScalar(tdesc, className);
}
- private void generateStringColumnCompareColumn(String[] tdesc) throws IOException {
+ private void generateStringGroupColumnCompareStringGroupColumn(String[] tdesc) throws IOException {
String operatorName = tdesc[1];
- String className = "StringCol" + operatorName + "StringColumn";
+ String className = "StringGroupCol" + operatorName + "StringGroupColumn";
generateStringColumnCompareScalar(tdesc, className);
}
@@ -941,15 +1182,42 @@ public class GenVectorCode extends Task
className, templateString);
}
+ private void generateStringCompareTruncStringScalar(String[] tdesc, String className, String baseClassName)
+ throws IOException {
+ String truncStringTypeName = tdesc[1];
+ String truncStringHiveType;
+ String truncStringHiveGetBytes;
+ if (truncStringTypeName == "Char") {
+ truncStringHiveType = "HiveChar";
+ truncStringHiveGetBytes = "getStrippedValue().getBytes()";
+ } else if (truncStringTypeName == "VarChar") {
+ truncStringHiveType = "HiveVarchar";
+ truncStringHiveGetBytes = "getValue().getBytes()";
+ } else {
+ throw new Error("Unsupported string type: " + truncStringTypeName);
+ }
+ String operatorSymbol = tdesc[3];
+ // Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ // Expand, and write result
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ templateString = templateString.replaceAll("<TruncStringTypeName>", truncStringTypeName);
+ templateString = templateString.replaceAll("<TruncStringHiveType>", truncStringHiveType);
+ templateString = templateString.replaceAll("<TruncStringHiveGetBytes>", truncStringHiveGetBytes);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+ }
+
private void generateFilterColumnCompareColumn(String[] tdesc) throws Exception {
- //The variables are all same as ColumnCompareScalar except that
- //this template doesn't need a return type. Pass anything as return type.
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
String className = "Filter" + getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Column";
- generateColumnBinaryOperatorColumn(tdesc, null, className);
+ generateColumnCompareOperatorColumn(tdesc, true, className);
}
private void generateColumnUnaryMinus(String[] tdesc) throws Exception {
@@ -984,6 +1252,13 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<ClassName>", className);
templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
templateString = templateString.replaceAll("<OperandType>", operandType);
+ String vectorExprArgType = operandType;
+ if (operandType.equals("long")) {
+ // Let comparisons occur for DATE and TIMESTAMP, too.
+ vectorExprArgType = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType>", vectorExprArgType);
+
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
}
@@ -1006,6 +1281,15 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<OperandType3>", operandType3);
templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ String vectorExprArgType2 = operandType2;
+ String vectorExprArgType3 = operandType3;
+ if (operandType2.equals("long") && operandType3.equals("long")) {
+ // Let this work occur for DATE and TIMESTAMP, too.
+ vectorExprArgType2 = "int_datetime_family";
+ vectorExprArgType3 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
+ templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
}
@@ -1028,6 +1312,15 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<OperandType3>", operandType3);
templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ String vectorExprArgType2 = operandType2;
+ String vectorExprArgType3 = operandType3;
+ if (operandType2.equals("long") && operandType3.equals("long")) {
+ // Let this work occur for DATE and TIMESTAMP, too.
+ vectorExprArgType2 = "int_datetime_family";
+ vectorExprArgType3 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
+ templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
}
@@ -1049,6 +1342,15 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<OperandType3>", operandType3);
templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ String vectorExprArgType2 = operandType2;
+ String vectorExprArgType3 = operandType3;
+ if (operandType2.equals("long") && operandType3.equals("long")) {
+ // Let this work occur for DATE and TIMESTAMP, too.
+ vectorExprArgType2 = "int_datetime_family";
+ vectorExprArgType3 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
+ templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
}
@@ -1073,6 +1375,7 @@ public class GenVectorCode extends Task
}
// template, <ClassNamePrefix>, <ReturnType>, <OperandType>, <FuncName>, <OperandCast>, <ResultCast>
+ // <Cleanup> <VectorExprArgType>
private void generateColumnUnaryFunc(String[] tdesc) throws Exception {
String classNamePrefix = tdesc[1];
String operandType = tdesc[3];
@@ -1087,6 +1390,8 @@ public class GenVectorCode extends Task
String operandCast = tdesc[5];
String resultCast = tdesc[6];
String cleanup = tdesc[7];
+ String vectorExprArgType = tdesc[8].isEmpty() ? operandType : tdesc[8];
+
// Expand, and write result
templateString = templateString.replaceAll("<ClassName>", className);
templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
@@ -1097,6 +1402,7 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandCast>", operandCast);
templateString = templateString.replaceAll("<ResultCast>", resultCast);
templateString = templateString.replaceAll("<Cleanup>", cleanup);
+ templateString = templateString.replaceAll("<VectorExprArgType>", vectorExprArgType);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
}
@@ -1108,58 +1414,53 @@ public class GenVectorCode extends Task
String className = getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Column";
String returnType = getArithmeticReturnType(operandType1, operandType2);
- generateColumnBinaryOperatorColumn(tdesc, returnType, className);
+ generateColumnArithmeticOperatorColumn(tdesc, returnType, className);
}
private void generateFilterColumnCompareScalar(String[] tdesc) throws Exception {
- //The variables are all same as ColumnCompareScalar except that
- //this template doesn't need a return type. Pass anything as return type.
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
String className = "Filter" + getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar";
- generateColumnBinaryOperatorScalar(tdesc, null, className);
+ generateColumnCompareOperatorScalar(tdesc, true, className);
}
private void generateFilterScalarCompareColumn(String[] tdesc) throws Exception {
- //this template doesn't need a return type. Pass anything as return type.
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
String className = "Filter" + getCamelCaseType(operandType1)
+ "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column";
- generateScalarBinaryOperatorColumn(tdesc, null, className);
+ generateScalarCompareOperatorColumn(tdesc, true, className);
}
private void generateColumnCompareScalar(String[] tdesc) throws Exception {
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
- String returnType = "long";
String className = getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar";
- generateColumnBinaryOperatorScalar(tdesc, returnType, className);
+ generateColumnCompareOperatorScalar(tdesc, false, className);
}
private void generateScalarCompareColumn(String[] tdesc) throws Exception {
String operatorName = tdesc[1];
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
- String returnType = "long";
String className = getCamelCaseType(operandType1)
+ "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column";
- generateScalarBinaryOperatorColumn(tdesc, returnType, className);
+ generateScalarCompareOperatorColumn(tdesc, false, className);
}
- private void generateColumnBinaryOperatorColumn(String[] tdesc, String returnType,
+ private void generateColumnCompareOperatorColumn(String[] tdesc, boolean filter,
String className) throws Exception {
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
- String outputColumnVectorType = this.getColumnVectorType(
- returnType == null ? "long" : returnType);
String inputColumnVectorType1 = this.getColumnVectorType(operandType1);
String inputColumnVectorType2 = this.getColumnVectorType(operandType2);
+ String returnType = "long";
+ String outputColumnVectorType = this.getColumnVectorType(returnType);
String operatorSymbol = tdesc[4];
//Read the template into a string;
@@ -1174,16 +1475,25 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<ReturnType>", returnType);
templateString = templateString.replaceAll("<CamelReturnType>", getCamelCaseType(returnType));
+ String vectorExprArgType1 = operandType1;
+ String vectorExprArgType2 = operandType2;
+ if (operandType1.equals("long") && operandType2.equals("long")) {
+ // Let comparisons occur for DATE and TIMESTAMP, too.
+ vectorExprArgType1 = "int_datetime_family";
+ vectorExprArgType2 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType1>", vectorExprArgType1);
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
- if(returnType==null){
+ if (filter) {
testCodeGen.addColumnColumnFilterTestCases(
className,
inputColumnVectorType1,
inputColumnVectorType2,
operatorSymbol);
- }else{
+ } else {
testCodeGen.addColumnColumnOperationTestCases(
className,
inputColumnVectorType1,
@@ -1192,13 +1502,44 @@ public class GenVectorCode extends Task
}
}
- private void generateColumnBinaryOperatorScalar(String[] tdesc, String returnType,
+ private void generateColumnArithmeticOperatorColumn(String[] tdesc, String returnType,
+ String className) throws Exception {
+ String operandType1 = tdesc[2];
+ String operandType2 = tdesc[3];
+ String outputColumnVectorType = this.getColumnVectorType(returnType);
+ String inputColumnVectorType1 = this.getColumnVectorType(operandType1);
+ String inputColumnVectorType2 = this.getColumnVectorType(operandType2);
+ String operatorSymbol = tdesc[4];
+
+ //Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<InputColumnVectorType1>", inputColumnVectorType1);
+ templateString = templateString.replaceAll("<InputColumnVectorType2>", inputColumnVectorType2);
+ templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ templateString = templateString.replaceAll("<OperandType1>", operandType1);
+ templateString = templateString.replaceAll("<OperandType2>", operandType2);
+ templateString = templateString.replaceAll("<ReturnType>", returnType);
+ templateString = templateString.replaceAll("<CamelReturnType>", getCamelCaseType(returnType));
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+
+ testCodeGen.addColumnColumnOperationTestCases(
+ className,
+ inputColumnVectorType1,
+ inputColumnVectorType2,
+ outputColumnVectorType);
+ }
+
+ private void generateColumnCompareOperatorScalar(String[] tdesc, boolean filter,
String className) throws Exception {
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
- String outputColumnVectorType = this.getColumnVectorType(
- returnType == null ? "long" : returnType);
String inputColumnVectorType = this.getColumnVectorType(operandType1);
+ String returnType = "long";
+ String outputColumnVectorType = this.getColumnVectorType(returnType);
String operatorSymbol = tdesc[4];
//Read the template into a string;
@@ -1211,10 +1552,20 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType1>", operandType1);
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<ReturnType>", returnType);
+ templateString = templateString.replaceAll("<CamelReturnType>", getCamelCaseType(returnType));
+ String vectorExprArgType1 = operandType1;
+ String vectorExprArgType2 = operandType2;
+ if (operandType1.equals("long") && operandType2.equals("long")) {
+ // Let comparisons occur for DATE and TIMESTAMP, too.
+ vectorExprArgType1 = "int_datetime_family";
+ vectorExprArgType2 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType1>", vectorExprArgType1);
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
- if(returnType==null) {
+ if (filter) {
testCodeGen.addColumnScalarFilterTestCases(
true,
className,
@@ -1231,13 +1582,42 @@ public class GenVectorCode extends Task
}
}
- private void generateScalarBinaryOperatorColumn(String[] tdesc, String returnType,
+ private void generateColumnArithmeticOperatorScalar(String[] tdesc, String returnType,
+ String className) throws Exception {
+ String operandType1 = tdesc[2];
+ String operandType2 = tdesc[3];
+ String outputColumnVectorType = this.getColumnVectorType(returnType);
+ String inputColumnVectorType = this.getColumnVectorType(operandType1);
+ String operatorSymbol = tdesc[4];
+
+ //Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
+ templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ templateString = templateString.replaceAll("<OperandType1>", operandType1);
+ templateString = templateString.replaceAll("<OperandType2>", operandType2);
+ templateString = templateString.replaceAll("<ReturnType>", returnType);
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+
+ testCodeGen.addColumnScalarOperationTestCases(
+ true,
+ className,
+ inputColumnVectorType,
+ outputColumnVectorType,
+ operandType2);
+ }
+
+ private void generateScalarCompareOperatorColumn(String[] tdesc, boolean filter,
String className) throws Exception {
String operandType1 = tdesc[2];
String operandType2 = tdesc[3];
- String outputColumnVectorType = this.getColumnVectorType(
- returnType == null ? "long" : returnType);
+ String returnType = "long";
String inputColumnVectorType = this.getColumnVectorType(operandType2);
+ String outputColumnVectorType = this.getColumnVectorType(returnType);
String operatorSymbol = tdesc[4];
//Read the template into a string;
@@ -1251,10 +1631,19 @@ public class GenVectorCode extends Task
templateString = templateString.replaceAll("<OperandType2>", operandType2);
templateString = templateString.replaceAll("<ReturnType>", returnType);
templateString = templateString.replaceAll("<CamelReturnType>", getCamelCaseType(returnType));
+ String vectorExprArgType1 = operandType1;
+ String vectorExprArgType2 = operandType2;
+ if (operandType1.equals("long") && operandType2.equals("long")) {
+ // Let comparisons occur for DATE and TIMESTAMP, too.
+ vectorExprArgType1 = "int_datetime_family";
+ vectorExprArgType2 = "int_datetime_family";
+ }
+ templateString = templateString.replaceAll("<VectorExprArgType1>", vectorExprArgType1);
+ templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
className, templateString);
- if(returnType==null) {
+ if (filter) {
testCodeGen.addColumnScalarFilterTestCases(
false,
className,
@@ -1269,7 +1658,38 @@ public class GenVectorCode extends Task
outputColumnVectorType,
operandType1);
}
- }
+ }
+
+ private void generateScalarArithmeticOperatorColumn(String[] tdesc, String returnType,
+ String className) throws Exception {
+ String operandType1 = tdesc[2];
+ String operandType2 = tdesc[3];
+ String outputColumnVectorType = this.getColumnVectorType(
+ returnType == null ? "long" : returnType);
+ String inputColumnVectorType = this.getColumnVectorType(operandType2);
+ String operatorSymbol = tdesc[4];
+
+ //Read the template into a string;
+ File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+ String templateString = readFile(templateFile);
+ templateString = templateString.replaceAll("<ClassName>", className);
+ templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
+ templateString = templateString.replaceAll("<OutputColumnVectorType>", outputColumnVectorType);
+ templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+ templateString = templateString.replaceAll("<OperandType1>", operandType1);
+ templateString = templateString.replaceAll("<OperandType2>", operandType2);
+ templateString = templateString.replaceAll("<ReturnType>", returnType);
+ templateString = templateString.replaceAll("<CamelReturnType>", getCamelCaseType(returnType));
+ writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+ className, templateString);
+
+ testCodeGen.addColumnScalarOperationTestCases(
+ false,
+ className,
+ inputColumnVectorType,
+ outputColumnVectorType,
+ operandType1);
+ }
//Binary arithmetic operator
private void generateColumnArithmeticScalar(String[] tdesc) throws Exception {
@@ -1279,7 +1699,7 @@ public class GenVectorCode extends Task
String className = getCamelCaseType(operandType1)
+ "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar";
String returnType = getArithmeticReturnType(operandType1, operandType2);
- generateColumnBinaryOperatorScalar(tdesc, returnType, className);
+ generateColumnArithmeticOperatorScalar(tdesc, returnType, className);
}
private void generateColumnArithmeticScalarDecimal(String[] tdesc) throws IOException {
@@ -1373,7 +1793,7 @@ public class GenVectorCode extends Task
String className = getCamelCaseType(operandType1)
+ "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column";
String returnType = getArithmeticReturnType(operandType1, operandType2);
- generateScalarBinaryOperatorColumn(tdesc, returnType, className);
+ generateScalarArithmeticOperatorColumn(tdesc, returnType, className);
}
private void generateFilterDecimalColumnCompareScalar(String[] tdesc) throws IOException {
Modified: hive/branches/spark/beeline/src/java/org/apache/hive/beeline/AbstractCommandHandler.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/java/org/apache/hive/beeline/AbstractCommandHandler.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/java/org/apache/hive/beeline/AbstractCommandHandler.java (original)
+++ hive/branches/spark/beeline/src/java/org/apache/hive/beeline/AbstractCommandHandler.java Mon Sep 8 04:38:17 2014
@@ -40,6 +40,7 @@ public abstract class AbstractCommandHan
private final String helpText;
private Completor[] parameterCompletors = new Completor[0];
+ protected transient Throwable lastException;
public AbstractCommandHandler(BeeLine beeLine, String[] names, String helpText,
Completor[] completors) {
@@ -101,4 +102,9 @@ public abstract class AbstractCommandHan
public Completor[] getParameterCompletors() {
return parameterCompletors;
}
+
+ @Override
+ public Throwable getLastException() {
+ return lastException;
+ }
}
Modified: hive/branches/spark/beeline/src/java/org/apache/hive/beeline/BeeLine.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/java/org/apache/hive/beeline/BeeLine.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/java/org/apache/hive/beeline/BeeLine.java (original)
+++ hive/branches/spark/beeline/src/java/org/apache/hive/beeline/BeeLine.java Mon Sep 8 04:38:17 2014
@@ -57,7 +57,6 @@ import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
@@ -618,9 +617,9 @@ public class BeeLine implements Closeabl
}
- boolean initArgs(String[] args) {
- List<String> commands = new LinkedList<String>();
- List<String> files = new LinkedList<String>();
+ int initArgs(String[] args) {
+ List<String> commands = Collections.emptyList();
+ List<String> files = Collections.emptyList();
CommandLine cl;
BeelineParser beelineParser;
@@ -630,7 +629,8 @@ public class BeeLine implements Closeabl
cl = beelineParser.parse(options, args);
} catch (ParseException e1) {
output(e1.getMessage());
- return false;
+ usage();
+ return -1;
}
String driver = null, user = null, pass = null, url = null;
@@ -638,8 +638,8 @@ public class BeeLine implements Closeabl
if (cl.hasOption("help")) {
- // Return false here, so usage will be printed.
- return false;
+ usage();
+ return 0;
}
Properties hiveVars = cl.getOptionProperties("hivevar");
@@ -690,7 +690,8 @@ public class BeeLine implements Closeabl
dispatch("!properties " + i.next());
}
- if (commands.size() > 0) {
+ int code = 0;
+ if (!commands.isEmpty()) {
// for single command execute, disable color
getOpts().setColor(false);
getOpts().setHeaderInterval(-1);
@@ -698,11 +699,13 @@ public class BeeLine implements Closeabl
for (Iterator<String> i = commands.iterator(); i.hasNext();) {
String command = i.next().toString();
debug(loc("executing-command", command));
- dispatch(command);
+ if (!dispatch(command)) {
+ code++;
+ }
}
exit = true; // execute and exit
}
- return true;
+ return code;
}
@@ -720,9 +723,9 @@ public class BeeLine implements Closeabl
}
try {
- if (!initArgs(args)) {
- usage();
- return ERRNO_ARGS;
+ int code = initArgs(args);
+ if (code != 0) {
+ return code;
}
if (getOpts().getScriptFile() != null) {
Modified: hive/branches/spark/beeline/src/java/org/apache/hive/beeline/CommandHandler.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/java/org/apache/hive/beeline/CommandHandler.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/java/org/apache/hive/beeline/CommandHandler.java (original)
+++ hive/branches/spark/beeline/src/java/org/apache/hive/beeline/CommandHandler.java Mon Sep 8 04:38:17 2014
@@ -74,4 +74,10 @@ interface CommandHandler {
* Returns the completors that can handle parameters.
*/
public Completor[] getParameterCompletors();
+
+ /**
+ * Returns exception thrown for last command
+ * @return
+ */
+ public Throwable getLastException();
}
\ No newline at end of file
Modified: hive/branches/spark/beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java (original)
+++ hive/branches/spark/beeline/src/java/org/apache/hive/beeline/HiveSchemaTool.java Mon Sep 8 04:38:17 2014
@@ -287,7 +287,7 @@ public class HiveSchemaTool {
}
} catch (IOException e) {
throw new HiveMetaException("Schema initialization FAILED!" +
- " Metastore state would be inconsistent !!", e);
+ " Metastore state would be inconsistent !!", e);
}
}
Modified: hive/branches/spark/beeline/src/java/org/apache/hive/beeline/ReflectiveCommandHandler.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/java/org/apache/hive/beeline/ReflectiveCommandHandler.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/java/org/apache/hive/beeline/ReflectiveCommandHandler.java (original)
+++ hive/branches/spark/beeline/src/java/org/apache/hive/beeline/ReflectiveCommandHandler.java Mon Sep 8 04:38:17 2014
@@ -40,6 +40,7 @@ public class ReflectiveCommandHandler ex
}
public boolean execute(String line) {
+ lastException = null;
try {
Object ob = beeLine.getCommands().getClass().getMethod(getName(),
new Class[] {String.class})
@@ -47,6 +48,7 @@ public class ReflectiveCommandHandler ex
return ob != null && ob instanceof Boolean
&& ((Boolean) ob).booleanValue();
} catch (Throwable e) {
+ lastException = e;
return beeLine.error(e);
}
}
Modified: hive/branches/spark/beeline/src/test/org/apache/hive/beeline/TestBeelineArgParsing.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/beeline/src/test/org/apache/hive/beeline/TestBeelineArgParsing.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/beeline/src/test/org/apache/hive/beeline/TestBeelineArgParsing.java (original)
+++ hive/branches/spark/beeline/src/test/org/apache/hive/beeline/TestBeelineArgParsing.java Mon Sep 8 04:38:17 2014
@@ -56,7 +56,7 @@ public class TestBeelineArgParsing {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"-u", "url", "-n", "name",
"-p", "password", "-d", "driver", "-a", "authType"};
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
Assert.assertTrue(bl.getOpts().getAuthType().equals("authType"));
}
@@ -69,7 +69,7 @@ public class TestBeelineArgParsing {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"-u", "url", "-u", "url2", "-n", "name",
"-p", "password", "-d", "driver"};
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
}
@@ -78,7 +78,7 @@ public class TestBeelineArgParsing {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"-u", "url", "-n", "name",
"-p", "password", "-d", "driver", "-e", "select1", "-e", "select2"};
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
Assert.assertTrue(bl.queries.contains("select1"));
Assert.assertTrue(bl.queries.contains("select2"));
@@ -93,7 +93,7 @@ public class TestBeelineArgParsing {
String args[] = new String[] {"-u", "url", "-n", "name",
"-p", "password", "-d", "driver", "--hiveconf", "a=avalue", "--hiveconf", "b=bvalue",
"--hivevar", "c=cvalue", "--hivevar", "d=dvalue"};
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
Assert.assertTrue(bl.getOpts().getHiveConfVariables().get("a").equals("avalue"));
Assert.assertTrue(bl.getOpts().getHiveConfVariables().get("b").equals("bvalue"));
@@ -107,7 +107,7 @@ public class TestBeelineArgParsing {
String args[] =
new String[] { "-u", "url", "-n", "name", "-p", "password", "-d", "driver",
"--autoCommit=true", "--verbose", "--truncateTable" };
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
Assert.assertTrue(bl.getOpts().getAutoCommit());
Assert.assertTrue(bl.getOpts().getVerbose());
@@ -122,7 +122,7 @@ public class TestBeelineArgParsing {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"-u", "url", "-n", "name",
"-p", "password", "-d", "driver", "-f", "myscript"};
- Assert.assertTrue(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
Assert.assertTrue(bl.connectArgs.equals("url name password driver"));
Assert.assertTrue(bl.getOpts().getScriptFile().equals("myscript"));
}
@@ -134,7 +134,7 @@ public class TestBeelineArgParsing {
public void testHelp() throws Exception {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"--help"};
- Assert.assertFalse(bl.initArgs(args));
+ Assert.assertEquals(0, bl.initArgs(args));
}
/**
@@ -144,7 +144,7 @@ public class TestBeelineArgParsing {
public void testUnmatchedArgs() throws Exception {
TestBeeline bl = new TestBeeline();
String args[] = new String[] {"-u", "url", "-n"};
- Assert.assertFalse(bl.initArgs(args));
+ Assert.assertEquals(-1, bl.initArgs(args));
}
}
Modified: hive/branches/spark/bin/hive
URL: http://svn.apache.org/viewvc/hive/branches/spark/bin/hive?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/bin/hive (original)
+++ hive/branches/spark/bin/hive Mon Sep 8 04:38:17 2014
@@ -99,7 +99,8 @@ done
# add the auxillary jars such as serdes
if [ -d "${HIVE_AUX_JARS_PATH}" ]; then
- for f in ${HIVE_AUX_JARS_PATH}/*.jar; do
+ hive_aux_jars_abspath=`cd ${HIVE_AUX_JARS_PATH} && pwd`
+ for f in $hive_aux_jars_abspath/*.jar; do
if [[ ! -f $f ]]; then
continue;
fi
Modified: hive/branches/spark/checkstyle/checkstyle.xml
URL: http://svn.apache.org/viewvc/hive/branches/spark/checkstyle/checkstyle.xml?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/checkstyle/checkstyle.xml (original)
+++ hive/branches/spark/checkstyle/checkstyle.xml Mon Sep 8 04:38:17 2014
@@ -65,7 +65,7 @@
<module name="Translation"/>
<module name="Header">
- <property name="headerFile" value="${basedir}/checkstyle/asf.header"/>
+ <property name="headerFile" value="checkstyle/asf.header"/>
</module>
<!-- Maximum file line length -->
@@ -78,7 +78,7 @@
<!-- List of files to ignore -->
<module name="SuppressionFilter">
- <property name="file" value="${basedir}/checkstyle/suppressions.xml"/>
+ <property name="file" value="checkstyle/suppressions.xml"/>
</module>
<!-- Ignore JavaCC/JJTree files -->
@@ -178,7 +178,6 @@
<!-- Checks for common coding problems -->
<!-- See http://checkstyle.sf.net/config_coding.html -->
<!-- module name="AvoidInlineConditionals"/-->
- <module name="DoubleCheckedLocking"/>
<module name="EmptyStatement"/>
<module name="EqualsAvoidNull"/>
<module name="EqualsHashCode"/>
Modified: hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/FileUtils.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/FileUtils.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/FileUtils.java (original)
+++ hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/FileUtils.java Mon Sep 8 04:38:17 2014
@@ -649,19 +649,34 @@ public final class FileUtils {
// if a user is a super user. Also super users running hive queries is not a common
// use case. super users can also do a chown to be able to drop the file
- final FileSystem fs = path.getFileSystem(conf);
- if (!fs.exists(path)) {
+ if(path == null) {
// no file/dir to be deleted
return;
}
- Path parPath = path.getParent();
+
+ final FileSystem fs = path.getFileSystem(conf);
// check user has write permissions on the parent dir
- FileStatus stat = fs.getFileStatus(path);
+ FileStatus stat = null;
+ try {
+ stat = fs.getFileStatus(path);
+ } catch (FileNotFoundException e) {
+ // ignore
+ }
+ if (stat == null) {
+ // no file/dir to be deleted
+ return;
+ }
FileUtils.checkFileAccessWithImpersonation(fs, stat, FsAction.WRITE, user);
+ HadoopShims shims = ShimLoader.getHadoopShims();
+ if (!shims.supportStickyBit()) {
+ // not supports sticky bit
+ return;
+ }
+
// check if sticky bit is set on the parent dir
- FileStatus parStatus = fs.getFileStatus(parPath);
- if (!parStatus.getPermission().getStickyBit()) {
+ FileStatus parStatus = fs.getFileStatus(path.getParent());
+ if (!shims.hasStickyBit(parStatus.getPermission())) {
// no sticky bit, so write permission on parent dir is sufficient
// no further checks needed
return;
Modified: hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/ServerUtils.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/ServerUtils.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/ServerUtils.java (original)
+++ hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/ServerUtils.java Mon Sep 8 04:38:17 2014
@@ -25,9 +25,7 @@ import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hive.conf.HiveConf;
/**
- *
- * ServerUtils.
- *
+ * ServerUtils (specific to HiveServer version 1)
*/
public class ServerUtils {
Modified: hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/StatsSetupConst.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/StatsSetupConst.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/StatsSetupConst.java (original)
+++ hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/StatsSetupConst.java Mon Sep 8 04:38:17 2014
@@ -116,8 +116,7 @@ public class StatsSetupConst {
/**
* @return List of all supported statistics
*/
- public static final String[] supportedStats = new String[]
- {NUM_FILES,ROW_COUNT,TOTAL_SIZE,RAW_DATA_SIZE};
+ public static final String[] supportedStats = {NUM_FILES,ROW_COUNT,TOTAL_SIZE,RAW_DATA_SIZE};
/**
* @return List of all statistics that need to be collected during query execution. These are
@@ -142,8 +141,8 @@ public class StatsSetupConst {
public static final String FALSE = "false";
- public static boolean areStatsUptoDate(Map<String,String> params) {
- String statsAcc = params.get(COLUMN_STATS_ACCURATE);
- return statsAcc == null ? false : statsAcc.equals(TRUE);
+ public static boolean areStatsUptoDate(Map<String, String> params) {
+ String statsAcc = params.get(COLUMN_STATS_ACCURATE);
+ return statsAcc == null ? false : statsAcc.equals(TRUE);
}
}
Modified: hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/type/HiveDecimal.java
URL: http://svn.apache.org/viewvc/hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/type/HiveDecimal.java?rev=1623263&r1=1623262&r2=1623263&view=diff
==============================================================================
--- hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/type/HiveDecimal.java (original)
+++ hive/branches/spark/common/src/java/org/apache/hadoop/hive/common/type/HiveDecimal.java Mon Sep 8 04:38:17 2014
@@ -254,16 +254,16 @@ public class HiveDecimal implements Comp
return null;
}
+ if (bd.scale() > maxScale) {
+ bd = bd.setScale(maxScale, RoundingMode.HALF_UP);
+ }
+
int maxIntDigits = maxPrecision - maxScale;
int intDigits = bd.precision() - bd.scale();
if (intDigits > maxIntDigits) {
return null;
}
- if (bd.scale() > maxScale) {
- bd = bd.setScale(maxScale, RoundingMode.HALF_UP);
- }
-
return bd;
}
}