9984

Build # 9984

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/ca7a1e69204f3a1a01d51dc398071f224551560b">ca7a1e692<a href="https://github.com/apache/carbondata/commit/ca7a1e69204f3a1a01d51dc398071f224551560b">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/88fd1ad1951cee45d0bbecf3ab284f36daf0e125">88fd1ad19</a>">88fd1ad19</a><a href="https://github.com/apache/carbondata/commit/ca7a1e69204f3a1a01d51dc398071f224551560b"> into 6026cb57c">6026cb57c</a>

Run Details

11 of 11 new or added lines in 4 files covered. (100.0%)

61700 of 77554 relevant lines covered (79.56%)

1.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.69

/core/src/main/java/org/apache/carbondata/core/datastore/page/statistics/PrimitivePageStatsCollector.java

/*
 * 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.carbondata.core.datastore.page.statistics;

import java.math.BigDecimal;

import org.apache.carbondata.core.datastore.page.encoding.ColumnPageEncoderMeta;
import org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert;
import org.apache.carbondata.core.metadata.ValueEncoderMeta;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;

import static org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert.FALSE_VALUE;
import static org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert.TRUE_VALUE;

/** statics for primitive column page */
public class PrimitivePageStatsCollector implements ColumnPageStatsCollector, SimpleStatsResult {
  private static final String ZERO_STRING = "0";
  private DataType dataType;
  private byte minByte, maxByte;
  private short minShort, maxShort;
  private int minInt, maxInt;
  private long minLong, maxLong;
  private double minDouble, maxDouble;
  private float minFloat, maxFloat;
  private BigDecimal minDecimal, maxDecimal;

  // scale of the double value, apply adaptive encoding if this is positive
  private int decimal;

  // scale of the double value, only for complex primitive.
  private int decimalCountForComplexPrimitive;

  private boolean isFirst = true;
  private BigDecimal zeroDecimal;

  // this is for encode flow
  public static PrimitivePageStatsCollector newInstance(DataType dataType) {
    return new PrimitivePageStatsCollector(dataType);
  }

  // this is for decode flow, create stats from encoder meta in carbondata file
  public static PrimitivePageStatsCollector newInstance(ColumnPageEncoderMeta meta) {
    PrimitivePageStatsCollector instance =
        new PrimitivePageStatsCollector(meta.getSchemaDataType());
    // set min max from meta
    DataType dataType = meta.getSchemaDataType();
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      instance.minByte = (byte) meta.getMinValue();
      instance.maxByte = (byte) meta.getMaxValue();
    } else if (dataType == DataTypes.SHORT) {
      instance.minShort = (short) meta.getMinValue();
      instance.maxShort = (short) meta.getMaxValue();
    } else if (dataType == DataTypes.INT) {
      instance.minInt = (int) meta.getMinValue();
      instance.maxInt = (int) meta.getMaxValue();
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      instance.minLong = (long) meta.getMinValue();
      instance.maxLong = (long) meta.getMaxValue();
    } else if (dataType == DataTypes.DOUBLE) {
      instance.minDouble = (double) meta.getMinValue();
      instance.maxDouble = (double) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else if (dataType == DataTypes.FLOAT) {
      instance.minFloat = (float) meta.getMinValue();
      instance.maxFloat = (float) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else if (DataTypes.isDecimal(dataType)) {
      instance.minDecimal = (BigDecimal) meta.getMinValue();
      instance.maxDecimal = (BigDecimal) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else {
      throw new UnsupportedOperationException(
          "unsupported data type for stats collection: " + meta.getSchemaDataType());
    }
    return instance;
  }

  public static PrimitivePageStatsCollector newInstance(ValueEncoderMeta meta) {
    PrimitivePageStatsCollector instance =
        new PrimitivePageStatsCollector(DataType.getDataType(meta.getType()));
    // set min max from meta
    DataType dataType = DataType.getDataType(meta.getType());
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      instance.minByte = (byte) meta.getMinValue();
      instance.maxByte = (byte) meta.getMaxValue();
    } else if (dataType == DataTypes.SHORT) {
      instance.minShort = (short) meta.getMinValue();
      instance.maxShort = (short) meta.getMaxValue();
    } else if (dataType == DataTypes.INT) {
      instance.minInt = (int) meta.getMinValue();
      instance.maxInt = (int) meta.getMaxValue();
    } else if (dataType == DataTypes.LEGACY_LONG || dataType == DataTypes.LONG
        || dataType == DataTypes.TIMESTAMP) {
      instance.minLong = (long) meta.getMinValue();
      instance.maxLong = (long) meta.getMaxValue();
    } else if (dataType == DataTypes.DOUBLE) {
      instance.minDouble = (double) meta.getMinValue();
      instance.maxDouble = (double) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else if (dataType == DataTypes.FLOAT) {
      instance.minFloat = (float) meta.getMinValue();
      instance.maxFloat = (float) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else if (DataTypes.isDecimal(dataType)) {
      instance.minDecimal = (BigDecimal) meta.getMinValue();
      instance.maxDecimal = (BigDecimal) meta.getMaxValue();
      instance.decimal = meta.getDecimal();
    } else {
      throw new UnsupportedOperationException(
          "unsupported data type for Stats collection: " + meta.getType());
    }
    return instance;
  }

  private PrimitivePageStatsCollector(DataType dataType) {
    this.dataType = dataType;
    resetPageStats();
  }

  private void resetPageStats() {
    if (dataType == DataTypes.BOOLEAN) {
      minByte = TRUE_VALUE;
      maxByte = FALSE_VALUE;
    } else if (dataType == DataTypes.BYTE) {
      minByte = Byte.MAX_VALUE;
      maxByte = Byte.MIN_VALUE;
    } else if (dataType == DataTypes.SHORT) {
      minShort = Short.MAX_VALUE;
      maxShort = Short.MIN_VALUE;
    } else if (dataType == DataTypes.INT) {
      minInt = Integer.MAX_VALUE;
      maxInt = Integer.MIN_VALUE;
    } else if (dataType == DataTypes.LEGACY_LONG || dataType == DataTypes.LONG
        || dataType == DataTypes.TIMESTAMP) {
      minLong = Long.MAX_VALUE;
      maxLong = Long.MIN_VALUE;
    } else if (dataType == DataTypes.DOUBLE) {
      minDouble = Double.POSITIVE_INFINITY;
      maxDouble = Double.NEGATIVE_INFINITY;
      decimal = 0;
    } else if (dataType == DataTypes.FLOAT) {
      minFloat = Float.MAX_VALUE;
      maxFloat = Float.MIN_VALUE;
      decimal = 0;
    } else if (DataTypes.isDecimal(dataType)) {
      this.zeroDecimal = BigDecimal.ZERO;
      decimal = 0;
    } else {
      throw new UnsupportedOperationException(
          "unsupported data type for Stats collection: " + dataType);
    }
  }

  @Override
  public void updateNull(int rowId) {
    long value = 0;
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      update((byte) value);
    } else if (dataType == DataTypes.SHORT) {
      update((short) value);
    } else if (dataType == DataTypes.INT) {
      update((int) value);
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      update(value);
    } else if (dataType == DataTypes.DOUBLE) {
      update(0d);
    } else if (dataType == DataTypes.FLOAT) {
      update(0f);
    } else if (DataTypes.isDecimal(dataType)) {
      if (isFirst) {
        maxDecimal = zeroDecimal;
        minDecimal = zeroDecimal;
        isFirst = false;
      } else {
        maxDecimal = (maxDecimal.compareTo(zeroDecimal) > 0) ? maxDecimal : zeroDecimal;
        minDecimal = (minDecimal.compareTo(zeroDecimal) < 0) ? minDecimal : zeroDecimal;
      }
    } else {
      throw new UnsupportedOperationException(
          "unsupported data type for Stats collection: " + dataType);
    }
  }

  @Override
  public void update(byte value) {
    if (minByte > value) {
      minByte = value;
    }
    if (maxByte < value) {
      maxByte = value;
    }
  }

  @Override
  public void update(short value) {
    if (minShort > value) {
      minShort = value;
    }
    if (maxShort < value) {
      maxShort = value;
    }
  }

  @Override
  public void update(int value) {
    if (minInt > value) {
      minInt = value;
    }
    if (maxInt < value) {
      maxInt = value;
    }
  }

  @Override
  public void update(long value) {
    if (minLong > value) {
      minLong = value;
    }
    if (maxLong < value) {
      maxLong = value;
    }
  }

  /**
   * Return number of digit after decimal point
   * TODO: it operation is costly, optimize for performance
   */
  private int getDecimalCount(double value) {
    int decimalPlaces = 0;
    try {
      String strValue = BigDecimal.valueOf(Math.abs(value)).toPlainString();
      int integerPlaces = strValue.indexOf('.');
      if (-1 != integerPlaces) {
        decimalPlaces = strValue.length() - integerPlaces - 1;
        // If decimal places are one and it is just zero then treat the decimal count a zero.
        if (decimalPlaces == 1) {
          if (strValue.substring(integerPlaces + 1, strValue.length()).equals(ZERO_STRING)) {
            decimalPlaces = 0;
          }
        }
      }
    } catch (NumberFormatException e) {
      if (!Double.isInfinite(value)) {
        throw e;
      }
    }
    return decimalPlaces;
  }

  private int getDecimalCount(float value) {
    return getDecimalCount((double) value);
  }

  @Override
  public void update(double value) {
    if (minDouble > value) {
      minDouble = value;
    }
    if (maxDouble < value) {
      maxDouble = value;
    }
    if (decimal >= 0) {
      int decimalCount = getDecimalCount(value);
      decimalCountForComplexPrimitive = decimalCount;
      if (decimalCount > 5) {
        // If deciaml count is too big, we do not do adaptive encoding.
        // So set decimal to negative value
        decimal = -1;
      } else if (decimalCount > decimal) {
        this.decimal = decimalCount;
      }
    }
  }
  @Override
  public void update(float value) {
    if (minFloat > value) {
      minFloat = value;
    }
    if (maxFloat < value) {
      maxFloat = value;
    }
    if (decimal >= 0) {
      int decimalCount = getDecimalCount(value);
      decimalCountForComplexPrimitive = decimalCount;
      if (decimalCount > 5) {
        // If deciaml count is too big, we do not do adaptive encoding.
        // So set decimal to negative value
        decimal = -1;
      } else if (decimalCount > decimal) {
        this.decimal = decimalCount;
      }
    }
  }

  public int getDecimalForComplexPrimitive() {
    decimal = decimalCountForComplexPrimitive;
    return decimalCountForComplexPrimitive;
  }

  @Override
  public void update(BigDecimal decimalValue) {
    if (isFirst) {
      maxDecimal = decimalValue;
      minDecimal = decimalValue;
      isFirst = false;
    } else {
      maxDecimal = (decimalValue.compareTo(maxDecimal) > 0) ? decimalValue : maxDecimal;
      minDecimal = (decimalValue.compareTo(minDecimal) < 0) ? decimalValue : minDecimal;
    }
  }

  @Override
  public void update(byte[] value) {
  }

  @Override
  public SimpleStatsResult getPageStats() {
    return this;
  }

  @Override
  public String toString() {
    if (dataType == DataTypes.BOOLEAN) {
      return String.format("min: %s, max: %s ", BooleanConvert.byte2Boolean(minByte),
              BooleanConvert.byte2Boolean(minByte));
    } else if (dataType == DataTypes.BYTE) {
      return String.format("min: %s, max: %s, decimal: %s ", minByte, maxByte, decimal);
    } else if (dataType == DataTypes.SHORT) {
      return String.format("min: %s, max: %s, decimal: %s ", minShort, maxShort, decimal);
    } else if (dataType == DataTypes.INT) {
      return String.format("min: %s, max: %s, decimal: %s ", minInt, maxInt, decimal);
    } else if (dataType == DataTypes.LONG) {
      return String.format("min: %s, max: %s, decimal: %s ", minLong, maxLong, decimal);
    } else if (dataType == DataTypes.DOUBLE) {
      return String.format("min: %s, max: %s, decimal: %s ", minDouble, maxDouble, decimal);
    } else if (dataType == DataTypes.FLOAT) {
      return String.format("min: %s, max: %s, decimal: %s ", minFloat, maxFloat, decimal);
    }
    return super.toString();
  }

  @Override
  public Object getMin() {
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      return minByte;
    } else if (dataType == DataTypes.SHORT) {
      return minShort;
    } else if (dataType == DataTypes.INT) {
      return minInt;
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      return minLong;
    } else if (dataType == DataTypes.DOUBLE) {
      return minDouble;
    } else if (dataType == DataTypes.FLOAT) {
      return minFloat;
    } else if (DataTypes.isDecimal(dataType)) {
      return minDecimal;
    }
    return null;
  }

  @Override
  public Object getMax() {
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      return maxByte;
    } else if (dataType == DataTypes.SHORT) {
      return maxShort;
    } else if (dataType == DataTypes.INT) {
      return maxInt;
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      return maxLong;
    } else if (dataType == DataTypes.DOUBLE) {
      return maxDouble;
    } else if (dataType == DataTypes.FLOAT) {
      return maxFloat;
    } else if (DataTypes.isDecimal(dataType)) {
      return maxDecimal;
    }
    return null;
  }

  @Override
  public int getDecimalCount() {
    return decimal;
  }

  @Override
  public DataType getDataType() {
    return dataType;
  }

  @Override public boolean writeMinMax() {
    return true;
  }

  @Override
  public void clear() {
    resetPageStats();
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.carbondata.core.datastore.page.statistics;
19
20	import java.math.BigDecimal;
21
22	import org.apache.carbondata.core.datastore.page.encoding.ColumnPageEncoderMeta;
23	import org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert;
24	import org.apache.carbondata.core.metadata.ValueEncoderMeta;
25	import org.apache.carbondata.core.metadata.datatype.DataType;
26	import org.apache.carbondata.core.metadata.datatype.DataTypes;
27
28	import static org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert.FALSE_VALUE;
29	import static org.apache.carbondata.core.datastore.page.encoding.bool.BooleanConvert.TRUE_VALUE;
30
31	/** statics for primitive column page */
32	public class PrimitivePageStatsCollector implements ColumnPageStatsCollector, SimpleStatsResult {
33	private static final String ZERO_STRING = "0";
34	private DataType dataType;
35	private byte minByte, maxByte;
36	private short minShort, maxShort;
37	private int minInt, maxInt;
38	private long minLong, maxLong;
39	private double minDouble, maxDouble;
40	private float minFloat, maxFloat;
41	private BigDecimal minDecimal, maxDecimal;
42
43	// scale of the double value, apply adaptive encoding if this is positive
44	private int decimal;
45
46	// scale of the double value, only for complex primitive.
47	private int decimalCountForComplexPrimitive;
48
49	private boolean isFirst = true;	2✔
50	private BigDecimal zeroDecimal;
51
52	// this is for encode flow
53	public static PrimitivePageStatsCollector newInstance(DataType dataType) {
54	return new PrimitivePageStatsCollector(dataType);	2✔
55	}
56
57	// this is for decode flow, create stats from encoder meta in carbondata file
58	public static PrimitivePageStatsCollector newInstance(ColumnPageEncoderMeta meta) {
59	PrimitivePageStatsCollector instance =	1✔
60	new PrimitivePageStatsCollector(meta.getSchemaDataType());	1✔
61	// set min max from meta
62	DataType dataType = meta.getSchemaDataType();	1✔
63	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	1✔
64	instance.minByte = (byte) meta.getMinValue();	1✔
65	instance.maxByte = (byte) meta.getMaxValue();	1✔
66	} else if (dataType == DataTypes.SHORT) {	1✔
67	instance.minShort = (short) meta.getMinValue();	1✔
68	instance.maxShort = (short) meta.getMaxValue();	1✔
69	} else if (dataType == DataTypes.INT) {	1✔
70	instance.minInt = (int) meta.getMinValue();	1✔
71	instance.maxInt = (int) meta.getMaxValue();	1✔
72	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	1✔
73	instance.minLong = (long) meta.getMinValue();	1✔
74	instance.maxLong = (long) meta.getMaxValue();	1✔
75	} else if (dataType == DataTypes.DOUBLE) {	1✔
76	instance.minDouble = (double) meta.getMinValue();	1✔
77	instance.maxDouble = (double) meta.getMaxValue();	1✔
78	instance.decimal = meta.getDecimal();	1✔
79	} else if (dataType == DataTypes.FLOAT) {	1✔
80	instance.minFloat = (float) meta.getMinValue();	1✔
81	instance.maxFloat = (float) meta.getMaxValue();	1✔
82	instance.decimal = meta.getDecimal();	1✔
83	} else if (DataTypes.isDecimal(dataType)) {	1✔
84	instance.minDecimal = (BigDecimal) meta.getMinValue();	1✔
85	instance.maxDecimal = (BigDecimal) meta.getMaxValue();	1✔
86	instance.decimal = meta.getDecimal();	1✔
87	} else {
88	throw new UnsupportedOperationException(	×
89	"unsupported data type for stats collection: " + meta.getSchemaDataType());	×
90	}
91	return instance;	1✔
92	}
93
94	public static PrimitivePageStatsCollector newInstance(ValueEncoderMeta meta) {
95	PrimitivePageStatsCollector instance =	×
96	new PrimitivePageStatsCollector(DataType.getDataType(meta.getType()));	×
97	// set min max from meta
98	DataType dataType = DataType.getDataType(meta.getType());	×
99	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	×
100	instance.minByte = (byte) meta.getMinValue();	×
101	instance.maxByte = (byte) meta.getMaxValue();	×
102	} else if (dataType == DataTypes.SHORT) {	×
103	instance.minShort = (short) meta.getMinValue();	×
104	instance.maxShort = (short) meta.getMaxValue();	×
105	} else if (dataType == DataTypes.INT) {	×
106	instance.minInt = (int) meta.getMinValue();	×
107	instance.maxInt = (int) meta.getMaxValue();	×
108	} else if (dataType == DataTypes.LEGACY_LONG \|\| dataType == DataTypes.LONG	×
109	\|\| dataType == DataTypes.TIMESTAMP) {
110	instance.minLong = (long) meta.getMinValue();	×
111	instance.maxLong = (long) meta.getMaxValue();	×
112	} else if (dataType == DataTypes.DOUBLE) {	×
113	instance.minDouble = (double) meta.getMinValue();	×
114	instance.maxDouble = (double) meta.getMaxValue();	×
115	instance.decimal = meta.getDecimal();	×
116	} else if (dataType == DataTypes.FLOAT) {	×
117	instance.minFloat = (float) meta.getMinValue();	×
118	instance.maxFloat = (float) meta.getMaxValue();	×
119	instance.decimal = meta.getDecimal();	×
120	} else if (DataTypes.isDecimal(dataType)) {	×
121	instance.minDecimal = (BigDecimal) meta.getMinValue();	×
122	instance.maxDecimal = (BigDecimal) meta.getMaxValue();	×
123	instance.decimal = meta.getDecimal();	×
124	} else {
125	throw new UnsupportedOperationException(	×
126	"unsupported data type for Stats collection: " + meta.getType());	×
127	}
128	return instance;	×
129	}
130
131	private PrimitivePageStatsCollector(DataType dataType) {	2✔
132	this.dataType = dataType;	2✔
133	resetPageStats();	2✔
134	}	2✔
135
136	private void resetPageStats() {
137	if (dataType == DataTypes.BOOLEAN) {	2✔
138	minByte = TRUE_VALUE;	1✔
139	maxByte = FALSE_VALUE;	1✔
140	} else if (dataType == DataTypes.BYTE) {	2✔
141	minByte = Byte.MAX_VALUE;	2✔
142	maxByte = Byte.MIN_VALUE;	2✔
143	} else if (dataType == DataTypes.SHORT) {	2✔
144	minShort = Short.MAX_VALUE;	1✔
145	maxShort = Short.MIN_VALUE;	1✔
146	} else if (dataType == DataTypes.INT) {	2✔
147	minInt = Integer.MAX_VALUE;	1✔
148	maxInt = Integer.MIN_VALUE;	1✔
149	} else if (dataType == DataTypes.LEGACY_LONG \|\| dataType == DataTypes.LONG	2✔
150	\|\| dataType == DataTypes.TIMESTAMP) {
151	minLong = Long.MAX_VALUE;	2✔
152	maxLong = Long.MIN_VALUE;	2✔
153	} else if (dataType == DataTypes.DOUBLE) {	1✔
154	minDouble = Double.POSITIVE_INFINITY;	1✔
155	maxDouble = Double.NEGATIVE_INFINITY;	1✔
156	decimal = 0;	1✔
157	} else if (dataType == DataTypes.FLOAT) {	1✔
158	minFloat = Float.MAX_VALUE;	1✔
159	maxFloat = Float.MIN_VALUE;	1✔
160	decimal = 0;	1✔
161	} else if (DataTypes.isDecimal(dataType)) {	1✔
162	this.zeroDecimal = BigDecimal.ZERO;	1✔
163	decimal = 0;	1✔
164	} else {
165	throw new UnsupportedOperationException(	×
166	"unsupported data type for Stats collection: " + dataType);
167	}
168	}	2✔
169
170	@Override
171	public void updateNull(int rowId) {
172	long value = 0;	1✔
173	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	1✔
174	update((byte) value);	1✔
175	} else if (dataType == DataTypes.SHORT) {	1✔
176	update((short) value);	1✔
177	} else if (dataType == DataTypes.INT) {	1✔
178	update((int) value);	1✔
179	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	1✔
180	update(value);	1✔
181	} else if (dataType == DataTypes.DOUBLE) {	1✔
182	update(0d);	1✔
183	} else if (dataType == DataTypes.FLOAT) {	1✔
184	update(0f);	1✔
185	} else if (DataTypes.isDecimal(dataType)) {	1✔
186	if (isFirst) {	1✔
187	maxDecimal = zeroDecimal;	1✔
188	minDecimal = zeroDecimal;	1✔
189	isFirst = false;	1✔
190	} else {
191	maxDecimal = (maxDecimal.compareTo(zeroDecimal) > 0) ? maxDecimal : zeroDecimal;	1✔
192	minDecimal = (minDecimal.compareTo(zeroDecimal) < 0) ? minDecimal : zeroDecimal;	1✔
193	}
194	} else {
195	throw new UnsupportedOperationException(	×
196	"unsupported data type for Stats collection: " + dataType);
197	}
198	}	1✔
199
200	@Override
201	public void update(byte value) {
202	if (minByte > value) {	2✔
203	minByte = value;	2✔
204	}
205	if (maxByte < value) {	2✔
206	maxByte = value;	2✔
207	}
208	}	2✔
209
210	@Override
211	public void update(short value) {
212	if (minShort > value) {	1✔
213	minShort = value;	1✔
214	}
215	if (maxShort < value) {	1✔
216	maxShort = value;	1✔
217	}
218	}	1✔
219
220	@Override
221	public void update(int value) {
222	if (minInt > value) {	1✔
223	minInt = value;	1✔
224	}
225	if (maxInt < value) {	1✔
226	maxInt = value;	1✔
227	}
228	}	1✔
229
230	@Override
231	public void update(long value) {
232	if (minLong > value) {	2✔
233	minLong = value;	2✔
234	}
235	if (maxLong < value) {	2✔
236	maxLong = value;	2✔
237	}
238	}	2✔
239
240	/**
241	* Return number of digit after decimal point
242	* TODO: it operation is costly, optimize for performance
243	*/
244	private int getDecimalCount(double value) {
245	int decimalPlaces = 0;	1✔
246	try {
247	String strValue = BigDecimal.valueOf(Math.abs(value)).toPlainString();	1✔
248	int integerPlaces = strValue.indexOf('.');	1✔
249	if (-1 != integerPlaces) {	1✔
250	decimalPlaces = strValue.length() - integerPlaces - 1;	1✔
251	// If decimal places are one and it is just zero then treat the decimal count a zero.
252	if (decimalPlaces == 1) {	1✔
253	if (strValue.substring(integerPlaces + 1, strValue.length()).equals(ZERO_STRING)) {	1✔
254	decimalPlaces = 0;	1✔
255	}
256	}
257	}
258	} catch (NumberFormatException e) {	1✔
259	if (!Double.isInfinite(value)) {	1✔
260	throw e;	×
261	}
262	}	1✔
263	return decimalPlaces;	1✔
264	}
265
266	private int getDecimalCount(float value) {
267	return getDecimalCount((double) value);	1✔
268	}
269
270	@Override
271	public void update(double value) {
272	if (minDouble > value) {	1✔
273	minDouble = value;	1✔
274	}
275	if (maxDouble < value) {	1✔
276	maxDouble = value;	1✔
277	}
278	if (decimal >= 0) {	1✔
279	int decimalCount = getDecimalCount(value);	1✔
280	decimalCountForComplexPrimitive = decimalCount;	1✔
281	if (decimalCount > 5) {	1✔
282	// If deciaml count is too big, we do not do adaptive encoding.
283	// So set decimal to negative value
284	decimal = -1;	1✔
285	} else if (decimalCount > decimal) {	1✔
286	this.decimal = decimalCount;	1✔
287	}
288	}
289	}	1✔
290	@Override
291	public void update(float value) {
292	if (minFloat > value) {	1✔
293	minFloat = value;	1✔
294	}
295	if (maxFloat < value) {	1✔
296	maxFloat = value;	1✔
297	}
298	if (decimal >= 0) {	1✔
299	int decimalCount = getDecimalCount(value);	1✔
300	decimalCountForComplexPrimitive = decimalCount;	1✔
301	if (decimalCount > 5) {	1✔
302	// If deciaml count is too big, we do not do adaptive encoding.
303	// So set decimal to negative value
304	decimal = -1;	1✔
305	} else if (decimalCount > decimal) {	1✔
306	this.decimal = decimalCount;	×
307	}
308	}
309	}	1✔
310
311	public int getDecimalForComplexPrimitive() {
312	decimal = decimalCountForComplexPrimitive;	1✔
313	return decimalCountForComplexPrimitive;	1✔
314	}
315
316	@Override
317	public void update(BigDecimal decimalValue) {
318	if (isFirst) {	1✔
319	maxDecimal = decimalValue;	1✔
320	minDecimal = decimalValue;	1✔
321	isFirst = false;	1✔
322	} else {
323	maxDecimal = (decimalValue.compareTo(maxDecimal) > 0) ? decimalValue : maxDecimal;	1✔
324	minDecimal = (decimalValue.compareTo(minDecimal) < 0) ? decimalValue : minDecimal;	1✔
325	}
326	}	1✔
327
328	@Override
329	public void update(byte[] value) {
330	}	×
331
332	@Override
333	public SimpleStatsResult getPageStats() {
334	return this;	2✔
335	}
336
337	@Override
338	public String toString() {
339	if (dataType == DataTypes.BOOLEAN) {	×
340	return String.format("min: %s, max: %s ", BooleanConvert.byte2Boolean(minByte),	×
341	BooleanConvert.byte2Boolean(minByte));	×
342	} else if (dataType == DataTypes.BYTE) {	×
343	return String.format("min: %s, max: %s, decimal: %s ", minByte, maxByte, decimal);	×
344	} else if (dataType == DataTypes.SHORT) {	×
345	return String.format("min: %s, max: %s, decimal: %s ", minShort, maxShort, decimal);	×
346	} else if (dataType == DataTypes.INT) {	×
347	return String.format("min: %s, max: %s, decimal: %s ", minInt, maxInt, decimal);	×
348	} else if (dataType == DataTypes.LONG) {	×
349	return String.format("min: %s, max: %s, decimal: %s ", minLong, maxLong, decimal);	×
350	} else if (dataType == DataTypes.DOUBLE) {	×
351	return String.format("min: %s, max: %s, decimal: %s ", minDouble, maxDouble, decimal);	×
352	} else if (dataType == DataTypes.FLOAT) {	×
353	return String.format("min: %s, max: %s, decimal: %s ", minFloat, maxFloat, decimal);	×
354	}
355	return super.toString();	×
356	}
357
358	@Override
359	public Object getMin() {
360	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	2✔
361	return minByte;	2✔
362	} else if (dataType == DataTypes.SHORT) {	2✔
363	return minShort;	1✔
364	} else if (dataType == DataTypes.INT) {	2✔
365	return minInt;	1✔
366	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	2✔
367	return minLong;	2✔
368	} else if (dataType == DataTypes.DOUBLE) {	1✔
369	return minDouble;	1✔
370	} else if (dataType == DataTypes.FLOAT) {	1✔
371	return minFloat;	1✔
372	} else if (DataTypes.isDecimal(dataType)) {	1✔
373	return minDecimal;	1✔
374	}
375	return null;	×
376	}
377
378	@Override
379	public Object getMax() {
380	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	2✔
381	return maxByte;	2✔
382	} else if (dataType == DataTypes.SHORT) {	2✔
383	return maxShort;	1✔
384	} else if (dataType == DataTypes.INT) {	2✔
385	return maxInt;	1✔
386	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	2✔
387	return maxLong;	2✔
388	} else if (dataType == DataTypes.DOUBLE) {	1✔
389	return maxDouble;	1✔
390	} else if (dataType == DataTypes.FLOAT) {	1✔
391	return maxFloat;	1✔
392	} else if (DataTypes.isDecimal(dataType)) {	1✔
393	return maxDecimal;	1✔
394	}
395	return null;	×
396	}
397
398	@Override
399	public int getDecimalCount() {
400	return decimal;	2✔
401	}
402
403	@Override
404	public DataType getDataType() {
405	return dataType;	2✔
406	}
407
408	@Override public boolean writeMinMax() {
409	return true;	2✔
410	}
411
412	@Override
413	public void clear() {
414	resetPageStats();	1✔
415	}	1✔
416	}

apache / carbondata / 9984

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous