commit fafd1fb131d1287b3dabd4767e73bedc6debe677 Author: Janaki Lahorani Date: Tue Feb 13 14:06:35 2018 -0800 HIVE-18718: Return valid parquet data without errors for integer like types When data is saved as bigint in parquet table, and read as int it results in execution error. For other natively supported formats like ORC, Text etc., error is not thrown. If the data is bigger than the maximum allowed, a NULL is returned. If the data is within the allowed range, the value is returned correctly. This fix makes Parquet match other natively supported ones. Change-Id: I61d5d61a3ee78b4f019a7db4a02921891e68d17c diff --git ql/src/java/org/apache/hadoop/hive/ql/io/parquet/convert/ETypeConverter.java ql/src/java/org/apache/hadoop/hive/ql/io/parquet/convert/ETypeConverter.java index 420559ecf617c4fcd2d9d69537d3351a4b8d7812..6b92b96a584bd88c95baa3788a6d21824d8e150c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/parquet/convert/ETypeConverter.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/parquet/convert/ETypeConverter.java @@ -118,6 +118,28 @@ public void addInt(final int value) { parent.set(index, new DoubleWritable((float) value)); } }; + case serdeConstants.SMALLINT_TYPE_NAME: + return new PrimitiveConverter() { + @Override + public void addInt(final int value) { + if ((value >= Short.MIN_VALUE) && (value <= Short.MAX_VALUE)) { + parent.set(index, new IntWritable((int)value)); + } else { + parent.set(index, null); + } + } + }; + case serdeConstants.TINYINT_TYPE_NAME: + return new PrimitiveConverter() { + @Override + public void addInt(final int value) { + if ((value >= Byte.MIN_VALUE) && (value <= Byte.MAX_VALUE)) { + parent.set(index, new IntWritable((int)value)); + } else { + parent.set(index, null); + } + } + }; } } return new PrimitiveConverter() { @@ -147,6 +169,39 @@ public void addLong(final long value) { parent.set(index, new DoubleWritable(value)); } }; + case serdeConstants.INT_TYPE_NAME: + return new PrimitiveConverter() { + @Override + public void addLong(long value) { + if ((value >= Integer.MIN_VALUE) && (value <= Integer.MAX_VALUE)) { + parent.set(index, new IntWritable((int)value)); + } else { + parent.set(index, null); + } + } + }; + case serdeConstants.SMALLINT_TYPE_NAME: + return new PrimitiveConverter() { + @Override + public void addLong(long value) { + if ((value >= Short.MIN_VALUE) && (value <= Short.MAX_VALUE)) { + parent.set(index, new IntWritable((int)value)); + } else { + parent.set(index, null); + } + } + }; + case serdeConstants.TINYINT_TYPE_NAME: + return new PrimitiveConverter() { + @Override + public void addLong(long value) { + if ((value >= Byte.MIN_VALUE) && (value <= Byte.MAX_VALUE)) { + parent.set(index, new IntWritable((int)value)); + } else { + parent.set(index, null); + } + } + }; } } return new PrimitiveConverter() { diff --git ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReader.java ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReader.java index 6bfa95aae0e0beba3799722a406022665a9ce690..df48abf6b54141cb29a33e7527f661ea861aaae7 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReader.java @@ -50,7 +50,7 @@ /** * @return the next Integer from the page */ - int readInteger(); + long readInteger(); /** * @return the next Float from the page @@ -97,6 +97,12 @@ */ Timestamp readTimestamp(); + /** + * @param value data to be checked for validity + * @return is data valid for the type + */ + boolean isValid(long value); + /** * @return the underlying dictionary if current reader is dictionary encoded */ @@ -124,7 +130,7 @@ * @param id in dictionary * @return the Integer from the dictionary by id */ - int readInteger(int id); + long readInteger(int id); /** * @param id in dictionary diff --git ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReaderFactory.java ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReaderFactory.java index 898a2c6c1c6242b5c02bab3dde38acc206b65cb8..d8009dacd6c100217b92e1be232447685681f54d 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReaderFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/ParquetDataColumnReaderFactory.java @@ -22,6 +22,7 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; import org.apache.hadoop.hive.ql.io.parquet.timestamp.NanoTime; import org.apache.hadoop.hive.ql.io.parquet.timestamp.NanoTimeUtils; +import org.apache.hadoop.hive.serde.serdeConstants; import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; import org.apache.hadoop.hive.serde2.typeinfo.CharTypeInfo; import org.apache.hadoop.hive.serde2.typeinfo.VarcharTypeInfo; @@ -172,15 +173,20 @@ public Timestamp readTimestamp(int id) { } @Override - public int readInteger() { + public long readInteger() { return valuesReader.readInteger(); } @Override - public int readInteger(int id) { + public long readInteger(int id) { return dict.decodeToInt(id); } + @Override + public boolean isValid(long value) { + return true; + } + @Override public long readLong(int id) { return dict.decodeToLong(id); @@ -337,6 +343,16 @@ public TypesFromInt64PageReader(Dictionary dict, int length) { super(dict, length); } + @Override + public long readInteger() { + return valuesReader.readLong(); + } + + @Override + public long readInteger(int id) { + return dict.decodeToLong(id); + } + @Override public float readFloat() { return valuesReader.readLong(); @@ -404,6 +420,97 @@ private static String convertToString(long value) { } } + /** + * The reader who reads long data using int type. + */ + public static class Types64Int2IntPageReader extends TypesFromInt64PageReader { + + public Types64Int2IntPageReader(ValuesReader realReader, int length) { + super(realReader, length); + } + + public Types64Int2IntPageReader(Dictionary dict, int length) { + super(dict, length); + } + + @Override + public boolean isValid(long value) { + return ((value <= Integer.MAX_VALUE) && (value >= Integer.MIN_VALUE)); + } + } + + /** + * The reader who reads long data using smallint type. + */ + public static class Types64Int2SmallintPageReader extends TypesFromInt64PageReader { + public Types64Int2SmallintPageReader(ValuesReader realReader, int length) { + super(realReader, length); + } + + public Types64Int2SmallintPageReader(Dictionary dict, int length) { + super(dict, length); + } + + @Override + public boolean isValid(long value) { + return ((value <= Short.MAX_VALUE) && (value >= Short.MIN_VALUE)); + } + } + + /** + * The reader who reads long data using tinyint type. + */ + public static class Types64Int2TinyintPageReader extends TypesFromInt64PageReader { + public Types64Int2TinyintPageReader(ValuesReader realReader, int length) { + super(realReader, length); + } + + public Types64Int2TinyintPageReader(Dictionary dict, int length) { + super(dict, length); + } + + @Override + public boolean isValid(long value) { + return ((value <= Byte.MAX_VALUE) && (value >= Byte.MIN_VALUE)); + } + } + + /** + * The reader who reads int data using smallint type. + */ + public static class Types32Int2SmallintPageReader extends TypesFromInt32PageReader { + public Types32Int2SmallintPageReader(ValuesReader realReader, int length) { + super(realReader, length); + } + + public Types32Int2SmallintPageReader(Dictionary dict, int length) { + super(dict, length); + } + + @Override + public boolean isValid(long value) { + return ((value <= Short.MAX_VALUE) && (value >= Short.MIN_VALUE)); + } + } + + /** + * The reader who reads int data using tinyint type. + */ + public static class Types32Int2TinyintPageReader extends TypesFromInt32PageReader { + public Types32Int2TinyintPageReader(ValuesReader realReader, int length) { + super(realReader, length); + } + + public Types32Int2TinyintPageReader(Dictionary dict, int length) { + super(dict, length); + } + + @Override + public boolean isValid(long value) { + return ((value <= Byte.MAX_VALUE) && (value >= Byte.MIN_VALUE)); + } + } + /** * The reader who reads from the underlying float value value. Implementation is in consist with * ETypeConverter EFLOAT_CONVERTER @@ -812,11 +919,32 @@ private static ParquetDataColumnReader getDataColumnReaderByTypeHelper(boolean i switch (parquetType.getPrimitiveTypeName()) { case INT32: - return isDictionary ? new TypesFromInt32PageReader(dictionary, length) : new - TypesFromInt32PageReader(valuesReader, length); + switch (hiveType.getTypeName()) { + case serdeConstants.SMALLINT_TYPE_NAME: + return isDictionary ? new Types32Int2SmallintPageReader(dictionary, + length) : new Types32Int2SmallintPageReader(valuesReader, length); + case serdeConstants.TINYINT_TYPE_NAME: + return isDictionary ? new Types32Int2TinyintPageReader(dictionary, + length) : new Types32Int2TinyintPageReader(valuesReader, length); + default: + return isDictionary ? new TypesFromInt32PageReader(dictionary, + length) : new TypesFromInt32PageReader(valuesReader, length); + } case INT64: - return isDictionary ? new TypesFromInt64PageReader(dictionary, length) : new - TypesFromInt64PageReader(valuesReader, length); + switch (hiveType.getTypeName()) { + case serdeConstants.INT_TYPE_NAME: + return isDictionary ? new Types64Int2IntPageReader(dictionary, + length) : new Types64Int2IntPageReader(valuesReader, length); + case serdeConstants.SMALLINT_TYPE_NAME: + return isDictionary ? new Types64Int2SmallintPageReader(dictionary, + length) : new Types64Int2SmallintPageReader(valuesReader, length); + case serdeConstants.TINYINT_TYPE_NAME: + return isDictionary ? new Types64Int2TinyintPageReader(dictionary, + length) : new Types64Int2TinyintPageReader(valuesReader, length); + default: + return isDictionary ? new TypesFromInt64PageReader(dictionary, + length) : new TypesFromInt64PageReader(valuesReader, length); + } case FLOAT: return isDictionary ? new TypesFromFloatPageReader(dictionary, length) : new TypesFromFloatPageReader(valuesReader, length); diff --git ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/VectorizedPrimitiveColumnReader.java ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/VectorizedPrimitiveColumnReader.java index 1442d69b0ff051d5d7d8d99e9ef44dd02b06d335..1cc9e62ee8d46d70615860ab1cdd0ab12c923137 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/VectorizedPrimitiveColumnReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/parquet/vector/VectorizedPrimitiveColumnReader.java @@ -121,6 +121,12 @@ private void readBatchHelper( } } + private static void setNullValue(ColumnVector c, int rowId) { + c.isNull[rowId] = true; + c.isRepeating = false; + c.noNulls = false; + } + private void readDictionaryIDs( int total, LongColumnVector c, @@ -133,9 +139,7 @@ private void readDictionaryIDs( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -151,12 +155,15 @@ private void readIntegers( readRepetitionAndDefinitionLevels(); if (definitionLevel >= maxDefLevel) { c.vector[rowId] = dataColumn.readInteger(); - c.isNull[rowId] = false; - c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); + if (dataColumn.isValid(c.vector[rowId])) { + c.isNull[rowId] = false; + c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); + } else { + c.vector[rowId] = 0; + setNullValue(c, rowId); + } } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -175,9 +182,7 @@ private void readDoubles( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -196,9 +201,7 @@ private void readBooleans( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -217,9 +220,7 @@ private void readLongs( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -238,9 +239,7 @@ private void readFloats( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -262,9 +261,7 @@ private void readDecimal( c.isNull[rowId] = false; c.isRepeating = c.isRepeating && (c.vector[0] == c.vector[rowId]); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -284,9 +281,7 @@ private void readString( // TODO figure out a better way to set repeat for Binary type c.isRepeating = false; } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -306,9 +301,7 @@ private void readChar( // TODO figure out a better way to set repeat for Binary type c.isRepeating = false; } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -328,9 +321,7 @@ private void readVarchar( // TODO figure out a better way to set repeat for Binary type c.isRepeating = false; } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -350,9 +341,7 @@ private void readBinaries( // TODO figure out a better way to set repeat for Binary type c.isRepeating = false; } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -377,9 +366,7 @@ private void readTimestamp(int total, TimestampColumnVector c, int rowId) throws c.isRepeating = c.isRepeating && ((c.time[0] == c.time[rowId]) && (c.nanos[0] == c.nanos[rowId])); } else { - c.isNull[rowId] = true; - c.isRepeating = false; - c.noNulls = false; + setNullValue(c, rowId); } rowId++; left--; @@ -411,8 +398,12 @@ private void decodeDictionaryIds( for (int i = rowId; i < rowId + num; ++i) { ((LongColumnVector) column).vector[i] = dictionary.readInteger((int) dictionaryIds.vector[i]); - } - break; + if (!(dictionary.isValid(((LongColumnVector) column).vector[i]))) { + column.noNulls = false; + ((LongColumnVector) column).vector[i] = 0; + ((LongColumnVector) column).isNull[i] = true; + } + } break; case DATE: case INTERVAL_YEAR_MONTH: case LONG: diff --git ql/src/test/queries/clientpositive/type_change_test_int.q ql/src/test/queries/clientpositive/type_change_test_int.q new file mode 100644 index 0000000000000000000000000000000000000000..2469d573cdc3182c8d3db02be1f6c58d21e7d69a --- /dev/null +++ ql/src/test/queries/clientpositive/type_change_test_int.q @@ -0,0 +1,293 @@ +-- Create a base table to be used for loading data: Begin +drop table if exists testAltCol; +create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT); + +insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123); + +insert into testAltCol values +(2, + 1, + 2, + 3, + 4); + +insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123); + +insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId; +-- Create a base table to be used for loading data: End + +-- Enable change of column type +SET hive.metastore.disallow.incompatible.col.type.changes=false; + +-- Text type: Begin +drop table if exists testAltColT; + +create table testAltColT stored as textfile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +drop table if exists testAltColT; +-- Text type: End + +-- Sequence File type: Begin +drop table if exists testAltColSF; + +create table testAltColSF stored as sequencefile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +drop table if exists testAltColSF; +-- Sequence File type: End + +-- RCFile type: Begin +drop table if exists testAltColRCF; + +create table testAltColRCF stored as rcfile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +drop table if exists testAltColRCF; +-- RCFile type: End + +-- ORC type: Begin +drop table if exists testAltColORC; + +create table testAltColORC stored as orc as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +drop table if exists testAltColORC; +-- ORC type: End + +-- Parquet type: Begin +drop table if exists testAltColP; + +create table testAltColP stored as parquet as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +drop table if exists testAltColP; +-- Parquet type: End + diff --git ql/src/test/queries/clientpositive/type_change_test_int_vectorized.q ql/src/test/queries/clientpositive/type_change_test_int_vectorized.q new file mode 100644 index 0000000000000000000000000000000000000000..12313ef409a0ef6e45bad8c274fa2f3a185deb04 --- /dev/null +++ ql/src/test/queries/clientpositive/type_change_test_int_vectorized.q @@ -0,0 +1,296 @@ +-- Create a base table to be used for loading data: Begin +drop table if exists testAltCol; +create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT); + +insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123); + +insert into testAltCol values +(2, + 1, + 2, + 3, + 4); + +insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123); + +insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId; +-- Create a base table to be used for loading data: End + +-- Enable change of column type +SET hive.metastore.disallow.incompatible.col.type.changes=false; + +-- Enable vectorization +SET hive.vectorized.execution.enabled=true; + +-- Text type: Begin +drop table if exists testAltColT; + +create table testAltColT stored as textfile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId; + +drop table if exists testAltColT; +-- Text type: End + +-- Sequence File type: Begin +drop table if exists testAltColSF; + +create table testAltColSF stored as sequencefile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId; + +drop table if exists testAltColSF; +-- Sequence File type: End + +-- RCFile type: Begin +drop table if exists testAltColRCF; + +create table testAltColRCF stored as rcfile as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId; + +drop table if exists testAltColRCF; +-- RCFile type: End + +-- ORC type: Begin +drop table if exists testAltColORC; + +create table testAltColORC stored as orc as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId; + +drop table if exists testAltColORC; +-- ORC type: End + +-- Parquet type: Begin +drop table if exists testAltColP; + +create table testAltColP stored as parquet as select * from testAltCol; + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to bigint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to int +alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to smallint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cSmallInt SMALLINT, + cInt SMALLINT, + cTinyint SMALLINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +-- bigint, int, smallint, and tinyint: type changed to tinyint +alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT); + +select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId; + +drop table if exists testAltColP; +-- Parquet type: End + diff --git ql/src/test/results/clientpositive/type_change_test_int.q.out ql/src/test/results/clientpositive/type_change_test_int.q.out new file mode 100644 index 0000000000000000000000000000000000000000..6775f17f3eff54715cdcf22633d6f471d7b3c349 --- /dev/null +++ ql/src/test/results/clientpositive/type_change_test_int.q.out @@ -0,0 +1,921 @@ +PREHOOK: query: drop table if exists testAltCol +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltCol +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltCol +POSTHOOK: query: create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltCol +PREHOOK: query: insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(2, + 1, + 2, + 3, + 4) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(2, + 1, + 2, + 3, + 4) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcol +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcol +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: drop table if exists testAltColT +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColT +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColT stored as textfile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColT +POSTHOOK: query: create table testAltColT stored as textfile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColT +POSTHOOK: Lineage: testaltcolt.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolt.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColT +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: drop table if exists testAltColT +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: drop table if exists testAltColSF +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColSF +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColSF stored as sequencefile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColSF +POSTHOOK: query: create table testAltColSF stored as sequencefile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColSF +POSTHOOK: Lineage: testaltcolsf.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColSF +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: drop table if exists testAltColSF +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: drop table if exists testAltColRCF +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColRCF +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColRCF stored as rcfile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColRCF +POSTHOOK: query: create table testAltColRCF stored as rcfile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColRCF +POSTHOOK: Lineage: testaltcolrcf.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColRCF +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: drop table if exists testAltColRCF +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: drop table if exists testAltColORC +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColORC +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColORC stored as orc as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColORC +POSTHOOK: query: create table testAltColORC stored as orc as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColORC +POSTHOOK: Lineage: testaltcolorc.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColORC +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: drop table if exists testAltColORC +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: drop table if exists testAltColP +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColP +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColP stored as parquet as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColP +POSTHOOK: query: create table testAltColP stored as parquet as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColP +POSTHOOK: Lineage: testaltcolp.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolp.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColP +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: drop table if exists testAltColP +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp diff --git ql/src/test/results/clientpositive/type_change_test_int_vectorized.q.out ql/src/test/results/clientpositive/type_change_test_int_vectorized.q.out new file mode 100644 index 0000000000000000000000000000000000000000..3e74fb514cac1b1847c7b171a9ac98e1040d21fe --- /dev/null +++ ql/src/test/results/clientpositive/type_change_test_int_vectorized.q.out @@ -0,0 +1,921 @@ +PREHOOK: query: drop table if exists testAltCol +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltCol +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltCol +POSTHOOK: query: create table testAltCol +(cId TINYINT, + cBigInt BIGINT, + cInt INT, + cSmallInt SMALLINT, + cTinyint TINYINT) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltCol +PREHOOK: query: insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(1, + 1234567890123456789, + 1234567890, + 12345, + 123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(2, + 1, + 2, + 3, + 4) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(2, + 1, + 2, + 3, + 4) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(3, + 1234567890123456789, + 1234567890, + 12345, + 123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@testaltcol +POSTHOOK: query: insert into testAltCol values +(4, + -1234567890123456789, + -1234567890, + -12345, + -123) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@testaltcol +POSTHOOK: Lineage: testaltcol.cbigint SCRIPT [] +POSTHOOK: Lineage: testaltcol.cid SCRIPT [] +POSTHOOK: Lineage: testaltcol.cint SCRIPT [] +POSTHOOK: Lineage: testaltcol.csmallint SCRIPT [] +POSTHOOK: Lineage: testaltcol.ctinyint SCRIPT [] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcol +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltCol order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcol +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: drop table if exists testAltColT +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColT +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColT stored as textfile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColT +POSTHOOK: query: create table testAltColT stored as textfile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColT +POSTHOOK: Lineage: testaltcolt.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolt.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolt.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: alter table testAltColT replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColT order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolt +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColT +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolt +PREHOOK: Output: default@testaltcolt +POSTHOOK: query: drop table if exists testAltColT +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolt +POSTHOOK: Output: default@testaltcolt +PREHOOK: query: drop table if exists testAltColSF +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColSF +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColSF stored as sequencefile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColSF +POSTHOOK: query: create table testAltColSF stored as sequencefile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColSF +POSTHOOK: Lineage: testaltcolsf.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolsf.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: alter table testAltColSF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColSF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolsf +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColSF +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolsf +PREHOOK: Output: default@testaltcolsf +POSTHOOK: query: drop table if exists testAltColSF +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolsf +POSTHOOK: Output: default@testaltcolsf +PREHOOK: query: drop table if exists testAltColRCF +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColRCF +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColRCF stored as rcfile as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColRCF +POSTHOOK: query: create table testAltColRCF stored as rcfile as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColRCF +POSTHOOK: Lineage: testaltcolrcf.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolrcf.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: alter table testAltColRCF replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColRCF order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolrcf +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColRCF +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolrcf +PREHOOK: Output: default@testaltcolrcf +POSTHOOK: query: drop table if exists testAltColRCF +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolrcf +POSTHOOK: Output: default@testaltcolrcf +PREHOOK: query: drop table if exists testAltColORC +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColORC +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColORC stored as orc as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColORC +POSTHOOK: query: create table testAltColORC stored as orc as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColORC +POSTHOOK: Lineage: testaltcolorc.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolorc.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt SMALLINT, + cInt SMALLINT, + cSmallInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: alter table testAltColORC replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColORC order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolorc +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColORC +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolorc +PREHOOK: Output: default@testaltcolorc +POSTHOOK: query: drop table if exists testAltColORC +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolorc +POSTHOOK: Output: default@testaltcolorc +PREHOOK: query: drop table if exists testAltColP +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table if exists testAltColP +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table testAltColP stored as parquet as select * from testAltCol +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@testaltcol +PREHOOK: Output: database:default +PREHOOK: Output: default@testAltColP +POSTHOOK: query: create table testAltColP stored as parquet as select * from testAltCol +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@testaltcol +POSTHOOK: Output: database:default +POSTHOOK: Output: default@testAltColP +POSTHOOK: Lineage: testaltcolp.cbigint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cbigint, type:bigint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.cid SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cid, type:tinyint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.cint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:cint, type:int, comment:null), ] +POSTHOOK: Lineage: testaltcolp.csmallint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:csmallint, type:smallint, comment:null), ] +POSTHOOK: Lineage: testaltcolp.ctinyint SIMPLE [(testaltcol)testaltcol.FieldSchema(name:ctinyint, type:tinyint, comment:null), ] +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt BIGINT, + cInt BIGINT, + cSmallInt BIGINT, + cTinyint BIGINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 1234567890123456789 1234567890 12345 123 +2 1 2 3 4 +3 1234567890123456789 1234567890 12345 123 +4 -1234567890123456789 -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt INT, + cInt INT, + cSmallInt INT, + cTinyint INT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL 1234567890 12345 123 +2 1 2 3 4 +3 NULL 1234567890 12345 123 +4 NULL -1234567890 -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cSmallInt SMALLINT, + cInt SMALLINT, + cTinyint SMALLINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt SMALLINT, + cSmallInt SMALLINT, + cInt SMALLINT, + cTinyint SMALLINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL NULL 12345 123 +2 1 2 3 4 +3 NULL NULL 12345 123 +4 NULL NULL -12345 -123 +PREHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +PREHOOK: type: ALTERTABLE_REPLACECOLS +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: alter table testAltColP replace columns +(cId TINYINT, + cBigInt TINYINT, + cInt TINYINT, + cSmallInt TINYINT, + cTinyint TINYINT) +POSTHOOK: type: ALTERTABLE_REPLACECOLS +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp +PREHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +PREHOOK: type: QUERY +PREHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +POSTHOOK: query: select cId, cBigInt, cInt, cSmallInt, cTinyint from testAltColP order by cId +POSTHOOK: type: QUERY +POSTHOOK: Input: default@testaltcolp +#### A masked pattern was here #### +1 NULL NULL NULL 123 +2 1 2 3 4 +3 NULL NULL NULL 123 +4 NULL NULL NULL -123 +PREHOOK: query: drop table if exists testAltColP +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@testaltcolp +PREHOOK: Output: default@testaltcolp +POSTHOOK: query: drop table if exists testAltColP +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@testaltcolp +POSTHOOK: Output: default@testaltcolp