9238

Build # 9238

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/ae87f2a1a25216d5c9b037a9ca8b6f3ef0aee58b">ae87f2a1a<a href="https://github.com/apache/carbondata/commit/ae87f2a1a25216d5c9b037a9ca8b6f3ef0aee58b">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/1ca17b20acf00efef63c8dc92444da93e53a99de">1ca17b20a</a>">1ca17b20a</a><a href="https://github.com/apache/carbondata/commit/ae87f2a1a25216d5c9b037a9ca8b6f3ef0aee58b"> into fa9a4eeeb">fa9a4eeeb</a>

Run Details

2138 of 2138 new or added lines in 77 files covered. (100.0%)

61503 of 76985 relevant lines covered (79.89%)

1.05 hits per line

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

0.0

/integration/spark-datasource/src/main/scala/org/apache/carbondata/spark/vectorreader/ColumnarVectorWrapper.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.spark.vectorreader;

import java.math.BigDecimal;

import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
import org.apache.carbondata.core.scan.scanner.LazyPageLoad;

import org.apache.spark.sql.CarbonVectorProxy;
import org.apache.spark.sql.carbondata.execution.datasources.CarbonSparkDataSourceUtil;
import org.apache.spark.sql.types.Decimal;

class ColumnarVectorWrapper implements CarbonColumnVector {

  private CarbonVectorProxy.ColumnVectorProxy sparkColumnVectorProxy;

  private CarbonVectorProxy carbonVectorProxy;

  private boolean[] filteredRows;

  private int counter;

  private int ordinal;

  private boolean isDictionary;

  private boolean filteredRowsExist;

  private DataType blockDataType;

  private CarbonColumnVector dictionaryVector;

  ColumnarVectorWrapper(CarbonVectorProxy writableColumnVector,
      boolean[] filteredRows, int ordinal) {
    this.sparkColumnVectorProxy = writableColumnVector.getColumnVector(ordinal);
    this.filteredRows = filteredRows;
    this.carbonVectorProxy = writableColumnVector;
    this.ordinal = ordinal;
  }

  @Override public void putBoolean(int rowId, boolean value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putBoolean(counter++, value, ordinal);
    }
  }

  @Override public void putFloat(int rowId, float value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putFloat(counter++, value,ordinal);
    }
  }

  @Override public void putShort(int rowId, short value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putShort(counter++, value, ordinal);
    }
  }

  @Override public void putShorts(int rowId, int count, short value) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putShort(counter++, value, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putShorts(rowId, count, value, ordinal);
    }
  }

  @Override public void putInt(int rowId, int value) {
    if (!filteredRows[rowId]) {
      if (isDictionary) {
        sparkColumnVectorProxy.putDictionaryInt(counter++, value, ordinal);
      } else {
        sparkColumnVectorProxy.putInt(counter++, value, ordinal);
      }
    }
  }

  @Override public void putInts(int rowId, int count, int value) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putInt(counter++, value, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putInts(rowId, count, value, ordinal);
    }
  }

  @Override public void putLong(int rowId, long value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putLong(counter++, value, ordinal);
    }
  }

  @Override public void putLongs(int rowId, int count, long value) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putLong(counter++, value, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putLongs(rowId, count, value, ordinal);
    }
  }

  @Override public void putDecimal(int rowId, BigDecimal value, int precision) {
    if (!filteredRows[rowId]) {
      Decimal toDecimal = Decimal.apply(value);
      sparkColumnVectorProxy.putDecimal(counter++, toDecimal, precision, ordinal);
    }
  }

  @Override public void putDecimals(int rowId, int count, BigDecimal value, int precision) {
    Decimal decimal = Decimal.apply(value);
    for (int i = 0; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putDecimal(counter++, decimal, precision, ordinal);
      }
      rowId++;
    }
  }

  @Override public void putDouble(int rowId, double value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putDouble(counter++, value, ordinal);
    }
  }

  @Override public void putDoubles(int rowId, int count, double value) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putDouble(counter++, value, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putDoubles(rowId, count, value, ordinal);
    }
  }

  @Override public void putByte(int rowId, byte value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putByte(counter++, value, ordinal);
    }
  }

  @Override public void putByteArray(int rowId, byte[] value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putByteArray(counter++, value, ordinal);
    }
  }

  @Override public void putBytes(int rowId, int count, byte[] value) {
    for (int i = 0; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putByteArray(counter++, value, ordinal);
      }
      rowId++;
    }
  }

  @Override public void putByteArray(int rowId, int offset, int length, byte[] value) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putByteArray(counter++, value, offset, length, ordinal);
    }
  }

  @Override public void putNull(int rowId) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putNull(counter++, ordinal);
    }
  }

  @Override public void putNulls(int rowId, int count) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putNull(counter++, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putNulls(rowId, count,ordinal);
    }
  }

  @Override public void putNotNull(int rowId) {
    if (!filteredRows[rowId]) {
      sparkColumnVectorProxy.putNotNull(counter++,ordinal);
    }
  }

  @Override public void putNotNull(int rowId, int count) {
    if (filteredRowsExist) {
      for (int i = 0; i < count; i++) {
        if (!filteredRows[rowId]) {
          sparkColumnVectorProxy.putNotNull(counter++, ordinal);
        }
        rowId++;
      }
    } else {
      sparkColumnVectorProxy.putNotNulls(rowId, count, ordinal);
    }
  }

  @Override public boolean isNull(int rowId) {
    return sparkColumnVectorProxy.isNullAt(rowId,ordinal);
  }

  @Override public void putObject(int rowId, Object obj) {
    //TODO handle complex types
  }

  @Override public Object getData(int rowId) {
    //TODO handle complex types
    return null;
  }

  @Override public void reset() {
    counter = 0;
    filteredRowsExist = false;
    if (null != dictionaryVector) {
      dictionaryVector.reset();
    }
  }

  @Override public DataType getType() {
    return CarbonSparkDataSourceUtil
        .convertSparkToCarbonDataType(sparkColumnVectorProxy.dataType(ordinal));
  }

  @Override
  public DataType getBlockDataType() {
    return blockDataType;
  }

  @Override
  public void setBlockDataType(DataType blockDataType) {
    this.blockDataType = blockDataType;
  }

  @Override
  public void setFilteredRowsExist(boolean filteredRowsExist) {
    this.filteredRowsExist = filteredRowsExist;
  }

  @Override public void setDictionary(CarbonDictionary dictionary) {
      sparkColumnVectorProxy.setDictionary(dictionary, ordinal);
  }

  @Override public boolean hasDictionary() {
    return sparkColumnVectorProxy.hasDictionary(ordinal);
  }

  public void reserveDictionaryIds() {
    sparkColumnVectorProxy.reserveDictionaryIds(carbonVectorProxy.numRows(), ordinal);
    dictionaryVector = new ColumnarVectorWrapper(carbonVectorProxy, filteredRows, ordinal);
    ((ColumnarVectorWrapper) dictionaryVector).isDictionary = true;
  }

  @Override public CarbonColumnVector getDictionaryVector() {
    return dictionaryVector;
  }

  @Override public void putFloats(int rowId, int count, float[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putFloat(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void putShorts(int rowId, int count, short[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putShort(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void putInts(int rowId, int count, int[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putInt(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void putLongs(int rowId, int count, long[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putLong(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void putDoubles(int rowId, int count, double[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putDouble(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void putBytes(int rowId, int count, byte[] src, int srcIndex) {
    for (int i = srcIndex; i < count; i++) {
      if (!filteredRows[rowId]) {
        sparkColumnVectorProxy.putByte(counter++, src[i], ordinal);
      }
      rowId++;
    }
  }

  @Override public void setLazyPage(LazyPageLoad lazyPage) {
    lazyPage.loadPage();
  }
}

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.spark.vectorreader;
19
20	import java.math.BigDecimal;
21
22	import org.apache.carbondata.core.metadata.datatype.DataType;
23	import org.apache.carbondata.core.scan.result.vector.CarbonColumnVector;
24	import org.apache.carbondata.core.scan.result.vector.CarbonDictionary;
25	import org.apache.carbondata.core.scan.scanner.LazyPageLoad;
26
27	import org.apache.spark.sql.CarbonVectorProxy;
28	import org.apache.spark.sql.carbondata.execution.datasources.CarbonSparkDataSourceUtil;
29	import org.apache.spark.sql.types.Decimal;
30
31	class ColumnarVectorWrapper implements CarbonColumnVector {
32
33	private CarbonVectorProxy.ColumnVectorProxy sparkColumnVectorProxy;
34
35	private CarbonVectorProxy carbonVectorProxy;
36
37	private boolean[] filteredRows;
38
39	private int counter;
40
41	private int ordinal;
42
43	private boolean isDictionary;
44
45	private boolean filteredRowsExist;
46
47	private DataType blockDataType;
48
49	private CarbonColumnVector dictionaryVector;
50
51	ColumnarVectorWrapper(CarbonVectorProxy writableColumnVector,
52	boolean[] filteredRows, int ordinal) {	×
53	this.sparkColumnVectorProxy = writableColumnVector.getColumnVector(ordinal);	×
54	this.filteredRows = filteredRows;	×
55	this.carbonVectorProxy = writableColumnVector;	×
56	this.ordinal = ordinal;	×
57	}	×
58
59	@Override public void putBoolean(int rowId, boolean value) {
60	if (!filteredRows[rowId]) {	×
61	sparkColumnVectorProxy.putBoolean(counter++, value, ordinal);	×
62	}
63	}	×
64
65	@Override public void putFloat(int rowId, float value) {
66	if (!filteredRows[rowId]) {	×
67	sparkColumnVectorProxy.putFloat(counter++, value,ordinal);	×
68	}
69	}	×
70
71	@Override public void putShort(int rowId, short value) {
72	if (!filteredRows[rowId]) {	×
73	sparkColumnVectorProxy.putShort(counter++, value, ordinal);	×
74	}
75	}	×
76
77	@Override public void putShorts(int rowId, int count, short value) {
78	if (filteredRowsExist) {	×
79	for (int i = 0; i < count; i++) {	×
80	if (!filteredRows[rowId]) {	×
81	sparkColumnVectorProxy.putShort(counter++, value, ordinal);	×
82	}
83	rowId++;	×
84	}
85	} else {
86	sparkColumnVectorProxy.putShorts(rowId, count, value, ordinal);	×
87	}
88	}	×
89
90	@Override public void putInt(int rowId, int value) {
91	if (!filteredRows[rowId]) {	×
92	if (isDictionary) {	×
93	sparkColumnVectorProxy.putDictionaryInt(counter++, value, ordinal);	×
94	} else {
95	sparkColumnVectorProxy.putInt(counter++, value, ordinal);	×
96	}
97	}
98	}	×
99
100	@Override public void putInts(int rowId, int count, int value) {
101	if (filteredRowsExist) {	×
102	for (int i = 0; i < count; i++) {	×
103	if (!filteredRows[rowId]) {	×
104	sparkColumnVectorProxy.putInt(counter++, value, ordinal);	×
105	}
106	rowId++;	×
107	}
108	} else {
109	sparkColumnVectorProxy.putInts(rowId, count, value, ordinal);	×
110	}
111	}	×
112
113	@Override public void putLong(int rowId, long value) {
114	if (!filteredRows[rowId]) {	×
115	sparkColumnVectorProxy.putLong(counter++, value, ordinal);	×
116	}
117	}	×
118
119	@Override public void putLongs(int rowId, int count, long value) {
120	if (filteredRowsExist) {	×
121	for (int i = 0; i < count; i++) {	×
122	if (!filteredRows[rowId]) {	×
123	sparkColumnVectorProxy.putLong(counter++, value, ordinal);	×
124	}
125	rowId++;	×
126	}
127	} else {
128	sparkColumnVectorProxy.putLongs(rowId, count, value, ordinal);	×
129	}
130	}	×
131
132	@Override public void putDecimal(int rowId, BigDecimal value, int precision) {
133	if (!filteredRows[rowId]) {	×
134	Decimal toDecimal = Decimal.apply(value);	×
135	sparkColumnVectorProxy.putDecimal(counter++, toDecimal, precision, ordinal);	×
136	}
137	}	×
138
139	@Override public void putDecimals(int rowId, int count, BigDecimal value, int precision) {
140	Decimal decimal = Decimal.apply(value);	×
141	for (int i = 0; i < count; i++) {	×
142	if (!filteredRows[rowId]) {	×
143	sparkColumnVectorProxy.putDecimal(counter++, decimal, precision, ordinal);	×
144	}
145	rowId++;	×
146	}
147	}	×
148
149	@Override public void putDouble(int rowId, double value) {
150	if (!filteredRows[rowId]) {	×
151	sparkColumnVectorProxy.putDouble(counter++, value, ordinal);	×
152	}
153	}	×
154
155	@Override public void putDoubles(int rowId, int count, double value) {
156	if (filteredRowsExist) {	×
157	for (int i = 0; i < count; i++) {	×
158	if (!filteredRows[rowId]) {	×
159	sparkColumnVectorProxy.putDouble(counter++, value, ordinal);	×
160	}
161	rowId++;	×
162	}
163	} else {
164	sparkColumnVectorProxy.putDoubles(rowId, count, value, ordinal);	×
165	}
166	}	×
167
168	@Override public void putByte(int rowId, byte value) {
169	if (!filteredRows[rowId]) {	×
170	sparkColumnVectorProxy.putByte(counter++, value, ordinal);	×
171	}
172	}	×
173
174	@Override public void putByteArray(int rowId, byte[] value) {
175	if (!filteredRows[rowId]) {	×
176	sparkColumnVectorProxy.putByteArray(counter++, value, ordinal);	×
177	}
178	}	×
179
180	@Override public void putBytes(int rowId, int count, byte[] value) {
181	for (int i = 0; i < count; i++) {	×
182	if (!filteredRows[rowId]) {	×
183	sparkColumnVectorProxy.putByteArray(counter++, value, ordinal);	×
184	}
185	rowId++;	×
186	}
187	}	×
188
189	@Override public void putByteArray(int rowId, int offset, int length, byte[] value) {
190	if (!filteredRows[rowId]) {	×
191	sparkColumnVectorProxy.putByteArray(counter++, value, offset, length, ordinal);	×
192	}
193	}	×
194
195	@Override public void putNull(int rowId) {
196	if (!filteredRows[rowId]) {	×
197	sparkColumnVectorProxy.putNull(counter++, ordinal);	×
198	}
199	}	×
200
201	@Override public void putNulls(int rowId, int count) {
202	if (filteredRowsExist) {	×
203	for (int i = 0; i < count; i++) {	×
204	if (!filteredRows[rowId]) {	×
205	sparkColumnVectorProxy.putNull(counter++, ordinal);	×
206	}
207	rowId++;	×
208	}
209	} else {
210	sparkColumnVectorProxy.putNulls(rowId, count,ordinal);	×
211	}
212	}	×
213
214	@Override public void putNotNull(int rowId) {
215	if (!filteredRows[rowId]) {	×
216	sparkColumnVectorProxy.putNotNull(counter++,ordinal);	×
217	}
218	}	×
219
220	@Override public void putNotNull(int rowId, int count) {
221	if (filteredRowsExist) {	×
222	for (int i = 0; i < count; i++) {	×
223	if (!filteredRows[rowId]) {	×
224	sparkColumnVectorProxy.putNotNull(counter++, ordinal);	×
225	}
226	rowId++;	×
227	}
228	} else {
229	sparkColumnVectorProxy.putNotNulls(rowId, count, ordinal);	×
230	}
231	}	×
232
233	@Override public boolean isNull(int rowId) {
234	return sparkColumnVectorProxy.isNullAt(rowId,ordinal);	×
235	}
236
237	@Override public void putObject(int rowId, Object obj) {
238	//TODO handle complex types
239	}	×
240
241	@Override public Object getData(int rowId) {
242	//TODO handle complex types
243	return null;	×
244	}
245
246	@Override public void reset() {
247	counter = 0;	×
248	filteredRowsExist = false;	×
249	if (null != dictionaryVector) {	×
250	dictionaryVector.reset();	×
251	}
252	}	×
253
254	@Override public DataType getType() {
255	return CarbonSparkDataSourceUtil	×
256	.convertSparkToCarbonDataType(sparkColumnVectorProxy.dataType(ordinal));	×
257	}
258
259	@Override
260	public DataType getBlockDataType() {
261	return blockDataType;	×
262	}
263
264	@Override
265	public void setBlockDataType(DataType blockDataType) {
266	this.blockDataType = blockDataType;	×
267	}	×
268
269	@Override
270	public void setFilteredRowsExist(boolean filteredRowsExist) {
271	this.filteredRowsExist = filteredRowsExist;	×
272	}	×
273
274	@Override public void setDictionary(CarbonDictionary dictionary) {
275	sparkColumnVectorProxy.setDictionary(dictionary, ordinal);	×
276	}	×
277
278	@Override public boolean hasDictionary() {
279	return sparkColumnVectorProxy.hasDictionary(ordinal);	×
280	}
281
282	public void reserveDictionaryIds() {
283	sparkColumnVectorProxy.reserveDictionaryIds(carbonVectorProxy.numRows(), ordinal);	×
284	dictionaryVector = new ColumnarVectorWrapper(carbonVectorProxy, filteredRows, ordinal);	×
285	((ColumnarVectorWrapper) dictionaryVector).isDictionary = true;	×
286	}	×
287
288	@Override public CarbonColumnVector getDictionaryVector() {
289	return dictionaryVector;	×
290	}
291
292	@Override public void putFloats(int rowId, int count, float[] src, int srcIndex) {
293	for (int i = srcIndex; i < count; i++) {	×
294	if (!filteredRows[rowId]) {	×
295	sparkColumnVectorProxy.putFloat(counter++, src[i], ordinal);	×
296	}
297	rowId++;	×
298	}
299	}	×
300
301	@Override public void putShorts(int rowId, int count, short[] src, int srcIndex) {
302	for (int i = srcIndex; i < count; i++) {	×
303	if (!filteredRows[rowId]) {	×
304	sparkColumnVectorProxy.putShort(counter++, src[i], ordinal);	×
305	}
306	rowId++;	×
307	}
308	}	×
309
310	@Override public void putInts(int rowId, int count, int[] src, int srcIndex) {
311	for (int i = srcIndex; i < count; i++) {	×
312	if (!filteredRows[rowId]) {	×
313	sparkColumnVectorProxy.putInt(counter++, src[i], ordinal);	×
314	}
315	rowId++;	×
316	}
317	}	×
318
319	@Override public void putLongs(int rowId, int count, long[] src, int srcIndex) {
320	for (int i = srcIndex; i < count; i++) {	×
321	if (!filteredRows[rowId]) {	×
322	sparkColumnVectorProxy.putLong(counter++, src[i], ordinal);	×
323	}
324	rowId++;	×
325	}
326	}	×
327
328	@Override public void putDoubles(int rowId, int count, double[] src, int srcIndex) {
329	for (int i = srcIndex; i < count; i++) {	×
330	if (!filteredRows[rowId]) {	×
331	sparkColumnVectorProxy.putDouble(counter++, src[i], ordinal);	×
332	}
333	rowId++;	×
334	}
335	}	×
336
337	@Override public void putBytes(int rowId, int count, byte[] src, int srcIndex) {
338	for (int i = srcIndex; i < count; i++) {	×
339	if (!filteredRows[rowId]) {	×
340	sparkColumnVectorProxy.putByte(counter++, src[i], ordinal);	×
341	}
342	rowId++;	×
343	}
344	}	×
345
346	@Override public void setLazyPage(LazyPageLoad lazyPage) {
347	lazyPage.loadPage();	×
348	}	×
349	}

apache / carbondata / 9238

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