database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-10-30 07:25:34 +03:00
Code Activity
Files
disable-gcc-toolset-build
mariadb-columnstore-engine/versioning/BRM/dbrm.h
Leonid Fedorov 82421c208f chore(ci): collect asan ubsan and libc++ build with mtr and regression status ignored (#3672) 
* MSan added with fixes for libc++

* libc++ sepatare build

* add libc++ to ci

* libstdc++ in CI

* libcpp and msan to external projects

* std::sqrt

* awful_hack(ci): install whole llvm instead of libc++ in terrible way for test containers

* Adding ddeb packages for teststages and repos

* libc++ more for test container

* save some money on debug

* colored coredumps

* revert ci

* chore(ci): collect asan ubsan and libc++ build with mtr and regression status ignored
2025-07-31 00:32:32 +04:00

1024 lines
43 KiB
C++
Raw Permalink Blame History

/* 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: dbrm.h 1878 2013-05-02 15:17:12Z dcathey $
*
*****************************************************************************/
/** @file
* class DBRM
*/
#pragma once
#include <unistd.h>
#include <sys/types.h>
#include <vector>
#include <set>
#include <string>
#include <boost/thread.hpp>
#include <boost/scoped_ptr.hpp>
#include "brmtypes.h"
#include "messagequeue.h"
#include "extentmap.h"
#include "vss.h"
#include "vbbm.h"
#include "copylocks.h"
#include "calpontsystemcatalog.h"
#include "sessionmanagerserver.h"
#include "configcpp.h"
#include "mastersegmenttable.h"
#define EXPORT
#ifdef BRM_DEBUG
#define DBRM_THROW
#else
#define DBRM_THROW throw()
#endif
namespace BRM
{
/** @brief The interface to the Distributed BRM system.
*
* There are 3 components of the Distributed BRM (DBRM).
* \li The interface
* \li The Master node
* \li Slave nodes
*
* The DBRM class is the interface, which is identical to the single-node
* version, the BlockResolutionManager class.
*
* The DBRM components effectively implement a networking & synchronization
* layer to the BlockResolutionManager class so that every node that needs
* BRM data always has an up-to-date copy of it locally. An operation that changes
* BRM data is duplicated on all hosts that run a Slave node so that every
* node has identical copies. All "read" operations are satisfied locally.
*
* Calpont configuration file entries are necessary for the interface, Master,
* and Slave to find each other. Config file entries look like
* \code
* <DBRM_Controller>
* <IPAddr>
* <Port>
* <NumWorkers>N</NumWorkers>
* </DBRM_Controller>
* <DBRM_Worker1>
* <IPAddr>
* <Port>
* </DBRM_Worker1>
* ...
* <DBRM_WorkerN>
* <IPAddr>
* <Port>
* </DBRM_WorkerN>
* \endcode
*/
class DBRM
{
public:
// The param noBRMFcns suppresses init of the ExtentMap, VSS, VBBM, and CopyLocks.
// It can speed up init if the caller only needs the other structures.
EXPORT DBRM(bool noBRMFcns = false);
EXPORT ~DBRM();
static void refreshShmWithLock()
{
MasterSegmentTableImpl::refreshShmWithLock();
ExtentMapRBTreeImpl::refreshShmWithLock();
FreeListImpl::refreshShmWithLock();
}
// @bug 1055+ - Added functions below for multiple files per OID enhancement.
/** @brief Get the OID, offset, db root, partition, and segment of a logical block ID.
*
* Get the OID, offset, db root, and partition of a logical block ID.
* @param lbid (in) The LBID to look up
* @param verid (in) The version of the LBID to look up
* @param vbFlags (in) If true, look for the block in the version buffer
* if false, the extent map
* @param oid (out) The OID of the file the LBID is allocated to
* @param fileBlockOffset (out) The file block offset of the LBID
* @param dbRoot (out) The DBRoot number that contains the file.
* @param partitionNum (out) The partition number for the file.
* @param segmentNum (out) The segment number for the file.
*
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int lookupLocal(LBID_t lbid, VER_t verid, bool vbFlag, OID_t& oid, uint16_t& dbRoot,
uint32_t& partitionNum, uint16_t& segmentNum, uint32_t& fileBlockOffset) throw();
/** @brief Get the LBID assigned to the given OID, block offset, partion, and segment.
*
* Get the LBID assigned to the given OID, block offset, partition, and segment.
* @param oid (in) The OID
* @param partitionNum (in) The partition number
* @parm segmentNum (in) The segment number
* @param fileBlockOffset (in) The offset in the OID to return the LBID of
* @param lbid (out) The LBID of the offset of the OID.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int lookupLocal(OID_t oid, uint32_t partitionNum, uint16_t segmentNum, uint32_t fileBlockOffset,
LBID_t& lbid) throw();
/** @brief A dbroot-specific version of lookupLocal() */
EXPORT int lookupLocal_DBroot(OID_t oid, uint32_t dbroot, uint32_t partitionNum, uint16_t segmentNum,
uint32_t fileBlockOffset, LBID_t& lbid) throw();
// @bug 1055-
/** @brief Get the starting LBID assigned to the extent containing
* the specified OID, block offset, partition, and segment.
*
* Get the LBID assigned to the given OID, partition, segment,
* and block offset.
* @param oid (in) The OID
* @param partitionNum (in) The partition number
* @parm segmentNum (in) The segment number
* @param fileBlockOffset (in) The requested offset in the specified OID
* @param lbid (out) The starting LBID of extent with specified offset
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int lookupLocalStartLbid(OID_t oid, uint32_t partitionNum, uint16_t segmentNum,
uint32_t fileBlockOffset, LBID_t& lbid) throw();
/**@brief Do a VSS lookup.
*
* Do a VSS lookup. Gets the version ID of the block the caller should use
* and determines whether it is in the version buffer or the main database.
* @param lbid (in) The block number
* @param qc (in) The SCN & txn list provided by SessionManager::verID().
* @param txnID (in) If the caller has a transaction ID, put it here.
* Otherwise use 0.
* @param outVer (out) The version the caller should use.
* @param vbFlag (out) If true, the block is in the version buffer;
* false, the block is in the main database.
* @param vbOnly (in) If true, it will only consider entries in the Version Buffer
* (vbFlag will be true on return). If false, it will also consider the main DB
* entries. This defaults to false.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int vssLookup(LBID_t lbid, const QueryContext& qc, VER_t txnID, VER_t* outVer, bool* vbFlag,
bool vbOnly = false) throw();
/** @brief Do many VSS lookups under one lock
*
* Do many VSS lookups under one lock.
* @param lbids (in) The LBIDs to look up
* @param qc (in) The input version info, equivalent to the verID param in vssLookup()
* @param txnID (in) The input transaction number, equivalent to the txnID param in vssLookup()
* @param out (out) The values equivalent to the out parameters in vssLookup() including the individual
* return codes, ordered as the lbid list.
* @return 0 on success, -1 on a fatal error.
*/
EXPORT int bulkVSSLookup(const std::vector<LBID_t>& lbids, const QueryContext_vss& qc, VER_t txnID,
std::vector<VSSData>* out);
/// returns the version in the main DB files or 0 if none exist
EXPORT VER_t getCurrentVersion(LBID_t lbid, bool* isLocked = NULL) const;
/// returns the highest version # in the version buffer, or -1 if none exist
EXPORT VER_t getHighestVerInVB(LBID_t lbid,
VER_t max = std::numeric_limits<VER_t>::max()) const; // returns
/// returns true if that block is in the version buffer, false otherwise including on error
EXPORT bool isVersioned(LBID_t lbid, VER_t version) const;
/// Do many getCurrentVersion lookups under one lock grab
EXPORT int bulkGetCurrentVersion(const std::vector<LBID_t>& lbids, std::vector<VER_t>* versions,
std::vector<bool>* isLocked = NULL) const;
/** @brief Get a complete list of LBIDs assigned to an OID
*
* Get a complete list of LBIDs assigned to an OID.
*/
EXPORT int lookup(OID_t oid, LBIDRange_v& lbidList) throw();
/** @brief Allocate a "stripe" of extents for columns in a table.
*
* Allocate a "stripe" of extents for the specified columns and DBRoot
* @param cols (in) List of column OIDs and column widths
* @param dbRoot (in) DBRoot for requested extents.
* @param partitionNum (in/out) Partition number in file path.
* If allocating OID's first extent for this DBRoot, then
* partitionNum is input, else it is an output arg.
* @param segmentNum (out) Segment number selected for new extents.
* @param extents (out) list of lbids, numBlks, and fbo for new extents
* @return 0 on success, -1 on error
*/
EXPORT int createStripeColumnExtents(const std::vector<CreateStripeColumnExtentsArgIn>& cols,
uint16_t dbRoot, uint32_t& partitionNum, uint16_t& segmentNum,
std::vector<CreateStripeColumnExtentsArgOut>& extents) DBRM_THROW;
/** @brief Allocate an extent for a column file
*
* Allocate a column extent for the specified OID and DBRoot.
* @param OID (in) The OID requesting the extent.
* @param colWidth (in) Column width of the OID.
* @param dbRoot (in) DBRoot where extent is to be added.
* @param partitionNum (in/out) Partition number in file path.
* If allocating OID's first extent for this DBRoot, then
* partitionNum is input, else it is an output arg.
* @param segmentNum (out) Segment number in file path.
* @param colDataType (in) the column type
* @param lbid (out) The first LBID of the extent created.
* @param allocdSize (out) The total number of LBIDs allocated.
* @param startBlockOffset (out) The first block of the extent created.
* @return 0 on success, -1 on error
*/
// @bug 4091: To be deprecated. Replaced by createStripeColumnExtents().
EXPORT int createColumnExtent_DBroot(OID_t oid, uint32_t colWidth, uint16_t dbRoot, uint32_t& partitionNum,
uint16_t& segmentNum,
execplan::CalpontSystemCatalog::ColDataType colDataType, LBID_t& lbid,
int& allocdSize, uint32_t& startBlockOffset) DBRM_THROW;
/** @brief Allocate extent for specified segment file
*
* Allocate column extent for the exact segment file
* specified by OID, DBRoot, partition, and segment.
* @param OID (in) The OID requesting the extent.
* @param colWidth (in) Column width of the OID.
* @param dbRoot (in) DBRoot where extent is to be added.
* @param partitionNum (in) Partition number in file path.
* @param segmentNum (in) Segment number in file path.
* @param lbid (out) The first LBID of the extent created.
* @param allocdSize (out) The total number of LBIDs allocated.
* @param startBlockOffset (out) The first block of the extent created.
* @return 0 on success, -1 on error
*/
EXPORT int createColumnExtentExactFile(OID_t oid, uint32_t colWidth, uint16_t dbRoot, uint32_t partitionNum,
uint16_t segmentNum,
execplan::CalpontSystemCatalog::ColDataType colDataType,
LBID_t& lbid, int& allocdSize,
uint32_t& startBlockOffset) DBRM_THROW;
/** @brief Allocate an extent for a dictionary store file
*
* Allocate a dictionary store extent for the specified OID, dbRoot,
* partition number, and segment number.
* @param OID (in) The OID requesting the extent.
* @param dbRoot (in) DBRoot to assign to the extent.
* @param partitionNum (in) Partition number to assign to the extent.
* @param segmentNum (in) Segment number to assign to the extent.
* @param colDataType (in) the column type
* @param lbid (out) The first LBID of the extent created.
* @param allocdSize (out) The total number of LBIDs allocated.
* @return 0 on success, -1 on error
*/
EXPORT int createDictStoreExtent(OID_t oid, uint16_t dbRoot, uint32_t partitionNum, uint16_t segmentNum,
LBID_t& lbid, int& allocdSize) DBRM_THROW;
/** @brief Rollback (delete) set of column extents for specific OID & DBRoot
*
* Deletes all the extents that logically follow the specified
* column extent; and sets the HWM for the specified extent.
* @param oid OID of the extents to be deleted.
* @param bDeleteAll Indicates if all extents in the oid and dbroot are to
* be deleted; else part#, seg#, and hwm are used.
* @param dbRoot DBRoot of the extents to be deleted.
* @param partitionNum Last partition to be kept.
* @param segmentNum Last segment in partitionNum to be kept.
* @param hwm HWM to be assigned to the last extent that is kept.
* @return 0 on success
*/
EXPORT int rollbackColumnExtents_DBroot(OID_t oid, bool bDeleteAll, uint16_t dbRoot, uint32_t partitionNum,
uint16_t segmentNum, HWM_t hwm) DBRM_THROW;
/** @brief Rollback (delete) a set of dict store extents for an OID & DBRoot
*
* Arguments specify the last stripe. Any extents after this are
* deleted. The hwm's of the extents in the last stripe are updated
* based on the contents of the hwm vector. If hwms is a partial list,
* (as in the first stripe of a partition), then any extents in sub-
* sequent segment files for that partition are deleted. if hwms is empty
* then all the extents in dbRoot are deleted.
* @param oid OID of the extents to be deleted or updated.
* @param dbRoot DBRoot of the extents to be deleted.
* @param partitionNum Last partition to be kept.
* @param segNums Vector of segment numbers for last partition to be kept.
* @param hwms Vector of hwms for the last partition to be kept.
* @return 0 on success
*/
EXPORT int rollbackDictStoreExtents_DBroot(OID_t oid, uint16_t dbRoot, uint32_t partitionNum,
const std::vector<uint16_t>& segNums,
const std::vector<HWM_t>& hwms) DBRM_THROW;
/** @brief delete of column extents for the specified extents.
*
* Deletes the extents from extent map
* @param extentInfo the information for extents
*/
EXPORT int deleteEmptyColExtents(const std::vector<ExtentInfo>& extentsInfo) DBRM_THROW;
/** @brief delete of dictionary extents for the specified extents.
*
* Deletes the extents from extent map
* @param extentInfo the information for extents
*/
EXPORT int deleteEmptyDictStoreExtents(const std::vector<ExtentInfo>& extentsInfo) DBRM_THROW;
/** @brief Delete the extents of an OID and invalidate VSS references to them
*
* Delete the extents assigned to an OID and deletes entries in the VSS
* that refer to the LBIDs used by it.
* @note The old version of this function deliberately did not delete the entries
* in the version buffer.
* @note This function is ridiculously slow right now.
* @param OID The OID of the object being deleted
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int deleteOID(OID_t oid) DBRM_THROW;
/** @brief Delete the extents of an OID and invalidate VSS references to them
*
* Delete the extents assigned to an OID and deletes entries in the VSS
* that refer to the LBIDs used by it.
* @note The old version of this function deliberately did not delete the entries
* in the version buffer.
* @note This function is ridiculously slow right now.
* @param OID The OID of the object being deleted
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int deleteOIDs(const std::vector<OID_t>& oids) DBRM_THROW;
/** @brief Gets the last local high water mark for an OID and dbRoot
*
* Get last local high water mark of an OID for a given dbRoot, relative to
* a segment file. The partition and segment numbers for the pertinent
* segment are also returned.
* @param OID (in) The OID
* @param dbRoot (in) The relevant DBRoot
* @param partitionNum (out) The relevant partition number
* @param segmentNum (out) The relevant segment number
* @param hwm (out) Last local high water mark for specified input
* @param status (out) State of the extent (Available, OutOfService, etc)
* @param bFound (out) Indicates whether an extent was found on the dbRoot
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getLastHWM_DBroot(int OID, uint16_t dbRoot, uint32_t& partitionNum, uint16_t& segmentNum,
HWM_t& hwm, int& status, bool& bFound) throw();
/** @brief Get the "high water mark" of an OID, partition, and segment
*
* Get local high water mark (aka, the highest numbered written block
* offset) for an OID,partition,segment relative to the segment file.
* This applies to either column or dictionary store OIDs.
* @param oid (in) The OID
* @param partitionNum (in) Relevant partition number.
* @param segmentNum (in) Relevant segment number.
* @param hwm (out) The high water mark of oid
* @param status (out) State of the extent (Available, OutOfService, etc)
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getLocalHWM(OID_t oid, uint32_t partitionNum, uint16_t segmentNum, HWM_t& hwm,
int& status) throw();
/** @brief Set the "high water mark" of an OID, partition, and segment
*
* Set the local high water mark (aka, the highest numbered written
* block offset) for the segment file referenced by the specified OID,
* partition, and segment number.
* This applies to either column or dictionary store OIDs.
* @param oid (in) The OID
* @param partitionNum (in) Relevant partition number.
* @param segmentNum (in) Relevant segment number.
* @param hwm (in) The high water mark of oid
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int setLocalHWM(OID_t oid, uint32_t partitionNum, uint16_t segmentNum, HWM_t hwm) DBRM_THROW;
EXPORT int bulkSetHWM(const std::vector<BulkSetHWMArg>&, VER_t transID = 0) DBRM_THROW;
/** @brief Does setLocalHWM, casual partitioning changes, & commit. The HWM &
* CP changes are atomic with this fcn. All functionality is optional. Passing
* in an empty vector for any of these parms makes it do nothing for the
* corresponding operation.
*
* It returns 0 if all operations succeed, -1 if any operation fails.
* The controllernode will undo all changes made on error.
*/
EXPORT int bulkSetHWMAndCP(const std::vector<BulkSetHWMArg>& hwmArgs,
const std::vector<CPInfo>& setCPDataArgs,
const std::vector<CPInfoMerge>& mergeCPDataArgs, VER_t transID) DBRM_THROW;
EXPORT int bulkUpdateDBRoot(const std::vector<BulkUpdateDBRootArg>&);
/** @brief Get HWM information about last segment file for each DBRoot
* assigned to a specific PM.
*
* Vector will contain an entry for each DBRoot. If no "available" extents
* are found for a DBRoot, then totalBlocks will be 0 (and hwmExtentIndex
* will be -1) for that DBRoot.
* @param oid The oid of interest.
* @param pmNumber The PM number of interest.
* @param emDbRootHwmInfos The vector of DbRoot/HWM related objects.
*/
EXPORT int getDbRootHWMInfo(OID_t oid, uint16_t pmNumber, EmDbRootHWMInfo_v& emDbRootHwmInfos) throw();
/** @brief Get the status (AVAILABLE, OUTOFSERVICE, etc) for the
* segment file represented by the specified OID, part# and seg#.
*
* Unlike many of the other DBRM functions, this function does
* not return a bad return code if no extent is found; the "found"
* flag indicates whether an extent was found or not.
*
* @param oid (in) The OID of interest
* @param partitionNum (in) The partition number of interest
* @param segmentNum (in) The segment number of interest
* @param bFound (out) Indicates if extent was found or not
* @param status (out) The state of the extents in the specified
* segment file.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getExtentState(OID_t oid, uint32_t partitionNum, uint16_t segmentNum, bool& bFound,
int& status) throw();
/** @brief Gets the extents of a given OID
*
* Gets the extents of a given OID.
* @param OID (in) The OID to get the extents for.
* @param entries (out) A snapshot of the OID's Extent Map entries
* sorted by starting LBID; note that The Real Entries can change at
* any time. Also, internally the size of an extent is measured in
* multiples of 1024 LBIDs. So, if the size field is 10, it represents
* 10240 LBIDs.
* @param sorted (in) indicates if output is to be sorted
* @param notFoundErr (in) indicates if no extents is considered an err
* @param incOutOfService (in) include/exclude out of service extents
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getExtents(int OID, std::vector<struct EMEntry>& entries, bool sorted = true,
bool notFoundErr = true, bool incOutOfService = false);
/** @brief Gets the extents of a given OID under specified dbroot
*
* Gets the extents of a given OID under specified dbroot.
* @param OID (in) The OID to get the extents for.
* @param entries (out) A snapshot of the OID's Extent Map entries
* @param dbroot (in) dbroot
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getExtents_dbroot(int OID, std::vector<struct EMEntry>& entries, const uint16_t dbroot) throw();
/** @brief Gets the number of extents for the specified OID and DBRoot
*
* @param OID (in) The OID of interest
* @param dbroot (in) The DBRoot of interest
* @param incOutOfService (in) include/exclude out of service extents
* @param numExtents (out) number of extents found for OID and dbroot
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getExtentCount_dbroot(int OID, uint16_t dbroot, bool incOutOfService,
uint64_t& numExtents) throw();
/** @brief Gets the number of rows in an extent
*
* Gets the number of rows in an extent.
* @return The extent size
*/
// dmc-getExtentSize() to be deprecated, replaced by getExtentRows()
EXPORT int getExtentSize() throw();
EXPORT unsigned getExtentRows() throw();
/** @brief Gets the DBRoot for the specified system catalog OID
*
* Function should only be called for System Catalog OIDs, as it assumes
* the OID is fully contained on a single DBRoot, returning the first
* DBRoot found. This only makes since for a System Catalog OID, because
* all other column OIDs can span multiple DBRoots.
*
* @param oid The system catalog OID
* @param dbRoot (out) the DBRoot holding the system catalog OID
*/
EXPORT int getSysCatDBRoot(OID_t oid, uint16_t& dbRoot) throw();
/** @brief Delete a Partition for the specified OID(s).
*
* @param OID (in) the OID of interest.
* @param partitionNums (in) the set of partitions to be deleted.
*/
EXPORT int deletePartition(const std::vector<OID_t>& oids, const std::set<LogicalPartition>& partitionNums,
std::string& emsg) DBRM_THROW;
/** @brief Mark a Partition for the specified OID(s) as out of service.
*
* @param OID (in) the OID of interest.
* @param partitionNums (in) the set of partitions to be marked out of service.
*/
EXPORT int markAllPartitionForDeletion(const std::vector<OID_t>& oids) DBRM_THROW;
/** @brief Mark a Partition for the specified OID(s) as out of service.
*
* @param OID (in) the OID of interest.
* @param partitionNums (in) the set of partitions to be marked out of service.
*/
EXPORT int markPartitionForDeletion(const std::vector<OID_t>& oids,
const std::set<LogicalPartition>& partitionNums,
std::string& emsg) DBRM_THROW;
/** @brief Restore a Partition for the specified OID(s).
*
* @param OID (in) the OID of interest.
* @param partitionNums (in) the set of partitions to be restored.
*/
EXPORT int restorePartition(const std::vector<OID_t>& oids, const std::set<LogicalPartition>& partitionNums,
std::string& emsg) DBRM_THROW;
/** @brief Get the list of out-of-service partitions for a given OID
*
* @param OID (in) the OID of interest.
* @param partitionNums (out) the out-of-service partitions for the oid.
* partitionNums will be in sorted order.
*/
EXPORT int getOutOfServicePartitions(OID_t oid, std::set<LogicalPartition>& partitionNums) throw();
/** @brief Delete all rows in the extent map that reside on the given DBRoot
*
* @param dbroot (in) the dbroot to be deleted
*/
EXPORT int deleteDBRoot(uint16_t dbroot) DBRM_THROW;
/** @brief Is the specified DBRoot empty with no extents.
* Returns error if extentmap shared memory is not loaded.
*
* @param dbroot DBRoot of interest
* @param isEmpty (output) Flag indiicating whether DBRoot is empty
* @param errMsg (output) Error message corresponding to bad return code
* @return ERR_OK on success
*/
EXPORT int isDBRootEmpty(uint16_t dbroot, bool& isEmpty, std::string& errMsg) throw();
/** @brief Registers a version buffer entry.
*
* Registers a version buffer entry at <vbOID, vbFBO> with
* values of <transID, lbid>.
* @note The version buffer locations must hold the 'copy' lock
* first.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int writeVBEntry(VER_t transID, LBID_t lbid, OID_t vbOID, uint32_t vbFBO) DBRM_THROW;
/** @brief Bulk registers a version buffer entry.
*
* Similar to writeVBEntry, but registers the version buffer
* entries in bulk for a list of lbids and vbFBOs, for a given
* transID and vbOID.
* @note The version buffer locations must hold the 'copy' lock
* first.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int bulkWriteVBEntry(VER_t transID, const std::vector<BRM::LBID_t>& lbids, OID_t vbOID,
const std::vector<uint32_t>& vbFBOs) DBRM_THROW;
/** @brief Retrieves a list of uncommitted LBIDs.
*
* Retrieves a list of uncommitted LBIDs for the given transaction ID.
* @param lbidList (out) On success this contains the ranges of LBIDs
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getUncommittedLBIDs(VER_t transID, std::vector<LBID_t>& lbidList) throw();
/** @brief Does what you think it does.
*
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getDBRootsForRollback(VER_t transID, std::vector<uint16_t>* dbRootList) throw();
// @bug 1509. Added getUncommittedExtentLBIDs function.
/** @brief Retrieves a list of uncommitted extent LBIDs.
*
* Retrieves a list of uncommitted LBIDs for the given transaction ID.
* This function differs from getUncommittedLBIDs in that only one LBID per
* extent is returned. It is used to return a list that can be used to update
* casual partitioning information which is tracked at the extent level rather
* than the block level.
* @param lbidList (out) On success this contains the ranges of LBIDs
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getUncommittedExtentLBIDs(VER_t transID, std::vector<LBID_t>& lbidList) throw();
// MCOL-5021
/** @brief Adds LBIDs to an existing list of LBIDs retrieved via call
* to getUncommittedExtentLBIDs().
*
* This function iterates over lbidList to find those LBIDs which belong to
* the AUX column. It then finds the corresponding LBIDs for all other columns
* which belong to the same table as the AUX LBID and appends them to lbidList.
* The updated lbidList is used by invalidateUncommittedExtentLBIDs().
* @param lbidList (in and out) This contains the ranges of LBIDs
*/
EXPORT void addToLBIDList(uint32_t sessionID, std::vector<LBID_t>& lbidList);
/** @brief Atomically prepare to copy data to the version buffer
*
* Atomically sets the copy flag on the specified LBID ranges
* and allocate blocks in the version buffer to copy them to.
* If any LBID in the range cannot be locked, none will be
* and this will return -1.
* @param transID The transaction ID doing the operation
* @param ranges (in) A list of LBID ranges that will be copied
* @param freeList (out) On success, a list of ranges of the version
* buffer blocks to copy the LBID range to.
* @note The caller must do a rollback or commit immediately after getting ERR_DEADLOCK (6).
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int beginVBCopy(VER_t transID, uint16_t dbRoot, const LBIDRange_v& ranges,
VBRange_v& freeList) DBRM_THROW;
/** @brief Atomically unset the copy lock & update the VSS. Beware! Read the warning!
*
* Atomically unset the copy lock for the specified LBID ranges
* and add a new locked VSS entry for each LBID in the range.
* @note The elements of the ranges parameter <b>MUST</b> be the
* same elements passed to beginVBCopy(). The number and order of the
* elements can be different, but every element in ranges must also
* have been an element in beginVBCopy's ranges.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int endVBCopy(VER_t transID, const LBIDRange_v& ranges) DBRM_THROW;
/** @brief Commit the changes made for the given transaction.
*
* This unlocks the VSS entries with VerID = transID.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int vbCommit(VER_t transID) DBRM_THROW;
/** @brief Reverse the changes made during the given transaction.
*
* Record that the given LBID was reverted to version verID.
* @warning This removes the copy locks held on all ranges by transID.
* @param transID The transaction ID
* @param lbidList The list of ranges to rollback.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int vbRollback(VER_t transID, const LBIDRange_v& lbidList) DBRM_THROW;
/** @brief Reverse the changes made during the given transaction.
*
* Record that the given LBID was reverted to version verID.
* @warning This removes the copy locks held on all ranges by transID.
* @param transID The transaction ID
* @param lbidList The list of singular LBIDs to rollback.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int vbRollback(VER_t transID, const std::vector<LBID_t>& lbidList) DBRM_THROW;
EXPORT int getUnlockedLBIDs(BlockList_t* list) DBRM_THROW;
/** @brief Reinitialize the versioning data structures.
*
* This entry point empties the VSS and VBBM structures on the
* slave nodes. At system startup and after recovery, the data left in
* the VSS and VBBM are unnecessary. The primary purpose of this function
* is to free up memory.
* @return 0 on success, non-0 on error (see brmtypes.h).
*/
EXPORT int clear() DBRM_THROW;
/** @brief Check the consistency of each data structure
*
* Check the consistency of each data structure
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int checkConsistency() throw();
/** @brief Get a list of the transactions currently in progress.
*
* Get a list of the transactions currently in progress. This scans
* the copy locks & VSS for LBIDs that are locked by some transaction
* and stores the transaction ID.
*
* @param txnList Caller-supplied set to store the results in.
* @return 0 on success, non-0 on error (see brmtypes.h)
*/
EXPORT int getCurrentTxnIDs(std::set<VER_t>& txnList) throw();
/** @brief Persistence API. Saves the local Extent Map to a file.
*
* Persistence API. Saves the <b>local</b> Extent Map to a file.
*
* @param filename Relative or absolute path to save to.
* @return 0 on success, -1 on error
*/
EXPORT int saveExtentMap(const std::string& filename) throw();
/** @brief Persistence API. Saves all BRM structures.
*
* Saves all <b>local</b> BRM structures to files.
*
* @param filename The filename prefix to use. Saves 4 files with that prefix.
* @return 0 on success, -1 on error
*/
EXPORT int saveState(std::string filename) throw();
/** @brief Persistence API. Saves all BRM structures using the filenames from Columnstore.xml.
*
* Saves all <b>local</b> BRM structures to files.
*
* @param filename The filename prefix to use. Saves 4 files with that prefix.
* @return 0 on success, -1 on error
*/
EXPORT int saveState() throw();
/** @brief A function that forces the BRM to write a snapshot of its data structures to disk
*
* A function that forces the BRM to write a snapshot of its data structures to disk.
* This happens automatically after commits and rollbacks. Bulk imports should call
* this fcn after an import.
*
* @return 0 on success, non-0 on error (see brmtypes.h).
*/
EXPORT int takeSnapshot() throw();
/* SessionManager interface */
EXPORT const QueryContext verID();
EXPORT const QueryContext sysCatVerID();
EXPORT uint8_t newCpimportJob(uint32_t& jobId);
EXPORT void finishCpimportJob(uint32_t jobId);
EXPORT const TxnID newTxnID(const SessionManagerServer::SID session, bool block, bool isDDL = false);
EXPORT void committed(BRM::TxnID& txnid);
EXPORT void rolledback(BRM::TxnID& txnid);
EXPORT const BRM::TxnID getTxnID(const SessionManagerServer::SID session);
EXPORT std::shared_ptr<SIDTIDEntry[]> SIDTIDMap(int& len);
EXPORT void sessionmanager_reset();
/* Note, these pull #s from two separate sequences. That is, they both
return 0, then 1, 2, 3, etc. */
EXPORT uint32_t getUnique32();
EXPORT uint64_t getUnique64();
/* New table lock interface */
/* returns a unique ID (> 0) for the lock on success, 0 on failure.
* Also, on failure, the ownerName, pid, and session ID parameters will be set
* to the owner of one of the overlapping locks. */
EXPORT uint64_t getTableLock(const std::vector<uint32_t>& pmList, uint32_t tableOID, std::string* ownerName,
uint32_t* ownerPID, int32_t* ownerSessionID, int32_t* ownerTxnID,
LockState state);
EXPORT bool releaseTableLock(uint64_t id);
EXPORT bool changeState(uint64_t id, LockState state);
EXPORT bool changeOwner(uint64_t id, const std::string& ownerName, uint32_t ownerPID,
int32_t ownerSessionID, int32_t ownerTxnID);
EXPORT bool checkOwner(uint64_t id);
EXPORT std::vector<TableLockInfo> getAllTableLocks();
EXPORT void releaseAllTableLocks();
EXPORT bool getTableLockInfo(uint64_t id, TableLockInfo* out);
/** Casual partitioning support **/
EXPORT int markExtentInvalid(const LBID_t lbid,
execplan::CalpontSystemCatalog::ColDataType colDataType) DBRM_THROW;
EXPORT int markExtentsInvalid(const std::vector<LBID_t>& lbids,
const std::vector<execplan::CalpontSystemCatalog::ColDataType>& colDataTypes)
DBRM_THROW;
template <typename T>
EXPORT int getExtentMaxMin(const LBID_t lbid, T& max, T& min, int32_t& seqNum);
EXPORT int setExtentMaxMin(const LBID_t lbid, const int64_t max, const int64_t min,
const int32_t seqNum) DBRM_THROW;
EXPORT int getExtentCPMaxMin(const LBID_t lbid, CPMaxMin& cpMaxMin);
/** @brief Updates the max and min casual partitioning info for the passed extents.
*
* @bug 1970.
*
* @param cpInfos vector of CPInfo objects. The firstLbid must be the first LBID in the extent.
* @return 0 on success, -1 on error
*/
EXPORT int setExtentsMaxMin(const CPInfoList_t& cpInfos) DBRM_THROW;
/** @brief Merges max/min casual partitioning info for the specified
* extents, with the current CP info.
*
* @param cpInfos vector of CPInfo objects. The Lbids must be the
* starting LBID in the relevant extent.
* @return 0 on success, -1 on error
*/
EXPORT int mergeExtentsMaxMin(const CPInfoMergeList_t& cpInfos) DBRM_THROW;
/* read-side interface for locking LBID ranges (used by PrimProc) */
EXPORT void lockLBIDRange(LBID_t start, uint32_t count);
EXPORT void releaseLBIDRange(LBID_t start, uint32_t count);
/* write-side interface for locking LBID ranges (used by DML) */
EXPORT int dmlLockLBIDRanges(const std::vector<LBIDRange>& ranges, int txnID);
EXPORT int dmlReleaseLBIDRanges(const std::vector<LBIDRange>& ranges);
/* OAM Interface */
EXPORT int halt() DBRM_THROW;
EXPORT int resume() DBRM_THROW;
EXPORT int forceReload() DBRM_THROW;
EXPORT int setReadOnly(bool b) DBRM_THROW;
EXPORT int startReadOnly() DBRM_THROW;
EXPORT int forceClearCpimportJobs() DBRM_THROW;
EXPORT int isReadWrite() throw();
EXPORT bool isEMEmpty() throw();
EXPORT std::vector<InlineLBIDRange> getEMFreeListEntries() throw();
/** @brief Check if the system is ready for updates
*
* Check is the system has completed rollback processing and is
* ready for updates
*/
EXPORT int getSystemReady() throw();
/** @brief Check if the system is ready for queries
*
* Check is the system has completed rollback processing and is
* ready for updates
*/
EXPORT int getSystemQueryReady() throw();
/** @brief Check if the system is suspended
*
* Suspended is caused by user at calpont-console
* @return 0 - system is not suspended, > 0 - system is
* suspended, < 0 on error
*/
EXPORT int getSystemSuspended() throw();
/** @brief Check if system suspension is pending
*
* If the user at calpont-console asks for suspension, but ddl,
* dml or cpimport are running, then we can't suspend. If user
* says suspend when all work completed, then this flag is set
* to prevent new work from starting.
* @param bRollback (out) if true, system is in a rollback mode
* before suspension.
* @return 0 - system is not in a suspend pending state, > 0 -
* system is in a suspend pending state, < 0 on error
*/
EXPORT int getSystemSuspendPending(bool& bRollback) throw();
/** @brief Check if system shutdown is pending
*
* If the user at calpont-console asks for shutdown, but ddl,
* dml or cpimport are running, then we can't shutdown. If user
* says shutdown when all work completed, then this flag is set
* to prevent new work from starting.
* @param bRollback (out) if true, system is in rollback mode
* before shutdown.
* @param bForce (out) if true, system is in force shutdown
* mode. No work of any kind should be done.
* @return 0 - system is not pending a shutdown, > 0 - system is
* pending a shutdown, < 0 on error
*/
EXPORT int getSystemShutdownPending(bool& bRollback, bool& bForce) throw();
/** @brief Mark the system as ready for updates
*
* The system has completed rollback processing and is therefore ready for updates
* @param bReady the state the ready flag should be set to.
* @return < 0 on error
*/
EXPORT int setSystemReady(bool bReady) throw();
/** @brief Mark the system as ready for queries
*
* The system has completed bring up all modules and is ready for queries
* Queries are allowed during DMLRollback, so SS_READY won't fork for queries.
* @param bReady the state the ready flag should be set to.
* @return < 0 on error
*/
EXPORT int setSystemQueryReady(bool bReady) throw();
/** @brief Mark the system as suspended (or not)
*
* @param bSuspended the suspend state the system should be set
* to.
* @return < 0 on error
*/
EXPORT int setSystemSuspended(bool bSuspended) throw();
/** @brief Mark the system as suspension pending
*
* @param bPending the suspend pending state the system should
* be set to.
* @param bRollback if true, rollback all active transactions
* before full suspension of writes (only used
* if bPending is true).
* @return < 0 on error
*/
EXPORT int setSystemSuspendPending(bool bPending, bool bRollback = false) throw();
/** @brief Mark the system as shutdown pending
*
* @param bPending the suspend pending state the system should
* be set to.
* @param bRollback if true, rollback all active transactions
* before shutting down. (only used if bPending
* is true).
* @param bForce if true, we're shutting down now. No further
* work, including rollback, should be done.
* (only used if bPending is true).
* @return < 0 on error
*/
EXPORT int setSystemShutdownPending(bool bPending, bool bRollback = false, bool bForce = false) throw();
/** @brief get the flags in the system state bit map.
* @param stateFlags (out)
* @return < 0 on error
*/
int getSystemState(uint32_t& stateFlags) throw();
/** @brief set the flags in the system state bit map.
*
* sets the flags that are set in stateFlags leaving other flags undisturbed
* @param stateFlags (out)
* @return < 0 on error
*/
int setSystemState(uint32_t stateFlags) throw();
/** @brief set the flags in the system state bit map.
*
* Clears the flags that are set in stateFlags leaving other flags undisturbed
* @param stateFlags (out)
* @return < 0 on error
*/
int clearSystemState(uint32_t stateFlags) throw();
/** @brief Check to see if Controller Node is functioning
*/
bool isDBRMReady() throw();
/* OID Manager interface. See oidserver.h for the API documentation. */
EXPORT int allocOIDs(int num);
EXPORT void returnOIDs(int start, int end);
EXPORT int oidm_size();
EXPORT int allocVBOID(uint32_t dbroot);
EXPORT int getDBRootOfVBOID(uint32_t vbOID);
EXPORT std::vector<uint16_t> getVBOIDToDBRootMap();
/* Autoincrement interface */
EXPORT void startAISequence(uint32_t OID, uint64_t firstNum, uint32_t colWidth,
execplan::CalpontSystemCatalog::ColDataType colDataType);
EXPORT bool getAIRange(uint32_t OID, uint32_t count, uint64_t* firstNum);
EXPORT bool getAIValue(uint32_t OID, uint64_t* value);
EXPORT void resetAISequence(uint32_t OID, uint64_t value);
EXPORT void getAILock(uint32_t OID);
EXPORT void releaseAILock(uint32_t OID);
/* Added to support unsigned */
/** @brief Invalidate the casual partitioning for all uncommited
* extents.
*
* Either txnid or plbidList can be passed . Only one will be
* used.
* @param txnid (in) - The transaction for which to get the lbid
* list.
* @param plbidList (in) - a list of lbids whose extents are to
* be invalidated. Only one lbid per extent should
* be in this list, such as returned in
* getUncommittedExtentLBIDs().
* @return nothing.
*/
EXPORT void invalidateUncommittedExtentLBIDs(execplan::CalpontSystemCatalog::SCN txnid, bool allExtents,
std::vector<LBID_t>* plbidList = NULL);
size_t EMIndexShmemSize();
size_t EMIndexShmemFree();
private:
DBRM(const DBRM& brm) = delete;
DBRM& operator=(const DBRM& brm) = delete;
int8_t send_recv(const messageqcpp::ByteStream& in, messageqcpp::ByteStream& out) throw();
void deleteAISequence(uint32_t OID); // called as part of deleteOID & deleteOIDs
boost::scoped_ptr<MasterSegmentTable> mst;
boost::scoped_ptr<ExtentMap> em;
boost::scoped_ptr<VBBM> vbbm;
boost::scoped_ptr<VSS> vss;
boost::scoped_ptr<CopyLocks> copylocks;
messageqcpp::MessageQueueClient* msgClient;
std::string masterName;
boost::mutex mutex;
config::Config* config;
bool fDebug;
};
} // namespace BRM
#undef EXPORT
View Git Blame Copy Permalink