package FlexibleEncoding.ORC;
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//package org.apache.hadoop.hive.ql.io.orc;
//
//import org.apache.hadoop.hive.common.type.HiveDecimal;
//import org.apache.hadoop.hive.serde2.io.DateWritable;
//import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
//import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
class ColumnStatisticsImpl implements ColumnStatistics {
// private static final class BooleanStatisticsImpl extends ColumnStatisticsImpl
// implements BooleanColumnStatistics {
// private long trueCount = 0;
//
// BooleanStatisticsImpl(OrcProto.ColumnStatistics stats) {
// super(stats);
// OrcProto.BucketStatistics bkt = stats.getBucketStatistics();
// trueCount = bkt.getCount(0);
// }
//
// BooleanStatisticsImpl() {
// }
//
// @Override
// void reset() {
// super.reset();
// trueCount = 0;
// }
//
// @Override
// void updateBoolean(boolean value) {
// if (value) {
// trueCount += 1;
// }
// }
//
// @Override
// void merge(ColumnStatisticsImpl other) {
// super.merge(other);
// BooleanStatisticsImpl bkt = (BooleanStatisticsImpl) other;
// trueCount += bkt.trueCount;
// }
//
// @Override
// OrcProto.ColumnStatistics.Builder serialize() {
// OrcProto.ColumnStatistics.Builder builder = super.serialize();
// OrcProto.BucketStatistics.Builder bucket =
// OrcProto.BucketStatistics.newBuilder();
// bucket.addCount(trueCount);
// builder.setBucketStatistics(bucket);
// return builder;
// }
//
// @Override
// public long getFalseCount() {
// return getNumberOfValues() - trueCount;
// }
//
// @Override
// public long getTrueCount() {
// return trueCount;
// }
//
// @Override
// public String toString() {
// return super.toString() + " true: " + trueCount;
// }
// }
//private static final class IntegerStatisticsImpl extends ColumnStatisticsImpl
// implements IntegerColumnStatistics {
//
// private long minimum = Long.MAX_VALUE;
// private long maximum = Long.MIN_VALUE;
// private long sum = 0;
// private boolean hasMinimum = false;
// private boolean overflow = false;
//
// IntegerStatisticsImpl() {
// }
//
// IntegerStatisticsImpl(OrcProto.ColumnStatistics stats) {
// super(stats);
// OrcProto.IntegerStatistics intStat = stats.getIntStatistics();
// if (intStat.hasMinimum()) {
// hasMinimum = true;
// minimum = intStat.getMinimum();
// }
// if (intStat.hasMaximum()) {
// maximum = intStat.getMaximum();
// }
// if (intStat.hasSum()) {
// sum = intStat.getSum();
// } else {
// overflow = true;
// }
// }
//
// @Override
// void reset() {
// super.reset();
// hasMinimum = false;
// minimum = Long.MAX_VALUE;
// maximum = Long.MIN_VALUE;
// sum = 0;
// overflow = false;
// }
//
// @Override
// void updateInteger(long value) {
// if (!hasMinimum) {
// hasMinimum = true;
// minimum = value;
// maximum = value;
// } else if (value < minimum) {
// minimum = value;
// } else if (value > maximum) {
// maximum = value;
// }
// if (!overflow) {
// boolean wasPositive = sum >= 0;
// sum += value;
// if ((value >= 0) == wasPositive) {
// overflow = (sum >= 0) != wasPositive;
// }
// }
// }
//
// @Override
// void merge(ColumnStatisticsImpl other) {
// IntegerStatisticsImpl otherInt = (IntegerStatisticsImpl) other;
// if (!hasMinimum) {
// hasMinimum = otherInt.hasMinimum;
// minimum = otherInt.minimum;
// maximum = otherInt.maximum;
// } else if (otherInt.hasMinimum) {
// if (otherInt.minimum < minimum) {
// minimum = otherInt.minimum;
// }
// if (otherInt.maximum > maximum) {
// maximum = otherInt.maximum;
// }
// }
// super.merge(other);
// overflow |= otherInt.overflow;
// if (!overflow) {
// boolean wasPositive = sum >= 0;
// sum += otherInt.sum;
// if ((otherInt.sum >= 0) == wasPositive) {
// overflow = (sum >= 0) != wasPositive;
// }
// }
// }
//
// @Override
// OrcProto.ColumnStatistics.Builder serialize() {
// OrcProto.ColumnStatistics.Builder builder = super.serialize();
// OrcProto.IntegerStatistics.Builder intb =
// OrcProto.IntegerStatistics.newBuilder();
// if (hasMinimum) {
// intb.setMinimum(minimum);
// intb.setMaximum(maximum);
// }
// if (!overflow) {
// intb.setSum(sum);
// }
// builder.setIntStatistics(intb);
// return builder;
// }
//
// @Override
// public long getMinimum() {
// return minimum;
// }
//
// @Override
// public long getMaximum() {
// return maximum;
// }
//
// @Override
// public boolean isSumDefined() {
// return !overflow;
// }
//
// @Override
// public long getSum() {
// return sum;
// }
//
// @Override
// public String toString() {
// StringBuilder buf = new StringBuilder(super.toString());
// if (hasMinimum) {
// buf.append(" min: ");
// buf.append(minimum);
// buf.append(" max: ");
// buf.append(maximum);
// }
// if (!overflow) {
// buf.append(" sum: ");
// buf.append(sum);
// }
// return buf.toString();
// }
// }
// private static final class DoubleStatisticsImpl extends ColumnStatisticsImpl
// implements DoubleColumnStatistics {
// private boolean hasMinimum = false;
// private double minimum = Double.MAX_VALUE;
// private double maximum = Double.MIN_VALUE;
// private double sum = 0;
//
// DoubleStatisticsImpl() {
// }
//
// DoubleStatisticsImpl(OrcProto.ColumnStatistics stats) {
// super(stats);
// OrcProto.DoubleStatistics dbl = stats.getDoubleStatistics();
// if (dbl.hasMinimum()) {
// hasMinimum = true;
// minimum = dbl.getMinimum();
// }
// if (dbl.hasMaximum()) {
// maximum = dbl.getMaximum();
// }
// if (dbl.hasSum()) {
// sum = dbl.getSum();
// }
// }
//
// @Override
// void reset() {
// super.reset();
// hasMinimum = false;
// minimum = Double.MAX_VALUE;
// maximum = Double.MIN_VALUE;
// sum = 0;
// }
//
// @Override
// void updateDouble(double value) {
// if (!hasMinimum) {
// hasMinimum = true;
// minimum = value;
// maximum = value;
// } else if (value < minimum) {
// minimum = value;
// } else if (value > maximum) {
// maximum = value;
// }
// sum += value;
// }
//
// @Override
// void merge(ColumnStatisticsImpl other) {
// super.merge(other);
// DoubleStatisticsImpl dbl = (DoubleStatisticsImpl) other;
// if (!hasMinimum) {
// hasMinimum = dbl.hasMinimum;
// minimum = dbl.minimum;
// maximum = dbl.maximum;
// } else if (dbl.hasMinimum) {
// if (dbl.minimum < minimum) {
// minimum = dbl.minimum;
// }
// if (dbl.maximum > maximum) {
// maximum = dbl.maximum;
// }
// }
// sum += dbl.sum;
// }
//
// @Override
// OrcProto.ColumnStatistics.Builder serialize() {
// OrcProto.ColumnStatistics.Builder builder = super.serialize();
// OrcProto.DoubleStatistics.Builder dbl =
// OrcProto.DoubleStatistics.newBuilder();
// if (hasMinimum) {
// dbl.setMinimum(minimum);
// dbl.setMaximum(maximum);
// }
// dbl.setSum(sum);
// builder.setDoubleStatistics(dbl);
// return builder;
// }
//
// @Override
// public double getMinimum() {
// return minimum;
// }
//
// @Override
// public double getMaximum() {
// return maximum;
// }
//
// @Override
// public double getSum() {
// return sum;
// }
//
// @Override
// public String toString() {
// StringBuilder buf = new StringBuilder(super.toString());
// if (hasMinimum) {
// buf.append(" min: ");
// buf.append(minimum);
// buf.append(" max: ");
// buf.append(maximum);
// }
// buf.append(" sum: ");
// buf.append(sum);
// return buf.toString();
// }
// }
private static final class StringStatisticsImpl extends ColumnStatisticsImpl
implements StringColumnStatistics {
private String minimum = null;
private String maximum = null;
StringStatisticsImpl() {
}
StringStatisticsImpl(OrcProto.ColumnStatistics stats) {
super(stats);
OrcProto.StringStatistics str = stats.getStringStatistics();
if (str.hasMaximum()) {
maximum = str.getMaximum();
}
if (str.hasMinimum()) {
minimum = str.getMinimum();
}
}
@Override
void reset() {
super.reset();
minimum = null;
maximum = null;
}
@Override
void updateString(String value) {
if (minimum == null) {
minimum = value;
maximum = value;
} else if (minimum.compareTo(value) > 0) {
minimum = value;
} else if (maximum.compareTo(value) < 0) {
maximum = value;
}
}
@Override
void merge(ColumnStatisticsImpl other) {
super.merge(other);
StringStatisticsImpl str = (StringStatisticsImpl) other;
if (minimum == null) {
minimum = str.minimum;
maximum = str.maximum;
} else if (str.minimum != null) {
if (minimum.compareTo(str.minimum) > 0) {
minimum = str.minimum;
} else if (maximum.compareTo(str.maximum) < 0) {
maximum = str.maximum;
}
}
}
@Override
OrcProto.ColumnStatistics.Builder serialize() {
OrcProto.ColumnStatistics.Builder result = super.serialize();
OrcProto.StringStatistics.Builder str =
OrcProto.StringStatistics.newBuilder();
if (getNumberOfValues() != 0) {
str.setMinimum(minimum);
str.setMaximum(maximum);
}
result.setStringStatistics(str);
return result;
}
@Override
public String getMinimum() {
return minimum;
}
@Override
public String getMaximum() {
return maximum;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder(super.toString());
if (getNumberOfValues() != 0) {
buf.append(" min: ");
buf.append(minimum);
buf.append(" max: ");
buf.append(maximum);
}
return buf.toString();
}
}
// private static final class DecimalStatisticsImpl extends ColumnStatisticsImpl
// implements DecimalColumnStatistics {
// private HiveDecimal minimum = null;
// private HiveDecimal maximum = null;
// private HiveDecimal sum = HiveDecimal.ZERO;
//
// DecimalStatisticsImpl() {
// }
//
// DecimalStatisticsImpl(OrcProto.ColumnStatistics stats) {
// super(stats);
// OrcProto.DecimalStatistics dec = stats.getDecimalStatistics();
// if (dec.hasMaximum()) {
// maximum = new HiveDecimal(dec.getMaximum());
// }
// if (dec.hasMinimum()) {
// minimum = new HiveDecimal(dec.getMinimum());
// }
// if (dec.hasSum()) {
// sum = new HiveDecimal(dec.getSum());
// } else {
// sum = null;
// }
// }
//
// @Override
// void reset() {
// super.reset();
// minimum = null;
// maximum = null;
// sum = HiveDecimal.ZERO;
// }
//
// @Override
// void updateDecimal(HiveDecimal value) {
// if (minimum == null) {
// minimum = value;
// maximum = value;
// } else if (minimum.compareTo(value) > 0) {
// minimum = value;
// } else if (maximum.compareTo(value) < 0) {
// maximum = value;
// }
// if (sum != null) {
// try {
// sum = sum.add(value);
// } catch (NumberFormatException nfe) {
// sum = null;
// }
// }
// }
//
// @Override
// void merge(ColumnStatisticsImpl other) {
// super.merge(other);
// DecimalStatisticsImpl dec = (DecimalStatisticsImpl) other;
// if (minimum == null) {
// minimum = dec.minimum;
// maximum = dec.maximum;
// sum = dec.sum;
// } else if (dec.minimum != null) {
// if (minimum.compareTo(dec.minimum) > 0) {
// minimum = dec.minimum;
// } else if (maximum.compareTo(dec.maximum) < 0) {
// maximum = dec.maximum;
// }
// if (sum == null || dec.sum == null) {
// sum = null;
// } else {
// sum = sum.add(dec.sum);
// }
// }
// }
//
// @Override
// OrcProto.ColumnStatistics.Builder serialize() {
// OrcProto.ColumnStatistics.Builder result = super.serialize();
// OrcProto.DecimalStatistics.Builder dec =
// OrcProto.DecimalStatistics.newBuilder();
// if (getNumberOfValues() != 0) {
// dec.setMinimum(minimum.toString());
// dec.setMaximum(maximum.toString());
// }
// if (sum != null) {
// dec.setSum(sum.toString());
// }
// result.setDecimalStatistics(dec);
// return result;
// }
//
// @Override
// public HiveDecimal getMinimum() {
// return minimum;
// }
//
// @Override
// public HiveDecimal getMaximum() {
// return maximum;
// }
//
// @Override
// public HiveDecimal getSum() {
// return sum;
// }
//
// @Override
// public String toString() {
// StringBuilder buf = new StringBuilder(super.toString());
// if (getNumberOfValues() != 0) {
// buf.append(" min: ");
// buf.append(minimum);
// buf.append(" max: ");
// buf.append(maximum);
// if (sum != null) {
// buf.append(" sum: ");
// buf.append(sum);
// }
// }
// return buf.toString();
// }
// }
//private static final class DateStatisticsImpl extends ColumnStatisticsImpl
// implements DateColumnStatistics {
// private DateWritable minimum = null;
// private DateWritable maximum = null;
//
// DateStatisticsImpl() {
// }
//
// DateStatisticsImpl(OrcProto.ColumnStatistics stats) {
// super(stats);
// OrcProto.DateStatistics dateStats = stats.getDateStatistics();
// // min,max values serialized/deserialized as int (days since epoch)
// if (dateStats.hasMaximum()) {
// maximum = new DateWritable(dateStats.getMaximum());
// }
// if (dateStats.hasMinimum()) {
// minimum = new DateWritable(dateStats.getMinimum());
// }
// }
//
// @Override
// void reset() {
// super.reset();
// minimum = null;
// maximum = null;
// }
//
// @Override
// void updateDate(DateWritable value) {
// if (minimum == null) {
// minimum = value;
// maximum = value;
// } else if (minimum.compareTo(value) > 0) {
// minimum = value;
// } else if (maximum.compareTo(value) < 0) {
// maximum = value;
// }
// }
//
// @Override
// void merge(ColumnStatisticsImpl other) {
// super.merge(other);
// DateStatisticsImpl dateStats = (DateStatisticsImpl) other;
// if (minimum == null) {
// minimum = dateStats.minimum;
// maximum = dateStats.maximum;
// } else if (dateStats.minimum != null) {
// if (minimum.compareTo(dateStats.minimum) > 0) {
// minimum = dateStats.minimum;
// } else if (maximum.compareTo(dateStats.maximum) < 0) {
// maximum = dateStats.maximum;
// }
// }
// }
//
// @Override
// OrcProto.ColumnStatistics.Builder serialize() {
// OrcProto.ColumnStatistics.Builder result = super.serialize();
// OrcProto.DateStatistics.Builder dateStats =
// OrcProto.DateStatistics.newBuilder();
// if (getNumberOfValues() != 0) {
// dateStats.setMinimum(minimum.getDays());
// dateStats.setMaximum(maximum.getDays());
// }
// result.setDateStatistics(dateStats);
// return result;
// }
//
// @Override
// public DateWritable getMinimum() {
// return minimum;
// }
//
// @Override
// public DateWritable getMaximum() {
// return maximum;
// }
//
// @Override
// public String toString() {
// StringBuilder buf = new StringBuilder(super.toString());
// if (getNumberOfValues() != 0) {
// buf.append(" min: ");
// buf.append(minimum);
// buf.append(" max: ");
// buf.append(maximum);
// }
// return buf.toString();
// }
// }
private long count = 0;
ColumnStatisticsImpl(OrcProto.ColumnStatistics stats) {
if (stats.hasNumberOfValues()) {
count = stats.getNumberOfValues();
}
}
ColumnStatisticsImpl() {
}
void increment() {
count += 1;
}
void updateBoolean(boolean value) {
throw new UnsupportedOperationException("Can't update boolean");
}
void updateInteger(long value) {
throw new UnsupportedOperationException("Can't update integer");
}
void updateDouble(double value) {
throw new UnsupportedOperationException("Can't update double");
}
void updateString(String value) {
throw new UnsupportedOperationException("Can't update string");
}
// void updateDecimal(HiveDecimal value) {
// throw new UnsupportedOperationException("Can't update decimal");
// }
//
// void updateDate(DateWritable value) {
// throw new UnsupportedOperationException("Can't update date");
// }
void merge(ColumnStatisticsImpl stats) {
count += stats.count;
}
void reset() {
count = 0;
}
@Override
public long getNumberOfValues() {
return count;
}
@Override
public String toString() {
return "count: " + count;
}
OrcProto.ColumnStatistics.Builder serialize() {
OrcProto.ColumnStatistics.Builder builder =
OrcProto.ColumnStatistics.newBuilder();
builder.setNumberOfValues(count);
return builder;
}
}
// static ColumnStatisticsImpl create(ObjectInspector inspector) {
// switch (inspector.getCategory()) {
// case PRIMITIVE:
// switch (((PrimitiveObjectInspector) inspector).getPrimitiveCategory()) {
// case BOOLEAN:
// // return new BooleanStatisticsImpl();
// case BYTE:
// case SHORT:
// case INT:
// case LONG:
// // return new IntegerStatisticsImpl();
// case FLOAT:
// case DOUBLE:
// // return new DoubleStatisticsImpl();
// case STRING:
// case VARCHAR:
// return new StringStatisticsImpl();
// case DECIMAL:
// // return new DecimalStatisticsImpl();
// case DATE:
// // return new DateStatisticsImpl();
// default:
// return new ColumnStatisticsImpl();
// }
// default:
// return new ColumnStatisticsImpl();
// }
// }
// static ColumnStatisticsImpl deserialize(OrcProto.ColumnStatistics stats) {
// if (stats.hasBucketStatistics()) {
// return new BooleanStatisticsImpl(stats);
// } else if (stats.hasIntStatistics()) {
// return new IntegerStatisticsImpl(stats);
// } else if (stats.hasDoubleStatistics()) {
// return new DoubleStatisticsImpl(stats);
// } else if (stats.hasStringStatistics()) {
// return new StringStatisticsImpl(stats);
// } else if (stats.hasDecimalStatistics()) {
// return new DecimalStatisticsImpl(stats);
// } else if (stats.hasDateStatistics()) {
// return new DateStatisticsImpl(stats);
// } else {
// return new ColumnStatisticsImpl(stats);
// }
// }
//}
//
//@Override
//public long getNumberOfValues() {
// // TODO Auto-generated method stub
// return 0;
//}