public ColumnItem(ColumnTypeCode columnType, EntityItem entityItem, AttributeItem attributeItem, ConditionOperator conditionOperator)
{
ColumnType = columnType;
EntityItem = entityItem;
AttributeItem = attributeItem;
ConditionOperatorCode = conditionOperator;
}
public static object ConvertFromList(IColumnInfo typeInfo, byte[] value, Type cSharpType)
{
if (typeInfo is ListColumnInfo)
{
ColumnTypeCode listTypecode = (typeInfo as ListColumnInfo).ValueTypeCode;
IColumnInfo listTypeinfo = (typeInfo as ListColumnInfo).ValueTypeInfo;
Type valueType = GetDefaultTypeFromCqlType(listTypecode, listTypeinfo);
int count = BytesToUInt16(value, 0);
int idx = 2;
Type openType = typeof(List <>);
Type listType = openType.MakeGenericType(valueType);
object ret = Activator.CreateInstance(listType);
MethodInfo addM = listType.GetMethod("Add");
for (int i = 0; i < count; i++)
{
var valBufLen = BytesToUInt16(value, idx);
idx += 2;
var valBuf = new byte[valBufLen];
Buffer.BlockCopy(value, idx, valBuf, 0, valBufLen);
idx += valBufLen;
addM.Invoke(ret, new[] { CqlConvert(valBuf, listTypecode, listTypeinfo) });
}
return(ret);
}
throw new DriverInternalError("Invalid ColumnInfo");
}
/// <summary>
/// Reduces allocations by reusing a 16-length buffer for types where is possible
/// </summary>
private static byte[] GetBuffer(int length, ColumnTypeCode typeCode)
{
if (length > 16)
{
return(new byte[length]);
}
switch (typeCode)
{
//blob and inet requires a new instance
case ColumnTypeCode.Blob:
case ColumnTypeCode.Inet:
//just to be safe
case ColumnTypeCode.Custom:
//The TypeCodec does not support offset and count for text
case ColumnTypeCode.Ascii:
case ColumnTypeCode.Text:
case ColumnTypeCode.Varchar:
//The TypeCodec does not support offset and count for varint
case ColumnTypeCode.Varint:
//The Decimal converter does not support count for decimal
case ColumnTypeCode.Decimal:
//The TypeCodec does not support offset and count for udts
case ColumnTypeCode.Udt:
case ColumnTypeCode.Tuple:
return(new byte[length]);
}
return(ReusableBuffer.Value);
}
public Type GetClrTypeForGraph(ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
if (!_defaultGraphTypes.TryGetValue(typeCode, out Func <IColumnInfo, Type> clrTypeHandler))
{
throw new ArgumentException($"No handler defined for type {typeCode}");
}
return(clrTypeHandler(typeInfo));
}
private static object Deserialize(IMetadataQueryProvider cc, byte[] buffer, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
if (buffer == null)
{
return(null);
}
return(cc.Serializer.Deserialize(buffer, 0, buffer.Length, typeCode, typeInfo));
}
private void InsertLegacySerializer(ColumnTypeCode typeCode, ITypeAdapter typeAdapter, bool reverse)
{
var type = typeAdapter.GetDataType();
var legacySerializer = new LegacyTypeSerializer(typeCode, typeAdapter, reverse);
_primitiveSerializers[type] = legacySerializer;
_primitiveDeserializers[typeCode] = legacySerializer;
_defaultTypes[typeCode] = _ => type;
}
internal Type GetClrType(ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
Func <IColumnInfo, Type> clrTypeHandler;
if (!_defaultTypes.TryGetValue(typeCode, out clrTypeHandler))
{
throw new ArgumentException("No handler defined for type " + typeCode);
}
return(clrTypeHandler(typeInfo));
}
public static byte[] InvCqlConvert(object value)
{
if (value == null)
{
return(null);
}
IColumnInfo typeInfo;
ColumnTypeCode typeCode = GetColumnTypeCodeInfo(value.GetType(), out typeInfo);
return(Encoders[typeCode](typeInfo, value));
}
private static string GetTypeString(PocoColumn column, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
if (typeInfo == null)
{
//Is a single type
return(typeCode.ToString().ToLower());
}
string typeName = null;
var frozenKey = column != null && column.HasFrozenKey;
var frozenValue = column != null && column.HasFrozenValue;
if (typeInfo is MapColumnInfo)
{
var mapInfo = (MapColumnInfo)typeInfo;
typeName = "map<" +
WrapFrozen(frozenKey, GetTypeString(null, mapInfo.KeyTypeCode, mapInfo.KeyTypeInfo)) +
", " +
WrapFrozen(frozenValue, GetTypeString(null, mapInfo.ValueTypeCode, mapInfo.ValueTypeInfo)) +
">";
}
else if (typeInfo is SetColumnInfo)
{
var setInfo = (SetColumnInfo)typeInfo;
typeName = "set<" +
WrapFrozen(frozenKey, GetTypeString(null, setInfo.KeyTypeCode, setInfo.KeyTypeInfo)) +
">";
}
else if (typeInfo is ListColumnInfo)
{
var setInfo = (ListColumnInfo)typeInfo;
typeName = "list<" +
WrapFrozen(frozenValue, GetTypeString(null, setInfo.ValueTypeCode, setInfo.ValueTypeInfo)) +
">";
}
else if (typeInfo is TupleColumnInfo)
{
var tupleInfo = (TupleColumnInfo)typeInfo;
typeName = "tuple<" +
string.Join(", ", tupleInfo.Elements.Select(e => GetTypeString(null, e.TypeCode, e.TypeInfo))) +
">";
}
else if (typeInfo is UdtColumnInfo)
{
var udtInfo = (UdtColumnInfo)typeInfo;
// Escape keyspace and name from the UDT
typeName = string.Join(".", udtInfo.Name.Split('.').Select(k => "\"" + k + "\""));
}
if (typeName == null)
{
throw new NotSupportedException(string.Format("Type {0} is not supported", typeCode));
}
return(WrapFrozen(column != null && column.IsFrozen, typeName));
}
public static Type GetDefaultTypeFromList(IColumnInfo typeInfo)
{
if (typeInfo is ListColumnInfo)
{
ColumnTypeCode listTypecode = (typeInfo as ListColumnInfo).ValueTypeCode;
IColumnInfo listTypeinfo = (typeInfo as ListColumnInfo).ValueTypeInfo;
Type valueType = GetDefaultTypeFromCqlType(listTypecode, listTypeinfo);
Type openType = typeof(IEnumerable <>);
Type listType = openType.MakeGenericType(valueType);
return(listType);
}
throw new DriverInternalError("Invalid ColumnInfo");
}
internal static void RegisterTypeInterpreter(ColumnTypeCode type_code)
{
{
var mth = typeof(TypeInterpreter).GetMethod("ConvertFrom" + (type_code.ToString()), new Type[] { typeof(IColumnInfo), typeof(byte[]), typeof(Type) });
GoMethods[(byte)type_code] = (CqlConvertDel)Delegate.CreateDelegate(typeof(CqlConvertDel), mth);
}
{
var mth = typeof(TypeInterpreter).GetMethod("GetDefaultTypeFrom" + (type_code.ToString()), new Type[] { typeof(IColumnInfo) });
TypMethods[(byte)type_code] = (GetDefaultTypeFromCqlTypeDel)Delegate.CreateDelegate(typeof(GetDefaultTypeFromCqlTypeDel), mth);
}
{
var mth = typeof(TypeInterpreter).GetMethod("InvConvertFrom" + (type_code.ToString()), new Type[] { typeof(IColumnInfo), typeof(byte[]) });
InvMethods[(byte)type_code] = (InvCqlConvertDel)Delegate.CreateDelegate(typeof(InvCqlConvertDel), mth);
}
}
/// <summary>
/// Helper method to generate a list column info of nested lists
/// </summary>
private static ListColumnInfo GetNestedListColumnInfo(int level, ColumnTypeCode singleType)
{
var columnInfo = new ListColumnInfo();
if (level == 0)
{
columnInfo.ValueTypeCode = singleType;
columnInfo.ValueTypeInfo = null;
}
else
{
columnInfo.ValueTypeCode = ColumnTypeCode.List;
columnInfo.ValueTypeInfo = GetNestedListColumnInfo(level - 1, singleType);
}
return(columnInfo);
}
/// <summary>
/// Helper method to generate a set column info of nested sets
/// </summary>
private static SetColumnInfo GetNestedSetColumnInfo(int level, ColumnTypeCode singleType)
{
var columnInfo = new SetColumnInfo();
if (level == 0)
{
columnInfo.KeyTypeCode = singleType;
columnInfo.KeyTypeInfo = null;
}
else
{
columnInfo.KeyTypeCode = ColumnTypeCode.Set;
columnInfo.KeyTypeInfo = GetNestedSetColumnInfo(level - 1, singleType);
}
return(columnInfo);
}
private IColumnInfo GetColumnInfo(BEBinaryReader reader, ColumnTypeCode code)
{
ColumnTypeCode innercode;
ColumnTypeCode vinnercode;
switch (code)
{
case ColumnTypeCode.Custom:
return(new CustomColumnInfo()
{
CustomTypeName = reader.ReadString()
});
case ColumnTypeCode.List:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new ListColumnInfo()
{
ValueTypeCode = innercode,
ValueTypeInfo = GetColumnInfo(reader, innercode)
});
case ColumnTypeCode.Map:
innercode = (ColumnTypeCode)reader.ReadUInt16();
var kci = GetColumnInfo(reader, innercode);
vinnercode = (ColumnTypeCode)reader.ReadUInt16();
var vci = GetColumnInfo(reader, vinnercode);
return(new MapColumnInfo()
{
KeyTypeCode = innercode,
KeyTypeInfo = kci,
ValueTypeCode = vinnercode,
ValueTypeInfo = vci
});
case ColumnTypeCode.Set:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new SetColumnInfo()
{
KeyTypeCode = innercode,
KeyTypeInfo = GetColumnInfo(reader, innercode)
});
default:
return(null);
}
}
public static Type GetDefaultTypeFromMap(IColumnInfo typeInfo)
{
if (typeInfo is MapColumnInfo)
{
ColumnTypeCode keyTypecode = (typeInfo as MapColumnInfo).KeyTypeCode;
IColumnInfo keyTypeinfo = (typeInfo as MapColumnInfo).KeyTypeInfo;
ColumnTypeCode valueTypecode = (typeInfo as MapColumnInfo).ValueTypeCode;
IColumnInfo valueTypeinfo = (typeInfo as MapColumnInfo).ValueTypeInfo;
Type keyType = GetDefaultTypeFromCqlType(keyTypecode, keyTypeinfo);
Type valueType = GetDefaultTypeFromCqlType(valueTypecode, valueTypeinfo);
Type openType = typeof(IDictionary <,>);
Type dicType = openType.MakeGenericType(keyType, valueType);
return(dicType);
}
throw new DriverInternalError("Invalid ColumnInfo");
}
/// <summary>
/// Reduces allocations by reusing a 16-length buffer for types where is possible
/// </summary>
private static byte[] GetBuffer(int length, ColumnTypeCode typeCode)
{
if (length > ReusableBufferLength)
{
return new byte[length];
}
switch (typeCode)
{
//blob requires a new instance
case ColumnTypeCode.Blob:
case ColumnTypeCode.Inet:
case ColumnTypeCode.Custom:
case ColumnTypeCode.Decimal:
return new byte[length];
}
return ReusableBuffer.Value;
}
/// <summary>
/// Reduces allocations by reusing a 16-length buffer for types where is possible
/// </summary>
private static byte[] GetBuffer(int length, ColumnTypeCode typeCode)
{
if (length > ReusableBufferLength)
{
return(new byte[length]);
}
switch (typeCode)
{
//blob requires a new instance
case ColumnTypeCode.Blob:
case ColumnTypeCode.Inet:
case ColumnTypeCode.Custom:
case ColumnTypeCode.Decimal:
return(new byte[length]);
}
return(ReusableBuffer.Value);
}
private static string GetTypeString(ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
if (typeInfo == null)
{
//Is a single type
return(typeCode.ToString().ToLower());
}
if (typeInfo is MapColumnInfo)
{
var mapInfo = typeInfo as MapColumnInfo;
return("map<" +
GetTypeString(mapInfo.KeyTypeCode, mapInfo.KeyTypeInfo) +
", " +
GetTypeString(mapInfo.ValueTypeCode, mapInfo.ValueTypeInfo) +
">");
}
if (typeInfo is SetColumnInfo)
{
var setInfo = typeInfo as SetColumnInfo;
return("set<" +
GetTypeString(setInfo.KeyTypeCode, setInfo.KeyTypeInfo) +
">");
}
if (typeInfo is ListColumnInfo)
{
var setInfo = typeInfo as ListColumnInfo;
return("list<" +
GetTypeString(setInfo.ValueTypeCode, setInfo.ValueTypeInfo) +
">");
}
if (typeInfo is TupleColumnInfo)
{
var tupleInfo = typeInfo as TupleColumnInfo;
return("tuple<" +
String.Join(", ", tupleInfo.Elements.Select(e => GetTypeString(e.TypeCode, e.TypeInfo))) +
">");
}
if (typeInfo is UdtColumnInfo)
{
var udtInfo = typeInfo as UdtColumnInfo;
return(udtInfo.Name);
}
throw new NotSupportedException(String.Format("Type {0} is not suppoted", typeCode));
}
public static object ConvertFromMap(IColumnInfo typeInfo, byte[] value, Type cSharpType)
{
if (typeInfo is MapColumnInfo)
{
ColumnTypeCode keyTypecode = (typeInfo as MapColumnInfo).KeyTypeCode;
IColumnInfo keyTypeinfo = (typeInfo as MapColumnInfo).KeyTypeInfo;
ColumnTypeCode valueTypecode = (typeInfo as MapColumnInfo).ValueTypeCode;
IColumnInfo valueTypeinfo = (typeInfo as MapColumnInfo).ValueTypeInfo;
Type keyType = GetDefaultTypeFromCqlType(keyTypecode, keyTypeinfo);
Type valueType = GetDefaultTypeFromCqlType(valueTypecode, valueTypeinfo);
int count = BytesToUInt16(value, 0);
int idx = 2;
Type openType = typeof(SortedDictionary <,>);
Type dicType = openType.MakeGenericType(keyType, valueType);
object ret = Activator.CreateInstance(dicType);
MethodInfo addM = dicType.GetMethod("Add");
for (int i = 0; i < count; i++)
{
var keyBufLen = BytesToUInt16(value, idx);
idx += 2;
var keyBuf = new byte[keyBufLen];
Buffer.BlockCopy(value, idx, keyBuf, 0, keyBufLen);
idx += keyBufLen;
var valueBufLen = BytesToUInt16(value, idx);
idx += 2;
var valueBuf = new byte[valueBufLen];
Buffer.BlockCopy(value, idx, valueBuf, 0, valueBufLen);
idx += valueBufLen;
addM.Invoke(ret, new[]
{
CqlConvert(keyBuf, keyTypecode, keyTypeinfo),
CqlConvert(valueBuf, valueTypecode, valueTypeinfo)
});
}
return(ret);
}
throw new DriverInternalError("Invalid ColumnInfo");
}
public static byte[] InvConvertFromList(IColumnInfo typeInfo, object value)
{
Type listType = GetDefaultTypeFromList(typeInfo);
CheckArgument(listType, value);
ColumnTypeCode listTypecode = (typeInfo as ListColumnInfo).ValueTypeCode;
IColumnInfo listTypeinfo = (typeInfo as ListColumnInfo).ValueTypeInfo;
var bufs = new List <byte[]>();
int cnt = 0;
int bsize = 2;
foreach (object obj in (value as IEnumerable))
{
byte[] buf = InvCqlConvert(obj);
bufs.Add(buf);
bsize += 2; //size of value
bsize += buf.Length;
cnt++;
}
var ret = new byte[bsize];
byte[] cntbuf = Int16ToBytes((short)cnt);
int idx = 0;
Buffer.BlockCopy(cntbuf, 0, ret, 0, 2);
idx += 2;
foreach (byte[] buf in bufs)
{
byte[] valBufSize = Int16ToBytes((short)buf.Length);
Buffer.BlockCopy(valBufSize, 0, ret, idx, 2);
idx += 2;
Buffer.BlockCopy(buf, 0, ret, idx, buf.Length);
idx += buf.Length;
}
return(ret);
}
internal object Deserialize(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
ITypeSerializer typeSerializer;
if (_primitiveDeserializers.TryGetValue(typeCode, out typeSerializer))
{
return(typeSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
}
switch (typeCode)
{
case ColumnTypeCode.Custom:
{
if (_customDeserializers.Count == 0 || !_customDeserializers.TryGetValue(typeInfo, out typeSerializer))
{
// Use byte[] by default
typeSerializer = TypeSerializer.PrimitiveByteArraySerializer;
}
return(typeSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
}
case ColumnTypeCode.Udt:
return(_udtSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.List:
case ColumnTypeCode.Set:
return(_collectionSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.Map:
return(_dictionarySerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.Tuple:
return(_tupleSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo));
}
//Unknown type, return the byte representation
return(buffer);
}
public object Deserialize(ProtocolVersion version, byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return(_serializer.Deserialize(version, buffer, offset, length, typeCode, typeInfo));
}
/// <summary>
/// Helper method to generate a set column info of nested sets
/// </summary>
private static SetColumnInfo GetNestedSetColumnInfo(int level, ColumnTypeCode singleType)
{
var columnInfo = new SetColumnInfo();
if (level == 0)
{
columnInfo.KeyTypeCode = singleType;
columnInfo.KeyTypeInfo = null;
}
else
{
columnInfo.KeyTypeCode = ColumnTypeCode.Set;
columnInfo.KeyTypeInfo = GetNestedSetColumnInfo(level - 1, singleType);
}
return columnInfo;
}
/// <summary>
/// Helper method to generate a list column info of nested lists
/// </summary>
private static ListColumnInfo GetNestedListColumnInfo(int level, ColumnTypeCode singleType)
{
var columnInfo = new ListColumnInfo();
if (level == 0)
{
columnInfo.ValueTypeCode = singleType;
columnInfo.ValueTypeInfo = null;
}
else
{
columnInfo.ValueTypeCode = ColumnTypeCode.List;
columnInfo.ValueTypeInfo = GetNestedListColumnInfo(level - 1, singleType);
}
return columnInfo;
}
private IColumnInfo GetColumnInfo(BEBinaryReader reader, ColumnTypeCode code)
{
ColumnTypeCode innercode;
switch (code)
{
case ColumnTypeCode.List:
innercode = (ColumnTypeCode) reader.ReadUInt16();
return new ListColumnInfo
{
ValueTypeCode = innercode,
ValueTypeInfo = GetColumnInfo(reader, innercode)
};
case ColumnTypeCode.Map:
innercode = (ColumnTypeCode) reader.ReadUInt16();
IColumnInfo kci = GetColumnInfo(reader, innercode);
var vinnercode = (ColumnTypeCode) reader.ReadUInt16();
IColumnInfo vci = GetColumnInfo(reader, vinnercode);
return new MapColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = kci,
ValueTypeCode = vinnercode,
ValueTypeInfo = vci
};
case ColumnTypeCode.Set:
innercode = (ColumnTypeCode) reader.ReadUInt16();
return new SetColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = GetColumnInfo(reader, innercode)
};
case ColumnTypeCode.Custom:
return new CustomColumnInfo { CustomTypeName = reader.ReadString() };
case ColumnTypeCode.Udt:
var udtInfo = new UdtColumnInfo(reader.ReadString() + "." + reader.ReadString());
var fieldLength = reader.ReadInt16();
for (var i = 0; i < fieldLength; i++)
{
var dataType = new ColumnDesc
{
Name = reader.ReadString(),
TypeCode = (ColumnTypeCode) reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
udtInfo.Fields.Add(dataType);
}
return udtInfo;
case ColumnTypeCode.Tuple:
{
var tupleInfo = new TupleColumnInfo();
var elementLength = reader.ReadInt16();
for (var i = 0; i < elementLength; i++)
{
var dataType = new ColumnDesc
{
TypeCode = (ColumnTypeCode) reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
tupleInfo.Elements.Add(dataType);
}
return tupleInfo;
}
default:
return null;
}
}
public static byte[] InvCqlConvert(object value, ColumnTypeCode type_code, IColumnInfo type_info)
{
return(InvMethods[(byte)type_code](type_info, value));
}
private IColumnInfo GetColumnInfo(FrameReader reader, ColumnTypeCode code)
{
ColumnTypeCode innercode;
switch (code)
{
case ColumnTypeCode.List:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new ListColumnInfo
{
ValueTypeCode = innercode,
ValueTypeInfo = GetColumnInfo(reader, innercode)
});
case ColumnTypeCode.Map:
innercode = (ColumnTypeCode)reader.ReadUInt16();
IColumnInfo kci = GetColumnInfo(reader, innercode);
var vinnercode = (ColumnTypeCode)reader.ReadUInt16();
IColumnInfo vci = GetColumnInfo(reader, vinnercode);
return(new MapColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = kci,
ValueTypeCode = vinnercode,
ValueTypeInfo = vci
});
case ColumnTypeCode.Set:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new SetColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = GetColumnInfo(reader, innercode)
});
case ColumnTypeCode.Custom:
return(new CustomColumnInfo {
CustomTypeName = reader.ReadString()
});
case ColumnTypeCode.Udt:
var udtInfo = new UdtColumnInfo(reader.ReadString() + "." + reader.ReadString());
var fieldLength = reader.ReadInt16();
for (var i = 0; i < fieldLength; i++)
{
var dataType = new ColumnDesc
{
Name = reader.ReadString(),
TypeCode = (ColumnTypeCode)reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
udtInfo.Fields.Add(dataType);
}
return(udtInfo);
case ColumnTypeCode.Tuple:
{
var tupleInfo = new TupleColumnInfo();
var elementLength = reader.ReadInt16();
for (var i = 0; i < elementLength; i++)
{
var dataType = new ColumnDesc
{
TypeCode = (ColumnTypeCode)reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
tupleInfo.Elements.Add(dataType);
}
return(tupleInfo);
}
default:
return(null);
}
}
/// <summary>
/// Reads from the internal stream, starting from offset, the amount of bytes defined by count and deserializes
/// the bytes.
/// </summary>
internal object ReadFromBytes(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
_stream.Read(buffer, offset, length);
return _serializer.Deserialize(buffer, 0, length, typeCode, typeInfo);
}
internal static object Deserialize(this Serializer serializer, byte[] buffer, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return serializer.Deserialize(buffer, 0, buffer.Length, typeCode, typeInfo);
}
private static void WriteTypedValue(
ColumnTypeCode type, IColumnInfo columnInfo,
byte[] bytes, int index, int count, BinaryWriter writer)
{
switch (type)
{
case ColumnTypeCode.Boolean:
case ColumnTypeCode.TinyInt:
case ColumnTypeCode.SmallInt:
case ColumnTypeCode.Int:
case ColumnTypeCode.Bigint:
case ColumnTypeCode.Ascii:
case ColumnTypeCode.Text:
case ColumnTypeCode.Json:
case ColumnTypeCode.Varchar:
case ColumnTypeCode.Blob:
case ColumnTypeCode.Inet:
case ColumnTypeCode.Uuid:
case ColumnTypeCode.Timeuuid:
case ColumnTypeCode.Date:
case ColumnTypeCode.Time:
writer.Write(bytes, index, count);
break;
case ColumnTypeCode.Float:
var copy = new byte[4];
Array.Copy(bytes, index, copy, 0, count);
Array.Reverse(copy);
var floatValue = BitConverter.ToSingle(copy, 0);
if (float.IsNaN(floatValue))
{
writer.Write(0xc07f);
}
else
{
writer.Write(bytes, index, count);
}
break;
case ColumnTypeCode.Double:
var doubleValue = BitConverter.Int64BitsToDouble(IPAddress.NetworkToHostOrder(BitConverter.ToInt64(bytes, index)));
if (double.IsNaN(doubleValue))
{
writer.Write((long)0xf87f);
}
else
{
writer.Write(bytes, index, count);
}
break;
case ColumnTypeCode.Timestamp:
var v = IPAddress.NetworkToHostOrder(BitConverter.ToInt64(bytes, index)) * 1000;
writer.Write(IPAddress.HostToNetworkOrder(v));
break;
case ColumnTypeCode.List:
case ColumnTypeCode.Set:
var childColumnDesc = ((ICollectionColumnInfo)columnInfo).GetChildType();
var length = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
for (var i = 0; i != length; ++i)
{
var size = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
WriteTypedValue(childColumnDesc.TypeCode, childColumnDesc.TypeInfo, bytes, index, size, writer);
index += size;
}
break;
case ColumnTypeCode.Map:
var mapColumnInfo = (MapColumnInfo)columnInfo;
var mapLength = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
for (var i = 0; i != mapLength; ++i)
{
var size = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
WriteTypedValue(mapColumnInfo.KeyTypeCode, mapColumnInfo.KeyTypeInfo, bytes, index, size, writer);
index += size;
size = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
WriteTypedValue(mapColumnInfo.ValueTypeCode, mapColumnInfo.ValueTypeInfo, bytes, index, size, writer);
index += size;
}
break;
case ColumnTypeCode.Udt:
var udtColumnInfo = (UdtColumnInfo)columnInfo;
var end = index + count;
for (var fieldIndex = 0; index < end; ++fieldIndex)
{
var size = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(bytes, index));
index += 4;
WriteTypedValue(udtColumnInfo.Fields[fieldIndex].TypeCode, udtColumnInfo.Fields[fieldIndex].TypeInfo, bytes, index, size, writer);
index += size;
}
break;
case ColumnTypeCode.Counter:
case ColumnTypeCode.Custom:
case ColumnTypeCode.Decimal:
case ColumnTypeCode.Tuple:
case ColumnTypeCode.Varint:
throw new InvalidTypeException("Datatype " + type.ToString() + " not supported in a partition key column");
default:
throw new InvalidTypeException("Unknown datatype " + type.ToString() + " for a partition key column");
}
}
private IColumnInfo GetColumnInfo(BEBinaryReader reader, ColumnTypeCode code)
{
ColumnTypeCode innercode;
ColumnTypeCode vinnercode;
switch (code)
{
case ColumnTypeCode.Custom:
return new CustomColumnInfo() { CustomTypeName = reader.ReadString() };
case ColumnTypeCode.List:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return new ListColumnInfo()
{
ValueTypeCode = innercode,
ValueTypeInfo = GetColumnInfo(reader, innercode)
};
case ColumnTypeCode.Map:
innercode = (ColumnTypeCode)reader.ReadUInt16();
var kci = GetColumnInfo(reader, innercode);
vinnercode = (ColumnTypeCode)reader.ReadUInt16();
var vci = GetColumnInfo(reader, vinnercode);
return new MapColumnInfo()
{
KeyTypeCode = innercode,
KeyTypeInfo = kci,
ValueTypeCode = vinnercode,
ValueTypeInfo = vci
};
case ColumnTypeCode.Set:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return new SetColumnInfo()
{
KeyTypeCode = innercode,
KeyTypeInfo = GetColumnInfo(reader, innercode)
};
default:
return null;
}
}
private void InsertLegacySerializer(ColumnTypeCode typeCode, ITypeAdapter typeAdapter, bool reverse)
{
var type = typeAdapter.GetDataType();
var legacySerializer = new LegacyTypeSerializer(typeCode, typeAdapter, reverse);
_primitiveSerializers[type] = legacySerializer;
_primitiveDeserializers[typeCode] = legacySerializer;
_defaultTypes[typeCode] = _ => type;
}
public Type GetClrTypeForGraph(ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return(_serializer.GetClrTypeForGraph(typeCode, typeInfo));
}
public static object CqlConvert(byte[] buffer, ColumnTypeCode type_code, IColumnInfo type_info, Type cSharpType = null)
{
return(GoMethods[(byte)type_code](type_info, buffer, cSharpType));
}
/// <summary>
/// Reads from the internal stream, starting from offset, the amount of bytes defined by count and deserializes
/// the bytes.
/// </summary>
internal object ReadFromBytes(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
_stream.Read(buffer, offset, length);
return(_serializer.Deserialize(buffer, 0, length, typeCode, typeInfo));
}
public static Type GetDefaultTypeFromCqlType(ColumnTypeCode type_code, IColumnInfo type_info)
{
return(TypMethods[(byte)type_code](type_info));
}
internal object Deserialize(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
ITypeSerializer typeSerializer;
if (_primitiveDeserializers.TryGetValue(typeCode, out typeSerializer))
{
return typeSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
}
switch (typeCode)
{
case ColumnTypeCode.Custom:
{
if (_customDeserializers.Count == 0 || !_customDeserializers.TryGetValue(typeInfo, out typeSerializer))
{
// Use byte[] by default
typeSerializer = TypeSerializer.PrimitiveByteArraySerializer;
}
return typeSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
}
case ColumnTypeCode.Udt:
return _udtSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
case ColumnTypeCode.List:
case ColumnTypeCode.Set:
return _collectionSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
case ColumnTypeCode.Map:
return _dictionarySerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
case ColumnTypeCode.Tuple:
return _tupleSerializer.Deserialize(_protocolVersion, buffer, offset, length, typeInfo);
}
//Unknown type, return the byte representation
return buffer;
}
/// <summary>
/// Reduces allocations by reusing a 16-length buffer for types where is possible
/// </summary>
private static byte[] GetBuffer(int length, ColumnTypeCode typeCode)
{
if (length > 16)
{
return new byte[length];
}
switch (typeCode)
{
//blob and inet requires a new instance
case ColumnTypeCode.Blob:
case ColumnTypeCode.Inet:
//just to be safe
case ColumnTypeCode.Custom:
//The TypeCodec does not support offset and count for text
case ColumnTypeCode.Ascii:
case ColumnTypeCode.Text:
case ColumnTypeCode.Varchar:
//The TypeCodec does not support offset and count for varint
case ColumnTypeCode.Varint:
//The Decimal converter does not support count for decimal
case ColumnTypeCode.Decimal:
//The TypeCodec does not support offset and count for udts
case ColumnTypeCode.Udt:
case ColumnTypeCode.Tuple:
return new byte[length];
}
return ReusableBuffer.Value;
}
public ColumnItem(ColumnTypeCode attributeToUpdate, EntityItem entityItem, AttributeItem attributeItem)
{
ColumnType = attributeToUpdate;
EntityItem = entityItem;
AttributeItem = attributeItem;
}
internal LegacyTypeSerializer(ColumnTypeCode typeCode, ITypeAdapter adapter, bool reverse)
{
_typeCode = typeCode;
_adapter = adapter;
_reverse = reverse;
}
internal static object Deserialize(this Serializer serializer, byte[] buffer, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return(serializer.Deserialize(buffer, 0, buffer.Length, typeCode, typeInfo));
}
internal Type GetClrType(ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
Func<IColumnInfo, Type> clrTypeHandler;
if (!_defaultTypes.TryGetValue(typeCode, out clrTypeHandler))
{
throw new ArgumentException("No handler defined for type " + typeCode);
}
return clrTypeHandler(typeInfo);
}
