1380

Build # 1380

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/f13066513e66167ec2868c9242125470c9c4e5a8">f13066513<a href="https://github.com/apache/carbondata/commit/f13066513e66167ec2868c9242125470c9c4e5a8">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/4cdcbc6411163d3b42a110f74d3343e7a5d38d0e">4cdcbc641</a>">4cdcbc641</a><a href="https://github.com/apache/carbondata/commit/f13066513e66167ec2868c9242125470c9c4e5a8"> into d27f20523">d27f20523</a>

Run Details

14 of 14 new or added lines in 2 files covered. (100.0%)

61373 of 77118 relevant lines covered (79.58%)

1.05 hits per line

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

46.1

/core/src/main/java/org/apache/carbondata/core/scan/result/vector/MeasureDataVectorProcessor.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.scan.result.vector;

import java.math.BigDecimal;
import java.util.BitSet;

import org.apache.carbondata.core.datastore.page.ColumnPage;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;

public class MeasureDataVectorProcessor {

  public interface MeasureVectorFiller {

    void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info);

    void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info);
  }

  public static class IntegralMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putInt(vectorOffset, (int)dataChunk.getLong(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putInt(vectorOffset, (int)dataChunk.getLong(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putInt(vectorOffset, (int)dataChunk.getLong(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putInt(vectorOffset, (int)dataChunk.getLong(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  /**
   * Fill Measure Vector For Boolean data type
   */
  public static class BooleanMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putBoolean(vectorOffset, dataChunk.getBoolean(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putBoolean(vectorOffset, dataChunk.getBoolean(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId,
        ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putBoolean(vectorOffset, dataChunk.getBoolean(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putBoolean(vectorOffset, dataChunk.getBoolean(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class ShortMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putShort(vectorOffset, (short) dataChunk.getLong(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putShort(vectorOffset, (short) dataChunk.getLong(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putShort(vectorOffset, (short) dataChunk.getLong(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putShort(vectorOffset, (short) dataChunk.getLong(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class LongMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putLong(vectorOffset, dataChunk.getLong(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putLong(vectorOffset, dataChunk.getLong(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putLong(vectorOffset, dataChunk.getLong(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putLong(vectorOffset, dataChunk.getLong(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class DecimalMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      int precision = info.measure.getMeasure().getPrecision();
      int newMeasureScale = info.measure.getMeasure().getScale();
      BitSet nullBitSet = dataChunk.getNullBits();
      for (int i = offset; i < len; i++) {
        if (nullBitSet.get(i)) {
          vector.putNull(vectorOffset);
        } else {
          BigDecimal decimal =
              dataChunk.getDecimal(i);
          if (decimal.scale() < newMeasureScale) {
            decimal = decimal.setScale(newMeasureScale);
          }
          vector.putDecimal(vectorOffset, decimal, precision);
        }
        vectorOffset++;
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      int precision = info.measure.getMeasure().getPrecision();
      BitSet nullBitSet = dataChunk.getNullBits();
      for (int i = offset; i < len; i++) {
        int currentRow = filteredRowId[i];
        if (nullBitSet.get(currentRow)) {
          vector.putNull(vectorOffset);
        } else {
          BigDecimal decimal = dataChunk.getDecimal(currentRow);
          if (info.measure.getMeasure().getScale() > decimal.scale()) {
            decimal = decimal.setScale(info.measure.getMeasure().getScale());
          }
          vector.putDecimal(vectorOffset, decimal, precision);
        }
        vectorOffset++;
      }
    }
  }
  public static class FloatMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putFloat(vectorOffset, dataChunk.getFloat(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putFloat(vectorOffset, dataChunk.getFloat(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putFloat(vectorOffset, dataChunk.getFloat(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putFloat(vectorOffset, dataChunk.getFloat(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class ByteMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putByte(vectorOffset, dataChunk.getByte(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putByte(vectorOffset, dataChunk.getByte(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putByte(vectorOffset, dataChunk.getByte(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putByte(vectorOffset, dataChunk.getByte(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class DefaultMeasureVectorFiller implements MeasureVectorFiller {

    @Override
    public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          vector.putDouble(vectorOffset, dataChunk.getDouble(i));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          if (nullBitSet.get(i)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putDouble(vectorOffset, dataChunk.getDouble(i));
          }
          vectorOffset++;
        }
      }
    }

    @Override
    public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
        ColumnVectorInfo info) {
      int offset = info.offset;
      int len = offset + info.size;
      int vectorOffset = info.vectorOffset;
      CarbonColumnVector vector = info.vector;
      BitSet nullBitSet = dataChunk.getNullBits();
      if (nullBitSet.isEmpty()) {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          vector.putDouble(vectorOffset, dataChunk.getDouble(currentRow));
          vectorOffset++;
        }
      } else {
        for (int i = offset; i < len; i++) {
          int currentRow = filteredRowId[i];
          if (nullBitSet.get(currentRow)) {
            vector.putNull(vectorOffset);
          } else {
            vector.putDouble(vectorOffset, dataChunk.getDouble(currentRow));
          }
          vectorOffset++;
        }
      }
    }
  }

  public static class MeasureVectorFillerFactory {

    public static MeasureVectorFiller getMeasureVectorFiller(DataType dataType) {
      if (dataType == DataTypes.BOOLEAN) {
        return new BooleanMeasureVectorFiller();
      } else if (dataType == DataTypes.SHORT) {
        return new ShortMeasureVectorFiller();
      } else if (dataType == DataTypes.INT) {
        return new IntegralMeasureVectorFiller();
      } else if (dataType == DataTypes.LONG) {
        return new LongMeasureVectorFiller();
      } else if (DataTypes.isDecimal(dataType)) {
        return new DecimalMeasureVectorFiller();
      } else if (dataType == DataTypes.FLOAT) {
        return new FloatMeasureVectorFiller();
      } else if (dataType == DataTypes.BYTE) {
        return new ByteMeasureVectorFiller();
      } else {
        return new DefaultMeasureVectorFiller();
      }
    }
  }

}

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	package org.apache.carbondata.core.scan.result.vector;
18
19	import java.math.BigDecimal;
20	import java.util.BitSet;
21
22	import org.apache.carbondata.core.datastore.page.ColumnPage;
23	import org.apache.carbondata.core.metadata.datatype.DataType;
24	import org.apache.carbondata.core.metadata.datatype.DataTypes;
25
26	public class MeasureDataVectorProcessor {	×
27
28	public interface MeasureVectorFiller {
29
30	void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info);
31
32	void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
33	ColumnVectorInfo info);
34	}
35
36	public static class IntegralMeasureVectorFiller implements MeasureVectorFiller {	1✔
37
38	@Override
39	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
40	int offset = info.offset;	1✔
41	int len = offset + info.size;	1✔
42	int vectorOffset = info.vectorOffset;	1✔
43	CarbonColumnVector vector = info.vector;	1✔
44	BitSet nullBitSet = dataChunk.getNullBits();	1✔
45	if (nullBitSet.isEmpty()) {	1✔
46	for (int i = offset; i < len; i++) {	1✔
47	vector.putInt(vectorOffset, (int)dataChunk.getLong(i));	1✔
48	vectorOffset++;	1✔
49	}
50	} else {
51	for (int i = offset; i < len; i++) {	1✔
52	if (nullBitSet.get(i)) {	1✔
53	vector.putNull(vectorOffset);	1✔
54	} else {
55	vector.putInt(vectorOffset, (int)dataChunk.getLong(i));	1✔
56	}
57	vectorOffset++;	1✔
58	}
59	}
60	}	1✔
61
62	@Override
63	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
64	ColumnVectorInfo info) {
65	int offset = info.offset;	1✔
66	int len = offset + info.size;	1✔
67	int vectorOffset = info.vectorOffset;	1✔
68	CarbonColumnVector vector = info.vector;	1✔
69	BitSet nullBitSet = dataChunk.getNullBits();	1✔
70	if (nullBitSet.isEmpty()) {	1✔
71	for (int i = offset; i < len; i++) {	1✔
72	int currentRow = filteredRowId[i];	1✔
73	vector.putInt(vectorOffset, (int)dataChunk.getLong(currentRow));	1✔
74	vectorOffset++;	1✔
75	}
76	} else {
77	for (int i = offset; i < len; i++) {	1✔
78	int currentRow = filteredRowId[i];	1✔
79	if (nullBitSet.get(currentRow)) {	1✔
80	vector.putNull(vectorOffset);	1✔
81	} else {
82	vector.putInt(vectorOffset, (int)dataChunk.getLong(currentRow));	1✔
83	}
84	vectorOffset++;	1✔
85	}
86	}
87	}	1✔
88	}
89
90	/**
91	* Fill Measure Vector For Boolean data type
92	*/
93	public static class BooleanMeasureVectorFiller implements MeasureVectorFiller {	1✔
94
95	@Override
96	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
97	int offset = info.offset;	×
98	int len = offset + info.size;	×
99	int vectorOffset = info.vectorOffset;	×
100	CarbonColumnVector vector = info.vector;	×
101	BitSet nullBitSet = dataChunk.getNullBits();	×
102	if (nullBitSet.isEmpty()) {	×
103	for (int i = offset; i < len; i++) {	×
104	vector.putBoolean(vectorOffset, dataChunk.getBoolean(i));	×
105	vectorOffset++;	×
106	}
107	} else {
108	for (int i = offset; i < len; i++) {	×
109	if (nullBitSet.get(i)) {	×
110	vector.putNull(vectorOffset);	×
111	} else {
112	vector.putBoolean(vectorOffset, dataChunk.getBoolean(i));	×
113	}
114	vectorOffset++;	×
115	}
116	}
117	}	×
118
119	@Override
120	public void fillMeasureVector(int[] filteredRowId,
121	ColumnPage dataChunk, ColumnVectorInfo info) {
122	int offset = info.offset;	×
123	int len = offset + info.size;	×
124	int vectorOffset = info.vectorOffset;	×
125	CarbonColumnVector vector = info.vector;	×
126	BitSet nullBitSet = dataChunk.getNullBits();	×
127	if (nullBitSet.isEmpty()) {	×
128	for (int i = offset; i < len; i++) {	×
129	int currentRow = filteredRowId[i];	×
130	vector.putBoolean(vectorOffset, dataChunk.getBoolean(currentRow));	×
131	vectorOffset++;	×
132	}
133	} else {
134	for (int i = offset; i < len; i++) {	×
135	int currentRow = filteredRowId[i];	×
136	if (nullBitSet.get(currentRow)) {	×
137	vector.putNull(vectorOffset);	×
138	} else {
139	vector.putBoolean(vectorOffset, dataChunk.getBoolean(currentRow));	×
140	}
141	vectorOffset++;	×
142	}
143	}
144	}	×
145	}
146
147	public static class ShortMeasureVectorFiller implements MeasureVectorFiller {	1✔
148
149	@Override
150	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
151	int offset = info.offset;	×
152	int len = offset + info.size;	×
153	int vectorOffset = info.vectorOffset;	×
154	CarbonColumnVector vector = info.vector;	×
155	BitSet nullBitSet = dataChunk.getNullBits();	×
156	if (nullBitSet.isEmpty()) {	×
157	for (int i = offset; i < len; i++) {	×
158	vector.putShort(vectorOffset, (short) dataChunk.getLong(i));	×
159	vectorOffset++;	×
160	}
161	} else {
162	for (int i = offset; i < len; i++) {	×
163	if (nullBitSet.get(i)) {	×
164	vector.putNull(vectorOffset);	×
165	} else {
166	vector.putShort(vectorOffset, (short) dataChunk.getLong(i));	×
167	}
168	vectorOffset++;	×
169	}
170	}
171	}	×
172
173	@Override
174	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
175	ColumnVectorInfo info) {
176	int offset = info.offset;	×
177	int len = offset + info.size;	×
178	int vectorOffset = info.vectorOffset;	×
179	CarbonColumnVector vector = info.vector;	×
180	BitSet nullBitSet = dataChunk.getNullBits();	×
181	if (nullBitSet.isEmpty()) {	×
182	for (int i = offset; i < len; i++) {	×
183	int currentRow = filteredRowId[i];	×
184	vector.putShort(vectorOffset, (short) dataChunk.getLong(currentRow));	×
185	vectorOffset++;	×
186	}
187	} else {
188	for (int i = offset; i < len; i++) {	×
189	int currentRow = filteredRowId[i];	×
190	if (nullBitSet.get(currentRow)) {	×
191	vector.putNull(vectorOffset);	×
192	} else {
193	vector.putShort(vectorOffset, (short) dataChunk.getLong(currentRow));	×
194	}
195	vectorOffset++;	×
196	}
197	}
198	}	×
199	}
200
201	public static class LongMeasureVectorFiller implements MeasureVectorFiller {	1✔
202
203	@Override
204	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
205	int offset = info.offset;	1✔
206	int len = offset + info.size;	1✔
207	int vectorOffset = info.vectorOffset;	1✔
208	CarbonColumnVector vector = info.vector;	1✔
209	BitSet nullBitSet = dataChunk.getNullBits();	1✔
210	if (nullBitSet.isEmpty()) {	1✔
211	for (int i = offset; i < len; i++) {	×
212	vector.putLong(vectorOffset, dataChunk.getLong(i));	×
213	vectorOffset++;	×
214	}
215	} else {
216	for (int i = offset; i < len; i++) {	1✔
217	if (nullBitSet.get(i)) {	1✔
218	vector.putNull(vectorOffset);	1✔
219	} else {
220	vector.putLong(vectorOffset, dataChunk.getLong(i));	1✔
221	}
222	vectorOffset++;	1✔
223	}
224	}
225	}	1✔
226
227	@Override
228	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
229	ColumnVectorInfo info) {
230	int offset = info.offset;	1✔
231	int len = offset + info.size;	1✔
232	int vectorOffset = info.vectorOffset;	1✔
233	CarbonColumnVector vector = info.vector;	1✔
234	BitSet nullBitSet = dataChunk.getNullBits();	1✔
235	if (nullBitSet.isEmpty()) {	1✔
236	for (int i = offset; i < len; i++) {	1✔
237	int currentRow = filteredRowId[i];	1✔
238	vector.putLong(vectorOffset, dataChunk.getLong(currentRow));	1✔
239	vectorOffset++;	1✔
240	}
241	} else {
242	for (int i = offset; i < len; i++) {	×
243	int currentRow = filteredRowId[i];	×
244	if (nullBitSet.get(currentRow)) {	×
245	vector.putNull(vectorOffset);	×
246	} else {
247	vector.putLong(vectorOffset, dataChunk.getLong(currentRow));	×
248	}
249	vectorOffset++;	×
250	}
251	}
252	}	1✔
253	}
254
255	public static class DecimalMeasureVectorFiller implements MeasureVectorFiller {	1✔
256
257	@Override
258	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
259	int offset = info.offset;	1✔
260	int len = offset + info.size;	1✔
261	int vectorOffset = info.vectorOffset;	1✔
262	CarbonColumnVector vector = info.vector;	1✔
263	int precision = info.measure.getMeasure().getPrecision();	1✔
264	int newMeasureScale = info.measure.getMeasure().getScale();	1✔
265	BitSet nullBitSet = dataChunk.getNullBits();	1✔
266	for (int i = offset; i < len; i++) {	1✔
267	if (nullBitSet.get(i)) {	1✔
268	vector.putNull(vectorOffset);	1✔
269	} else {
270	BigDecimal decimal =	1✔
271	dataChunk.getDecimal(i);	1✔
272	if (decimal.scale() < newMeasureScale) {	1✔
273	decimal = decimal.setScale(newMeasureScale);	×
274	}
275	vector.putDecimal(vectorOffset, decimal, precision);	1✔
276	}
277	vectorOffset++;	1✔
278	}
279	}	1✔
280
281	@Override
282	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
283	ColumnVectorInfo info) {
284	int offset = info.offset;	1✔
285	int len = offset + info.size;	1✔
286	int vectorOffset = info.vectorOffset;	1✔
287	CarbonColumnVector vector = info.vector;	1✔
288	int precision = info.measure.getMeasure().getPrecision();	1✔
289	BitSet nullBitSet = dataChunk.getNullBits();	1✔
290	for (int i = offset; i < len; i++) {	1✔
291	int currentRow = filteredRowId[i];	1✔
292	if (nullBitSet.get(currentRow)) {	1✔
293	vector.putNull(vectorOffset);	×
294	} else {
295	BigDecimal decimal = dataChunk.getDecimal(currentRow);	1✔
296	if (info.measure.getMeasure().getScale() > decimal.scale()) {	1✔
297	decimal = decimal.setScale(info.measure.getMeasure().getScale());	×
298	}
299	vector.putDecimal(vectorOffset, decimal, precision);	1✔
300	}
301	vectorOffset++;	1✔
302	}
303	}	1✔
304	}
305	public static class FloatMeasureVectorFiller implements MeasureVectorFiller {	×
306
307	@Override
308	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
309	int offset = info.offset;	×
310	int len = offset + info.size;	×
311	int vectorOffset = info.vectorOffset;	×
312	CarbonColumnVector vector = info.vector;	×
313	BitSet nullBitSet = dataChunk.getNullBits();	×
314	if (nullBitSet.isEmpty()) {	×
315	for (int i = offset; i < len; i++) {	×
316	vector.putFloat(vectorOffset, dataChunk.getFloat(i));	×
317	vectorOffset++;	×
318	}
319	} else {
320	for (int i = offset; i < len; i++) {	×
321	if (nullBitSet.get(i)) {	×
322	vector.putNull(vectorOffset);	×
323	} else {
324	vector.putFloat(vectorOffset, dataChunk.getFloat(i));	×
325	}
326	vectorOffset++;	×
327	}
328	}
329	}	×
330
331	@Override
332	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
333	ColumnVectorInfo info) {
334	int offset = info.offset;	×
335	int len = offset + info.size;	×
336	int vectorOffset = info.vectorOffset;	×
337	CarbonColumnVector vector = info.vector;	×
338	BitSet nullBitSet = dataChunk.getNullBits();	×
339	if (nullBitSet.isEmpty()) {	×
340	for (int i = offset; i < len; i++) {	×
341	int currentRow = filteredRowId[i];	×
342	vector.putFloat(vectorOffset, dataChunk.getFloat(currentRow));	×
343	vectorOffset++;	×
344	}
345	} else {
346	for (int i = offset; i < len; i++) {	×
347	int currentRow = filteredRowId[i];	×
348	if (nullBitSet.get(currentRow)) {	×
349	vector.putNull(vectorOffset);	×
350	} else {
351	vector.putFloat(vectorOffset, dataChunk.getFloat(currentRow));	×
352	}
353	vectorOffset++;	×
354	}
355	}
356	}	×
357	}
358
359	public static class ByteMeasureVectorFiller implements MeasureVectorFiller {	×
360
361	@Override
362	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
363	int offset = info.offset;	×
364	int len = offset + info.size;	×
365	int vectorOffset = info.vectorOffset;	×
366	CarbonColumnVector vector = info.vector;	×
367	BitSet nullBitSet = dataChunk.getNullBits();	×
368	if (nullBitSet.isEmpty()) {	×
369	for (int i = offset; i < len; i++) {	×
370	vector.putByte(vectorOffset, dataChunk.getByte(i));	×
371	vectorOffset++;	×
372	}
373	} else {
374	for (int i = offset; i < len; i++) {	×
375	if (nullBitSet.get(i)) {	×
376	vector.putNull(vectorOffset);	×
377	} else {
378	vector.putByte(vectorOffset, dataChunk.getByte(i));	×
379	}
380	vectorOffset++;	×
381	}
382	}
383	}	×
384
385	@Override
386	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
387	ColumnVectorInfo info) {
388	int offset = info.offset;	×
389	int len = offset + info.size;	×
390	int vectorOffset = info.vectorOffset;	×
391	CarbonColumnVector vector = info.vector;	×
392	BitSet nullBitSet = dataChunk.getNullBits();	×
393	if (nullBitSet.isEmpty()) {	×
394	for (int i = offset; i < len; i++) {	×
395	int currentRow = filteredRowId[i];	×
396	vector.putByte(vectorOffset, dataChunk.getByte(currentRow));	×
397	vectorOffset++;	×
398	}
399	} else {
400	for (int i = offset; i < len; i++) {	×
401	int currentRow = filteredRowId[i];	×
402	if (nullBitSet.get(currentRow)) {	×
403	vector.putNull(vectorOffset);	×
404	} else {
405	vector.putByte(vectorOffset, dataChunk.getByte(currentRow));	×
406	}
407	vectorOffset++;	×
408	}
409	}
410	}	×
411	}
412
413	public static class DefaultMeasureVectorFiller implements MeasureVectorFiller {	1✔
414
415	@Override
416	public void fillMeasureVector(ColumnPage dataChunk, ColumnVectorInfo info) {
417	int offset = info.offset;	1✔
418	int len = offset + info.size;	1✔
419	int vectorOffset = info.vectorOffset;	1✔
420	CarbonColumnVector vector = info.vector;	1✔
421	BitSet nullBitSet = dataChunk.getNullBits();	1✔
422	if (nullBitSet.isEmpty()) {	1✔
423	for (int i = offset; i < len; i++) {	1✔
424	vector.putDouble(vectorOffset, dataChunk.getDouble(i));	1✔
425	vectorOffset++;	1✔
426	}
427	} else {
428	for (int i = offset; i < len; i++) {	1✔
429	if (nullBitSet.get(i)) {	1✔
430	vector.putNull(vectorOffset);	1✔
431	} else {
432	vector.putDouble(vectorOffset, dataChunk.getDouble(i));	1✔
433	}
434	vectorOffset++;	1✔
435	}
436	}
437	}	1✔
438
439	@Override
440	public void fillMeasureVector(int[] filteredRowId, ColumnPage dataChunk,
441	ColumnVectorInfo info) {
442	int offset = info.offset;	1✔
443	int len = offset + info.size;	1✔
444	int vectorOffset = info.vectorOffset;	1✔
445	CarbonColumnVector vector = info.vector;	1✔
446	BitSet nullBitSet = dataChunk.getNullBits();	1✔
447	if (nullBitSet.isEmpty()) {	1✔
448	for (int i = offset; i < len; i++) {	1✔
449	int currentRow = filteredRowId[i];	1✔
450	vector.putDouble(vectorOffset, dataChunk.getDouble(currentRow));	1✔
451	vectorOffset++;	1✔
452	}
453	} else {
454	for (int i = offset; i < len; i++) {	×
455	int currentRow = filteredRowId[i];	×
456	if (nullBitSet.get(currentRow)) {	×
457	vector.putNull(vectorOffset);	×
458	} else {
459	vector.putDouble(vectorOffset, dataChunk.getDouble(currentRow));	×
460	}
461	vectorOffset++;	×
462	}
463	}
464	}	1✔
465	}
466
467	public static class MeasureVectorFillerFactory {	×
468
469	public static MeasureVectorFiller getMeasureVectorFiller(DataType dataType) {
470	if (dataType == DataTypes.BOOLEAN) {	1✔
471	return new BooleanMeasureVectorFiller();	1✔
472	} else if (dataType == DataTypes.SHORT) {	1✔
473	return new ShortMeasureVectorFiller();	1✔
474	} else if (dataType == DataTypes.INT) {	1✔
475	return new IntegralMeasureVectorFiller();	1✔
476	} else if (dataType == DataTypes.LONG) {	1✔
477	return new LongMeasureVectorFiller();	1✔
478	} else if (DataTypes.isDecimal(dataType)) {	1✔
479	return new DecimalMeasureVectorFiller();	1✔
480	} else if (dataType == DataTypes.FLOAT) {	1✔
481	return new FloatMeasureVectorFiller();	×
482	} else if (dataType == DataTypes.BYTE) {	1✔
483	return new ByteMeasureVectorFiller();	×
484	} else {
485	return new DefaultMeasureVectorFiller();	1✔
486	}
487	}
488	}
489
490	}

apache / carbondata / 1380

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