317 lines
9.8 KiB
C++
317 lines
9.8 KiB
C++
/*
|
|
Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights
|
|
reserved.
|
|
|
|
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 St, Fifth Floor, Boston, MA
|
|
02110-1301 USA
|
|
*/
|
|
#ifndef NDBMEMCACHE_OPERATION_H
|
|
#define NDBMEMCACHE_OPERATION_H
|
|
|
|
#ifndef __cplusplus
|
|
#error "This file is for C++ only"
|
|
#endif
|
|
|
|
#include <NdbApi.hpp>
|
|
|
|
#include "ndbmemcache_global.h"
|
|
#include "Record.h"
|
|
#include "QueryPlan.h"
|
|
#include "debug.h"
|
|
#include "workitem.h"
|
|
|
|
/* Use a QueryPlan to perform an operation.
|
|
|
|
A query plan owns three records: a key_record, a val_record, and a row_record.
|
|
In general, the purpose of the Operation class is to hide this fact from
|
|
the user, and to perform one of Record's method using the correct record.
|
|
*/
|
|
|
|
class Operation {
|
|
public:
|
|
/* Pointers to buffers used in operations.
|
|
These are public because the caller owns the memory they point to. */
|
|
char *buffer;
|
|
char *key_buffer;
|
|
|
|
private:
|
|
/* Private instance variables */
|
|
const QueryPlan *plan;
|
|
const int op;
|
|
const Record *record;
|
|
Uint8 row_mask[4];
|
|
Uint8 key_mask[4];
|
|
Uint8 * read_mask_ptr;
|
|
|
|
/* Private methods */
|
|
void set_default_record();
|
|
bool setFieldsInRow(int offset, const char *type, int, const char *, size_t);
|
|
|
|
public:
|
|
// Constructors
|
|
Operation(QueryPlan *p, int o = 1, char *kbuf = 0);
|
|
Operation(workitem *, Uint32 saved_row_mask = 0);
|
|
Operation(QueryPlan *p, char * buffer);
|
|
|
|
// Public Methods
|
|
void save_row_mask(Uint32 * loc);
|
|
|
|
// Select columns for reading
|
|
void readSelectedColumns();
|
|
void readAllColumns();
|
|
void readColumn(int id);
|
|
|
|
// Methods for writing to the key record
|
|
size_t requiredKeyBuffer();
|
|
void clearKeyNullBits();
|
|
bool setKey(int nparts, const char *key_str, size_t key_str_len);
|
|
bool setKeyPart(int id, const char *strval, size_t strlen);
|
|
bool setKeyPartInt(int id, int value);
|
|
void setKeyPartNull(int id);
|
|
|
|
// Methods for writing to the row
|
|
size_t requiredBuffer();
|
|
void setNullBits();
|
|
void clearNullBits();
|
|
bool setKeyFieldsInRow(int nparts, const char *key_str, size_t key_str_len);
|
|
bool setValueFieldsInRow(int nparts, const char *val_str, size_t val_str_len);
|
|
bool setColumn(int id, const char *strval, size_t strlen);
|
|
bool setColumnInt(int id, int value);
|
|
bool setColumnBigUnsigned(int id, Uint64 value);
|
|
void setColumnNull(int id);
|
|
void setColumnNotNull(int id);
|
|
|
|
// Methods for reading columns from the response
|
|
int nValues() const;
|
|
bool isNull(int id) const;
|
|
size_t getStringifiedLength() const;
|
|
void * getPointer(int id) const;
|
|
int getIntValue(int id) const;
|
|
Uint64 getBigUnsignedValue(int id) const;
|
|
bool getStringValueNoCopy(int id, char **dstptr, size_t *lenptr) const;
|
|
bool appendCRLF(int id, size_t len) const;
|
|
size_t copyValue(int id, char *dest) const;
|
|
|
|
/* NdbTransaction method wrappers */
|
|
// startTransaction
|
|
NdbTransaction *startTransaction(Ndb *) const;
|
|
|
|
// read
|
|
const NdbOperation *readTuple(NdbTransaction *tx,
|
|
NdbOperation::LockMode lmod = NdbOperation::LM_SimpleRead);
|
|
|
|
// delete
|
|
const NdbOperation *deleteTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions *options = 0);
|
|
const NdbOperation *deleteCurrentTuple(NdbScanOperation *, NdbTransaction *,
|
|
NdbOperation::OperationOptions *opts = 0);
|
|
|
|
// write
|
|
const NdbOperation *writeTuple(NdbTransaction *tx);
|
|
const NdbOperation *insertRow(NdbTransaction *tx);
|
|
const NdbOperation *insertTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions *options = 0);
|
|
const NdbOperation *updateTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions *options = 0);
|
|
|
|
// scan
|
|
NdbScanOperation *scanTable(NdbTransaction *tx,
|
|
NdbOperation::LockMode lmod = NdbOperation::LM_Read,
|
|
NdbScanOperation::ScanOptions *options = 0);
|
|
NdbIndexScanOperation *scanIndex(NdbTransaction *tx,
|
|
NdbIndexScanOperation::IndexBound *bound);
|
|
};
|
|
|
|
|
|
/* ================= Inline methods ================= */
|
|
|
|
inline void Operation::save_row_mask(Uint32 * loc) {
|
|
memcpy(loc, row_mask, 4);
|
|
}
|
|
|
|
/* Select columns for reading */
|
|
|
|
inline void Operation::readSelectedColumns() {
|
|
read_mask_ptr = row_mask;
|
|
}
|
|
|
|
inline void Operation::readAllColumns() {
|
|
read_mask_ptr = 0;
|
|
}
|
|
|
|
inline void Operation::readColumn(int id) {
|
|
record->maskActive(id, row_mask);
|
|
}
|
|
|
|
/* Methods for writing to the key record */
|
|
|
|
inline size_t Operation::requiredKeyBuffer() {
|
|
/* Malloc checkers complain if this +1 is not present. Not sure why.
|
|
Theory: because the terminating null of a C-string may be written there. */
|
|
return plan->key_record->rec_size + 1;
|
|
}
|
|
|
|
inline void Operation::clearKeyNullBits() {
|
|
plan->key_record->clearNullBits(key_buffer);
|
|
}
|
|
|
|
inline bool Operation::setKeyPart(int id, const char *strval, size_t str_len) {
|
|
int s = plan->key_record->encode(id, strval, str_len, key_buffer, key_mask);
|
|
return (s > 0);
|
|
}
|
|
|
|
inline bool Operation::setKeyPartInt(int id, int value) {
|
|
return plan->key_record->setIntValue(id, value, key_buffer, key_mask);
|
|
}
|
|
|
|
inline void Operation::setKeyPartNull(int id) {
|
|
plan->key_record->setNull(id, key_buffer, key_mask);
|
|
}
|
|
|
|
|
|
/* Methods for writing to the row */
|
|
|
|
inline size_t Operation::requiredBuffer() {
|
|
return record->rec_size + 1;
|
|
}
|
|
|
|
inline void Operation::setNullBits() {
|
|
record->setNullBits(buffer);
|
|
}
|
|
|
|
inline void Operation::clearNullBits() {
|
|
record->clearNullBits(buffer);
|
|
}
|
|
|
|
inline bool Operation::setColumn(int id, const char *strval, size_t strlen) {
|
|
int s = record->encode(id, strval, strlen, buffer, row_mask);
|
|
return (s > 0);
|
|
}
|
|
|
|
inline bool Operation::setColumnInt(int id, int value) {
|
|
return record->setIntValue(id, value, buffer, row_mask);
|
|
}
|
|
|
|
inline bool Operation::setColumnBigUnsigned(int id, Uint64 value) {
|
|
return record->setUint64Value(id, value, buffer, row_mask);
|
|
}
|
|
|
|
inline void Operation::setColumnNull(int id) {
|
|
record->setNull(id, buffer, row_mask);
|
|
}
|
|
|
|
inline void Operation::setColumnNotNull(int id) {
|
|
record->setNotNull(id, buffer, row_mask);
|
|
}
|
|
|
|
inline bool Operation::setKeyFieldsInRow(int nparts, const char *dbkey, size_t key_len) {
|
|
return setFieldsInRow(COL_STORE_KEY, "key", nparts, dbkey, key_len);
|
|
}
|
|
|
|
inline bool Operation::setValueFieldsInRow(int nparts, const char *dbval, size_t val_len) {
|
|
return setFieldsInRow(COL_STORE_VALUE, "value", nparts, dbval, val_len);
|
|
}
|
|
|
|
|
|
/* Methods for reading columns from the response */
|
|
|
|
inline int Operation::nValues() const {
|
|
return record->nvalues;
|
|
}
|
|
|
|
inline bool Operation::isNull(int id) const {
|
|
return record->isNull(id, buffer);
|
|
}
|
|
|
|
inline size_t Operation::getStringifiedLength() const {
|
|
return record->getStringifiedLength(buffer);
|
|
}
|
|
|
|
inline void * Operation::getPointer(int id) const {
|
|
return record->getPointer(id, buffer);
|
|
}
|
|
|
|
inline int Operation::getIntValue(int id) const {
|
|
return record->getIntValue(id, buffer);
|
|
}
|
|
|
|
inline Uint64 Operation::getBigUnsignedValue(int id) const {
|
|
return record->getUint64Value(id, buffer);
|
|
}
|
|
|
|
inline bool Operation::appendCRLF(int id, size_t len) const {
|
|
return record->appendCRLF(id, len, buffer);
|
|
}
|
|
|
|
|
|
/* NdbTransaction method wrappers */
|
|
|
|
inline const NdbOperation *
|
|
Operation::readTuple(NdbTransaction *tx, NdbOperation::LockMode lmode) {
|
|
return tx->readTuple(plan->key_record->ndb_record, key_buffer,
|
|
record->ndb_record, buffer, lmode,
|
|
read_mask_ptr);
|
|
}
|
|
|
|
inline const NdbOperation *
|
|
Operation::deleteTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions * options) {
|
|
return tx->deleteTuple(plan->key_record->ndb_record, key_buffer,
|
|
plan->val_record->ndb_record, 0, 0, options);
|
|
}
|
|
|
|
inline const NdbOperation * Operation::writeTuple(NdbTransaction *tx) {
|
|
return tx->writeTuple(plan->key_record->ndb_record, key_buffer,
|
|
plan->row_record->ndb_record, buffer, row_mask);
|
|
}
|
|
|
|
inline const NdbOperation * Operation::insertRow(NdbTransaction *tx) {
|
|
return tx->insertTuple(plan->row_record->ndb_record, buffer, row_mask);
|
|
}
|
|
|
|
inline const NdbOperation *
|
|
Operation::insertTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions * options) {
|
|
return tx->insertTuple(plan->key_record->ndb_record, key_buffer,
|
|
plan->row_record->ndb_record, buffer,
|
|
row_mask, options);
|
|
}
|
|
|
|
inline const NdbOperation *
|
|
Operation::updateTuple(NdbTransaction *tx,
|
|
NdbOperation::OperationOptions * options) {
|
|
return tx->updateTuple(plan->key_record->ndb_record, key_buffer,
|
|
plan->row_record->ndb_record, buffer,
|
|
row_mask, options);
|
|
}
|
|
|
|
inline NdbScanOperation *
|
|
Operation::scanTable(NdbTransaction *tx, NdbOperation::LockMode lmode,
|
|
NdbScanOperation::ScanOptions *opts) {
|
|
return tx->scanTable(record->ndb_record, lmode,
|
|
read_mask_ptr, opts, 0);
|
|
}
|
|
|
|
inline const NdbOperation *
|
|
Operation::deleteCurrentTuple(NdbScanOperation *scanop,
|
|
NdbTransaction *tx,
|
|
NdbOperation::OperationOptions *opts) {
|
|
return scanop->deleteCurrentTuple(tx, record->ndb_record, buffer,
|
|
read_mask_ptr, opts);
|
|
}
|
|
|
|
|
|
#endif
|