const char* keyspace,

size_t keyspace_length) {

batch->set_keyspace(cass::String(keyspace, keyspace_length));

return CASS_OK;

CassConsistency consistency) {

batch->set_consistency(consistency);

return CASS_OK;

CassConsistency serial_consistency) {

batch->set_serial_consistency(serial_consistency);

return CASS_OK;

cass_int64_t timestamp) {

batch->set_timestamp(timestamp);

return CASS_OK;

cass_uint64_t timeout_ms) {

batch->set_request_timeout_ms(timeout_ms);

return CASS_OK;

cass_bool_t is_idempotent) {

batch->set_is_idempotent(is_idempotent == cass_true);

return CASS_OK;

CassRetryPolicy* retry_policy) {

batch->set_retry_policy(retry_policy);

return CASS_OK;

const CassCustomPayload* payload) {

batch->set_custom_payload(payload);

return CASS_OK;

cass_bool_t enabled) {

batch->set_tracing(enabled == cass_true);

return CASS_OK;

const char* name) {

return cass_batch_set_execution_profile_n(batch,

name,

SAFE_STRLEN(name));

const char* name,

size_t name_length) {

if (name_length > 0) {

batch->set_execution_profile_name(cass::String(name, name_length));

} else {

batch->set_execution_profile_name(cass::String());

}

return CASS_OK;

int length = 0;

uint32_t flags = 0;

{

// <type> [byte] + <n> [short]

size_t buf_size = sizeof(uint8_t) + sizeof(uint16_t);

Buffer buf(buf_size);

size_t pos = buf.encode_byte(0, type_);

buf.encode_uint16(pos, statements().size());

bufs->push_back(buf);

length += buf_size;

}

for (BatchRequest::StatementVec::const_iterator i = statements_.begin(),

end = statements_.end(); i != end; ++i) {

const Statement::Ptr& statement(*i);

if (statement->has_names_for_values()) {

callback->on_error(CASS_ERROR_LIB_BAD_PARAMS,

"Batches cannot contain queries with named values");

return REQUEST_ERROR_BATCH_WITH_NAMED_VALUES;

}

int32_t result = statement->encode_batch(version, callback, bufs);

if (result < 0) {

return result;

}

length += result;

}

{

// <consistency> [short]

size_t buf_size = sizeof(uint16_t);

// <flags>[<serial_consistency><timestamp><keyspace>]

if (version >= CASS_PROTOCOL_VERSION_V5) {

buf_size += sizeof(int32_t); // [int]

} else {

buf_size += sizeof(uint8_t); // [byte]

}

if (callback->serial_consistency() != 0) {

buf_size += sizeof(uint16_t); // [short]

flags |= CASS_QUERY_FLAG_SERIAL_CONSISTENCY;

}

if (callback->timestamp() != CASS_INT64_MIN) {

buf_size += sizeof(int64_t); // [long]

flags |= CASS_QUERY_FLAG_DEFAULT_TIMESTAMP;

}

if (version.supports_set_keyspace() && !keyspace().empty()) {

buf_size += sizeof(uint16_t) + keyspace().size();

flags |= CASS_QUERY_FLAG_WITH_KEYSPACE;

}

Buffer buf(buf_size);

size_t pos = buf.encode_uint16(0, callback->consistency());

if (version >= CASS_PROTOCOL_VERSION_V5) {

pos = buf.encode_int32(pos, flags);

} else {

pos = buf.encode_byte(pos, flags);

}

if (callback->serial_consistency() != 0) {

pos = buf.encode_uint16(pos, callback->serial_consistency());

}

if (callback->timestamp() != CASS_INT64_MIN) {

pos = buf.encode_int64(pos, callback->timestamp());

}

if (version.supports_set_keyspace() && !keyspace().empty()) {

pos = buf.encode_string(pos, keyspace().data(), keyspace().size());

}

bufs->push_back(buf);

length += buf_size;

}

return length;

// If the keyspace is not set then inherit the keyspace of the first

// statement with a non-empty keyspace.

if (keyspace().empty()) {

set_keyspace(statement->keyspace());

}

statements_.push_back(Statement::Ptr(statement));

for (StatementVec::const_iterator it = statements_.begin(),

end = statements_.end(); it != end; ++it) {

const Statement::Ptr& statement(*it);

if (statement->kind() == CASS_BATCH_KIND_PREPARED) {

ExecuteRequest* execute_request = static_cast<ExecuteRequest*>(statement.get());

if (execute_request->prepared()->id() == id) {

*query = execute_request->prepared()->query();

return true;

}

}

}

return false;

for (BatchRequest::StatementVec::const_iterator i = statements_.begin();

i != statements_.end(); ++i) {

if ((*i)->get_routing_key(routing_key)) {

return true;

}

}

return false;