�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Fwriteengine%2F'>writeengine</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Fwriteengine%2Fwrapper%2F'>wrapper</a>/</p><hr><h3>✏️ Editing: writeengine.h</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

//  $Id: writeengine.h 4726 2013-08-07 03:38:36Z bwilkinson $

/** @file */

#pragma once
#include &lt;stdio.h&gt;
#include &lt;string&gt;

// the header file for fd
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;fcntl.h&gt;
// end
#include &lt;boost/lexical_cast.hpp&gt;
#include &lt;tr1/unordered_set&gt;

#include &quot;we_brm.h&quot;
#include &quot;we_colop.h&quot;
#include &quot;we_index.h&quot;
#include &quot;we_tablemetadata.h&quot;
#include &quot;we_dbrootextenttracker.h&quot;
#include &quot;we_rbmetawriter.h&quot;
#include &quot;brmtypes.h&quot;
#include &quot;we_chunkmanager.h&quot;

#define IO_BUFF_SIZE 81920

#define EXPORT
/** Namespace WriteEngine */
namespace WriteEngine
{
//... Total compression operation: un_compresssed, compressed
const int UN_COMPRESSED_OP = 0;
const int COMPRESSED_OP_1 = 1;
const int COMPRESSED_OP_2 = 2;
const int TOTAL_COMPRESS_OP = 3;

//...Forward class declarations
class Log;

// Bug4312. During transactions, we need to mark each extent modified as invalid.
// In order to prevent thrashing, marking the same extent everytime we get an lbid
// for an extent, we remember the starting lbid for each extent marked for the
// transaction. We also add a sequence number so we can age them out of the list
// for truly long running transactions.
struct TxnLBIDRec
{
  std::tr1::unordered_set&lt;BRM::LBID_t&gt; m_LBIDSet;
  std::vector&lt;BRM::LBID_t&gt; m_LBIDs;
  std::vector&lt;execplan::CalpontSystemCatalog::ColDataType&gt; m_ColDataTypes;

  TxnLBIDRec(){};
  ~TxnLBIDRec()
  {
  }
  void AddLBID(BRM::LBID_t lbid, const execplan::CalpontSystemCatalog::ColDataType&amp; colDataType)
  {
    if (m_LBIDSet.insert(lbid).second)
    {
      m_LBIDs.push_back(lbid);
      m_ColDataTypes.push_back(colDataType);
    }
  }
};

typedef boost::shared_ptr&lt;TxnLBIDRec&gt; SP_TxnLBIDRec_t;
typedef std::set&lt;BRM::LBID_t&gt; dictLBIDRec_t;

/** @brief Range information for 1 or 2 extents changed by DML operation. */
struct ColSplitMaxMinInfo
{
  ExtCPInfo fSplitMaxMinInfo[2];      /** @brief internal to write engine: min/max ranges for data in one and,
                                         possible, second extent. */
  ExtCPInfo* fSplitMaxMinInfoPtrs[2]; /** @brief pointers to CPInfos in fSplitMaxMinInfo above */
  ColSplitMaxMinInfo(execplan::CalpontSystemCatalog::ColDataType colDataType, int colWidth)
   : fSplitMaxMinInfo{ExtCPInfo(colDataType, colWidth), ExtCPInfo(colDataType, colWidth)}
  {
    fSplitMaxMinInfoPtrs[0] = fSplitMaxMinInfoPtrs[1] = NULL;  // disable by default.
  }
};

typedef std::vector&lt;ColSplitMaxMinInfo&gt; ColSplitMaxMinInfoList;

/** Class WriteEngineWrapper */
class WriteEngineWrapper : public WEObj
{
 public:
  /**
   * @brief Constructor
   */
  EXPORT WriteEngineWrapper();

  EXPORT WriteEngineWrapper(const WriteEngineWrapper&amp; rhs);
  /**
   * @brief Default Destructor
   */
  EXPORT ~WriteEngineWrapper();

  /************************************************************************
   * Interface definitions
   ************************************************************************/
  /**
   * @brief Performs static/global initialization for BRMWrapper.
   * Should be called once from the main thread.
   */
  EXPORT static void init(unsigned subSystemID);

  /**
   * @brief Build a index from an oid file (NOTE: this is write engine internal used function, just for test
   * purpose and not for generic use
   */
  int buildIndex(const OID&amp; colOid, const OID&amp; treeOid, const OID&amp; listOid,
                 execplan::CalpontSystemCatalog::ColDataType colDataType, int width, int hwm, bool resetFile,
                 uint64_t&amp; totalRows, int maxRow = IDX_DEFAULT_READ_ROW)
  {
    return -1;
  }

  /**
   * @brief Build a index from a file
   */
  int buildIndex(const std::string&amp; sourceFileName, const OID&amp; treeOid, const OID&amp; listOid,
                 execplan::CalpontSystemCatalog::ColDataType colDataType, int width, int hwm, bool resetFile,
                 uint64_t&amp; totalRows, const std::string&amp; indexName, Log* pLogger,
                 int maxRow = IDX_DEFAULT_READ_ROW)
  {
    return -1;
  }

  /**
   * @brief Close a index file
   */
  void closeIndex()
  {
  }

  /**
   * @brief Close a dictionary
   */
  int closeDctnry(const TxnID&amp; txnid, int i, bool realClose = true)
  {
    return m_dctnry[op(i)]-&gt;closeDctnry(realClose);
  }

  /**
   * @brief Commit transaction
   */
  int commit(const TxnID&amp; txnid)
  {
    m_txnLBIDMap.erase(txnid);
    return BRMWrapper::getInstance()-&gt;commit(txnid);
  }

  /**
   * @brief Convert interface value list to internal value array
   */
  EXPORT void convertValArray(const size_t totalRow,
                              const execplan::CalpontSystemCatalog::ColType&amp; cscColType,
                              const ColType colType, ColTupleList&amp; curTupleList, void* valArray,
                              bool bFromList = true);
  /**
   * @brief Updates range information given old range information, old values, new values and column
   * information.
   */
  EXPORT void updateMaxMinRange(const size_t totalNewRow, const size_t totalOldRow,
                                const execplan::CalpontSystemCatalog::ColType&amp; cscColType,
                                const ColType colType, const void* valArray, const void* oldValArray,
                                ExtCPInfo* maxMin, bool canStartWithInvalidRange);

  /**
   * @brief Create a column, include object ids for column data and bitmap files
   * @param dataOid column datafile object id
   * @param dataType column data type
   * @param dataWidth column width
   * @param dbRoot DBRoot under which file is to be located (1-based)
   * @param partition Starting partition number for segment file path (0-based).
   * @param compressionType compression type
   */
  EXPORT int createColumn(const TxnID&amp; txnid, const OID&amp; dataOid,
                          execplan::CalpontSystemCatalog::ColDataType dataType, int dataWidth,
                          uint16_t dbRoot, uint32_t partition = 0, int compressionType = 0);

  // BUG931
  /**
   * @brief Fill a new column with default value using row-ids from a reference column
   *
   * @param txnid Transaction id
   * @param dataOid OID of the new column
   * @param dataType Data-type of the new column
   * @param dataWidth Width of the new column
   * @param defaultVal Default value to be filled in the new column
   * @param refColOID OID of the reference column
   * @param refColDataType Data-type of the referecne column
   * @param refColWidth Width of the reference column
   */
  EXPORT int fillColumn(const TxnID&amp; txnid, const OID&amp; dataOid,
                        const execplan::CalpontSystemCatalog::ColType&amp; colType, ColTuple defaultVal,
                        const OID&amp; refColOID, execplan::CalpontSystemCatalog::ColDataType refColDataType,
                        int refColWidth, int refCompressionType, bool isNULL, int compressionType,
                        const std::string&amp; defaultValStr, const OID&amp; dictOid = 0, bool autoincrement = false);

  /**
   * @brief Create a index related files, include object ids for index tree and list files

   * @param treeOid index tree file object id
   * @param listOid index list file object id
   */
  int createIndex(const TxnID&amp; txnid, const OID&amp; treeOid, const OID&amp; listOid)
  {
    int rc = -1;
    return rc;
  }

  /**
   * @brief Create dictionary
   * @param dctnryOid dictionary signature file object id
   * @param partition Starting partition number for segment file path (0-based).
   * @param segment segment number
   * @param compressionType compression type
   */
  EXPORT int createDctnry(const TxnID&amp; txnid, const OID&amp; dctnryOid, int colWidth, uint16_t dbRoot,
                          uint32_t partiotion = 0, uint16_t segment = 0, int compressionType = 0);

  /**
   * @brief Delete a list of rows from a table
   * @param colStructList column struct list
   * @param colOldValueList column old values list (return value)
   * @param rowIdList row id list
   */
  EXPORT int deleteRow(const TxnID&amp; txnid, const std::vector&lt;CSCTypesList&gt;&amp; colExtentsColType,
                       std::vector&lt;ColStructList&gt;&amp; colExtentsStruct, std::vector&lt;void*&gt;&amp; colOldValueList,
                       std::vector&lt;RIDList&gt;&amp; ridLists, const int32_t tableOid,
                       bool hasAUXCol = false);

  /**
   * @brief Delete a list of rows from a table
   * @param colStructList column struct list
   * @param rowIdList row id list
   */

  EXPORT int deleteBadRows(const TxnID&amp; txnid, ColStructList&amp; colStructs, RIDList&amp; ridList,
                           DctnryStructList&amp; dctnryStructList);

  /**
   * @brief delete a dictionary signature and its token
   * @param dctnryStruct dictionary structure
   * @param dctnryTuple dictionary tuple
   */
  // ITER17_Obsolete
  // int deleteToken(const TxnID&amp; txnid, Token&amp; token); // Files need already open
  // int deleteToken(const TxnID&amp; txnid, DctnryStruct&amp; dctnryStruct, Token&amp; token);

  /**
   * @brief Drop a column, include object ids for column data file
   * @param dataOid column datafile object id
   */
  int dropColumn(const TxnID&amp; txnid, const OID dataOid)
  {
    return m_colOp[0]-&gt;dropColumn((FID)dataOid);
  }

  /**
   * @brief Drop files
   * @param dataOids column and dictionary datafile object id
   */
  int dropFiles(const TxnID&amp; txnid, const std::vector&lt;int32_t&gt;&amp; dataOids)
  {
    return m_colOp[0]-&gt;dropFiles(dataOids);
  }

  /**
   * @brief Delete files for one partition
   * @param dataOids column and dictionary datafile object id
   */
  int deletePartitions(const std::vector&lt;OID&gt;&amp; dataOids, const std::vector&lt;BRM::PartitionInfo&gt;&amp; partitions)
  {
    return m_colOp[0]-&gt;dropPartitions(dataOids, partitions);
  }

  int deleteOIDsFromExtentMap(const TxnID&amp; txnid, const std::vector&lt;int32_t&gt;&amp; dataOids)
  {
    return m_colOp[0]-&gt;deleteOIDsFromExtentMap(dataOids);
  }

  /**
   * @brief Create a index related files, include object ids for index tree and list files
   * @param treeOid index tree file object id
   * @param listOid index list file object id
   */
  int dropIndex(const TxnID&amp; txnid, const OID&amp; treeOid, const OID&amp; listOid)
  {
    return -1;
  }

  /**
   * @brief Drop a dictionary
   * @param dctnryOid dictionary signature file object id
   * @param treeOid dictionary tree file object id
   * @param listOid index list file object id
   */
  int dropDctnry(const TxnID&amp; txnid, const OID&amp; dctnryOid, const OID&amp; treeOid, const OID&amp; listOid)
  {
    return m_dctnry[0]-&gt;dropDctnry(dctnryOid);
  }

  /**
   * @brief Flush VM write cache
   * @param None
   */
  EXPORT void flushVMCache() const;

  /**
   * @brief Insert values into a table
   * @param colStructList column structure list
   * @param colValueList column value list
   * @param dicStringListt dictionary values list
   * @param dbRootExtentTrackers dbrootTrackers
   * @param bFirstExtentOnThisPM true when there is no extent on this PM
   * @param insertSelect if insert with select, the hwm block is skipped
   * @param isAutoCommitOn if autocommit on, only the hwm block is versioned,
   *        else eveything is versioned
   * @param tableOid used to get table meta data
   * @param isFirstBatchPm to track if this batch is first batch for this PM.
   */
  EXPORT int insertColumnRecs(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                              ColStructList&amp; colStructList, ColValueList&amp; colValueList,
                              DctnryStructList&amp; dctnryStructList, DictStrList&amp; dictStrList,
                              std::vector&lt;boost::shared_ptr&lt;DBRootExtentTracker&gt; &gt;&amp; dbRootExtentTrackers,
                              RBMetaWriter* fRBMetaWriter, bool bFirstExtentOnThisPM,
                              bool insertSelect = false, bool isAutoCommitOn = false, OID tableOid = 0,
                              bool isFirstBatchPm = false);

  EXPORT int insertColumnRecsBinary(
      const TxnID&amp; txnid, ColStructList&amp; colStructList, std::vector&lt;uint64_t&gt;&amp; colValueList,
      DctnryStructList&amp; dctnryStructList, DictStrList&amp; dictStrList,
      std::vector&lt;boost::shared_ptr&lt;DBRootExtentTracker&gt; &gt;&amp; dbRootExtentTrackers, RBMetaWriter* fRBMetaWriter,
      bool bFirstExtentOnThisPM, bool insertSelect = false, bool isAutoCommitOn = false, OID tableOid = 0,
      bool isFirstBatchPm = false);

  /**
   * @brief Insert values into systables
   * @param colStructList column structure list
   * @param colValueList column value list
   * @param dicStringListt dictionary values list
   */
  EXPORT int insertColumnRec_SYS(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                                 ColStructList&amp; colStructList, ColValueList&amp; colValueList,
                                 DctnryStructList&amp; dctnryStructList, DictStrList&amp; dictStrList,
                                 const int32_t tableOid);

  /**
   * @brief Insert a row
   * @param colStructList column structure list
   * @param colValueList column value list
   * @param dicStringListt dictionary values list
   */
  EXPORT int insertColumnRec_Single(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                                    ColStructList&amp; colStructList, ColValueList&amp; colValueList,
                                    DctnryStructList&amp; dctnryStructList, DictStrList&amp; dictStrList,
                                    const int32_t tableOid);
  /**
   * @brief Open dictionary
   * @param txnid relevant transaction
   * @param dctnryStruct dictionary column to open
   * @param useTmpSuffix Bulk HDFS usage: use *.tmp file suffix
   */
  // @bug 5572 - HDFS usage: add *.tmp file backup flag
  int openDctnry(const TxnID&amp; txnid, DctnryStruct dctnryStruct, bool useTmpSuffix)
  {
    int compress_op = op(dctnryStruct.fCompressionType);
    m_dctnry[compress_op]-&gt;setTransId(txnid);
    return m_dctnry[compress_op]-&gt;openDctnry(dctnryStruct.dctnryOid, dctnryStruct.fColDbRoot,
                                             dctnryStruct.fColPartition, dctnryStruct.fColSegment,
                                             useTmpSuffix);
  }

  /**
   * @brief Rollback transaction (common portion)
   */
  EXPORT int rollbackCommon(const TxnID&amp; txnid, int sessionId);

  /**
   * @brief Rollback transaction
   */
  EXPORT int rollbackTran(const TxnID&amp; txnid, int sessionId);

  /**
   * @brief Rollback transaction
   */
  EXPORT int rollbackBlocks(const TxnID&amp; txnid, int sessionId);

  /**
   * @brief Rollback transaction
   */
  EXPORT int rollbackVersion(const TxnID&amp; txnid, int sessionId);

  /**
   * @brief Set the IsInsert flag in the ChunkManagers.
   * This forces flush at end of block. Used only for bulk insert.
   */
  void setIsInsert(bool bIsInsert)
  {
    m_colOp[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;setIsInsert(bIsInsert);
    m_dctnry[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;setIsInsert(true);
    m_colOp[COMPRESSED_OP_2]-&gt;chunkManager()-&gt;setIsInsert(bIsInsert);
    m_dctnry[COMPRESSED_OP_2]-&gt;chunkManager()-&gt;setIsInsert(true);
  }

  /**
   * @brief Get the IsInsert flag as set in the ChunkManagers.
   * Since both chunk managers are supposed to be in lockstep as regards the
   * isInsert flag, we need only grab one.
   *
   */
  bool getIsInsert()
  {
    return m_colOp[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;getIsInsert();
  }

  std::tr1::unordered_map&lt;TxnID, SP_TxnLBIDRec_t&gt;&amp; getTxnMap()
  {
    return m_txnLBIDMap;
  };
  std::tr1::unordered_map&lt;TxnID, dictLBIDRec_t&gt;&amp; getDictMap()
  {
    return m_dictLBIDMap;
  };
  /**
   * @brief Flush the ChunkManagers.
   */
  int flushChunks(int rc, const std::map&lt;FID, FID&gt;&amp; columOids)
  {
    std::vector&lt;int32_t&gt; compressedOpIds = {COMPRESSED_OP_1, COMPRESSED_OP_2};

    for (const auto compressedOpId : compressedOpIds)
    {
      auto rtn = m_colOp[compressedOpId]-&gt;chunkManager()-&gt;flushChunks(rc, columOids);
      if (rtn != NO_ERROR)
        return rtn;

      rtn = m_dctnry[compressedOpId]-&gt;chunkManager()-&gt;flushChunks(rc, columOids);
      if (rtn != NO_ERROR)
        return rtn;
    }

    return NO_ERROR;
  }

  /**
   * @brief Set the transaction id into all fileops
   */
  void setTransId(const TxnID&amp; txnid)
  {
    for (int i = 0; i &lt; TOTAL_COMPRESS_OP; i++)
    {
      m_colOp[i]-&gt;setTransId(txnid);
      m_dctnry[i]-&gt;setTransId(txnid);
    }
  }

  /**
   * @brief Set the fIsBulk id into all fileops
   */
  void setBulkFlag(bool isBulk)
  {
    for (int i = 0; i &lt; TOTAL_COMPRESS_OP; i++)
    {
      m_colOp[i]-&gt;setBulkFlag(isBulk);
      m_dctnry[i]-&gt;setBulkFlag(isBulk);
    }
  }

  /**
   * @brief Set the fIsFix  into all fileops
   */
  void setFixFlag(bool isFix = false)
  {
    for (int i = 0; i &lt; TOTAL_COMPRESS_OP; i++)
    {
      m_colOp[i]-&gt;setFixFlag(isFix);
      m_dctnry[i]-&gt;setFixFlag(isFix);
    }
  }

  /**
   * @brief let chunkmanager start transaction.
   *
   */
  int startTransaction(const TxnID&amp; txnid)
  {
    int rc = 0;
    rc = m_colOp[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;startTransaction(txnid);
    // if ( rc == 0)
    //	rc = m_dctnry[COMPRESSED_OP]-&gt;chunkManager()-&gt;startTransaction(txnid);
    return rc;
  }

  /**
   * @brief let chunkmanager confirm transaction.
   *
   */
  int confirmTransaction(const TxnID&amp; txnid)
  {
    int rc = 0;
    rc = m_colOp[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;confirmTransaction(txnid);
    return rc;
  }

  /**
   * @brief let chunkmanager end transaction.
   *
   */
  int endTransaction(const TxnID&amp; txnid, bool success)
  {
    int rc = 0;
    rc = m_colOp[COMPRESSED_OP_1]-&gt;chunkManager()-&gt;endTransaction(txnid, success);
    // if ( rc == 0)
    //	rc = m_dctnry[COMPRESSED_OP]-&gt;chunkManager()-&gt;endTransaction(txnid, success);
    return rc;
  }

  /**
   * @brief Tokenize a dictionary signature into a token
   * @param dctnryStruct dictionary structure
   * @param dctnryTuple dictionary tuple
   * @param useTmpSuffix Bulk HDFS usage: use *.tmp file suffix
   */
  EXPORT int tokenize(const TxnID&amp; txnid, DctnryTuple&amp;, int compType);  // Files need open first
  EXPORT int tokenize(const TxnID&amp; txnid, DctnryStruct&amp; dctnryStruct, DctnryTuple&amp; dctnryTuple,
                      bool useTmpSuffix);

  /**
   * @brief Update values into a column (New one)
   * @param colStructList column structure list
   * @param colValueList column value list
   * @param colOldValueList column old values list (return value)
   * @param ridList row id list
   */
  EXPORT int updateColumnRec(const TxnID&amp; txnid, const std::vector&lt;CSCTypesList&gt;&amp; colExtentsColType,
                             std::vector&lt;ColStructList&gt;&amp; colExtentsStruct, ColValueList&amp; colValueList,
                             std::vector&lt;void*&gt;&amp; colOldValueList, std::vector&lt;RIDList&gt;&amp; ridLists,
                             std::vector&lt;DctnryStructList&gt;&amp; dctnryExtentsStruct,
                             DctnryValueList&amp; dctnryValueList, const int32_t tableOid,
                             bool hasAUXCol = false);

  /**
   * @brief Update values into columns
   * @param colStructList column structure list
   * @param colValueList column value list
   * @param ridList row id list
   */

  EXPORT int updateColumnRecs(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                              std::vector&lt;ColStruct&gt;&amp; colStructList, ColValueList&amp; colValueList,
                              const RIDList&amp; ridLists, const int32_t tableOid);

  /**
   * @brief Release specified table lock.
   * @param lockID Table lock id to be released.
   * @param errorMsg Return error message
   */
  EXPORT int clearTableLockOnly(uint64_t lockID, std::string&amp; errorMsg);

  /**
   * @brief Rollback the specified table
   * @param tableOid Table to be rolled back
   * @param lockID Table lock id of the table to be rolled back.
   *        Currently used for logging only.
   * @param tableName Name of table associated with tableOid.
   *        Currently used for logging only.
   * @param applName Application that is driving this bulk rollback.
   *        Currently used for logging only.
   * @param debugConsole Enable logging to console
   * @param errorMsg Return error message
   */
  EXPORT int bulkRollback(OID tableOid, uint64_t lockID, const std::string&amp; tableName,
                          const std::string&amp; applName, bool debugConsole, std::string&amp; errorMsg);

  /**
   * @brief update SYSCOLUMN next value
   * @param oidValueMap
   */
  EXPORT int updateNextValue(const TxnID txnId, const OID&amp; columnoid, const uint64_t nextVal,
                             const uint32_t sessionID, const uint16_t dbRoot);

  /**
   * @brief write active datafiles to disk
   *
   */
  EXPORT int flushDataFiles(int rc, const TxnID txnId, std::map&lt;FID, FID&gt;&amp; columnOids);

  /**
   * @brief Process versioning for batch insert - only version the hwm block.
   */
  EXPORT int processBatchVersions(const TxnID&amp; txnid, std::vector&lt;Column&gt; columns,
                                  std::vector&lt;BRM::LBIDRange&gt;&amp; rangeList);

  EXPORT void writeVBEnd(const TxnID&amp; txnid, std::vector&lt;BRM::LBIDRange&gt;&amp; rangeList);

  /************************************************************************
   * Future implementations
   ************************************************************************/
  /**
   * @brief Begin transaction
   */
  // todo: add implementation when we work on version control
  // int beginTran(const TransID transOid) { return NO_ERROR; }

  /**
   * @brief End transaction
   */
  // todo: add implementation when we work on version control
  // int endTran(const TransID transOid) { return NO_ERROR; }
  // WIP
  void setDebugLevel(const DebugLevel level)
  {
    WEObj::setDebugLevel(level);

    for (int i = 0; i &lt; TOTAL_COMPRESS_OP; i++)
    {
      m_colOp[i]-&gt;setDebugLevel(level);
      m_dctnry[i]-&gt;setDebugLevel(level);
    }
  }  // todo: cleanup

  /************************************************************************
   * Internal use definitions
   ************************************************************************/
 private:
  /**
   * @brief Check whether the passing parameters are valid
   */
  int checkValid(const TxnID&amp; txnid, const ColStructList&amp; colStructList, const ColValueList&amp; colValueList,
                 const RIDList&amp; ridList) const;

  /**
   * @brief Find the smallest column for this table
   */
  void findSmallestColumn(uint32_t&amp; colId, ColStructList colStructList);

  /**
   * @brief Convert interface column type to an internal column type
   */
  void convertValue(const execplan::CalpontSystemCatalog::ColType&amp; cscColType, ColType colType,
                    void* valArray, size_t pos, boost::any&amp; data, bool fromList = true);

  /**
   * @brief Convert column value to its internal representation
   *
   * @param colType Column data-type
   * @param value Memory pointer for storing output value. Should be pre-allocated
   * @param data Column data
   */
  void convertValue(const execplan::CalpontSystemCatalog::ColType&amp; cscColType, const ColType colType,
                    void* value, boost::any&amp; data);

  /**
   * @brief Print input value from DDL/DML processors
   */
  void printInputValue(const ColStructList&amp; colStructList, const ColValueList&amp; colValueList,
                       const RIDList&amp; ridList, const DctnryStructList&amp; dctnryStructList,
                       const DictStrList&amp; dictStrList) const;

  /**
   * @brief Process version buffer
   */
  int processVersionBuffer(IDBDataFile* pFile, const TxnID&amp; txnid, const ColStruct&amp; colStruct, int width,
                           int totalRow, const RID* rowIdArray, std::vector&lt;BRM::LBIDRange&gt;&amp; rangeList);

  /**
   * @brief Process version buffers for update and delete @Bug 1886,2870
   */
  int processVersionBuffers(IDBDataFile* pFile, const TxnID&amp; txnid, const ColStruct&amp; colStruct, int width,
                            int totalRow, const RIDList&amp; ridList, std::vector&lt;BRM::LBIDRange&gt;&amp; rangeList);

  int processBeginVBCopy(const TxnID&amp; txnid, const std::vector&lt;ColStruct&gt;&amp; colStructList,
                         const RIDList&amp; ridList, std::vector&lt;BRM::VBRange&gt;&amp; freeList,
                         std::vector&lt;std::vector&lt;uint32_t&gt; &gt;&amp; fboLists,
                         std::vector&lt;std::vector&lt;BRM::LBIDRange&gt; &gt;&amp; rangeLists,
                         std::vector&lt;BRM::LBIDRange&gt;&amp; rangeListTot);

  /**
   * @brief Common methods to write values to a column
   */
  int writeColumnRec(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypes, const ColStructList&amp; colStructList,
                     ColValueList&amp; colValueList, RID* rowIdArray, const ColStructList&amp; newColStructList,
                     ColValueList&amp; newColValueList, const int32_t tableOid, bool useTmpSuffix,
                     bool versioning = true, ColSplitMaxMinInfoList* maxMins = NULL);

  int writeColumnRecBinary(const TxnID&amp; txnid, const ColStructList&amp; colStructList,
                           std::vector&lt;uint64_t&gt;&amp; colValueList, RID* rowIdArray,
                           const ColStructList&amp; newColStructList, std::vector&lt;uint64_t&gt;&amp; newColValueList,
                           const int32_t tableOid, bool useTmpSuffix, bool versioning = true);

  //@Bug 1886,2870 pass the address of ridList vector
  int writeColumnRecUpdate(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                           const ColStructList&amp; colStructList, const ColValueList&amp; colValueList,
                           std::vector&lt;void*&gt;&amp; colOldValueList, const RIDList&amp; ridList,
                           const int32_t tableOid, bool convertStructFlag = true,
                           ColTupleList::size_type nRows = 0, std::vector&lt;ExtCPInfo*&gt;* cpInfos = NULL,
                           bool hasAUXCol = false);

  // For update column from column to use
  int writeColumnRecords(const TxnID&amp; txnid, const CSCTypesList&amp; cscColTypeList,
                         std::vector&lt;ColStruct&gt;&amp; colStructList, ColValueList&amp; colValueList,
                         const RIDList&amp; ridLists, const int32_t tableOid, bool versioning = true,
                         std::vector&lt;ExtCPInfo*&gt;* cpInfos = NULL);

  /**
   * @brief util method to convert rowid to a column file
   *
   */
  int convertRidToColumn(RID&amp; rid, uint16_t&amp; dbRoot, uint32_t&amp; partition, uint16_t&amp; segment,
                         const RID filesPerColumnPartition, const RID extentsPerSegmentFile,
                         const RID extentRows, uint16_t startDBRoot, unsigned dbrootCnt);

  void AddDictToList(const TxnID txnid, std::vector&lt;BRM::LBID_t&gt;&amp; lbids);
  void RemoveTxnFromDictMap(const TxnID txnid);

  // Bug 4312: We use a hash map to hold the set of starting LBIDS for a given
  // txn so that we don&#039;t waste time marking the same extent as invalid. This
  // list should be trimmed if it gets too big.
  int AddLBIDtoList(const TxnID txnid, const ColStruct&amp; colStruct, const int fbo,
                    ExtCPInfo* cpInfo = NULL  // provide CPInfo pointer if you want max/min updated.
  );

  // Get CPInfo for given starting LBID and column description structure.
  int GetLBIDRange(const BRM::LBID_t startingLBID, const ColStruct&amp; colStruct, ExtCPInfo&amp; cpInfo);

  // mark extents of the transaction as invalid. erase transaction from txn-&gt;lbidsrec map if requested.
  int markTxnExtentsAsInvalid(const TxnID txnid, bool erase = false);

  // write LBID&#039;s new ranges.
  int setExtentsNewMaxMins(const ColSplitMaxMinInfoList&amp; maxMins, bool haveSplit);

  int RemoveTxnFromLBIDMap(const TxnID txnid);

  int op(int compressionType)
  {
    switch (compressionType)
    {
      case 1:
      case 2: return COMPRESSED_OP_1;
      case 3: return COMPRESSED_OP_2;
    }

    return 0;
  }

  // This is a Map of sets of LBIDS for each transaction. A Transaction&#039;s list will be removed upon commit or
  // rollback.
  std::tr1::unordered_map&lt;TxnID, SP_TxnLBIDRec_t&gt; m_txnLBIDMap;

  // MCOL-1160: We need to track dictionary LBIDs so we can tell PrimProc
  // to flush the blocks after an API bulk-write.
  std::tr1::unordered_map&lt;TxnID, dictLBIDRec_t&gt; m_dictLBIDMap;

  ColumnOp* m_colOp[TOTAL_COMPRESS_OP];  // column operations
  Dctnry* m_dctnry[TOTAL_COMPRESS_OP];   // dictionary operations
  OpType m_opType;                       // operation type
};

}  // namespace WriteEngine

#undef EXPORT
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Fwriteengine%2Fwrapper'>🔙 Back</a></p>