apache / carbondata / 871

Build # 871

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/0371d15e18dccdf7ded1d17aa6ab906b194f0bca">0371d15e1<a href="https://github.com/apache/carbondata/commit/0371d15e18dccdf7ded1d17aa6ab906b194f0bca">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/c9150519a3af2481343b747b2c8043d8495afbb6">c9150519a</a>">c9150519a</a><a href="https://github.com/apache/carbondata/commit/0371d15e18dccdf7ded1d17aa6ab906b194f0bca"> into 2081bc87a">2081bc87a</a>

Run Details

5 of 5 new or added lines in 1 file covered. (100.0%)

60488 of 75085 relevant lines covered (80.56%)

1.06 hits per line

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

81.25

/core/src/main/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImpl.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.reader.sortindex;

import java.io.IOException;
import java.util.List;

import org.apache.carbondata.common.logging.LogService;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.cache.dictionary.DictionaryColumnUniqueIdentifier;
import org.apache.carbondata.core.datastore.impl.FileFactory;
import org.apache.carbondata.core.reader.CarbonDictionaryColumnMetaChunk;
import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReader;
import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReaderImpl;
import org.apache.carbondata.core.reader.ThriftReader;
import org.apache.carbondata.format.ColumnSortInfo;

import org.apache.thrift.TBase;

/**
 * Implementation for reading the dictionary sort index and inverted sort index .
 */
public class CarbonDictionarySortIndexReaderImpl implements CarbonDictionarySortIndexReader {

  /**
   * column name
   */
  protected DictionaryColumnUniqueIdentifier dictionaryColumnUniqueIdentifier;

  /**
   * the path of the dictionary Sort Index file
   */
  protected String sortIndexFilePath;

  /**
   * Column sort info thrift instance.
   */
  ColumnSortInfo columnSortInfo = null;

  /**
   * Comment for <code>LOGGER</code>
   */
  private static final LogService LOGGER =
      LogServiceFactory.getLogService(CarbonDictionarySortIndexReaderImpl.class.getName());

  /**
   * dictionary sortIndex file Reader
   */
  private ThriftReader dictionarySortIndexThriftReader;

  /**
   * @param dictionaryColumnUniqueIdentifier column name
   */
  public CarbonDictionarySortIndexReaderImpl(
      final DictionaryColumnUniqueIdentifier dictionaryColumnUniqueIdentifier) {
    this.dictionaryColumnUniqueIdentifier = dictionaryColumnUniqueIdentifier;
  }

  /**
   * method for reading the carbon dictionary sort index data
   * from columns sortIndex file.
   *
   * @return The method return's the list of dictionary sort Index and sort Index reverse
   * In case of no member for column empty list will be return
   * @throws IOException In case any I/O error occurs
   */
  @Override public List<Integer> readSortIndex() throws IOException {
    if (null == columnSortInfo) {
      readColumnSortInfo();
    }
    return columnSortInfo.getSort_index();
  }

  /**
   * method for reading the carbon dictionary sort index data
   * from columns sortIndex file.
   * In case of no member empty list will be return
   *
   * @throws IOException In case any I/O error occurs
   */
  private void readColumnSortInfo() throws IOException {
    init();
    try {
      columnSortInfo = (ColumnSortInfo) dictionarySortIndexThriftReader.read();
    } catch (IOException ie) {
      LOGGER.error(ie, "problem while reading the column sort info.");
      throw new IOException("problem while reading the column sort info.", ie);
    } finally {
      if (null != dictionarySortIndexThriftReader) {
        dictionarySortIndexThriftReader.close();
      }
    }
  }

  /**
   * method for reading the carbon dictionary inverted sort index data
   * from columns sortIndex file.
   *
   * @return The method return's the list of dictionary inverted sort Index
   * @throws IOException In case any I/O error occurs
   */
  @Override public List<Integer> readInvertedSortIndex() throws IOException {
    if (null == columnSortInfo) {
      readColumnSortInfo();
    }
    return columnSortInfo.getSort_index_inverted();
  }

  /**
   * The method initializes the dictionary Sort Index file path
   * and initialize and opens the thrift reader for dictionary sortIndex file.
   *
   * @throws IOException if any I/O errors occurs
   */
  private void init() throws IOException {
    initPath();
    openThriftReader();
  }

  protected void initPath() {
    try {
      CarbonDictionaryColumnMetaChunk chunkMetaObjectForLastSegmentEntry =
          getChunkMetaObjectForLastSegmentEntry();
      long dictOffset = chunkMetaObjectForLastSegmentEntry.getEnd_offset();
      this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath(dictOffset);
      if (!FileFactory
          .isFileExist(this.sortIndexFilePath, FileFactory.getFileType(this.sortIndexFilePath))) {
        this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath();
      }
    } catch (IOException e) {
      this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath();
    }

  }

  /**
   * This method will read the dictionary chunk metadata thrift object for last entry
   *
   * @return last entry of dictionary meta chunk
   * @throws IOException if an I/O error occurs
   */
  private CarbonDictionaryColumnMetaChunk getChunkMetaObjectForLastSegmentEntry()
      throws IOException {
    CarbonDictionaryMetadataReader columnMetadataReaderImpl = getDictionaryMetadataReader();
    try {
      // read the last segment entry for dictionary metadata
      return columnMetadataReaderImpl.readLastEntryOfDictionaryMetaChunk();
    } finally {
      // Close metadata reader
      columnMetadataReaderImpl.close();
    }
  }

  /**
   * @return
   */
  protected CarbonDictionaryMetadataReader getDictionaryMetadataReader() {
    return new CarbonDictionaryMetadataReaderImpl(dictionaryColumnUniqueIdentifier);
  }

  /**
   * This method will open the dictionary sort index file stream for reading
   *
   * @throws IOException in case any I/O errors occurs
   */
  private void openThriftReader() throws IOException {
    this.dictionarySortIndexThriftReader =
        new ThriftReader(this.sortIndexFilePath, new ThriftReader.TBaseCreator() {
          @Override public TBase create() {
            return new ColumnSortInfo();
          }
        });
    dictionarySortIndexThriftReader.open();
  }

  /**
   * Closes this stream and releases any system resources associated
   * with it. If the stream is already closed then invoking this
   * method has no effect.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override public void close() throws IOException {
    if (null != dictionarySortIndexThriftReader) {
      dictionarySortIndexThriftReader.close();
    }
  }
}

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.reader.sortindex;
18
19	import java.io.IOException;
20	import java.util.List;
21
22	import org.apache.carbondata.common.logging.LogService;
23	import org.apache.carbondata.common.logging.LogServiceFactory;
24	import org.apache.carbondata.core.cache.dictionary.DictionaryColumnUniqueIdentifier;
25	import org.apache.carbondata.core.datastore.impl.FileFactory;
26	import org.apache.carbondata.core.reader.CarbonDictionaryColumnMetaChunk;
27	import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReader;
28	import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReaderImpl;
29	import org.apache.carbondata.core.reader.ThriftReader;
30	import org.apache.carbondata.format.ColumnSortInfo;
31
32	import org.apache.thrift.TBase;
33
34	/**
35	* Implementation for reading the dictionary sort index and inverted sort index .
36	*/
37	public class CarbonDictionarySortIndexReaderImpl implements CarbonDictionarySortIndexReader {
38
39	/**
40	* column name
41	*/
42	protected DictionaryColumnUniqueIdentifier dictionaryColumnUniqueIdentifier;
43
44	/**
45	* the path of the dictionary Sort Index file
46	*/
47	protected String sortIndexFilePath;
48
49	/**
50	* Column sort info thrift instance.
51	*/
52	ColumnSortInfo columnSortInfo = null;	2✔
53
54	/**
55	* Comment for <code>LOGGER</code>
56	*/
57	private static final LogService LOGGER =	2✔
58	LogServiceFactory.getLogService(CarbonDictionarySortIndexReaderImpl.class.getName());	2✔
59
60	/**
61	* dictionary sortIndex file Reader
62	*/
63	private ThriftReader dictionarySortIndexThriftReader;
64
65	/**
66	* @param dictionaryColumnUniqueIdentifier column name
67	*/
68	public CarbonDictionarySortIndexReaderImpl(
69	final DictionaryColumnUniqueIdentifier dictionaryColumnUniqueIdentifier) {	2✔
70	this.dictionaryColumnUniqueIdentifier = dictionaryColumnUniqueIdentifier;	2✔
71	}	2✔
72
73	/**
74	* method for reading the carbon dictionary sort index data
75	* from columns sortIndex file.
76	*
77	* @return The method return's the list of dictionary sort Index and sort Index reverse
78	* In case of no member for column empty list will be return
79	* @throws IOException In case any I/O error occurs
80	*/
81	@Override public List<Integer> readSortIndex() throws IOException {
82	if (null == columnSortInfo) {	2✔
83	readColumnSortInfo();	2✔
84	}
85	return columnSortInfo.getSort_index();	2✔
86	}
87
88	/**
89	* method for reading the carbon dictionary sort index data
90	* from columns sortIndex file.
91	* In case of no member empty list will be return
92	*
93	* @throws IOException In case any I/O error occurs
94	*/
95	private void readColumnSortInfo() throws IOException {
96	init();	2✔
97	try {
98	columnSortInfo = (ColumnSortInfo) dictionarySortIndexThriftReader.read();	2✔
99	} catch (IOException ie) {	×
100	LOGGER.error(ie, "problem while reading the column sort info.");	×
101	throw new IOException("problem while reading the column sort info.", ie);	×
102	} finally {
103	if (null != dictionarySortIndexThriftReader) {	2✔
104	dictionarySortIndexThriftReader.close();	2✔
105	}
106	}	×
107	}	2✔
108
109	/**
110	* method for reading the carbon dictionary inverted sort index data
111	* from columns sortIndex file.
112	*
113	* @return The method return's the list of dictionary inverted sort Index
114	* @throws IOException In case any I/O error occurs
115	*/
116	@Override public List<Integer> readInvertedSortIndex() throws IOException {
117	if (null == columnSortInfo) {	2✔
118	readColumnSortInfo();	×
119	}
120	return columnSortInfo.getSort_index_inverted();	2✔
121	}
122
123	/**
124	* The method initializes the dictionary Sort Index file path
125	* and initialize and opens the thrift reader for dictionary sortIndex file.
126	*
127	* @throws IOException if any I/O errors occurs
128	*/
129	private void init() throws IOException {
130	initPath();	2✔
131	openThriftReader();	2✔
132	}	2✔
133
134	protected void initPath() {
135	try {
136	CarbonDictionaryColumnMetaChunk chunkMetaObjectForLastSegmentEntry =	2✔
137	getChunkMetaObjectForLastSegmentEntry();	2✔
138	long dictOffset = chunkMetaObjectForLastSegmentEntry.getEnd_offset();	2✔
139	this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath(dictOffset);	2✔
140	if (!FileFactory	2✔
141	.isFileExist(this.sortIndexFilePath, FileFactory.getFileType(this.sortIndexFilePath))) {	2✔
142	this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath();	×
143	}
144	} catch (IOException e) {	×
145	this.sortIndexFilePath = dictionaryColumnUniqueIdentifier.getSortIndexFilePath();	×
146	}	2✔
147
148	}	2✔
149
150	/**
151	* This method will read the dictionary chunk metadata thrift object for last entry
152	*
153	* @return last entry of dictionary meta chunk
154	* @throws IOException if an I/O error occurs
155	*/
156	private CarbonDictionaryColumnMetaChunk getChunkMetaObjectForLastSegmentEntry()
157	throws IOException {
158	CarbonDictionaryMetadataReader columnMetadataReaderImpl = getDictionaryMetadataReader();	2✔
159	try {
160	// read the last segment entry for dictionary metadata
161	return columnMetadataReaderImpl.readLastEntryOfDictionaryMetaChunk();	2✔
162	} finally {
163	// Close metadata reader
164	columnMetadataReaderImpl.close();	2✔
165	}	×
166	}
167
168	/**
169	* @return
170	*/
171	protected CarbonDictionaryMetadataReader getDictionaryMetadataReader() {
172	return new CarbonDictionaryMetadataReaderImpl(dictionaryColumnUniqueIdentifier);	2✔
173	}
174
175	/**
176	* This method will open the dictionary sort index file stream for reading
177	*
178	* @throws IOException in case any I/O errors occurs
179	*/
180	private void openThriftReader() throws IOException {
181	this.dictionarySortIndexThriftReader =	2✔
182	new ThriftReader(this.sortIndexFilePath, new ThriftReader.TBaseCreator() {	2✔
183	@Override public TBase create() {
184	return new ColumnSortInfo();	2✔
185	}
186	});
187	dictionarySortIndexThriftReader.open();	2✔
188	}	2✔
189
190	/**
191	* Closes this stream and releases any system resources associated
192	* with it. If the stream is already closed then invoking this
193	* method has no effect.
194	*
195	* @throws IOException if an I/O error occurs
196	*/
197	@Override public void close() throws IOException {
198	if (null != dictionarySortIndexThriftReader) {	2✔
199	dictionarySortIndexThriftReader.close();	2✔
200	}
201	}	2✔
202	}

apache / carbondata / 871

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