You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-08-26 05:02:32 +03:00
342f71e7fb
According to C++ spec: If an inline function or variable (since C++17) with external linkage is defined differently in different translation units, the behavior is undefined. The undefined behaviour causes link errors for cpimport binary. /usr/bin/ld: /tmp/cpimport.bin.av067N.ltrans0.ltrans.o:(.data.rel.ro+0x6c8): undefined reference to `WriteEngine::ColumnOp::isEmptyRow(unsigned long*, unsigned char const*, int)' The isEmptyRow method is defined as inline in the cpp file and not inline in the header file. As the method is not used as part of an external API by any of the callers, nor is it subclassed, mark it as a normal (non virtual) *inline* member function.
352 lines
13 KiB
C++
352 lines
13 KiB
C++
/* 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: we_colop.h 4728 2013-08-08 19:26:10Z chao $
|
|
|
|
|
|
/** @file */
|
|
|
|
#ifndef _WE_COLOP_H_
|
|
#define _WE_COLOP_H_
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "we_dbfileop.h"
|
|
#include "brmtypes.h"
|
|
#include "we_dbrootextenttracker.h"
|
|
#include "we_tablemetadata.h"
|
|
#include "../dictionary/we_dctnry.h"
|
|
#if defined(_MSC_VER) && defined(WRITEENGINE_DLLEXPORT)
|
|
#define EXPORT __declspec(dllexport)
|
|
#else
|
|
#define EXPORT
|
|
#endif
|
|
|
|
/** Namespace WriteEngine */
|
|
namespace WriteEngine
|
|
{
|
|
class Log;
|
|
|
|
//const int COL_DATATYPE_NUM = 15;
|
|
//const char ColDataTypeStr[COL_DATATYPE_NUM][20] = { "bit", "tinyint", "char", "smallint", "decimal", "medint", "integer", "float", "date", "bigint",
|
|
// "double", "datetime", "varchar", "clob", "blob" };
|
|
|
|
/** Class ColumnOp */
|
|
class ColumnOp : public DbFileOp
|
|
{
|
|
public:
|
|
/**
|
|
* @brief Constructor
|
|
*/
|
|
EXPORT ColumnOp();
|
|
EXPORT ColumnOp(Log* logger);
|
|
|
|
/**
|
|
* @brief Default Destructor
|
|
*/
|
|
EXPORT virtual ~ColumnOp();
|
|
|
|
EXPORT virtual int allocRowId(const TxnID& txnid,
|
|
bool useStartingExtent,
|
|
Column& column,
|
|
uint64_t totalRow,
|
|
RID* rowIdArray,
|
|
HWM& hwm,
|
|
bool& newExtent,
|
|
uint64_t& rowsLeft,
|
|
HWM& newHwm,
|
|
bool& newFile,
|
|
ColStructList& newColStructList,
|
|
DctnryStructList& newDctnryStructList,
|
|
std::vector<boost::shared_ptr<DBRootExtentTracker> >& dbRootExtentTrackers,
|
|
bool insertSelect,
|
|
bool isBatchInsert,
|
|
OID tableOid, bool isFirstBatchPm,
|
|
std::vector<BRM::LBID_t>* newEtents);
|
|
|
|
/**
|
|
* @brief Create column file(s)
|
|
*/
|
|
EXPORT virtual int createColumn(Column& column,
|
|
int colNo,
|
|
int colWidth,
|
|
execplan::CalpontSystemCatalog::ColDataType colDataType,
|
|
ColType colType,
|
|
FID dataFid,
|
|
uint16_t dbRoot,
|
|
uint32_t partition);
|
|
|
|
/**
|
|
* @brief Fills up a column with null/default values in all non-empty rows as the reference column. The reference column
|
|
* would typically be another column of the same table.
|
|
*
|
|
* @param column The new colum
|
|
* @param refCol The reference column for identifying valid rows
|
|
* @param defaultVal The default value of the new column
|
|
* @param dictOid The dictionary store OID for a dictionary column
|
|
* @param dictColWidth The dictionary string width for a dictionary column
|
|
*/
|
|
//BUG931
|
|
EXPORT virtual int fillColumn(const TxnID& txnid,
|
|
Column& column,
|
|
Column& refCol,
|
|
void* defaultVal,
|
|
Dctnry* dctnry,
|
|
ColumnOp* refColOp,
|
|
const OID dictOid = 0,
|
|
const int dictColWidth = 0,
|
|
const std::string defaultValStr = "",
|
|
bool autoincrement = false);
|
|
|
|
/**
|
|
* @brief Create a table file
|
|
*/
|
|
EXPORT virtual int createTable() const;
|
|
|
|
/**
|
|
* @brief Drop column file(s)
|
|
*/
|
|
EXPORT virtual int dropColumn(const FID dataFid);
|
|
|
|
/**
|
|
* @brief Drop column and dictionary file(s)
|
|
*/
|
|
EXPORT virtual int dropFiles(const std::vector<int32_t>& dataFids);
|
|
|
|
/**
|
|
* @brief Delete file(s) for the given partition
|
|
*/
|
|
EXPORT virtual int dropPartitions(const std::vector<OID>& dataFids,
|
|
const std::vector<BRM::PartitionInfo>& partitions);
|
|
|
|
|
|
EXPORT virtual int deleteOIDsFromExtentMap(const std::vector<int32_t>& dataFids);
|
|
/**
|
|
* @brief Drop a table file
|
|
*/
|
|
int dropTable() const
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/**
|
|
* @brief Expand the abbreviated extent to a full extent for this column.
|
|
*/
|
|
EXPORT virtual int expandAbbrevExtent(const Column& column);
|
|
|
|
/**
|
|
* @brief Add an extent to the specified column OID and DBRoot.
|
|
* When this function returns, the file position will be located at the
|
|
* end of the file. If the applicable column segment file does not exist,
|
|
* extendColumn() will create the new segment file.
|
|
* The extent must already exist in the extentmap prior to calling this fctn.
|
|
*
|
|
* @param column Column struct with input column attributes.
|
|
* @param leaveFileOpen Leave the db file open when leaving this function
|
|
* @param hwm The fbo of the column segment file where the new extent begins
|
|
* @param startLbid The starting LBID for the new extent.
|
|
* @param allocSize Number of blocks to be written for an extent
|
|
* @param dbRoot The DBRoot of the file with the new extent.
|
|
* @param partition Partition num of the file with the new extent.
|
|
* @param segment The segment number of the file with the new extent.
|
|
* @param segFile (out) Name of segment file to which the extent is added.
|
|
* @param pFile (out) FILE ptr to the file where the extent is added.
|
|
* @param newFile (out) Indicates if extent was added to new or existing file
|
|
* @param hdrs (out) Contents of headers if file is compressed.
|
|
* @return returns NO_ERROR if success.
|
|
*/
|
|
EXPORT int extendColumn(const Column& column,
|
|
bool leaveFileOpen,
|
|
HWM hwm,
|
|
BRM::LBID_t startLbid,
|
|
int allocSize,
|
|
uint16_t dbRoot,
|
|
uint32_t partition,
|
|
uint16_t segment,
|
|
std::string& segFile,
|
|
IDBDataFile*& pFile,
|
|
bool& newFile,
|
|
char* hdrs = NULL);
|
|
|
|
/**
|
|
* @brief Add an extent to the OID specified in the column argument.
|
|
* When this function returns, the file position will be located at the
|
|
* end of the file.
|
|
*
|
|
* @param column Column struct with input column attributes.
|
|
* @param dbRoot (in) The DBRoot of the file with the new extent.
|
|
* @param partition (in) The partition num of the file with the new extent.
|
|
* @param segment (in) The segment number of the file with the new extent.
|
|
* @param segFile (out) Name of segment file to which the extent is added.
|
|
* @param startLbid (out) The starting LBID for the new extent.
|
|
* @param newFile (out) Indicates if extent was added to new or existing file
|
|
* @param hdsr (out) Contents of headers if file is compressed.
|
|
* @param allocSize (out) number of blocks to be written for an extent
|
|
* @return returns NO_ERROR if success.
|
|
*/
|
|
EXPORT int addExtent(const Column& column,
|
|
uint16_t dbRoot,
|
|
uint32_t partition,
|
|
uint16_t segment,
|
|
std::string& segFile,
|
|
BRM::LBID_t& startLbid,
|
|
bool& newFile,
|
|
int& allocSize,
|
|
char* hdrs = NULL);
|
|
|
|
/**
|
|
* @brief Get columne data type
|
|
*/
|
|
EXPORT virtual bool getColDataType(const char* name, execplan::CalpontSystemCatalog::ColDataType& colDataType) const;
|
|
|
|
/**
|
|
* @brief Initialize the column
|
|
*/
|
|
EXPORT virtual void initColumn(Column& column) const;
|
|
|
|
/**
|
|
* @brief Check whether it is an empty row
|
|
*/
|
|
inline bool isEmptyRow(uint64_t* curVal,
|
|
const uint8_t* emptyVal,
|
|
const int colWidth);
|
|
|
|
/**
|
|
* @brief Check whether it is a valid column
|
|
*/
|
|
EXPORT virtual bool isValid(Column& column) const;
|
|
|
|
/**
|
|
* @brief Open column file, segFile is set to the name of the column
|
|
* segment file that is opened.
|
|
*/
|
|
EXPORT virtual int openColumnFile(Column& column,
|
|
std::string& segFile,
|
|
bool useTmpSuffix,
|
|
int ioBuffSize = DEFAULT_BUFSIZ) const;
|
|
|
|
/**
|
|
* @brief Open table file
|
|
*/
|
|
int openTableFile() const
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/**
|
|
* @brief Delete a file
|
|
*/
|
|
EXPORT virtual void setColParam(Column& column, int colNo = 0,
|
|
int colWidth = 0,
|
|
execplan::CalpontSystemCatalog::ColDataType colDataType = execplan::CalpontSystemCatalog::INT,
|
|
ColType colType = WR_INT,
|
|
FID dataFid = 0,
|
|
int comppre = 0,
|
|
uint16_t dbRoot = 0,
|
|
uint32_t partition = 0,
|
|
uint16_t segment = 0) const;
|
|
|
|
/**
|
|
* @brief Write row(s)
|
|
*/
|
|
EXPORT virtual int writeRow(Column& curCol,
|
|
uint64_t totalRow,
|
|
const RID* rowIdArray,
|
|
const void* valArray,
|
|
void* oldValArray =0,
|
|
bool bDelete = false);
|
|
|
|
/**
|
|
* @brief Write row(s) for delete @Bug 1886,2870
|
|
*/
|
|
EXPORT virtual int writeRows(Column& curCol,
|
|
uint64_t totalRow,
|
|
const RIDList& ridList,
|
|
const void* valArray,
|
|
void* oldValArray = 0,
|
|
bool bDelete = false);
|
|
|
|
/**
|
|
* @brief Write row(s) for update @Bug 1886,2870
|
|
*/
|
|
EXPORT virtual int writeRowsValues(Column& curCol,
|
|
uint64_t totalRow,
|
|
const RIDList& ridList,
|
|
const void* valArray,
|
|
void* oldValArray = 0);
|
|
|
|
/**
|
|
* @brief Test if the pFile is an abbreviated extent.
|
|
*/
|
|
virtual bool abbreviatedExtent(IDBDataFile* pFile, int colWidth) const = 0;
|
|
|
|
/**
|
|
* @brief Caculate the number of blocks in file.
|
|
*/
|
|
virtual int blocksInFile(IDBDataFile* pFile) const = 0;
|
|
|
|
/**
|
|
* @brief Clear a column
|
|
*/
|
|
EXPORT void clearColumn(Column& column) const;
|
|
|
|
/**
|
|
* @brief open a data file of column
|
|
*/
|
|
virtual IDBDataFile* openFile(const Column& column, uint16_t dbRoot, uint32_t partition,
|
|
uint16_t segment, std::string& segFile, bool useTmpSuffix, const char* mode = "r+b",
|
|
int ioBuffSize = DEFAULT_BUFSIZ) const = 0;
|
|
|
|
|
|
/**
|
|
* @brief backup blocks to version buffer
|
|
*/
|
|
int writeVB(IDBDataFile* pSource, const OID sourceOid, IDBDataFile* pTarget, const OID targetOid,
|
|
const std::vector<uint32_t>& fboList, const BRM::VBRange& freeList,
|
|
size_t& nBlocksProcessed, const size_t fboCurrentOffset);
|
|
|
|
/**
|
|
* @brief restore blocks from version buffer
|
|
*/
|
|
int copyVB(IDBDataFile* pSource, const BRM::VER_t txnD, const OID oid, std::vector<uint32_t>& fboList,
|
|
std::vector<BRM::LBIDRange>& rangeList);
|
|
/**
|
|
* @brief close column file
|
|
*/
|
|
EXPORT virtual void closeColumnFile(Column& column) const;
|
|
|
|
protected:
|
|
|
|
/**
|
|
* @brief populate readBuf with data in block #lbid
|
|
*/
|
|
virtual int readBlock(IDBDataFile* pFile, unsigned char* readBuf, const uint64_t fbo) = 0;
|
|
|
|
/**
|
|
* @brief output writeBuf to pFile starting at position fbo
|
|
*/
|
|
virtual int saveBlock(IDBDataFile* pFile, const unsigned char* writeBuf, const uint64_t fbo) = 0;
|
|
|
|
private:
|
|
};
|
|
|
|
} //end of namespace
|
|
|
|
#undef EXPORT
|
|
|
|
#endif // _WE_COLOP_H_
|