content: /*
   * 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.index.dev;
  
  import java.io.IOException;
  import java.util.List;
  
  import org.apache.carbondata.common.annotations.InterfaceAudience;
  import org.apache.carbondata.common.annotations.InterfaceStability;
  import org.apache.carbondata.core.datastore.impl.FileFactory;
  import org.apache.carbondata.core.datastore.page.ColumnPage;
  import org.apache.carbondata.core.index.Segment;
  import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
  import org.apache.carbondata.core.util.CarbonUtil;
  import org.apache.carbondata.core.util.path.CarbonTablePath;
  
  /**
   * Writer interface for index.
   * Developer should implement this interface to write index files.
   * Writer will be called for every new block/blocklet/page is created when data load is executing.
   */
  @InterfaceAudience.Developer("Index")
  @InterfaceStability.Evolving
  public abstract class IndexWriter {
  
    protected String tablePath;
  
    protected String segmentId;
  
    protected String indexPath;
  
    protected List<CarbonColumn> indexColumns;
  
    private boolean isWritingFinished;
  
    public IndexWriter(String tablePath, String indexName, List<CarbonColumn> indexColumns,
        Segment segment, String shardName) {
      this.tablePath = tablePath;
      this.segmentId = segment.getSegmentNo();
      this.indexPath = CarbonTablePath.getIndexStorePathOnShardName(
          tablePath, segmentId, indexName, shardName);
      this.indexColumns = indexColumns;
    }
  
    protected final List<CarbonColumn> getIndexColumns() {
      return indexColumns;
    }
  
    /**
     * Start of new block notification.
     *
     * @param blockId file name of the carbondata file
     */
    public abstract void onBlockStart(String blockId) throws IOException;
  
    /**
     * End of block notification
     */
    public abstract void onBlockEnd(String blockId) throws IOException;
  
    /**
     * Start of new blocklet notification.
     *
     * @param blockletId sequence number of blocklet in the block
     */
    public abstract void onBlockletStart(int blockletId) throws IOException;
  
    /**
     * End of blocklet notification
     *
     * @param blockletId sequence number of blocklet in the block
     */
    public abstract void onBlockletEnd(int blockletId) throws IOException;
  
    /**
     * Add columnar page data to the index, order of field is same as `indexColumns` in
     * IndexMeta returned in IndexFactory.
     * Implementation should copy the content of it as needed, because its memory
     * may be freed after this method returns, in case of unsafe memory
     */
    public abstract void onPageAdded(int blockletId, int pageId, int pageSize, ColumnPage[] pages)
        throws IOException;
  
    /**
     * This is called during closing of writer.So after this call no more data will be sent to this
     * class.
     */
    public abstract void finish() throws IOException;
  
    /**
     * It commits the index file by copying the file from temp folder to actual folder
     *
     * @param indexFile file path of index file
     * @throws IOException if IO fails
     */
    protected void commitFile(String indexFile) throws IOException {
      if (!indexFile.startsWith(indexPath)) {
        throw new UnsupportedOperationException(
            "index file " + indexFile + " is not written in provided directory path "
                + indexPath);
      }
      String indexFileName = indexFile.substring(indexPath.length());
      String carbonFilePath = indexFileName.substring(0, indexFileName.lastIndexOf("/"));
      String segmentPath = CarbonTablePath.getSegmentPath(tablePath, segmentId);
      if (carbonFilePath.length() > 0) {
        carbonFilePath = segmentPath + carbonFilePath;
        FileFactory.mkdirs(carbonFilePath);
      } else {
        carbonFilePath = segmentPath;
      }
      CarbonUtil.copyCarbonDataFileToCarbonStorePath(indexFile, carbonFilePath, 0);
    }
  
    /**
     * Return store path for index
     */
    public static String getDefaultIndexPath(
        String tablePath, String segmentId, String indexName) {
      return CarbonTablePath.getIndexesStorePath(tablePath, segmentId, indexName);
    }
  
    public boolean isWritingFinished() {
      return isWritingFinished;
    }
  
    public void setWritingFinished(boolean writingFinished) {
      isWritingFinished = writingFinished;
    }
  }
  