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
* @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);
};
/**
*
* @param {Buffer} bytes
* @param {OtherCustomColumnInfo | VectorColumnInfo} columnInfo
*/
this.decodeCustom = function (bytes, columnInfo) {
// Make sure we actually have something to process in typeName before we go any further
if (!columnInfo) {
return this.handleBuffer(bytes);
}
// Special handling for vector custom types (since they have args)
if ('customTypeName' in columnInfo && columnInfo.customTypeName === 'vector') {
return this.decodeVector(bytes, columnInfo);
}
if(typeof columnInfo.info === 'string' && columnInfo.info.startsWith(customTypeNames.vector)) {
const vectorColumnInfo = /** @type {VectorColumnInfo} */ (this.parseFqTypeName(columnInfo.info));
return this.decodeVector(bytes, vectorColumnInfo);
}
const handler = customDecoders[columnInfo.info];
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, columnInfo) {
const subtype = columnInfo.info;
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, columnInfo) {
const arr = this.decodeList(bytes, columnInfo);
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, columnInfo) {
const subtypes = columnInfo.info;
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 {UdtColumnInfo} columnInfo
* @private
*/
this.decodeUdt = function (bytes, columnInfo) {
const udtInfo = columnInfo.info;
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, columnInfo) {
const tupleInfo = columnInfo.info;
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;
};
/**
*
* @param {any} value
* @param {OtherCustomColumnInfo | VectorColumnInfo} columnInfo
*/
this.encodeCustom = function (value, columnInfo) {
if ('customTypeName' in columnInfo && columnInfo.customTypeName === 'vector') {
return this.encodeVector(value, columnInfo);
}
if(typeof columnInfo.info === 'string' && columnInfo.info.startsWith(customTypeNames.vector)) {
const vectorColumnInfo = /** @type {VectorColumnInfo} */ (this.parseFqTypeName(columnInfo.info));
return this.encodeVector(value, vectorColumnInfo);
}
const handler = customEncoders[columnInfo.info];
if (handler) {
return handler.call(this, value);
}
throw new TypeError('No encoding handler found for type ' + columnInfo);
};
/**
* @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} 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, columnInfo) {
const subtype = columnInfo.info;
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, columnInfo) {
if (this.encodingOptions.set && value instanceof this.encodingOptions.set) {
const arr = [];
value.forEach(function (x) {
arr.push(x);
});
return this.encodeList(arr, columnInfo);
}
return this.encodeList(value, columnInfo);
};
/**
* Serializes a map into a Buffer
* @param value
* @param {MapColumnInfo} columnInfo
* @returns {Buffer}
* @private
*/
this.encodeMap = function (value, columnInfo) {
const subtypes = columnInfo.info;
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);
};
/**
*
* @param {any} value
* @param {UdtColumnInfo} columnInfo
*/
this.encodeUdt = function (value, columnInfo) {
const udtInfo = columnInfo.info;
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);
};
/**
*
* @param {any} value
* @param {TupleColumnInfo} columnInfo
*/
this.encodeTuple = function (value, columnInfo) {
const tupleInfo = columnInfo.info;
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);
};
/**
*
* @param {Buffer} buffer
* @param {VectorColumnInfo} params
* @returns {Vector}
*/
this.decodeVector = function(buffer, params) {
const subtype = params.info[0];
const dimension = params.info[1];
const elemLength = this.serializationSizeIfFixed(subtype);
const rv = [];
let offset = 0;
for (let i = 0; i < dimension; i++) {
if (elemLength === -1) {
// var sized
const [size, bytesRead] = utils.VIntCoding.uvintUnpack(buffer.subarray(offset));
offset += bytesRead;
if (offset + size > buffer.length) {
throw new TypeError('Not enough bytes to decode the vector');
}
rv[i] = this.decode(buffer.subarray(offset, offset + size), subtype);
offset += size;
}else{
if (offset + elemLength > buffer.length) {
throw new TypeError('Not enough bytes to decode the vector');
}
rv[i] = this.decode(buffer.subarray(offset, offset + elemLength), subtype);
offset += elemLength;
}
}
if (offset !== buffer.length) {
throw new TypeError('Extra bytes found after decoding the vector');
}
const typeInfo = (types.getDataTypeNameByCode(subtype));
return new Vector(rv, typeInfo);
};
/**
* @param {ColumnInfo} cqlType
* @returns {Number}
*/
this.serializationSizeIfFixed = function (cqlType) {
switch (cqlType.code) {
case dataTypes.bigint:
return 8;
case dataTypes.boolean:
return 1;
case dataTypes.timestamp:
return 8;
case dataTypes.double:
return 8;
case dataTypes.float:
return 4;
case dataTypes.int:
return 4;
case dataTypes.timeuuid:
return 16;
case dataTypes.uuid:
return 16;
case dataTypes.custom:
if ('customTypeName' in cqlType && cqlType.customTypeName === 'vector'){
const subtypeSerialSize = this.serializationSizeIfFixed(cqlType.info[0]);
if (subtypeSerialSize === -1){
return -1;
}
return subtypeSerialSize * cqlType.info[1];
}
return -1;
default:
return -1;
}
};
/**
* @param {Vector} value
* @param {VectorColumnInfo} params
* @returns {Buffer}
*/
this.encodeVector = function(value, params) {
if (!(value instanceof Vector)) {
throw new TypeError("Driver only supports Vector type when encoding a vector");
}
const dimension = params.info[1];
if (value.length !== dimension) {
throw new TypeError(`Expected vector with ${dimension} dimensions, observed size of ${value.length}`);
}
if (value.length === 0) {
throw new TypeError("Cannot encode empty array as vector");
}
const serializationSize = this.serializationSizeIfFixed(params.info[0]);
const encoded = [];
for (const elem of value) {
const elemBuffer = this.encode(elem, params.info[0]);
if (serializationSize === -1) {
encoded.push(utils.VIntCoding.uvintPack(elemBuffer.length));
}
encoded.push(elemBuffer);
}
return Buffer.concat(encoded);
};
/**
* Extract the (typed) arguments from a vector type
*
* @param {String} typeName
* @param {String} stringToExclude Leading string indicating this is a vector type (to be excluded when eval'ing args)
* @param {Function} subtypeResolveFn Function used to resolve subtype type; varies depending on type naming convention
* @returns {VectorColumnInfo}
* @internal
*/
this.parseVectorTypeArgs = function(typeName, stringToExclude, subtypeResolveFn) {
const argsStartIndex = stringToExclude.length + 1;
const argsLength = typeName.length - (stringToExclude.length + 2);
const params = parseParams(typeName, argsStartIndex, argsLength);
if (params.length === 2) {
/** @type {VectorColumnInfo} */
const columnInfo = { code: dataTypes.custom, info: [subtypeResolveFn.bind(this)(params[0].trim()), parseInt(params[1].trim(), 10 )], customTypeName : 'vector'};
return columnInfo;
}
throw new TypeError('Not a valid type ' + typeName);
};
/**
* If not provided, it uses the array of buffers or the parameters and hints to build the routingKey
* @param {Array} params
* @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 {ColumnInfo} type */ 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); }; /** * 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 {ColumnInfo | Number | String} 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.
*