int32_t QueryRequest::encode_batch(int version, BufferVec* bufs, RequestCallback* callback) const {
int32_t length = 0;
const std::string& query(query_);
// <kind><string><n>[name_1]<value_1>...[name_n]<value_n> ([byte][long string][short][bytes]...[bytes])
int buf_size = sizeof(uint8_t) + sizeof(int32_t) + query.size() + sizeof(uint16_t);
bufs->push_back(Buffer(buf_size));
length += buf_size;
Buffer& buf = bufs->back();
size_t pos = buf.encode_byte(0, kind());
pos = buf.encode_long_string(pos, query.data(), query.size());
if (has_names_for_values()) {
if (version < 3) {
LOG_ERROR("Protocol version %d does not support named values", version);
return REQUEST_ERROR_UNSUPPORTED_PROTOCOL;
}
buf.encode_uint16(pos, value_names_.size());
length += copy_buffers_with_names(version, bufs, callback->encoding_cache());
} else {
buf.encode_uint16(pos, elements_count());
if (elements_count() > 0) {
int32_t result = copy_buffers(version, bufs, callback);
if (result < 0) return result;
length += result;
}
}
return length;
}
bool Statement::get_routing_key(std::string* routing_key, EncodingCache* cache) const {
if (key_indices_.empty()) return false;
if (key_indices_.size() == 1) {
assert(key_indices_.front() < elements_count());
const AbstractData::Element& element(elements()[key_indices_.front()]);
if (element.is_empty()) {
return false;
}
Buffer buf(element.get_buffer_cached(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION, cache, true));
routing_key->assign(buf.data() + sizeof(int32_t),
buf.size() - sizeof(int32_t));
} else {
size_t length = 0;
for (std::vector<size_t>::const_iterator i = key_indices_.begin();
i != key_indices_.end(); ++i) {
assert(*i < elements_count());
const AbstractData::Element& element(elements()[*i]);
if (element.is_empty()) {
return false;
}
size_t size = element.get_size(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION) - sizeof(int32_t);
length += sizeof(uint16_t) + size + 1;
}
routing_key->clear();
routing_key->reserve(length);
for (std::vector<size_t>::const_iterator i = key_indices_.begin();
i != key_indices_.end(); ++i) {
const AbstractData::Element& element(elements()[*i]);
Buffer buf(element.get_buffer_cached(CASS_HIGHEST_SUPPORTED_PROTOCOL_VERSION, cache, true));
size_t size = buf.size() - sizeof(int32_t);
char size_buf[sizeof(uint16_t)];
encode_uint16(size_buf, size);
routing_key->append(size_buf, sizeof(uint16_t));
routing_key->append(buf.data() + sizeof(int32_t), size);
routing_key->push_back(0);
}
}
return true;
}
int32_t ExecuteRequest::encode_batch(int version, BufferVec* bufs, Handler* handler) const {
int32_t length = 0;
const std::string& id(prepared_->id());
// <kind><id><n><value_1>...<value_n> ([byte][short bytes][short][bytes]...[bytes])
int buf_size = sizeof(uint8_t) + sizeof(uint16_t) + id.size() + sizeof(uint16_t);
bufs->push_back(Buffer(buf_size));
length += buf_size;
Buffer& buf = bufs->back();
size_t pos = buf.encode_byte(0, kind());
pos = buf.encode_string(pos, id.data(), id.size());
buf.encode_uint16(pos, elements_count());
if (elements_count() > 0) {
int32_t result = copy_buffers(version, bufs, handler);
if (result < 0) return result;
length += result;
}
return length;
}
size_t QueryRequest::get_indices(StringRef name, IndexVec* indices) {
set_has_names_for_values(true);
if (value_names_.get_indices(name, indices) == 0) {
if (value_names_.size() > elements_count()) {
// No more space left for new named values
return 0;
}
if (name.size() > 0 && name.front() == '"' && name.back() == '"') {
name = name.substr(1, name.size() - 2);
}
indices->push_back(value_names_.add(ValueName(name.to_string())));
}
return indices->size();
}
int ExecuteRequest::internal_encode_v1(Handler* handler, BufferVec* bufs) const {
size_t length = 0;
const int version = 1;
const std::string& prepared_id = prepared_->id();
// <id> [short bytes] + <n> [short]
size_t prepared_buf_size = sizeof(uint16_t) + prepared_id.size() +
sizeof(uint16_t);
{
bufs->push_back(Buffer(prepared_buf_size));
length += prepared_buf_size;
Buffer& buf = bufs->back();
size_t pos = buf.encode_string(0,
prepared_id.data(),
prepared_id.size());
buf.encode_uint16(pos, elements_count());
// <value_1>...<value_n>
int32_t result = copy_buffers(version, bufs, handler);
if (result < 0) return result;
length += result;
}
{
// <consistency> [short]
size_t buf_size = sizeof(uint16_t);
Buffer buf(buf_size);
buf.encode_uint16(0, handler->consistency());
bufs->push_back(buf);
length += buf_size;
}
return length;
}
int QueryRequest::internal_encode(int version, RequestCallback* callback, BufferVec* bufs) const {
int length = 0;
uint8_t flags = this->flags();
// <query> [long string] + <consistency> [short] + <flags> [byte]
size_t query_buf_size = sizeof(int32_t) + query_.size() +
sizeof(uint16_t) + sizeof(uint8_t);
size_t paging_buf_size = 0;
if (elements_count() > 0) { // <values> = <n><value_1>...<value_n>
query_buf_size += sizeof(uint16_t); // <n> [short]
flags |= CASS_QUERY_FLAG_VALUES;
}
if (page_size() > 0) {
paging_buf_size += sizeof(int32_t); // [int]
flags |= CASS_QUERY_FLAG_PAGE_SIZE;
}
if (!paging_state().empty()) {
paging_buf_size += sizeof(int32_t) + paging_state().size(); // [bytes]
flags |= CASS_QUERY_FLAG_PAGING_STATE;
}
if (serial_consistency() != 0) {
paging_buf_size += sizeof(uint16_t); // [short]
flags |= CASS_QUERY_FLAG_SERIAL_CONSISTENCY;
}
if (version >= 3 && callback->timestamp() != CASS_INT64_MIN) {
paging_buf_size += sizeof(int64_t); // [long]
flags |= CASS_QUERY_FLAG_DEFAULT_TIMESTAMP;
}
{
bufs->push_back(Buffer(query_buf_size));
length += query_buf_size;
Buffer& buf = bufs->back();
size_t pos = buf.encode_long_string(0, query_.data(), query_.size());
pos = buf.encode_uint16(pos, callback->consistency());
pos = buf.encode_byte(pos, flags);
if (has_names_for_values()) {
if (version < 3) {
LOG_ERROR("Protocol version %d does not support named values", version);
return REQUEST_ERROR_UNSUPPORTED_PROTOCOL;
}
buf.encode_uint16(pos, value_names_.size());
length += copy_buffers_with_names(version, bufs, callback->encoding_cache());
} else if (elements_count() > 0) {
buf.encode_uint16(pos, elements_count());
int32_t result = copy_buffers(version, bufs, callback);
if (result < 0) return result;
length += result;
}
}
if (paging_buf_size > 0) {
bufs->push_back(Buffer(paging_buf_size));
length += paging_buf_size;
Buffer& buf = bufs->back();
size_t pos = 0;
if (page_size() >= 0) {
pos = buf.encode_int32(pos, page_size());
}
if (!paging_state().empty()) {
pos = buf.encode_bytes(pos, paging_state().data(), paging_state().size());
}
if (serial_consistency() != 0) {
pos = buf.encode_uint16(pos, serial_consistency());
}
if (version >= 3 && callback->timestamp() != CASS_INT64_MIN) {
pos = buf.encode_int64(pos, callback->timestamp());
}
}
return length;
}
int ExecuteRequest::internal_encode(int version, Handler* handler, BufferVec* bufs) const {
int length = 0;
uint8_t flags = this->flags();
const std::string& prepared_id = prepared_->id();
// <id> [short bytes] + <consistency> [short] + <flags> [byte]
size_t prepared_buf_size = sizeof(uint16_t) + prepared_id.size() +
sizeof(uint16_t) + sizeof(uint8_t);
size_t paging_buf_size = 0;
if (elements_count() > 0) { // <values> = <n><value_1>...<value_n>
prepared_buf_size += sizeof(uint16_t); // <n> [short]
flags |= CASS_QUERY_FLAG_VALUES;
}
if (page_size() >= 0) {
paging_buf_size += sizeof(int32_t); // [int]
flags |= CASS_QUERY_FLAG_PAGE_SIZE;
}
if (!paging_state().empty()) {
paging_buf_size += sizeof(int32_t) + paging_state().size(); // [bytes]
flags |= CASS_QUERY_FLAG_PAGING_STATE;
}
if (serial_consistency() != 0) {
paging_buf_size += sizeof(uint16_t); // [short]
flags |= CASS_QUERY_FLAG_SERIAL_CONSISTENCY;
}
if (version >= 3 && handler->timestamp() != CASS_INT64_MIN) {
paging_buf_size += sizeof(int64_t); // [long]
flags |= CASS_QUERY_FLAG_DEFAULT_TIMESTAMP;
}
{
bufs->push_back(Buffer(prepared_buf_size));
length += prepared_buf_size;
Buffer& buf = bufs->back();
size_t pos = buf.encode_string(0,
prepared_id.data(),
prepared_id.size());
pos = buf.encode_uint16(pos, handler->consistency());
pos = buf.encode_byte(pos, flags);
if (elements_count() > 0) {
buf.encode_uint16(pos, elements_count());
int32_t result = copy_buffers(version, bufs, handler);
if (result < 0) return result;
length += result;
}
}
if (paging_buf_size > 0) {
bufs->push_back(Buffer(paging_buf_size));
length += paging_buf_size;
Buffer& buf = bufs->back();
size_t pos = 0;
if (page_size() >= 0) {
pos = buf.encode_int32(pos, page_size());
}
if (!paging_state().empty()) {
pos = buf.encode_bytes(pos, paging_state().data(), paging_state().size());
}
if (serial_consistency() != 0) {
pos = buf.encode_uint16(pos, serial_consistency());
}
if (version >= 3 && handler->timestamp() != CASS_INT64_MIN) {
pos = buf.encode_int64(pos, handler->timestamp());
}
}
return length;
}
