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; } }
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); }