9674

Build # 9674

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/8ac0656de0f8f57530ca235f55ae23653f6638b9">8ac0656de<a href="https://github.com/apache/carbondata/commit/8ac0656de0f8f57530ca235f55ae23653f6638b9">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/564e95512df9b421932bcdc2f6940d01f51f56e4">564e95512</a>">564e95512</a><a href="https://github.com/apache/carbondata/commit/8ac0656de0f8f57530ca235f55ae23653f6638b9"> into ceb135175">ceb135175</a>

Run Details

619 of 619 new or added lines in 54 files covered. (100.0%)

61379 of 77138 relevant lines covered (79.57%)

1.05 hits per line

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

33.33

/core/src/main/java/org/apache/carbondata/core/datastore/chunk/store/impl/safe/AbstractNonDictionaryVectorFiller.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.chunk.store.impl.safe;

import org.apache.carbondata.common.annotations.InterfaceAudience;
import org.apache.carbondata.common.annotations.InterfaceStability;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.util.ByteUtil;
import org.apache.carbondata.core.util.DataTypeUtil;

@InterfaceAudience.Internal
@InterfaceStability.Stable
public abstract class AbstractNonDictionaryVectorFiller {

  protected int numberOfRows;

  public AbstractNonDictionaryVectorFiller(int numberOfRows) {
    this.numberOfRows = numberOfRows;
  }

  public abstract void fillVector(byte[] data, CarbonColumnVector vector);

}

class NonDictionaryVectorFillerFactory {

  public static AbstractNonDictionaryVectorFiller getVectorFiller(int length, DataType type,
      int numberOfRows, int actualDataLength) {
    if (type == DataTypes.STRING) {
      if (length > DataTypes.SHORT.getSizeInBytes()) {
        return new LongStringVectorFiller(numberOfRows, actualDataLength);
      } else {
        return new StringVectorFiller(numberOfRows, actualDataLength);
      }
    } else if (type == DataTypes.VARCHAR) {
      return new LongStringVectorFiller(numberOfRows, actualDataLength);
    } else if (type == DataTypes.TIMESTAMP) {
      return new TimeStampVectorFiller(numberOfRows);
    } else if (type == DataTypes.BOOLEAN) {
      return new BooleanVectorFiller(numberOfRows);
    } else if (type == DataTypes.SHORT) {
      return new ShortVectorFiller(numberOfRows);
    } else if (type == DataTypes.INT) {
      return new IntVectorFiller(numberOfRows);
    } else if (type == DataTypes.LONG) {
      return new LongVectorFiller(numberOfRows);
    } else {
      throw new UnsupportedOperationException("Not supported datatype : " + type);
    }

  }

}

class StringVectorFiller extends AbstractNonDictionaryVectorFiller {

  private int actualDataLength;

  public StringVectorFiller(int numberOfRows, int actualDataLength) {
    super(numberOfRows);
    this.actualDataLength = actualDataLength;
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    ByteUtil.UnsafeComparer comparator = ByteUtil.UnsafeComparer.INSTANCE;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (comparator.equals(CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY, 0,
          CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY.length, data, localOffset, length)) {
        vector.putNull(i);
      } else {
        vector.putArray(i, localOffset, length);
      }
      localOffset += length;
    }
    vector.putAllByteArray(data, 0, actualDataLength);
  }
}

class LongStringVectorFiller extends AbstractNonDictionaryVectorFiller {

  private int actualDataLength;

  public LongStringVectorFiller(int numberOfRows, int actualDataLength) {
    super(numberOfRows);
    this.actualDataLength = actualDataLength;
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    ByteUtil.UnsafeComparer comparator = ByteUtil.UnsafeComparer.INSTANCE;
    for (int i = 0; i < numberOfRows; i++) {
      int length =
          (((data[localOffset] & 0xFF) << 24) | ((data[localOffset + 1] & 0xFF) << 16) | (
              (data[localOffset + 2] & 0xFF) << 8) | (data[localOffset + 3] & 0xFF));
      localOffset += 4;
      if (comparator.equals(CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY, 0,
          CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY.length, data, localOffset, length)) {
        vector.putNull(i);
      } else {
        vector.putArray(i, localOffset, length);
      }
      localOffset += length;
    }
    vector.putAllByteArray(data, 0, actualDataLength);
  }
}

class BooleanVectorFiller extends AbstractNonDictionaryVectorFiller {

  public BooleanVectorFiller(int numberOfRows) {
    super(numberOfRows);
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (length == 0) {
        vector.putNull(i);
      } else {
        vector.putBoolean(i, ByteUtil.toBoolean(data[localOffset]));
      }
      localOffset += length;
    }
  }
}

class ShortVectorFiller extends AbstractNonDictionaryVectorFiller {

  public ShortVectorFiller(int numberOfRows) {
    super(numberOfRows);
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (length == 0) {
        vector.putNull(i);
      } else {
        vector.putShort(i, ByteUtil.toXorShort(data, localOffset, length));
      }
      localOffset += length;
    }
  }
}

class IntVectorFiller extends AbstractNonDictionaryVectorFiller {

  public IntVectorFiller(int numberOfRows) {
    super(numberOfRows);
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (length == 0) {
        vector.putNull(i);
      } else {
        vector.putInt(i, ByteUtil.toXorInt(data, localOffset, length));
      }
      localOffset += length;
    }
  }
}

class LongVectorFiller extends AbstractNonDictionaryVectorFiller {

  public LongVectorFiller(int numberOfRows) {
    super(numberOfRows);
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (length == 0) {
        vector.putNull(i);
      } else {
        vector.putLong(i, DataTypeUtil
            .getDataBasedOnRestructuredDataType(data, vector.getBlockDataType(), localOffset,
                length));
      }
      localOffset += length;
    }
  }
}

class TimeStampVectorFiller extends AbstractNonDictionaryVectorFiller {

  public TimeStampVectorFiller(int numberOfRows) {
    super(numberOfRows);
  }

  @Override
  public void fillVector(byte[] data, CarbonColumnVector vector) {
    // start position will be used to store the current data position
    int localOffset = 0;
    for (int i = 0; i < numberOfRows; i++) {
      int length = (((data[localOffset] & 0xFF) << 8) | (data[localOffset + 1] & 0xFF));
      localOffset += 2;
      if (length == 0) {
        vector.putNull(i);
      } else {
        vector.putLong(i, ByteUtil.toXorLong(data, localOffset, length) * 1000L);
      }
      localOffset += length;
    }
  }
}

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.chunk.store.impl.safe;
19
20	import org.apache.carbondata.common.annotations.InterfaceAudience;
21	import org.apache.carbondata.common.annotations.InterfaceStability;
22	import org.apache.carbondata.core.constants.CarbonCommonConstants;
23	import org.apache.carbondata.core.metadata.datatype.DataType;
24	import org.apache.carbondata.core.metadata.datatype.DataTypes;
25	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
26	import org.apache.carbondata.core.util.ByteUtil;
27	import org.apache.carbondata.core.util.DataTypeUtil;
28
29	@InterfaceAudience.Internal
30	@InterfaceStability.Stable
31	public abstract class AbstractNonDictionaryVectorFiller {
32
33	protected int numberOfRows;
34
35	public AbstractNonDictionaryVectorFiller(int numberOfRows) {	1✔
36	this.numberOfRows = numberOfRows;	1✔
37	}	1✔
38
39	public abstract void fillVector(byte[] data, CarbonColumnVector vector);
40
41	}
42
43	class NonDictionaryVectorFillerFactory {	×
44
45	public static AbstractNonDictionaryVectorFiller getVectorFiller(int length, DataType type,
46	int numberOfRows, int actualDataLength) {
47	if (type == DataTypes.STRING) {	1✔
48	if (length > DataTypes.SHORT.getSizeInBytes()) {	1✔
49	return new LongStringVectorFiller(numberOfRows, actualDataLength);	×
50	} else {
51	return new StringVectorFiller(numberOfRows, actualDataLength);	1✔
52	}
53	} else if (type == DataTypes.VARCHAR) {	1✔
54	return new LongStringVectorFiller(numberOfRows, actualDataLength);	1✔
55	} else if (type == DataTypes.TIMESTAMP) {	×
56	return new TimeStampVectorFiller(numberOfRows);	×
57	} else if (type == DataTypes.BOOLEAN) {	×
58	return new BooleanVectorFiller(numberOfRows);	×
59	} else if (type == DataTypes.SHORT) {	×
60	return new ShortVectorFiller(numberOfRows);	×
61	} else if (type == DataTypes.INT) {	×
62	return new IntVectorFiller(numberOfRows);	×
63	} else if (type == DataTypes.LONG) {	×
64	return new LongVectorFiller(numberOfRows);	×
65	} else {
66	throw new UnsupportedOperationException("Not supported datatype : " + type);	×
67	}
68
69	}
70
71	}
72
73	class StringVectorFiller extends AbstractNonDictionaryVectorFiller {
74
75	private int actualDataLength;
76
77	public StringVectorFiller(int numberOfRows, int actualDataLength) {
78	super(numberOfRows);	1✔
79	this.actualDataLength = actualDataLength;	1✔
80	}	1✔
81
82	@Override
83	public void fillVector(byte[] data, CarbonColumnVector vector) {
84	// start position will be used to store the current data position
85	int localOffset = 0;	1✔
86	ByteUtil.UnsafeComparer comparator = ByteUtil.UnsafeComparer.INSTANCE;	1✔
87	for (int i = 0; i < numberOfRows; i++) {	1✔
88	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	1✔
89	localOffset += 2;	1✔
90	if (comparator.equals(CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY, 0,	1✔
91	CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY.length, data, localOffset, length)) {
92	vector.putNull(i);	1✔
93	} else {
94	vector.putArray(i, localOffset, length);	1✔
95	}
96	localOffset += length;	1✔
97	}
98	vector.putAllByteArray(data, 0, actualDataLength);	1✔
99	}	1✔
100	}
101
102	class LongStringVectorFiller extends AbstractNonDictionaryVectorFiller {
103
104	private int actualDataLength;
105
106	public LongStringVectorFiller(int numberOfRows, int actualDataLength) {
107	super(numberOfRows);	1✔
108	this.actualDataLength = actualDataLength;	1✔
109	}	1✔
110
111	@Override
112	public void fillVector(byte[] data, CarbonColumnVector vector) {
113	// start position will be used to store the current data position
114	int localOffset = 0;	1✔
115	ByteUtil.UnsafeComparer comparator = ByteUtil.UnsafeComparer.INSTANCE;	1✔
116	for (int i = 0; i < numberOfRows; i++) {	1✔
117	int length =	1✔
118	(((data[localOffset] & 0xFF) << 24) \| ((data[localOffset + 1] & 0xFF) << 16) \| (
119	(data[localOffset + 2] & 0xFF) << 8) \| (data[localOffset + 3] & 0xFF));
120	localOffset += 4;	1✔
121	if (comparator.equals(CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY, 0,	1✔
122	CarbonCommonConstants.MEMBER_DEFAULT_VAL_ARRAY.length, data, localOffset, length)) {
123	vector.putNull(i);	×
124	} else {
125	vector.putArray(i, localOffset, length);	1✔
126	}
127	localOffset += length;	1✔
128	}
129	vector.putAllByteArray(data, 0, actualDataLength);	1✔
130	}	1✔
131	}
132
133	class BooleanVectorFiller extends AbstractNonDictionaryVectorFiller {
134
135	public BooleanVectorFiller(int numberOfRows) {
136	super(numberOfRows);	×
137	}	×
138
139	@Override
140	public void fillVector(byte[] data, CarbonColumnVector vector) {
141	// start position will be used to store the current data position
142	int localOffset = 0;	×
143	for (int i = 0; i < numberOfRows; i++) {	×
144	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	×
145	localOffset += 2;	×
146	if (length == 0) {	×
147	vector.putNull(i);	×
148	} else {
149	vector.putBoolean(i, ByteUtil.toBoolean(data[localOffset]));	×
150	}
151	localOffset += length;	×
152	}
153	}	×
154	}
155
156	class ShortVectorFiller extends AbstractNonDictionaryVectorFiller {
157
158	public ShortVectorFiller(int numberOfRows) {
159	super(numberOfRows);	×
160	}	×
161
162	@Override
163	public void fillVector(byte[] data, CarbonColumnVector vector) {
164	// start position will be used to store the current data position
165	int localOffset = 0;	×
166	for (int i = 0; i < numberOfRows; i++) {	×
167	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	×
168	localOffset += 2;	×
169	if (length == 0) {	×
170	vector.putNull(i);	×
171	} else {
172	vector.putShort(i, ByteUtil.toXorShort(data, localOffset, length));	×
173	}
174	localOffset += length;	×
175	}
176	}	×
177	}
178
179	class IntVectorFiller extends AbstractNonDictionaryVectorFiller {
180
181	public IntVectorFiller(int numberOfRows) {
182	super(numberOfRows);	×
183	}	×
184
185	@Override
186	public void fillVector(byte[] data, CarbonColumnVector vector) {
187	// start position will be used to store the current data position
188	int localOffset = 0;	×
189	for (int i = 0; i < numberOfRows; i++) {	×
190	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	×
191	localOffset += 2;	×
192	if (length == 0) {	×
193	vector.putNull(i);	×
194	} else {
195	vector.putInt(i, ByteUtil.toXorInt(data, localOffset, length));	×
196	}
197	localOffset += length;	×
198	}
199	}	×
200	}
201
202	class LongVectorFiller extends AbstractNonDictionaryVectorFiller {
203
204	public LongVectorFiller(int numberOfRows) {
205	super(numberOfRows);	×
206	}	×
207
208	@Override
209	public void fillVector(byte[] data, CarbonColumnVector vector) {
210	// start position will be used to store the current data position
211	int localOffset = 0;	×
212	for (int i = 0; i < numberOfRows; i++) {	×
213	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	×
214	localOffset += 2;	×
215	if (length == 0) {	×
216	vector.putNull(i);	×
217	} else {
218	vector.putLong(i, DataTypeUtil	×
219	.getDataBasedOnRestructuredDataType(data, vector.getBlockDataType(), localOffset,	×
220	length));
221	}
222	localOffset += length;	×
223	}
224	}	×
225	}
226
227	class TimeStampVectorFiller extends AbstractNonDictionaryVectorFiller {
228
229	public TimeStampVectorFiller(int numberOfRows) {
230	super(numberOfRows);	×
231	}	×
232
233	@Override
234	public void fillVector(byte[] data, CarbonColumnVector vector) {
235	// start position will be used to store the current data position
236	int localOffset = 0;	×
237	for (int i = 0; i < numberOfRows; i++) {	×
238	int length = (((data[localOffset] & 0xFF) << 8) \| (data[localOffset + 1] & 0xFF));	×
239	localOffset += 2;	×
240	if (length == 0) {	×
241	vector.putNull(i);	×
242	} else {
243	vector.putLong(i, ByteUtil.toXorLong(data, localOffset, length) * 1000L);	×
244	}
245	localOffset += length;	×
246	}
247	}	×
248	}

apache / carbondata / 9674

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