Index: conf/hive-default.xml =================================================================== --- conf/hive-default.xml (revision 1164293) +++ conf/hive-default.xml (working copy) @@ -1169,4 +1169,13 @@ The class responsible logging client side performance metrics. Must be a subclass of org.apache.hadoop.hive.ql.log.PerfLogger + + hive.mapred.bigint.comparison.mode + nonstrict + If this is set to be strict, whenever a bigint may implictely be converted to a double, either because of a where condition, a join + condtion, or two columns being combined as part of a union, where in any of these cases one side is a bigint and the other is a string or a double, + an exception will be thrown alerting the user to the possibility of a loss in precision. If this is set to nonstrict, a warning to that effect is + given. + + Index: common/src/java/org/apache/hadoop/hive/conf/HiveConf.java =================================================================== --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java (revision 1164293) +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java (working copy) @@ -281,6 +281,9 @@ HIVEMAPAGGRHASHMINREDUCTION("hive.map.aggr.hash.min.reduction", (float) 0.5), HIVEMULTIGROUPBYSINGLEMR("hive.multigroupby.singlemr", false), + // prevents comparisons between bigints and doubles/strings for precision reasons + HIVEBIGINTCOMPARISIONMODE("hive.mapred.bigint.comparison.mode", "nonstrict"), + // for hive udtf operator HIVEUDTFAUTOPROGRESS("hive.udtf.auto.progress", false), Index: ql/src/test/results/clientnegative/compare_string_bigint.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_string_bigint.q.out (revision 1164293) +++ ql/src/test/results/clientnegative/compare_string_bigint.q.out (working copy) @@ -1 +1 @@ -FAILED: Error in semantic analysis: Line 0:-1 Wrong arguments ''1'': In strict mode, comparing bigints and strings is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.mode=nonstrict +FAILED: Error in semantic analysis: Line 0:-1 Wrong arguments ''1'': In strict mode, comparing bigints and strings is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientnegative/compare_string_bigint_union.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_string_bigint_union.q.out (revision 0) +++ ql/src/test/results/clientnegative/compare_string_bigint_union.q.out (revision 0) @@ -0,0 +1 @@ +FAILED: Error in semantic analysis: In strict mode, bigints and doubles are considered different schemas in unions as conversion may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientnegative/compare_string_bigint_join.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_string_bigint_join.q.out (revision 0) +++ ql/src/test/results/clientnegative/compare_string_bigint_join.q.out (revision 0) @@ -0,0 +1 @@ +FAILED: Error in semantic analysis: In strict mode, comparing bigints and strings as part of a join is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientnegative/compare_double_bigint_union.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_double_bigint_union.q.out (revision 0) +++ ql/src/test/results/clientnegative/compare_double_bigint_union.q.out (revision 0) @@ -0,0 +1 @@ +FAILED: Error in semantic analysis: In strict mode, bigints and doubles are considered different schemas in unions as conversion may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientnegative/compare_double_bigint_join.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_double_bigint_join.q.out (revision 0) +++ ql/src/test/results/clientnegative/compare_double_bigint_join.q.out (revision 0) @@ -0,0 +1 @@ +FAILED: Error in semantic analysis: In strict mode, comparing bigints and strings as part of a join is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientnegative/compare_double_bigint.q.out =================================================================== --- ql/src/test/results/clientnegative/compare_double_bigint.q.out (revision 1164293) +++ ql/src/test/results/clientnegative/compare_double_bigint.q.out (working copy) @@ -1 +1 @@ -FAILED: Error in semantic analysis: Line 0:-1 Wrong arguments '1.0': In strict mode, comparing bigints and doubles is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.mode=nonstrict +FAILED: Error in semantic analysis: Line 0:-1 Wrong arguments '1.0': In strict mode, comparing bigints and doubles is not allowed, it may result in a loss of precision. If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict Index: ql/src/test/results/clientpositive/filter_join_breaktask2.q.out =================================================================== --- ql/src/test/results/clientpositive/filter_join_breaktask2.q.out (revision 1164293) +++ ql/src/test/results/clientpositive/filter_join_breaktask2.q.out (working copy) @@ -253,11 +253,11 @@ PREHOOK: query: select * from T2 PREHOOK: type: QUERY PREHOOK: Input: default@t2@ds=2010-04-17 -PREHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-10_566_4433224025311049348/-mr-10000 +PREHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_023_47054873695306612/-mr-10000 POSTHOOK: query: select * from T2 POSTHOOK: type: QUERY POSTHOOK: Input: default@t2@ds=2010-04-17 -POSTHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-10_566_4433224025311049348/-mr-10000 +POSTHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_023_47054873695306612/-mr-10000 POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c1 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c2 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c3 SIMPLE [] @@ -382,11 +382,11 @@ PREHOOK: query: select * from T1 PREHOOK: type: QUERY PREHOOK: Input: default@t1@ds=2010-04-17 -PREHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-10_954_8596376016737090385/-mr-10000 +PREHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_319_7114393356071103957/-mr-10000 POSTHOOK: query: select * from T1 POSTHOOK: type: QUERY POSTHOOK: Input: default@t1@ds=2010-04-17 -POSTHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-10_954_8596376016737090385/-mr-10000 +POSTHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_319_7114393356071103957/-mr-10000 POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c1 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c2 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c3 SIMPLE [] @@ -511,11 +511,11 @@ PREHOOK: query: select * from T3 PREHOOK: type: QUERY PREHOOK: Input: default@t3@ds=2010-04-17 -PREHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-11_371_4261884027917519942/-mr-10000 +PREHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_535_5237381418457669677/-mr-10000 POSTHOOK: query: select * from T3 POSTHOOK: type: QUERY POSTHOOK: Input: default@t3@ds=2010-04-17 -POSTHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-11_371_4261884027917519942/-mr-10000 +POSTHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_535_5237381418457669677/-mr-10000 POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c1 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c2 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c3 SIMPLE [] @@ -640,11 +640,11 @@ PREHOOK: query: select * from T4 PREHOOK: type: QUERY PREHOOK: Input: default@t4@ds=2010-04-17 -PREHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-11_796_8203509595344384965/-mr-10000 +PREHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_738_1873352144920946319/-mr-10000 POSTHOOK: query: select * from T4 POSTHOOK: type: QUERY POSTHOOK: Input: default@t4@ds=2010-04-17 -POSTHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-11_796_8203509595344384965/-mr-10000 +POSTHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_738_1873352144920946319/-mr-10000 POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c1 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c2 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c3 SIMPLE [] @@ -766,6 +766,7 @@ POSTHOOK: Lineage: t4 PARTITION(ds=2010-04-17).c83 EXPRESSION [] POSTHOOK: Lineage: t4 PARTITION(ds=2010-04-17).c9 SIMPLE [] 4 1 1 8 4 5 1 0 9 U 2 2 0 2 1 1 J C A U 2 s 2 NULL NULL NULL NULL NULL NULL 1 j S 6 NULL 1 2 J g 1 e 2 1 2 U P p 3 0 0 0 1 1 1 0 0 0 6 2 j NULL NULL NULL NULL NULL NULL 5 NULL NULL j 2 2 1 2 2 1 1 1 1 1 1 1 1 32 NULL 2010-04-17 +WARNING: Comparing a bigint and a string as part of a join may result in a loss of precision. PREHOOK: query: SELECT a.c1 as a_c1, b.c1 b_c1, d.c0 as d_c0 FROM T1 a JOIN T2 b ON (a.c1 = b.c1 AND a.ds='2010-04-17' AND b.ds='2010-04-17') @@ -778,7 +779,7 @@ PREHOOK: Input: default@t2@ds=2010-04-17 PREHOOK: Input: default@t3@ds=2010-04-17 PREHOOK: Input: default@t4@ds=2010-04-17 -PREHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-12_248_6929768884094642056/-mr-10000 +PREHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_995_8049375160895979440/-mr-10000 POSTHOOK: query: SELECT a.c1 as a_c1, b.c1 b_c1, d.c0 as d_c0 FROM T1 a JOIN T2 b ON (a.c1 = b.c1 AND a.ds='2010-04-17' AND b.ds='2010-04-17') @@ -791,7 +792,7 @@ POSTHOOK: Input: default@t2@ds=2010-04-17 POSTHOOK: Input: default@t3@ds=2010-04-17 POSTHOOK: Input: default@t4@ds=2010-04-17 -POSTHOOK: Output: file:/tmp/jsichi/hive_2010-08-26_15-41-12_248_6929768884094642056/-mr-10000 +POSTHOOK: Output: file:/var/folders/Y1/Y1Kf7th8FAawW1lYb6Tt+l+pemQ/-Tmp-/kevinwilfong/hive_2011-09-02_09-44-45_995_8049375160895979440/-mr-10000 POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c1 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c2 SIMPLE [] POSTHOOK: Lineage: t1 PARTITION(ds=2010-04-17).c3 SIMPLE [] Index: ql/src/test/queries/clientnegative/compare_double_bigint_union.q =================================================================== --- ql/src/test/queries/clientnegative/compare_double_bigint_union.q (revision 0) +++ ql/src/test/queries/clientnegative/compare_double_bigint_union.q (revision 0) @@ -0,0 +1,5 @@ +set hive.mapred.bigint.comparison.mode=strict; + +-- This should fail until we fix the issue with precision when casting a bigint to a double + +select * from (select cast(key as double) from src union all select cast(key as bigint) from src) a limit 10; \ No newline at end of file Index: ql/src/test/queries/clientnegative/compare_string_bigint_join.q =================================================================== --- ql/src/test/queries/clientnegative/compare_string_bigint_join.q (revision 0) +++ ql/src/test/queries/clientnegative/compare_string_bigint_join.q (revision 0) @@ -0,0 +1,5 @@ +set hive.mapred.bigint.comparison.mode=strict; + +--This should fail until we fix the issue with precision when casting a bigint to a double + +select * from src a join src b on (cast(a.key as bigint) = cast(b.key as string)) limit 10; \ No newline at end of file Index: ql/src/test/queries/clientnegative/compare_double_bigint.q =================================================================== --- ql/src/test/queries/clientnegative/compare_double_bigint.q (revision 1164293) +++ ql/src/test/queries/clientnegative/compare_double_bigint.q (working copy) @@ -1,4 +1,4 @@ -set hive.mapred.mode=strict; +set hive.mapred.bigint.comparison.mode=strict; -- This should fail until we fix the issue with precision when casting a bigint to a double Index: ql/src/test/queries/clientnegative/compare_double_bigint_join.q =================================================================== --- ql/src/test/queries/clientnegative/compare_double_bigint_join.q (revision 0) +++ ql/src/test/queries/clientnegative/compare_double_bigint_join.q (revision 0) @@ -0,0 +1,5 @@ +set hive.mapred.bigint.comparison.mode=strict; + +-- This should fail until we fix the issue with precision when casting a bigint to a double + +select * from src a join src b on (cast(a.key as bigint) = cast(b.key as string)) limit 10; \ No newline at end of file Index: ql/src/test/queries/clientnegative/compare_string_bigint.q =================================================================== --- ql/src/test/queries/clientnegative/compare_string_bigint.q (revision 1164293) +++ ql/src/test/queries/clientnegative/compare_string_bigint.q (working copy) @@ -1,4 +1,4 @@ -set hive.mapred.mode=strict; +set hive.mapred.bigint.comparison.mode=strict; --This should fail until we fix the issue with precision when casting a bigint to a double Index: ql/src/test/queries/clientnegative/compare_string_bigint_union.q =================================================================== --- ql/src/test/queries/clientnegative/compare_string_bigint_union.q (revision 0) +++ ql/src/test/queries/clientnegative/compare_string_bigint_union.q (revision 0) @@ -0,0 +1,5 @@ +set hive.mapred.bigint.comparison.mode=strict; + +--This should fail until we fix the issue with precision when casting a bigint to a double + +select * from (select cast(key as double) from src union all select cast(key as bigint) from src) a limit 10; \ No newline at end of file Index: ql/src/test/queries/clientpositive/filter_join_breaktask2.q =================================================================== --- ql/src/test/queries/clientpositive/filter_join_breaktask2.q (revision 1164293) +++ ql/src/test/queries/clientpositive/filter_join_breaktask2.q (working copy) @@ -26,6 +26,8 @@ select * from T3; select * from T4; +set hive.mapred.bigint.comparison.mode=nonstrict; + SELECT a.c1 as a_c1, b.c1 b_c1, d.c0 as d_c0 FROM T1 a JOIN T2 b ON (a.c1 = b.c1 AND a.ds='2010-04-17' AND b.ds='2010-04-17') Index: ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java (revision 1164293) +++ ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java (working copy) @@ -175,14 +175,14 @@ // For now, if a bigint is going to be cast to a double throw an error or warning if ((oiTypeInfo0.equals(TypeInfoFactory.stringTypeInfo) && oiTypeInfo1.equals(TypeInfoFactory.longTypeInfo)) || (oiTypeInfo0.equals(TypeInfoFactory.longTypeInfo) && oiTypeInfo1.equals(TypeInfoFactory.stringTypeInfo))) { - if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEMAPREDMODE).equalsIgnoreCase("strict")) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { throw new UDFArgumentException(ErrorMsg.NO_COMPARE_BIGINT_STRING.getMsg()); } else { console.printError("WARNING: Comparing a bigint and a string may result in a loss of precision."); } } else if ((oiTypeInfo0.equals(TypeInfoFactory.doubleTypeInfo) && oiTypeInfo1.equals(TypeInfoFactory.longTypeInfo)) || (oiTypeInfo0.equals(TypeInfoFactory.longTypeInfo) && oiTypeInfo1.equals(TypeInfoFactory.doubleTypeInfo))) { - if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEMAPREDMODE).equalsIgnoreCase("strict")) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { throw new UDFArgumentException(ErrorMsg.NO_COMPARE_BIGINT_DOUBLE.getMsg()); } else { console.printError("WARNING: Comparing a bigint and a double may result in a loss of precision."); Index: ql/src/java/org/apache/hadoop/hive/ql/parse/ErrorMsg.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/parse/ErrorMsg.java (revision 1164293) +++ ql/src/java/org/apache/hadoop/hive/ql/parse/ErrorMsg.java (working copy) @@ -182,10 +182,22 @@ INSERT_INTO_BUCKETIZED_TABLE("Bucketized tables do not support INSERT INTO:"), NO_COMPARE_BIGINT_STRING("In strict mode, comparing bigints and strings is not allowed, " + "it may result in a loss of precision. " - + "If you really want to perform the operation, set hive.mapred.mode=nonstrict"), + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), NO_COMPARE_BIGINT_DOUBLE("In strict mode, comparing bigints and doubles is not allowed, " + "it may result in a loss of precision. " - + "If you really want to perform the operation, set hive.mapred.mode=nonstrict"), + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), + NO_JOIN_BIGINT_STRING("In strict mode, comparing bigints and strings as part of a join is not allowed, " + + "it may result in a loss of precision. " + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), + NO_JOIN_BIGINT_DOUBLE("In strict mode, comparing bigints and doubles as part of a join is not allowed, " + + "it may result in a loss of precision. " + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), + NO_UNION_BIGINT_STRING("In strict mode, bigints and strings are considered different schemas in unions " + + "as conversion may result in a loss of precision. " + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), + NO_UNION_BIGINT_DOUBLE("In strict mode, bigints and doubles are considered different schemas in unions " + + "as conversion may result in a loss of precision. " + + "If you really want to perform the operation, set hive.mapred.bigint.comparison.mode=nonstrict"), ; private String mesg; Index: ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java =================================================================== --- ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java (revision 1164293) +++ ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java (working copy) @@ -27,9 +27,9 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import java.util.TreeSet; -import java.util.Map.Entry; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; @@ -66,6 +66,7 @@ import org.apache.hadoop.hive.ql.exec.TableScanOperator; import org.apache.hadoop.hive.ql.exec.Task; import org.apache.hadoop.hive.ql.exec.TaskFactory; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; import org.apache.hadoop.hive.ql.exec.UnionOperator; import org.apache.hadoop.hive.ql.exec.Utilities; import org.apache.hadoop.hive.ql.hooks.ReadEntity; @@ -92,6 +93,7 @@ import org.apache.hadoop.hive.ql.optimizer.GenMRFileSink1; import org.apache.hadoop.hive.ql.optimizer.GenMROperator; import org.apache.hadoop.hive.ql.optimizer.GenMRProcContext; +import org.apache.hadoop.hive.ql.optimizer.GenMRProcContext.GenMapRedCtx; import org.apache.hadoop.hive.ql.optimizer.GenMRRedSink1; import org.apache.hadoop.hive.ql.optimizer.GenMRRedSink2; import org.apache.hadoop.hive.ql.optimizer.GenMRRedSink3; @@ -101,7 +103,6 @@ import org.apache.hadoop.hive.ql.optimizer.GenMapRedUtils; import org.apache.hadoop.hive.ql.optimizer.MapJoinFactory; import org.apache.hadoop.hive.ql.optimizer.Optimizer; -import org.apache.hadoop.hive.ql.optimizer.GenMRProcContext.GenMapRedCtx; import org.apache.hadoop.hive.ql.optimizer.physical.PhysicalContext; import org.apache.hadoop.hive.ql.optimizer.physical.PhysicalOptimizer; import org.apache.hadoop.hive.ql.optimizer.ppr.PartitionPruner; @@ -122,6 +123,7 @@ import org.apache.hadoop.hive.ql.plan.FetchWork; import org.apache.hadoop.hive.ql.plan.FileSinkDesc; import org.apache.hadoop.hive.ql.plan.FilterDesc; +import org.apache.hadoop.hive.ql.plan.FilterDesc.sampleDesc; import org.apache.hadoop.hive.ql.plan.ForwardDesc; import org.apache.hadoop.hive.ql.plan.GroupByDesc; import org.apache.hadoop.hive.ql.plan.HiveOperation; @@ -144,13 +146,12 @@ import org.apache.hadoop.hive.ql.plan.TableScanDesc; import org.apache.hadoop.hive.ql.plan.UDTFDesc; import org.apache.hadoop.hive.ql.plan.UnionDesc; -import org.apache.hadoop.hive.ql.plan.FilterDesc.sampleDesc; import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.ql.session.SessionState.ResourceType; import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator.Mode; import org.apache.hadoop.hive.ql.udf.generic.GenericUDFHash; import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF; -import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator.Mode; import org.apache.hadoop.hive.serde.Constants; import org.apache.hadoop.hive.serde2.Deserializer; import org.apache.hadoop.hive.serde2.MetadataTypedColumnsetSerDe; @@ -158,9 +159,9 @@ import org.apache.hadoop.hive.serde2.SerDeUtils; import org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category; import org.apache.hadoop.hive.serde2.objectinspector.StructField; import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; @@ -4897,6 +4898,22 @@ for (int i = 1; i < right.length; i++) { TypeInfo a = commonType; TypeInfo b = keys.get(i).get(k).getTypeInfo(); + // For now, if a bigint is going to be cast to a double throw an error or warning + if ((a.equals(TypeInfoFactory.stringTypeInfo) && b.equals(TypeInfoFactory.longTypeInfo)) || + (a.equals(TypeInfoFactory.longTypeInfo) && b.equals(TypeInfoFactory.stringTypeInfo))) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { + throw new UDFArgumentException(ErrorMsg.NO_JOIN_BIGINT_STRING.getMsg()); + } else { + console.printError("WARNING: Comparing a bigint and a string as part of a join may result in a loss of precision."); + } + } else if ((a.equals(TypeInfoFactory.doubleTypeInfo) && b.equals(TypeInfoFactory.longTypeInfo)) || + (a.equals(TypeInfoFactory.longTypeInfo) && b.equals(TypeInfoFactory.doubleTypeInfo))) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { + throw new UDFArgumentException(ErrorMsg.NO_JOIN_BIGINT_DOUBLE.getMsg()); + } else { + console.printError("WARNING: Comparing a bigint and a double as part of a join may result in a loss of precision."); + } + } commonType = FunctionRegistry.getCommonClassForComparison(a, b); if (commonType == null) { throw new SemanticException( @@ -5986,6 +6003,22 @@ getPositionFromInternalName(rInfo.getInternalName()) + ". Column positions should match for a UNION")); } + // For now, if a bigint is going to be cast to a double throw an error or warning + if ((lInfo.getType().equals(TypeInfoFactory.stringTypeInfo) && rInfo.getType().equals(TypeInfoFactory.longTypeInfo)) || + (lInfo.getType().equals(TypeInfoFactory.longTypeInfo) && rInfo.getType().equals(TypeInfoFactory.stringTypeInfo))) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { + throw new UDFArgumentException(ErrorMsg.NO_UNION_BIGINT_STRING.getMsg()); + } else { + console.printError("WARNING: Converting between a bigint and a string as part of a union may result in a loss of precision."); + } + } else if ((lInfo.getType().equals(TypeInfoFactory.doubleTypeInfo) && rInfo.getType().equals(TypeInfoFactory.longTypeInfo)) || + (lInfo.getType().equals(TypeInfoFactory.longTypeInfo) && rInfo.getType().equals(TypeInfoFactory.doubleTypeInfo))) { + if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVEBIGINTCOMPARISIONMODE).equalsIgnoreCase("strict")) { + throw new UDFArgumentException(ErrorMsg.NO_UNION_BIGINT_DOUBLE.getMsg()); + } else { + console.printError("WARNING: Converting between a bigint and a double as part of a union may result in a loss of precision."); + } + } //try widening coversion, otherwise fail union TypeInfo commonTypeInfo = FunctionRegistry.getCommonClassForComparison(lInfo.getType(), rInfo.getType());