null value.
* @private
* @type {Set}
*/
const zeroLengthTypesSupported = new Set([
dataTypes.text,
dataTypes.ascii,
dataTypes.varchar,
dataTypes.custom,
dataTypes.blob
]);
/**
* Serializes and deserializes to and from a CQL type and a Javascript Type.
* @param {Number} protocolVersion
* @param {ClientOptions} options
* @constructor
*/
function Encoder(protocolVersion, options) {
this.encodingOptions = options.encoding || utils.emptyObject;
defineInstanceMembers.call(this);
this.setProtocolVersion(protocolVersion);
setEncoders.call(this);
if (this.encodingOptions.copyBuffer) {
this.handleBuffer = handleBufferCopy;
}
else {
this.handleBuffer = handleBufferRef;
}
}
/**
* Declares the privileged instance members.
* @private
*/
function defineInstanceMembers() {
/**
* Sets the protocol version and the encoding/decoding methods depending on the protocol version
* @param {Number} value
* @ignore
* @internal
*/
this.setProtocolVersion = function (value) {
this.protocolVersion = value;
//Set the collection serialization based on the protocol version
this.decodeCollectionLength = decodeCollectionLengthV3;
this.getLengthBuffer = getLengthBufferV3;
this.collectionLengthSize = 4;
if (!types.protocolVersion.uses4BytesCollectionLength(this.protocolVersion)) {
this.decodeCollectionLength = decodeCollectionLengthV2;
this.getLengthBuffer = getLengthBufferV2;
this.collectionLengthSize = 2;
}
};
const customDecoders = {
[customTypeNames.duration]: decodeDuration,
[customTypeNames.lineString]: decodeLineString,
[customTypeNames.point]: decodePoint,
[customTypeNames.polygon]: decodePolygon,
[customTypeNames.dateRange]: decodeDateRange
};
const customEncoders = {
[customTypeNames.duration]: encodeDuration,
[customTypeNames.lineString]: encodeLineString,
[customTypeNames.point]: encodePoint,
[customTypeNames.polygon]: encodePolygon,
[customTypeNames.dateRange]: encodeDateRange
};
// Decoding methods
this.decodeBlob = function (bytes) {
return this.handleBuffer(bytes);
};
this.decodeCustom = function (bytes, typeName) {
const handler = customDecoders[typeName];
if (handler) {
return handler.call(this, bytes);
}
return this.handleBuffer(bytes);
};
this.decodeUtf8String = function (bytes) {
return bytes.toString('utf8');
};
this.decodeAsciiString = function (bytes) {
return bytes.toString('ascii');
};
this.decodeBoolean = function (bytes) {
return !!bytes.readUInt8(0);
};
this.decodeDouble = function (bytes) {
return bytes.readDoubleBE(0);
};
this.decodeFloat = function (bytes) {
return bytes.readFloatBE(0);
};
this.decodeInt = function (bytes) {
return bytes.readInt32BE(0);
};
this.decodeSmallint = function (bytes) {
return bytes.readInt16BE(0);
};
this.decodeTinyint = function (bytes) {
return bytes.readInt8(0);
};
this._decodeCqlLongAsLong = function (bytes) {
return Long.fromBuffer(bytes);
};
this._decodeCqlLongAsBigInt = function (bytes) {
return BigInt.asIntN(64, (BigInt(bytes.readUInt32BE(0)) << bigInt32) | BigInt(bytes.readUInt32BE(4)));
};
this.decodeLong = this.encodingOptions.useBigIntAsLong
? this._decodeCqlLongAsBigInt
: this._decodeCqlLongAsLong;
this._decodeVarintAsInteger = function (bytes) {
return Integer.fromBuffer(bytes);
};
this._decodeVarintAsBigInt = function decodeVarintAsBigInt(bytes) {
let result = bigInt0;
if (bytes[0] <= 0x7f) {
for (let i = 0; i < bytes.length; i++) {
const b = BigInt(bytes[bytes.length - 1 - i]);
result = result | (b << BigInt(i * 8));
}
} else {
for (let i = 0; i < bytes.length; i++) {
const b = BigInt(bytes[bytes.length - 1 - i]);
result = result | ((~b & bigInt8BitsOn) << BigInt(i * 8));
}
result = ~result;
}
return result;
};
this.decodeVarint = this.encodingOptions.useBigIntAsVarint
? this._decodeVarintAsBigInt
: this._decodeVarintAsInteger;
this.decodeDecimal = function(bytes) {
return BigDecimal.fromBuffer(bytes);
};
this.decodeTimestamp = function(bytes) {
return new Date(this._decodeCqlLongAsLong(bytes).toNumber());
};
this.decodeDate = function (bytes) {
return types.LocalDate.fromBuffer(bytes);
};
this.decodeTime = function (bytes) {
return types.LocalTime.fromBuffer(bytes);
};
/*
* Reads a list from bytes
*/
this.decodeList = function (bytes, subtype) {
const totalItems = this.decodeCollectionLength(bytes, 0);
let offset = this.collectionLengthSize;
const list = new Array(totalItems);
for (let i = 0; i < totalItems; i++) {
//bytes length of the item
const length = this.decodeCollectionLength(bytes, offset);
offset += this.collectionLengthSize;
//slice it
list[i] = this.decode(bytes.slice(offset, offset+length), subtype);
offset += length;
}
return list;
};
/*
* Reads a Set from bytes
*/
this.decodeSet = function (bytes, subtype) {
const arr = this.decodeList(bytes, subtype);
if (this.encodingOptions.set) {
const setConstructor = this.encodingOptions.set;
return new setConstructor(arr);
}
return arr;
};
/*
* Reads a map (key / value) from bytes
*/
this.decodeMap = function (bytes, subtypes) {
let map;
const totalItems = this.decodeCollectionLength(bytes, 0);
let offset = this.collectionLengthSize;
const self = this;
function readValues(callback, thisArg) {
for (let i = 0; i < totalItems; i++) {
const keyLength = self.decodeCollectionLength(bytes, offset);
offset += self.collectionLengthSize;
const key = self.decode(bytes.slice(offset, offset + keyLength), subtypes[0]);
offset += keyLength;
const valueLength = self.decodeCollectionLength(bytes, offset);
offset += self.collectionLengthSize;
if (valueLength < 0) {
callback.call(thisArg, key, null);
continue;
}
const value = self.decode(bytes.slice(offset, offset + valueLength), subtypes[1]);
offset += valueLength;
callback.call(thisArg, key, value);
}
}
if (this.encodingOptions.map) {
const mapConstructor = this.encodingOptions.map;
map = new mapConstructor();
readValues(map.set, map);
}
else {
map = {};
readValues(function (key, value) {
map[key] = value;
});
}
return map;
};
this.decodeUuid = function (bytes) {
return new types.Uuid(this.handleBuffer(bytes));
};
this.decodeTimeUuid = function (bytes) {
return new types.TimeUuid(this.handleBuffer(bytes));
};
this.decodeInet = function (bytes) {
return new types.InetAddress(this.handleBuffer(bytes));
};
/**
* Decodes a user defined type into an object
* @param {Buffer} bytes
* @param {{fields: Array}} udtInfo
* @private
*/
this.decodeUdt = function (bytes, udtInfo) {
const result = {};
let offset = 0;
for (let i = 0; i < udtInfo.fields.length && offset < bytes.length; i++) {
//bytes length of the field value
const length = bytes.readInt32BE(offset);
offset += 4;
//slice it
const field = udtInfo.fields[i];
if (length < 0) {
result[field.name] = null;
continue;
}
result[field.name] = this.decode(bytes.slice(offset, offset+length), field.type);
offset += length;
}
return result;
};
this.decodeTuple = function (bytes, tupleInfo) {
const elements = new Array(tupleInfo.length);
let offset = 0;
for (let i = 0; i < tupleInfo.length && offset < bytes.length; i++) {
const length = bytes.readInt32BE(offset);
offset += 4;
if (length < 0) {
elements[i] = null;
continue;
}
elements[i] = this.decode(bytes.slice(offset, offset+length), tupleInfo[i]);
offset += length;
}
return types.Tuple.fromArray(elements);
};
//Encoding methods
this.encodeFloat = function (value) {
if (typeof value === 'string') {
// All numeric types are supported as strings for historical reasons
value = parseFloat(value);
if (Number.isNaN(value)) {
throw new TypeError(`Expected string representation of a number, obtained ${util.inspect(value)}`);
}
}
if (typeof value !== 'number') {
throw new TypeError('Expected Number, obtained ' + util.inspect(value));
}
const buf = utils.allocBufferUnsafe(4);
buf.writeFloatBE(value, 0);
return buf;
};
this.encodeDouble = function (value) {
if (typeof value === 'string') {
// All numeric types are supported as strings for historical reasons
value = parseFloat(value);
if (Number.isNaN(value)) {
throw new TypeError(`Expected string representation of a number, obtained ${util.inspect(value)}`);
}
}
if (typeof value !== 'number') {
throw new TypeError('Expected Number, obtained ' + util.inspect(value));
}
const buf = utils.allocBufferUnsafe(8);
buf.writeDoubleBE(value, 0);
return buf;
};
/**
* @param {Date|String|Long|Number} value
* @private
*/
this.encodeTimestamp = function (value) {
const originalValue = value;
if (typeof value === 'string') {
value = new Date(value);
}
if (value instanceof Date) {
//milliseconds since epoch
value = value.getTime();
if (isNaN(value)) {
throw new TypeError('Invalid date: ' + originalValue);
}
}
if (this.encodingOptions.useBigIntAsLong) {
value = BigInt(value);
}
return this.encodeLong(value);
};
/**
* @param {Date|String|LocalDate} value
* @returns {Buffer}
* @throws {TypeError}
* @private
*/
this.encodeDate = function (value) {
const originalValue = value;
try {
if (typeof value === 'string') {
value = types.LocalDate.fromString(value);
}
if (value instanceof Date) {
value = types.LocalDate.fromDate(value);
}
}
catch (err) {
//Wrap into a TypeError
throw new TypeError('LocalDate could not be parsed ' + err);
}
if (!(value instanceof types.LocalDate)) {
throw new TypeError('Expected Date/String/LocalDate, obtained ' + util.inspect(originalValue));
}
return value.toBuffer();
};
/**
* @param {String|LocalDate} value
* @returns {Buffer}
* @throws {TypeError}
* @private
*/
this.encodeTime = function (value) {
const originalValue = value;
try {
if (typeof value === 'string') {
value = types.LocalTime.fromString(value);
}
}
catch (err) {
//Wrap into a TypeError
throw new TypeError('LocalTime could not be parsed ' + err);
}
if (!(value instanceof types.LocalTime)) {
throw new TypeError('Expected String/LocalTime, obtained ' + util.inspect(originalValue));
}
return value.toBuffer();
};
/**
* @param {Uuid|String|Buffer} value
* @private
*/
this.encodeUuid = function (value) {
if (typeof value === 'string') {
try {
value = types.Uuid.fromString(value).getBuffer();
}
catch (err) {
throw new TypeError(err.message);
}
} else if (value instanceof types.Uuid) {
value = value.getBuffer();
} else {
throw new TypeError('Not a valid Uuid, expected Uuid/String/Buffer, obtained ' + util.inspect(value));
}
return value;
};
/**
* @param {String|InetAddress|Buffer} value
* @returns {Buffer}
* @private
*/
this.encodeInet = function (value) {
if (typeof value === 'string') {
value = types.InetAddress.fromString(value);
}
if (value instanceof types.InetAddress) {
value = value.getBuffer();
}
if (!(value instanceof Buffer)) {
throw new TypeError('Not a valid Inet, expected InetAddress/Buffer, obtained ' + util.inspect(value));
}
return value;
};
/**
* @param {Long|Buffer|String|Number} value
* @private
*/
this._encodeBigIntFromLong = function (value) {
if (typeof value === 'number') {
value = Long.fromNumber(value);
} else if (typeof value === 'string') {
value = Long.fromString(value);
}
let buf = null;
if (value instanceof Long) {
buf = Long.toBuffer(value);
} else if (value instanceof MutableLong) {
buf = Long.toBuffer(value.toImmutable());
}
if (buf === null) {
throw new TypeError('Not a valid bigint, expected Long/Number/String/Buffer, obtained ' + util.inspect(value));
}
return buf;
};
this._encodeBigIntFromBigInt = function (value) {
if (typeof value === 'string') {
// All numeric types are supported as strings for historical reasons
value = BigInt(value);
}
// eslint-disable-next-line valid-typeof
if (typeof value !== 'bigint') {
// Only BigInt values are supported
throw new TypeError('Not a valid BigInt value, obtained ' + util.inspect(value));
}
const buffer = utils.allocBufferUnsafe(8);
buffer.writeUInt32BE(Number(value >> bigInt32) >>> 0, 0);
buffer.writeUInt32BE(Number(value & bigInt32BitsOn), 4);
return buffer;
};
this.encodeLong = this.encodingOptions.useBigIntAsLong
? this._encodeBigIntFromBigInt
: this._encodeBigIntFromLong;
/**
* @param {Integer|Buffer|String|Number} value
* @returns {Buffer}
* @private
*/
this._encodeVarintFromInteger = function (value) {
if (typeof value === 'number') {
value = Integer.fromNumber(value);
}
if (typeof value === 'string') {
value = Integer.fromString(value);
}
let buf = null;
if (value instanceof Buffer) {
buf = value;
}
if (value instanceof Integer) {
buf = Integer.toBuffer(value);
}
if (buf === null) {
throw new TypeError('Not a valid varint, expected Integer/Number/String/Buffer, obtained ' + util.inspect(value));
}
return buf;
};
this._encodeVarintFromBigInt = function (value) {
if (typeof value === 'string') {
// All numeric types are supported as strings for historical reasons
value = BigInt(value);
}
// eslint-disable-next-line valid-typeof
if (typeof value !== 'bigint') {
throw new TypeError('Not a valid varint, expected BigInt, obtained ' + util.inspect(value));
}
if (value === bigInt0) {
return buffers.int8Zero;
}
else if (value === bigIntMinus1) {
return buffers.int8MaxValue;
}
const parts = [];
if (value > bigInt0){
while (value !== bigInt0) {
parts.unshift(Number(value & bigInt8BitsOn));
value = value >> bigInt8;
}
if (parts[0] > 0x7f) {
// Positive value needs a padding
parts.unshift(0);
}
} else {
while (value !== bigIntMinus1) {
parts.unshift(Number(value & bigInt8BitsOn));
value = value >> bigInt8;
}
if (parts[0] <= 0x7f) {
// Negative value needs a padding
parts.unshift(0xff);
}
}
return utils.allocBufferFromArray(parts);
};
this.encodeVarint = this.encodingOptions.useBigIntAsVarint
? this._encodeVarintFromBigInt
: this._encodeVarintFromInteger;
/**
* @param {BigDecimal|Buffer|String|Number} value
* @returns {Buffer}
* @private
*/
this.encodeDecimal = function (value) {
if (typeof value === 'number') {
value = BigDecimal.fromNumber(value);
} else if (typeof value === 'string') {
value = BigDecimal.fromString(value);
}
let buf = null;
if (value instanceof BigDecimal) {
buf = BigDecimal.toBuffer(value);
} else {
throw new TypeError('Not a valid varint, expected BigDecimal/Number/String/Buffer, obtained ' + util.inspect(value));
}
return buf;
};
this.encodeString = function (value, encoding) {
if (typeof value !== 'string') {
throw new TypeError('Not a valid text value, expected String obtained ' + util.inspect(value));
}
return utils.allocBufferFromString(value, encoding);
};
this.encodeUtf8String = function (value) {
return this.encodeString(value, 'utf8');
};
this.encodeAsciiString = function (value) {
return this.encodeString(value, 'ascii');
};
this.encodeBlob = function (value) {
if (!(value instanceof Buffer)) {
throw new TypeError('Not a valid blob, expected Buffer obtained ' + util.inspect(value));
}
return value;
};
this.encodeCustom = function (value, name) {
const handler = customEncoders[name];
if (handler) {
return handler.call(this, value);
}
throw new TypeError('No encoding handler found for type ' + name);
};
/**
* @param {Boolean} value
* @returns {Buffer}
* @private
*/
this.encodeBoolean = function (value) {
return value ? buffers.int8One : buffers.int8Zero;
};
/**
* @param {Number|String} value
* @private
*/
this.encodeInt = function (value) {
if (isNaN(value)) {
throw new TypeError('Expected Number, obtained ' + util.inspect(value));
}
const buf = utils.allocBufferUnsafe(4);
buf.writeInt32BE(value, 0);
return buf;
};
/**
* @param {Number|String} value
* @private
*/
this.encodeSmallint = function (value) {
if (isNaN(value)) {
throw new TypeError('Expected Number, obtained ' + util.inspect(value));
}
const buf = utils.allocBufferUnsafe(2);
buf.writeInt16BE(value, 0);
return buf;
};
/**
* @param {Number|String} value
* @private
*/
this.encodeTinyint = function (value) {
if (isNaN(value)) {
throw new TypeError('Expected Number, obtained ' + util.inspect(value));
}
const buf = utils.allocBufferUnsafe(1);
buf.writeInt8(value, 0);
return buf;
};
this.encodeList = function (value, subtype) {
if (!Array.isArray(value)) {
throw new TypeError('Not a valid list value, expected Array obtained ' + util.inspect(value));
}
if (value.length === 0) {
return null;
}
const parts = [];
parts.push(this.getLengthBuffer(value));
for (let i = 0;i < value.length;i++) {
const val = value[i];
if (val === null || typeof val === 'undefined' || val === types.unset) {
throw new TypeError('A collection can\'t contain null or unset values');
}
const bytes = this.encode(val, subtype);
//include item byte length
parts.push(this.getLengthBuffer(bytes));
//include item
parts.push(bytes);
}
return Buffer.concat(parts);
};
this.encodeSet = function (value, subtype) {
if (this.encodingOptions.set && value instanceof this.encodingOptions.set) {
const arr = [];
value.forEach(function (x) {
arr.push(x);
});
return this.encodeList(arr, subtype);
}
return this.encodeList(value, subtype);
};
/**
* Serializes a map into a Buffer
* @param value
* @param {Array} [subtypes]
* @returns {Buffer}
* @private
*/
this.encodeMap = function (value, subtypes) {
const parts = [];
let propCounter = 0;
let keySubtype = null;
let valueSubtype = null;
const self = this;
if (subtypes) {
keySubtype = subtypes[0];
valueSubtype = subtypes[1];
}
function addItem(val, key) {
if (key === null || typeof key === 'undefined' || key === types.unset) {
throw new TypeError('A map can\'t contain null or unset keys');
}
if (val === null || typeof val === 'undefined' || val === types.unset) {
throw new TypeError('A map can\'t contain null or unset values');
}
const keyBuffer = self.encode(key, keySubtype);
//include item byte length
parts.push(self.getLengthBuffer(keyBuffer));
//include item
parts.push(keyBuffer);
//value
const valueBuffer = self.encode(val, valueSubtype);
//include item byte length
parts.push(self.getLengthBuffer(valueBuffer));
//include item
if (valueBuffer !== null) {
parts.push(valueBuffer);
}
propCounter++;
}
if (this.encodingOptions.map && value instanceof this.encodingOptions.map) {
//Use Map#forEach() method to iterate
value.forEach(addItem);
}
else {
//Use object
for (const key in value) {
if (!value.hasOwnProperty(key)) {
continue;
}
const val = value[key];
addItem(val, key);
}
}
parts.unshift(this.getLengthBuffer(propCounter));
return Buffer.concat(parts);
};
this.encodeUdt = function (value, udtInfo) {
const parts = [];
let totalLength = 0;
for (let i = 0; i < udtInfo.fields.length; i++) {
const field = udtInfo.fields[i];
const item = this.encode(value[field.name], field.type);
if (!item) {
parts.push(nullValueBuffer);
totalLength += 4;
continue;
}
if (item === types.unset) {
parts.push(unsetValueBuffer);
totalLength += 4;
continue;
}
const lengthBuffer = utils.allocBufferUnsafe(4);
lengthBuffer.writeInt32BE(item.length, 0);
parts.push(lengthBuffer);
parts.push(item);
totalLength += item.length + 4;
}
return Buffer.concat(parts, totalLength);
};
this.encodeTuple = function (value, tupleInfo) {
const parts = [];
let totalLength = 0;
const length = Math.min(tupleInfo.length, value.length);
for (let i = 0; i < length; i++) {
const type = tupleInfo[i];
const item = this.encode(value.get(i), type);
if (!item) {
parts.push(nullValueBuffer);
totalLength += 4;
continue;
}
if (item === types.unset) {
parts.push(unsetValueBuffer);
totalLength += 4;
continue;
}
const lengthBuffer = utils.allocBufferUnsafe(4);
lengthBuffer.writeInt32BE(item.length, 0);
parts.push(lengthBuffer);
parts.push(item);
totalLength += item.length + 4;
}
return Buffer.concat(parts, totalLength);
};
/**
* If not provided, it uses the array of buffers or the parameters and hints to build the routingKey
* @param {Array} params
* @param {ExecutionOptions} execOptions
* @param [keys] parameter keys and positions in the params array
* @throws TypeError
* @internal
* @ignore
*/
this.setRoutingKeyFromUser = function (params, execOptions, keys) {
let totalLength = 0;
const userRoutingKey = execOptions.getRoutingKey();
if (Array.isArray(userRoutingKey)) {
if (userRoutingKey.length === 1) {
execOptions.setRoutingKey(userRoutingKey[0]);
return;
}
// Its a composite routing key
totalLength = 0;
for (let i = 0; i < userRoutingKey.length; i++) {
const item = userRoutingKey[i];
if (!item) {
// Invalid routing key part provided by the user, clear the value
execOptions.setRoutingKey(null);
return;
}
totalLength += item.length + 3;
}
execOptions.setRoutingKey(concatRoutingKey(userRoutingKey, totalLength));
return;
}
// If routingKey is present, ensure it is a Buffer, Token, or TokenRange. Otherwise throw an error.
if (userRoutingKey) {
if (userRoutingKey instanceof Buffer || userRoutingKey instanceof token.Token
|| userRoutingKey instanceof token.TokenRange) {
return;
}
throw new TypeError(`Unexpected routingKey '${util.inspect(userRoutingKey)}' provided. ` +
`Expected Buffer, Array* This is part of an experimental API, this can be changed future releases. *
* @param {Buffer} buffer Raw buffer to be decoded. * @param {Object} type An object containing the data typecode and info.
* @param {Number} type.code Type code.
* @param {Object} [type.info] Additional information on the type for complex / nested types.
*/
Encoder.prototype.decode = function (buffer, type) {
if (buffer === null || (buffer.length === 0 && !zeroLengthTypesSupported.has(type.code))) {
return null;
}
const decoder = this.decoders[type.code];
if (!decoder) {
throw new Error('Unknown data type: ' + type.code);
}
return decoder.call(this, buffer, type.info);
};
/**
* Encodes Javascript types into Buffer according to the Cassandra protocol.
* * This is part of an experimental API, this can be changed future releases. *
* @param {*} value The value to be converted. * @param {{code: number, info: *|Object}|String|Number} [typeInfo] The type information. *It can be either a:
*String representing the data type.Number with one of the values of {@link module:types~dataTypes dataTypes}.Object containing the type.code as one of the values of
* {@link module:types~dataTypes dataTypes} and type.info.
*