apache / carbondata / 684

Build # 684

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/161d93afe7da296cb007aacea9e9dece72041d34">161d93afe<a href="https://github.com/apache/carbondata/commit/161d93afe7da296cb007aacea9e9dece72041d34">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/dc5e93252ec85fde6acc5d00992f41cdf030452a">dc5e93252</a>">dc5e93252</a><a href="https://github.com/apache/carbondata/commit/161d93afe7da296cb007aacea9e9dece72041d34"> into f2398948c">f2398948c</a>

Run Details

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

59911 of 74356 relevant lines covered (80.57%)

1.07 hits per line

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

99.04

/core/src/main/java/org/apache/carbondata/core/datastore/page/encoding/ColumnPageEncoder.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.encoding;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

import org.apache.carbondata.common.logging.LogService;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.datastore.ColumnType;
import org.apache.carbondata.core.datastore.TableSpec;
import org.apache.carbondata.core.datastore.compression.Compressor;
import org.apache.carbondata.core.datastore.compression.CompressorFactory;
import org.apache.carbondata.core.datastore.page.ColumnPage;
import org.apache.carbondata.core.datastore.page.ComplexColumnPage;
import org.apache.carbondata.core.datastore.page.encoding.compress.DirectCompressCodec;
import org.apache.carbondata.core.memory.MemoryException;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.util.CarbonMetadataUtil;
import org.apache.carbondata.core.util.CarbonUtil;
import org.apache.carbondata.core.util.DataTypeUtil;
import org.apache.carbondata.format.BlockletMinMaxIndex;
import org.apache.carbondata.format.DataChunk2;
import org.apache.carbondata.format.Encoding;
import org.apache.carbondata.format.LocalDictionaryChunk;
import org.apache.carbondata.format.LocalDictionaryChunkMeta;
import org.apache.carbondata.format.PresenceMeta;

import static org.apache.carbondata.core.datastore.page.encoding.DefaultEncodingFactory.selectCodecByAlgorithmForFloating;
import static org.apache.carbondata.core.datastore.page.encoding.DefaultEncodingFactory.selectCodecByAlgorithmForIntegral;

public abstract class ColumnPageEncoder {

  /**
   * logger
   */
  private static final LogService LOGGER =
      LogServiceFactory.getLogService(ColumnPageEncoder.class.getName());

  protected abstract byte[] encodeData(ColumnPage input) throws MemoryException, IOException;

  protected abstract List<Encoding> getEncodingList();

  protected abstract ColumnPageEncoderMeta getEncoderMeta(ColumnPage inputPage);

  /**
   * Get the target data type of the page if encoded
   *
   * @param inputPage
   * @return
   */
  public DataType getTargetDataType(ColumnPage inputPage) {
    ColumnPageEncoderMeta encoderMeta = getEncoderMeta(inputPage);
    if (null != encoderMeta) {
      return encoderMeta.getStoreDataType();
    } else {
      return null;
    }
  }

  public Encoding getTypeOfEncoding() {
    if (CarbonUtil.isEncodedWithMeta(getEncodingList())) {
      return getEncodingList().get(0);
    }
    return null;
  }

  /**
   * Return a encoded column page by encoding the input page
   * The encoded binary data and metadata are wrapped in encoding column page
   */
  public EncodedColumnPage encode(ColumnPage inputPage) throws IOException, MemoryException {
    byte[] encodedBytes = encodeData(inputPage);
    DataChunk2 pageMetadata = buildPageMetadata(inputPage, encodedBytes);
    return new EncodedColumnPage(pageMetadata, encodedBytes, inputPage);
  }

  private DataChunk2 buildPageMetadata(ColumnPage inputPage, byte[] encodedBytes)
      throws IOException {
    DataChunk2 dataChunk = new DataChunk2();
    dataChunk.setData_page_length(encodedBytes.length);
    fillBasicFields(inputPage, dataChunk);
    fillNullBitSet(inputPage, dataChunk);
    fillEncoding(inputPage, dataChunk);
    fillMinMaxIndex(inputPage, dataChunk);
    fillLegacyFields(dataChunk);
    return dataChunk;
  }

  private void fillBasicFields(ColumnPage inputPage, DataChunk2 dataChunk) {
    dataChunk.setChunk_meta(
        CarbonMetadataUtil.getChunkCompressorMeta(inputPage.getColumnCompressorName()));
    dataChunk.setNumberOfRowsInpage(inputPage.getPageSize());
    dataChunk.setRowMajor(false);
  }

  private void fillNullBitSet(ColumnPage inputPage, DataChunk2 dataChunk) {
    PresenceMeta presenceMeta = new PresenceMeta();
    presenceMeta.setPresent_bit_streamIsSet(true);
    Compressor compressor = CompressorFactory.getInstance().getCompressor(
        inputPage.getColumnCompressorName());
    presenceMeta.setPresent_bit_stream(
        compressor.compressByte(inputPage.getNullBits().toByteArray()));
    dataChunk.setPresence(presenceMeta);
  }

  private void fillEncoding(ColumnPage inputPage, DataChunk2 dataChunk) throws IOException {
    dataChunk.setEncoders(getEncodingList());
    dataChunk.setEncoder_meta(buildEncoderMeta(inputPage));
  }

  private List<ByteBuffer> buildEncoderMeta(ColumnPage inputPage) throws IOException {
    ColumnPageEncoderMeta meta = getEncoderMeta(inputPage);
    List<ByteBuffer> metaDatas = new ArrayList<>();
    if (meta != null) {
      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      DataOutputStream out = new DataOutputStream(stream);
      meta.write(out);
      metaDatas.add(ByteBuffer.wrap(stream.toByteArray()));
    }
    return metaDatas;
  }

  private void fillMinMaxIndex(ColumnPage inputPage, DataChunk2 dataChunk) {
    dataChunk.setMin_max(buildMinMaxIndex(inputPage, dataChunk.encoders));
  }

  private BlockletMinMaxIndex buildMinMaxIndex(ColumnPage inputPage, List<Encoding> encoders) {
    BlockletMinMaxIndex index = new BlockletMinMaxIndex();
    ByteBuffer max;
    ByteBuffer min;
    if (CarbonUtil.isEncodedWithMeta(encoders)
        && inputPage.getColumnSpec().getColumnType() == ColumnType.PLAIN_VALUE) {
      max = ByteBuffer.wrap(DataTypeUtil
          .getMinMaxBytesBasedOnDataTypeForNoDictionaryColumn(inputPage.getStatistics().getMax(),
              inputPage.getDataType()));
      min = ByteBuffer.wrap(DataTypeUtil
          .getMinMaxBytesBasedOnDataTypeForNoDictionaryColumn(inputPage.getStatistics().getMin(),
              inputPage.getDataType()));
    } else {
      byte[] bytes =
          CarbonUtil.getValueAsBytes(inputPage.getDataType(), inputPage.getStatistics().getMax());
      max = ByteBuffer.wrap(bytes);
      min = ByteBuffer.wrap(
          CarbonUtil.getValueAsBytes(inputPage.getDataType(), inputPage.getStatistics().getMin()));
    }
    index.addToMax_values(max);
    index.addToMin_values(min);
    index.addToMin_max_presence(inputPage.getStatistics().writeMinMax());
    return index;
  }

  /**
   * `buildPageMetadata` will call this for backward compatibility
   */
  protected void fillLegacyFields(DataChunk2 dataChunk)
      throws IOException {
    // Subclass should override this to update datachunk2 if any backward compatibility if required,
    // For example, when using IndexStorageCodec, rle_page_length and rowid_page_length need to be
    // updated
  }

  /**
   * Apply encoding algorithm for complex column page and return the coded data
   * TODO: remove this interface after complex column page is unified with column page
   */
  public static EncodedColumnPage[] encodeComplexColumn(ComplexColumnPage input)
      throws IOException, MemoryException {
    EncodedColumnPage[] encodedPages = new EncodedColumnPage[input.getComplexColumnIndex()];
    int index = 0;
    while (index < input.getComplexColumnIndex()) {
      ColumnPage subColumnPage = input.getColumnPage(index);
      encodedPages[index] = encodedColumn(subColumnPage);
      index++;
    }
    return encodedPages;
  }

  public static EncodedColumnPage encodedColumn(ColumnPage page)
      throws IOException, MemoryException {
    ColumnPageEncoder pageEncoder = createCodecForDimension(page);
    if (pageEncoder == null) {
      ColumnPageEncoder encoder = new DirectCompressCodec(DataTypes.BYTE_ARRAY).createEncoder(null);
      return encoder.encode(page);
    } else {
      LOGGER.debug("Encoder result ---> Source data type: " + pageEncoder.getEncoderMeta(page)
          .getColumnSpec().getSchemaDataType() + " Destination data type: " + pageEncoder
          .getEncoderMeta(page).getStoreDataType() + " for the column: " + pageEncoder
          .getEncoderMeta(page).getColumnSpec().getFieldName());

      return pageEncoder.encode(page);
    }
  }

  private static ColumnPageEncoder createCodecForDimension(ColumnPage inputPage) {
    TableSpec.ColumnSpec columnSpec = inputPage.getColumnSpec();
    if (columnSpec.getColumnType() == ColumnType.COMPLEX_PRIMITIVE) {
      if (inputPage.getDataType() == DataTypes.BYTE_ARRAY
          || inputPage.getDataType() == DataTypes.STRING) {
        // use legacy encoder
        return null;
      } else if ((inputPage.getDataType() == DataTypes.BYTE) || (inputPage.getDataType()
          == DataTypes.SHORT) || (inputPage.getDataType() == DataTypes.INT) || (
          inputPage.getDataType() == DataTypes.LONG)) {
        return selectCodecByAlgorithmForIntegral(inputPage.getStatistics(), true, columnSpec)
            .createEncoder(null);
      } else if ((inputPage.getDataType() == DataTypes.FLOAT) || (inputPage.getDataType()
          == DataTypes.DOUBLE)) {
        return selectCodecByAlgorithmForFloating(inputPage.getStatistics(), true, columnSpec)
            .createEncoder(null);
      }
    }
    // use legacy encoder
    return null;
  }


  /**
   * Below method to encode the dictionary page
   * @param dictionaryPage
   * dictionary column page
   * @return local dictionary chunk
   * @throws IOException
   * Problem in encoding
   * @throws MemoryException
   * problem in encoding
   */
  public LocalDictionaryChunk encodeDictionary(ColumnPage dictionaryPage)
      throws IOException, MemoryException {
    LocalDictionaryChunk localDictionaryChunk = new LocalDictionaryChunk();
    localDictionaryChunk.setDictionary_data(encodeData(dictionaryPage));
    LocalDictionaryChunkMeta localDictionaryChunkMeta = new LocalDictionaryChunkMeta();
    localDictionaryChunkMeta.setEncoders(getEncodingList());
    localDictionaryChunkMeta.setEncoder_meta(buildEncoderMeta(dictionaryPage));
    localDictionaryChunk.setDictionary_meta(localDictionaryChunkMeta);
    return localDictionaryChunk;
  }

}

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.encoding;
19
20	import java.io.ByteArrayOutputStream;
21	import java.io.DataOutputStream;
22	import java.io.IOException;
23	import java.nio.ByteBuffer;
24	import java.util.ArrayList;
25	import java.util.List;
26
27	import org.apache.carbondata.common.logging.LogService;
28	import org.apache.carbondata.common.logging.LogServiceFactory;
29	import org.apache.carbondata.core.datastore.ColumnType;
30	import org.apache.carbondata.core.datastore.TableSpec;
31	import org.apache.carbondata.core.datastore.compression.Compressor;
32	import org.apache.carbondata.core.datastore.compression.CompressorFactory;
33	import org.apache.carbondata.core.datastore.page.ColumnPage;
34	import org.apache.carbondata.core.datastore.page.ComplexColumnPage;
35	import org.apache.carbondata.core.datastore.page.encoding.compress.DirectCompressCodec;
36	import org.apache.carbondata.core.memory.MemoryException;
37	import org.apache.carbondata.core.metadata.datatype.DataType;
38	import org.apache.carbondata.core.metadata.datatype.DataTypes;
39	import org.apache.carbondata.core.util.CarbonMetadataUtil;
40	import org.apache.carbondata.core.util.CarbonUtil;
41	import org.apache.carbondata.core.util.DataTypeUtil;
42	import org.apache.carbondata.format.BlockletMinMaxIndex;
43	import org.apache.carbondata.format.DataChunk2;
44	import org.apache.carbondata.format.Encoding;
45	import org.apache.carbondata.format.LocalDictionaryChunk;
46	import org.apache.carbondata.format.LocalDictionaryChunkMeta;
47	import org.apache.carbondata.format.PresenceMeta;
48
49	import static org.apache.carbondata.core.datastore.page.encoding.DefaultEncodingFactory.selectCodecByAlgorithmForFloating;
50	import static org.apache.carbondata.core.datastore.page.encoding.DefaultEncodingFactory.selectCodecByAlgorithmForIntegral;
51
52	public abstract class ColumnPageEncoder {	2✔
53
54	/**
55	* logger
56	*/
57	private static final LogService LOGGER =	2✔
58	LogServiceFactory.getLogService(ColumnPageEncoder.class.getName());	2✔
59
60	protected abstract byte[] encodeData(ColumnPage input) throws MemoryException, IOException;
61
62	protected abstract List<Encoding> getEncodingList();
63
64	protected abstract ColumnPageEncoderMeta getEncoderMeta(ColumnPage inputPage);
65
66	/**
67	* Get the target data type of the page if encoded
68	*
69	* @param inputPage
70	* @return
71	*/
72	public DataType getTargetDataType(ColumnPage inputPage) {
73	ColumnPageEncoderMeta encoderMeta = getEncoderMeta(inputPage);	1✔
74	if (null != encoderMeta) {	1✔
75	return encoderMeta.getStoreDataType();	1✔
76	} else {
77	return null;	1✔
78	}
79	}
80
81	public Encoding getTypeOfEncoding() {
82	if (CarbonUtil.isEncodedWithMeta(getEncodingList())) {	1✔
83	return getEncodingList().get(0);	1✔
84	}
85	return null;	×
86	}
87
88	/**
89	* Return a encoded column page by encoding the input page
90	* The encoded binary data and metadata are wrapped in encoding column page
91	*/
92	public EncodedColumnPage encode(ColumnPage inputPage) throws IOException, MemoryException {
93	byte[] encodedBytes = encodeData(inputPage);	2✔
94	DataChunk2 pageMetadata = buildPageMetadata(inputPage, encodedBytes);	2✔
95	return new EncodedColumnPage(pageMetadata, encodedBytes, inputPage);	2✔
96	}
97
98	private DataChunk2 buildPageMetadata(ColumnPage inputPage, byte[] encodedBytes)
99	throws IOException {
100	DataChunk2 dataChunk = new DataChunk2();	2✔
101	dataChunk.setData_page_length(encodedBytes.length);	2✔
102	fillBasicFields(inputPage, dataChunk);	2✔
103	fillNullBitSet(inputPage, dataChunk);	2✔
104	fillEncoding(inputPage, dataChunk);	2✔
105	fillMinMaxIndex(inputPage, dataChunk);	2✔
106	fillLegacyFields(dataChunk);	2✔
107	return dataChunk;	2✔
108	}
109
110	private void fillBasicFields(ColumnPage inputPage, DataChunk2 dataChunk) {
111	dataChunk.setChunk_meta(	2✔
112	CarbonMetadataUtil.getChunkCompressorMeta(inputPage.getColumnCompressorName()));	2✔
113	dataChunk.setNumberOfRowsInpage(inputPage.getPageSize());	2✔
114	dataChunk.setRowMajor(false);	2✔
115	}	2✔
116
117	private void fillNullBitSet(ColumnPage inputPage, DataChunk2 dataChunk) {
118	PresenceMeta presenceMeta = new PresenceMeta();	2✔
119	presenceMeta.setPresent_bit_streamIsSet(true);	2✔
120	Compressor compressor = CompressorFactory.getInstance().getCompressor(	2✔
121	inputPage.getColumnCompressorName());	2✔
122	presenceMeta.setPresent_bit_stream(	2✔
123	compressor.compressByte(inputPage.getNullBits().toByteArray()));	2✔
124	dataChunk.setPresence(presenceMeta);	2✔
125	}	2✔
126
127	private void fillEncoding(ColumnPage inputPage, DataChunk2 dataChunk) throws IOException {
128	dataChunk.setEncoders(getEncodingList());	2✔
129	dataChunk.setEncoder_meta(buildEncoderMeta(inputPage));	2✔
130	}	2✔
131
132	private List<ByteBuffer> buildEncoderMeta(ColumnPage inputPage) throws IOException {
133	ColumnPageEncoderMeta meta = getEncoderMeta(inputPage);	2✔
134	List<ByteBuffer> metaDatas = new ArrayList<>();	2✔
135	if (meta != null) {	2✔
136	ByteArrayOutputStream stream = new ByteArrayOutputStream();	2✔
137	DataOutputStream out = new DataOutputStream(stream);	2✔
138	meta.write(out);	2✔
139	metaDatas.add(ByteBuffer.wrap(stream.toByteArray()));	2✔
140	}
141	return metaDatas;	2✔
142	}
143
144	private void fillMinMaxIndex(ColumnPage inputPage, DataChunk2 dataChunk) {
145	dataChunk.setMin_max(buildMinMaxIndex(inputPage, dataChunk.encoders));	2✔
146	}	2✔
147
148	private BlockletMinMaxIndex buildMinMaxIndex(ColumnPage inputPage, List<Encoding> encoders) {
149	BlockletMinMaxIndex index = new BlockletMinMaxIndex();	2✔
150	ByteBuffer max;
151	ByteBuffer min;
152	if (CarbonUtil.isEncodedWithMeta(encoders)	2✔
153	&& inputPage.getColumnSpec().getColumnType() == ColumnType.PLAIN_VALUE) {	1✔
154	max = ByteBuffer.wrap(DataTypeUtil	1✔
155	.getMinMaxBytesBasedOnDataTypeForNoDictionaryColumn(inputPage.getStatistics().getMax(),	1✔
156	inputPage.getDataType()));	1✔
157	min = ByteBuffer.wrap(DataTypeUtil	1✔
158	.getMinMaxBytesBasedOnDataTypeForNoDictionaryColumn(inputPage.getStatistics().getMin(),	1✔
159	inputPage.getDataType()));	1✔
160	} else {
161	byte[] bytes =	2✔
162	CarbonUtil.getValueAsBytes(inputPage.getDataType(), inputPage.getStatistics().getMax());	2✔
163	max = ByteBuffer.wrap(bytes);	2✔
164	min = ByteBuffer.wrap(	2✔
165	CarbonUtil.getValueAsBytes(inputPage.getDataType(), inputPage.getStatistics().getMin()));	2✔
166	}
167	index.addToMax_values(max);	2✔
168	index.addToMin_values(min);	2✔
169	index.addToMin_max_presence(inputPage.getStatistics().writeMinMax());	2✔
170	return index;	2✔
171	}
172
173	/**
174	* `buildPageMetadata` will call this for backward compatibility
175	*/
176	protected void fillLegacyFields(DataChunk2 dataChunk)
177	throws IOException {
178	// Subclass should override this to update datachunk2 if any backward compatibility if required,
179	// For example, when using IndexStorageCodec, rle_page_length and rowid_page_length need to be
180	// updated
181	}	2✔
182
183	/**
184	* Apply encoding algorithm for complex column page and return the coded data
185	* TODO: remove this interface after complex column page is unified with column page
186	*/
187	public static EncodedColumnPage[] encodeComplexColumn(ComplexColumnPage input)
188	throws IOException, MemoryException {
189	EncodedColumnPage[] encodedPages = new EncodedColumnPage[input.getComplexColumnIndex()];	1✔
190	int index = 0;	1✔
191	while (index < input.getComplexColumnIndex()) {	1✔
192	ColumnPage subColumnPage = input.getColumnPage(index);	1✔
193	encodedPages[index] = encodedColumn(subColumnPage);	1✔
194	index++;	1✔
195	}	1✔
196	return encodedPages;	1✔
197	}
198
199	public static EncodedColumnPage encodedColumn(ColumnPage page)
200	throws IOException, MemoryException {
201	ColumnPageEncoder pageEncoder = createCodecForDimension(page);	1✔
202	if (pageEncoder == null) {	1✔
203	ColumnPageEncoder encoder = new DirectCompressCodec(DataTypes.BYTE_ARRAY).createEncoder(null);	1✔
204	return encoder.encode(page);	1✔
205	} else {
206	LOGGER.debug("Encoder result ---> Source data type: " + pageEncoder.getEncoderMeta(page)	1✔
207	.getColumnSpec().getSchemaDataType() + " Destination data type: " + pageEncoder	1✔
208	.getEncoderMeta(page).getStoreDataType() + " for the column: " + pageEncoder	1✔
209	.getEncoderMeta(page).getColumnSpec().getFieldName());	1✔
210
211	return pageEncoder.encode(page);	1✔
212	}
213	}
214
215	private static ColumnPageEncoder createCodecForDimension(ColumnPage inputPage) {
216	TableSpec.ColumnSpec columnSpec = inputPage.getColumnSpec();	1✔
217	if (columnSpec.getColumnType() == ColumnType.COMPLEX_PRIMITIVE) {	1✔
218	if (inputPage.getDataType() == DataTypes.BYTE_ARRAY	1✔
219	\|\| inputPage.getDataType() == DataTypes.STRING) {	1✔
220	// use legacy encoder
221	return null;	1✔
222	} else if ((inputPage.getDataType() == DataTypes.BYTE) \|\| (inputPage.getDataType()	1✔
223	== DataTypes.SHORT) \|\| (inputPage.getDataType() == DataTypes.INT) \|\| (	1✔
224	inputPage.getDataType() == DataTypes.LONG)) {	1✔
225	return selectCodecByAlgorithmForIntegral(inputPage.getStatistics(), true, columnSpec)	1✔
226	.createEncoder(null);	1✔
227	} else if ((inputPage.getDataType() == DataTypes.FLOAT) \|\| (inputPage.getDataType()	1✔
228	== DataTypes.DOUBLE)) {
229	return selectCodecByAlgorithmForFloating(inputPage.getStatistics(), true, columnSpec)	1✔
230	.createEncoder(null);	1✔
231	}
232	}
233	// use legacy encoder
234	return null;	1✔
235	}
236
237
238	/**
239	* Below method to encode the dictionary page
240	* @param dictionaryPage
241	* dictionary column page
242	* @return local dictionary chunk
243	* @throws IOException
244	* Problem in encoding
245	* @throws MemoryException
246	* problem in encoding
247	*/
248	public LocalDictionaryChunk encodeDictionary(ColumnPage dictionaryPage)
249	throws IOException, MemoryException {
250	LocalDictionaryChunk localDictionaryChunk = new LocalDictionaryChunk();	2✔
251	localDictionaryChunk.setDictionary_data(encodeData(dictionaryPage));	2✔
252	LocalDictionaryChunkMeta localDictionaryChunkMeta = new LocalDictionaryChunkMeta();	2✔
253	localDictionaryChunkMeta.setEncoders(getEncodingList());	2✔
254	localDictionaryChunkMeta.setEncoder_meta(buildEncoderMeta(dictionaryPage));	2✔
255	localDictionaryChunk.setDictionary_meta(localDictionaryChunkMeta);	2✔
256	return localDictionaryChunk;	2✔
257	}
258
259	}

apache / carbondata / 684

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