/// <summary>
/// 获取数据库表对象实体
/// </summary>
public DBTable GetTable(string tableName)
{
DBTable dt = new DBTable()
{
Name = tableName
};
DataColumn[] dcArray = GetColums(tableName);
ColumnDesc[] tableDesc = GetColumnDesc(tableName);
dt.ColumnList = new List <DBColumn>();
foreach (DataColumn dc in dcArray)
{
ColumnDesc cd = tableDesc.FirstOrDefault(c => c.Field == dc.Caption);
if (cd != null)
{
dt.ColumnList.Add(new DBColumn(cd));
}
else
{
dt.ColumnList.Add(new DBColumn(dc));
}
}
return(dt);
}
public ColumnDesc[] GetColumnDesc(string tableName)
{
List <ColumnDesc> td = new List <ColumnDesc>();
DataTable tableDesc = sqlServer.ExecuteDataTable($@"
SELECT
syscolumns.name AS Field,
syscolumns.id,
syscolumns.isnullable AS 'Null',
systypes.name AS Type,
syscolumns.[length] AS Lenth,
ISNULL(
sys.extended_properties.
VALUE
,
''
) AS Comment,
CASE keyColumn.Column_name
WHEN syscolumns.name THEN
'1'
ELSE
'0'
END AS 'Key'
FROM
sysobjects
JOIN syscolumns ON sysobjects.id = syscolumns.id
JOIN systypes ON syscolumns.xusertype = systypes.xusertype
LEFT JOIN sys.identity_columns ON sys.identity_columns.object_id = syscolumns.id
AND sys.identity_columns.column_id = syscolumns.colid
LEFT JOIN sys.extended_properties ON sys.extended_properties.major_id = syscolumns.id
AND sys.extended_properties.minor_id = syscolumns.colid,
INFORMATION_SCHEMA.KEY_COLUMN_USAGE keyColumn
WHERE
sysobjects.name = '{tableName}'
AND keyColumn.TABLE_NAME = sysobjects.name");
foreach (DataRow item in tableDesc.Rows)
{
ColumnDesc columnDesc = new ColumnDesc()
{
Comment = item["Comment"].ToString(),
Field = item["Field"].ToString(),
Key = item["Key"].ToString().ToLower() == "1",
Null = item["Null"].ToString().ToLower() == "1"
};
columnDesc.SetType(item["Type"].ToString());
td.Add(columnDesc);
}
return(td.ToArray());
}
public AggregateMetadata(string name, string keyspaceName, string[] signature, ColumnDesc[] argumentTypes,
string stateFunction, ColumnDesc stateType, string finalFunction,
string initialCondition, ColumnDesc returnType)
{
Name = name;
KeyspaceName = keyspaceName;
Signature = signature;
ArgumentTypes = argumentTypes;
StateFunction = stateFunction;
StateType = stateType;
FinalFunction = finalFunction;
InitialCondition = initialCondition;
ReturnType = returnType;
}
public void Row_TryConvertToType_Should_Convert_Timestamps()
{
var timestampTypeInfo = new ColumnDesc {
TypeCode = ColumnTypeCode.Timestamp
};
var values = new[]
{
//column desc, value, type and expected type
new object[] { DateTimeOffset.Now, timestampTypeInfo, typeof(DateTime) },
new object[] { DateTimeOffset.Now, timestampTypeInfo, typeof(DateTimeOffset) },
new object[] { DateTimeOffset.Now, timestampTypeInfo, typeof(object), typeof(DateTimeOffset) },
new object[] { DateTimeOffset.Now, timestampTypeInfo, typeof(IConvertible), typeof(DateTime) }
};
foreach (var item in values)
{
var value = Row.TryConvertToType(item[0], (ColumnDesc)item[1], (Type)item[2]);
Assert.AreEqual(item.Length > 3 ? item[3] : item[2], value.GetType());
}
}
public ColumnDesc[] GetColumnDesc(string tableName)
{
List <ColumnDesc> td = new List <ColumnDesc>();
DataTable tableDesc = mySql.ExecuteDataTable($"show full fields from `{tableName}`");
foreach (DataRow item in tableDesc.Rows)
{
ColumnDesc columnDesc = new ColumnDesc()
{
Comment = item["Comment"].ToString(),
Field = item["Field"].ToString(),
Key = item["Key"].ToString().ToLower() == "pri",
Null = item["Null"].ToString().ToLower() == "yes"
};
columnDesc.SetType(item["Type"].ToString());
td.Add(columnDesc);
}
return(td.ToArray());
}
private ColumnHeader AddColumn(ColumnDesc desc)
{
Debug.Assert(desc.Type != ColumnType.CheckBox || Columns.Count == 0);
if (desc.Type == ColumnType.Button)
{
hasAnyButtons = true;
}
if (desc.Type == ColumnType.DropDown)
{
hasAnyDropDowns = true;
}
columnDescs.Add(desc);
var header = Columns.Add(desc.Name);
header.Width = -2; // Auto size.
Debug.Assert(Columns.Count == columnDescs.Count);
return(header);
}
private void InitColumns()
{
_columns = new List <ITableColumn>();
RowSet rows = _provider.CassandraSession.Execute(string.Format("select * from system.schema_columns where columnfamily_name = '{0}' allow filtering;", TableName));
foreach (var row in rows)
{
if (_usedIdentifiers == null || _usedIdentifiers.Contains(row["column_name"].ToString()))
{
TableColumn column = CassandraTableMetadata.TableColumns.Where(c => c.Name == row["column_name"].ToString()).First();
Type dataType = GetDataType(column.TypeCode);
if (_data != null)
{
_columns.Add(new CassandraTableColumn(row["column_name"].ToString(), dataType, _data[row["column_name"].ToString()], row["type"].ToString()));
}
else
{
_columns.Add(new CassandraTableColumn(row["column_name"].ToString(), dataType, GetDefaultValueForType(dataType.ToString(), "Sample Text"), row["type"].ToString()));
}
ColumnDesc cd = new ColumnDesc();
}
}
}
public void Row_TryConvertToType_Should_Convert_Lists()
{
var listIntTypeInfo = new ColumnDesc {
TypeCode = ColumnTypeCode.List, TypeInfo = new ListColumnInfo {
ValueTypeCode = ColumnTypeCode.Int
}
};
var values = new[]
{
new object[] { new [] { 1, 2, 3 }, listIntTypeInfo, typeof(int[]) },
new object[] { new [] { 1, 2, 3 }, listIntTypeInfo, typeof(object), typeof(int[]) },
new object[] { new [] { 1, 2, 3 }, listIntTypeInfo, typeof(IEnumerable <int>), typeof(int[]) },
new object[] { new [] { 1, 2, 3 }, listIntTypeInfo, typeof(List <int>) },
new object[] { new [] { 1, 2, 3 }, listIntTypeInfo, typeof(IList <int>), typeof(List <int>) }
};
foreach (var item in values)
{
var value = Row.TryConvertToType(item[0], (ColumnDesc)item[1], (Type)item[2]);
Assert.AreEqual(item.Length > 3 ? item[3] : item[2], value.GetType());
CollectionAssert.AreEqual((int[])item[0], (IEnumerable <int>)value);
}
}
public void Row_TryConvertToType_Should_Convert_Sets()
{
var setIntTypeInfo = new ColumnDesc { TypeCode = ColumnTypeCode.Set, TypeInfo = new SetColumnInfo { KeyTypeCode = ColumnTypeCode.Int } };
var values = new[]
{
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(int[])},
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(object), typeof(int[])},
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(IEnumerable<int>), typeof(int[])},
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(HashSet<int>)},
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(SortedSet<int>)},
new object[] {new [] {1, 2, 3}, setIntTypeInfo, typeof(ISet<int>), typeof(List<int>)}
};
foreach (var item in values)
{
var value = Row.TryConvertToType(item[0], (ColumnDesc)item[1], (Type)item[2]);
Assert.AreEqual(item.Length > 3 ? item[3] : item[2], value.GetType());
CollectionAssert.AreEqual((int[]) item[0], (IEnumerable<int>) value);
}
}
public void Row_TryConvertToType_Should_Convert_Timestamps()
{
var timestampTypeInfo = new ColumnDesc {TypeCode = ColumnTypeCode.Timestamp};
var values = new[]
{
//column desc, value, type and expected type
new object[] {DateTimeOffset.Now, timestampTypeInfo, typeof(DateTime)},
new object[] {DateTimeOffset.Now, timestampTypeInfo, typeof(DateTimeOffset)},
new object[] {DateTimeOffset.Now, timestampTypeInfo, typeof(object), typeof(DateTimeOffset)},
new object[] {DateTimeOffset.Now, timestampTypeInfo, typeof(IConvertible), typeof(DateTime)}
};
foreach (var item in values)
{
var value = Row.TryConvertToType(item[0], (ColumnDesc)item[1], (Type)item[2]);
Assert.AreEqual(item.Length > 3 ? item[3] : item[2], value.GetType());
}
}
public ColumnTypeCode GetCqlType(Type type, out IColumnInfo typeInfo)
{
typeInfo = null;
ITypeSerializer typeSerializer;
if (_primitiveSerializers.TryGetValue(type, out typeSerializer))
{
return(typeSerializer.CqlType);
}
if (_customSerializers.Count > 0 && _customSerializers.TryGetValue(type, out typeSerializer))
{
typeInfo = typeSerializer.TypeInfo;
return(typeSerializer.CqlType);
}
if (type.IsArray)
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode = GetCqlType(type.GetElementType(), out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.List);
}
if (type.GetTypeInfo().IsGenericType)
{
if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out typeInfo));
}
if (typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(type))
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode;
var interfaces = type.GetTypeInfo().GetInterfaces();
if (typeof(IDictionary).GetTypeInfo().IsAssignableFrom(type) &&
interfaces.Any(t => t.GetTypeInfo().IsGenericType&& t.GetGenericTypeDefinition() == typeof(IDictionary <,>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out keyTypeInfo);
valueTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[1], out valueTypeInfo);
typeInfo = new MapColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo,
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.Map);
}
if (interfaces.Any(t => t.GetTypeInfo().IsGenericType&& t.GetGenericTypeDefinition() == typeof(ISet <>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out keyTypeInfo);
typeInfo = new SetColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo
};
return(ColumnTypeCode.Set);
}
valueTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.List);
}
if (typeof(IStructuralComparable).GetTypeInfo().IsAssignableFrom(type) && type.FullName.StartsWith("System.Tuple"))
{
typeInfo = new TupleColumnInfo
{
Elements = type.GetTypeInfo().GetGenericArguments().Select(t =>
{
IColumnInfo tupleSubTypeInfo;
var dataType = new ColumnDesc
{
TypeCode = GetCqlType(t, out tupleSubTypeInfo),
TypeInfo = tupleSubTypeInfo
};
return(dataType);
}).ToList()
};
return(ColumnTypeCode.Tuple);
}
}
//Determine if its a Udt type
var udtMap = _udtSerializer.GetUdtMap(type);
if (udtMap != null)
{
typeInfo = udtMap.Definition;
return(ColumnTypeCode.Udt);
}
throw new InvalidTypeException("Unknown Cassandra target type for CLR type " + type.FullName);
}
private List<ColumnDesc> GetColumnData( List<Column> Columns )
{
List<ColumnDesc> results = new List<ColumnDesc>();
foreach ( Column column in Columns ) {
ColumnDesc result = new ColumnDesc();
result.Name = column.Name;
result.Nullable = column.Nullable;
result.SqlDataType = column.DataType.SqlDataType;
result.PropertyType = this.GetTypeFromSqlType( column.DataType.SqlDataType );
result.Length = column.DataType.MaximumLength;
result.IsPrimaryKey = column.InPrimaryKey;
results.Add( result );
}
return results;
}
/// <summary>
/// Parses a given fully-qualified class type name to get the data type information
/// </summary>
/// <exception cref="ArgumentException" />
internal static ColumnDesc ParseFqTypeName(string typeName, int startIndex = 0, int length = 0)
{
const StringComparison comparison = StringComparison.Ordinal;
var dataType = new ColumnDesc();
if (length == 0)
{
length = typeName.Length;
}
if (length > ReversedTypeName.Length && typeName.IndexOf(ReversedTypeName, startIndex, comparison) == startIndex)
{
//move the start index and subtract the length plus parenthesis
startIndex += ReversedTypeName.Length + 1;
length -= ReversedTypeName.Length + 2;
dataType.IsReversed = true;
}
if (length > FrozenTypeName.Length && typeName.IndexOf(FrozenTypeName, startIndex, comparison) == startIndex)
{
//Remove the frozen
startIndex += FrozenTypeName.Length + 1;
length -= FrozenTypeName.Length + 2;
dataType.IsFrozen = true;
}
if (typeName == EmptyTypeName)
{
dataType.TypeCode = ColumnTypeCode.Custom;
dataType.TypeInfo = null;
return dataType;
}
//Quick check if its a single type
if (length <= SingleFqTypeNamesLength)
{
ColumnTypeCode typeCode;
if (startIndex > 0)
{
typeName = typeName.Substring(startIndex, length);
}
if (SingleFqTypeNames.TryGetValue(typeName, out typeCode))
{
dataType.TypeCode = typeCode;
return dataType;
}
throw GetTypeException(typeName);
}
if (typeName.IndexOf(ListTypeName, startIndex, comparison) == startIndex)
{
//Its a list
//org.apache.cassandra.db.marshal.ListType(innerType)
//move cursor across the name and bypass the parenthesis
startIndex += ListTypeName.Length + 1;
length -= ListTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
if (innerTypes.Count != 1)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.List;
var subType = ParseFqTypeName(innerTypes[0]);
dataType.TypeInfo = new ListColumnInfo()
{
ValueTypeCode = subType.TypeCode,
ValueTypeInfo = subType.TypeInfo
};
return dataType;
}
if (typeName.IndexOf(SetTypeName, startIndex, comparison) == startIndex)
{
//Its a set
//org.apache.cassandra.db.marshal.SetType(innerType)
//move cursor across the name and bypass the parenthesis
startIndex += SetTypeName.Length + 1;
length -= SetTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
if (innerTypes.Count != 1)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Set;
var subType = ParseFqTypeName(innerTypes[0]);
dataType.TypeInfo = new SetColumnInfo()
{
KeyTypeCode = subType.TypeCode,
KeyTypeInfo = subType.TypeInfo
};
return dataType;
}
if (typeName.IndexOf(MapTypeName, startIndex, comparison) == startIndex)
{
//org.apache.cassandra.db.marshal.MapType(keyType,valueType)
//move cursor across the name and bypass the parenthesis
startIndex += MapTypeName.Length + 1;
length -= MapTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
//It should contain the key and value types
if (innerTypes.Count != 2)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Map;
var keyType = ParseFqTypeName(innerTypes[0]);
var valueType = ParseFqTypeName(innerTypes[1]);
dataType.TypeInfo = new MapColumnInfo()
{
KeyTypeCode = keyType.TypeCode,
KeyTypeInfo = keyType.TypeInfo,
ValueTypeCode = valueType.TypeCode,
ValueTypeInfo = valueType.TypeInfo
};
return dataType;
}
if (typeName.IndexOf(UdtTypeName, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += UdtTypeName.Length + 1;
length -= UdtTypeName.Length + 2;
var udtParams = ParseParams(typeName, startIndex, length);
if (udtParams.Count < 2)
{
//It should contain at least the keyspace, name of the udt and a type
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Udt;
dataType.Keyspace = udtParams[0];
dataType.Name = HexToUtf8(udtParams[1]);
var udtInfo = new UdtColumnInfo(dataType.Keyspace + "." + dataType.Name);
for (var i = 2; i < udtParams.Count; i++)
{
var p = udtParams[i];
var separatorIndex = p.IndexOf(':');
var c = ParseFqTypeName(p, separatorIndex + 1, p.Length - (separatorIndex + 1));
c.Name = HexToUtf8(p.Substring(0, separatorIndex));
udtInfo.Fields.Add(c);
}
dataType.TypeInfo = udtInfo;
return dataType;
}
if (typeName.IndexOf(TupleTypeName, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += TupleTypeName.Length + 1;
length -= TupleTypeName.Length + 2;
var tupleParams = ParseParams(typeName, startIndex, length);
if (tupleParams.Count < 1)
{
//It should contain at least the keyspace, name of the udt and a type
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Tuple;
var tupleInfo = new TupleColumnInfo();
foreach (var subTypeName in tupleParams)
{
tupleInfo.Elements.Add(ParseFqTypeName(subTypeName));
}
dataType.TypeInfo = tupleInfo;
return dataType;
}
throw GetTypeException(typeName);
}
/// <summary>
/// Parses a given CQL type name to get the data type information
/// </summary>
/// <exception cref="ArgumentException" />
internal static Task<ColumnDesc> ParseTypeName(Func<string, string, Task<UdtColumnInfo>> udtResolver, string keyspace, string typeName, int startIndex = 0, int length = 0)
{
const StringComparison comparison = StringComparison.Ordinal;
var dataType = new ColumnDesc();
if (length == 0)
{
length = typeName.Length;
}
if (typeName.IndexOf(CqlNames.Frozen, startIndex, comparison) == startIndex)
{
//Remove the frozen
startIndex += CqlNames.Frozen.Length + 1;
length -= CqlNames.Frozen.Length + 2;
dataType.IsFrozen = true;
}
if (typeName == CqlNames.Empty)
{
dataType.TypeCode = ColumnTypeCode.Custom;
dataType.TypeInfo = null;
return TaskHelper.ToTask(dataType);
}
if (typeName.IndexOf(CqlNames.List, startIndex, comparison) == startIndex)
{
//Its a list: move cursor across the name and bypass the angle brackets
startIndex += CqlNames.List.Length + 1;
length -= CqlNames.List.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
if (innerTypes.Count != 1)
{
return TaskHelper.FromException<ColumnDesc>(GetTypeException(typeName));
}
dataType.TypeCode = ColumnTypeCode.List;
return ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim())
.ContinueSync(subType =>
{
dataType.TypeInfo = new ListColumnInfo
{
ValueTypeCode = subType.TypeCode,
ValueTypeInfo = subType.TypeInfo
};
return dataType;
});
}
if (typeName.IndexOf(CqlNames.Set, startIndex, comparison) == startIndex)
{
//Its a set: move cursor across the name and bypass the angle brackets
startIndex += CqlNames.Set.Length + 1;
length -= CqlNames.Set.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
if (innerTypes.Count != 1)
{
return TaskHelper.FromException<ColumnDesc>(GetTypeException(typeName));
}
dataType.TypeCode = ColumnTypeCode.Set;
return ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim())
.ContinueSync(subType =>
{
dataType.TypeInfo = new SetColumnInfo
{
KeyTypeCode = subType.TypeCode,
KeyTypeInfo = subType.TypeInfo
};
return dataType;
});
}
if (typeName.IndexOf(CqlNames.Map, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += CqlNames.Map.Length + 1;
length -= CqlNames.Map.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
//It should contain the key and value types
if (innerTypes.Count != 2)
{
return TaskHelper.FromException<ColumnDesc>(GetTypeException(typeName));
}
dataType.TypeCode = ColumnTypeCode.Map;
var keyTypeTask = ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim());
var valueTypeTask = ParseTypeName(udtResolver, keyspace, innerTypes[1].Trim());
return Task.Factory.ContinueWhenAll(new[] { keyTypeTask, valueTypeTask }, tasks =>
{
dataType.TypeInfo = new MapColumnInfo
{
KeyTypeCode = tasks[0].Result.TypeCode,
KeyTypeInfo = tasks[0].Result.TypeInfo,
ValueTypeCode = tasks[1].Result.TypeCode,
ValueTypeInfo = tasks[1].Result.TypeInfo
};
return dataType;
});
}
if (typeName.IndexOf(CqlNames.Tuple, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += CqlNames.Tuple.Length + 1;
length -= CqlNames.Tuple.Length + 2;
var tupleParams = ParseParams(typeName, startIndex, length, '<', '>');
if (tupleParams.Count < 1)
{
//It should contain at least the keyspace, name of the udt and a type
return TaskHelper.FromException<ColumnDesc>(GetTypeException(typeName));
}
dataType.TypeCode = ColumnTypeCode.Tuple;
var elementTasks = tupleParams
.Select(subTypeName => ParseTypeName(udtResolver, keyspace, subTypeName.Trim()))
.ToArray();
return Task.Factory.ContinueWhenAll(elementTasks, tasks =>
{
dataType.TypeInfo = new TupleColumnInfo(tasks.Select(t => t.Result));
return dataType;
});
}
if (startIndex > 0)
{
typeName = typeName.Substring(startIndex, length);
}
ColumnTypeCode typeCode;
if (SingleCqlNames.TryGetValue(typeName, out typeCode))
{
dataType.TypeCode = typeCode;
return TaskHelper.ToTask(dataType);
}
return udtResolver(keyspace, typeName).ContinueSync(typeInfo =>
{
if (typeInfo == null)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Udt;
dataType.TypeInfo = typeInfo;
return dataType;
});
}
/// <summary>
/// Parses a given CQL type name to get the data type information
/// </summary>
/// <exception cref="ArgumentException" />
internal static Task <ColumnDesc> ParseTypeName(Func <string, string, Task <UdtColumnInfo> > udtResolver, string keyspace, string typeName, int startIndex = 0, int length = 0)
{
const StringComparison comparison = StringComparison.Ordinal;
var dataType = new ColumnDesc();
if (length == 0)
{
length = typeName.Length;
}
if (typeName.IndexOf(CqlNames.Frozen, startIndex, comparison) == startIndex)
{
//Remove the frozen
startIndex += CqlNames.Frozen.Length + 1;
length -= CqlNames.Frozen.Length + 2;
dataType.IsFrozen = true;
}
if (typeName == CqlNames.Empty)
{
dataType.TypeCode = ColumnTypeCode.Custom;
dataType.TypeInfo = null;
return(TaskHelper.ToTask(dataType));
}
if (typeName.IndexOf(CqlNames.List, startIndex, comparison) == startIndex)
{
//Its a list: move cursor across the name and bypass the angle brackets
startIndex += CqlNames.List.Length + 1;
length -= CqlNames.List.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
if (innerTypes.Count != 1)
{
return(TaskHelper.FromException <ColumnDesc>(GetTypeException(typeName)));
}
dataType.TypeCode = ColumnTypeCode.List;
return(ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim())
.ContinueSync(subType =>
{
dataType.TypeInfo = new ListColumnInfo
{
ValueTypeCode = subType.TypeCode,
ValueTypeInfo = subType.TypeInfo
};
return dataType;
}));
}
if (typeName.IndexOf(CqlNames.Set, startIndex, comparison) == startIndex)
{
//Its a set: move cursor across the name and bypass the angle brackets
startIndex += CqlNames.Set.Length + 1;
length -= CqlNames.Set.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
if (innerTypes.Count != 1)
{
return(TaskHelper.FromException <ColumnDesc>(GetTypeException(typeName)));
}
dataType.TypeCode = ColumnTypeCode.Set;
return(ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim())
.ContinueSync(subType =>
{
dataType.TypeInfo = new SetColumnInfo
{
KeyTypeCode = subType.TypeCode,
KeyTypeInfo = subType.TypeInfo
};
return dataType;
}));
}
if (typeName.IndexOf(CqlNames.Map, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += CqlNames.Map.Length + 1;
length -= CqlNames.Map.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length, '<', '>');
//It should contain the key and value types
if (innerTypes.Count != 2)
{
return(TaskHelper.FromException <ColumnDesc>(GetTypeException(typeName)));
}
dataType.TypeCode = ColumnTypeCode.Map;
var keyTypeTask = ParseTypeName(udtResolver, keyspace, innerTypes[0].Trim());
var valueTypeTask = ParseTypeName(udtResolver, keyspace, innerTypes[1].Trim());
return(Task.Factory.ContinueWhenAll(new[] { keyTypeTask, valueTypeTask }, tasks =>
{
dataType.TypeInfo = new MapColumnInfo
{
KeyTypeCode = tasks[0].Result.TypeCode,
KeyTypeInfo = tasks[0].Result.TypeInfo,
ValueTypeCode = tasks[1].Result.TypeCode,
ValueTypeInfo = tasks[1].Result.TypeInfo
};
return dataType;
}));
}
if (typeName.IndexOf(CqlNames.Tuple, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += CqlNames.Tuple.Length + 1;
length -= CqlNames.Tuple.Length + 2;
var tupleParams = ParseParams(typeName, startIndex, length, '<', '>');
if (tupleParams.Count < 1)
{
//It should contain at least the keyspace, name of the udt and a type
return(TaskHelper.FromException <ColumnDesc>(GetTypeException(typeName)));
}
dataType.TypeCode = ColumnTypeCode.Tuple;
var elementTasks = tupleParams
.Select(subTypeName => ParseTypeName(udtResolver, keyspace, subTypeName.Trim()))
.ToArray();
return(Task.Factory.ContinueWhenAll(elementTasks, tasks =>
{
dataType.TypeInfo = new TupleColumnInfo(tasks.Select(t => t.Result));
return dataType;
}));
}
if (startIndex > 0)
{
typeName = typeName.Substring(startIndex, length);
}
ColumnTypeCode typeCode;
if (SingleCqlNames.TryGetValue(typeName, out typeCode))
{
dataType.TypeCode = typeCode;
return(TaskHelper.ToTask(dataType));
}
typeName = typeName.Replace("\"", "");
return(udtResolver(keyspace, typeName).ContinueSync(typeInfo =>
{
if (typeInfo == null)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Udt;
dataType.TypeInfo = typeInfo;
return dataType;
}));
}
/// <summary>
/// Parses a given fully-qualified class type name to get the data type information
/// </summary>
/// <exception cref="ArgumentException" />
internal static ColumnDesc ParseFqTypeName(string typeName, int startIndex = 0, int length = 0)
{
const StringComparison comparison = StringComparison.Ordinal;
var dataType = new ColumnDesc();
if (length == 0)
{
length = typeName.Length;
}
if (length > ReversedTypeName.Length && typeName.IndexOf(ReversedTypeName, startIndex, comparison) == startIndex)
{
//move the start index and subtract the length plus parenthesis
startIndex += ReversedTypeName.Length + 1;
length -= ReversedTypeName.Length + 2;
dataType.IsReversed = true;
}
if (length > FrozenTypeName.Length && typeName.IndexOf(FrozenTypeName, startIndex, comparison) == startIndex)
{
//Remove the frozen
startIndex += FrozenTypeName.Length + 1;
length -= FrozenTypeName.Length + 2;
dataType.IsFrozen = true;
}
if (typeName == EmptyTypeName)
{
dataType.TypeCode = ColumnTypeCode.Custom;
dataType.TypeInfo = null;
return(dataType);
}
//Quick check if its a single type
if (length <= SingleFqTypeNamesLength)
{
ColumnTypeCode typeCode;
if (startIndex > 0)
{
typeName = typeName.Substring(startIndex, length);
}
if (SingleFqTypeNames.TryGetValue(typeName, out typeCode))
{
dataType.TypeCode = typeCode;
return(dataType);
}
throw GetTypeException(typeName);
}
if (typeName.IndexOf(ListTypeName, startIndex, comparison) == startIndex)
{
//Its a list
//org.apache.cassandra.db.marshal.ListType(innerType)
//move cursor across the name and bypass the parenthesis
startIndex += ListTypeName.Length + 1;
length -= ListTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
if (innerTypes.Count != 1)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.List;
var subType = ParseFqTypeName(innerTypes[0]);
dataType.TypeInfo = new ListColumnInfo()
{
ValueTypeCode = subType.TypeCode,
ValueTypeInfo = subType.TypeInfo
};
return(dataType);
}
if (typeName.IndexOf(SetTypeName, startIndex, comparison) == startIndex)
{
//Its a set
//org.apache.cassandra.db.marshal.SetType(innerType)
//move cursor across the name and bypass the parenthesis
startIndex += SetTypeName.Length + 1;
length -= SetTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
if (innerTypes.Count != 1)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Set;
var subType = ParseFqTypeName(innerTypes[0]);
dataType.TypeInfo = new SetColumnInfo()
{
KeyTypeCode = subType.TypeCode,
KeyTypeInfo = subType.TypeInfo
};
return(dataType);
}
if (typeName.IndexOf(MapTypeName, startIndex, comparison) == startIndex)
{
//org.apache.cassandra.db.marshal.MapType(keyType,valueType)
//move cursor across the name and bypass the parenthesis
startIndex += MapTypeName.Length + 1;
length -= MapTypeName.Length + 2;
var innerTypes = ParseParams(typeName, startIndex, length);
//It should contain the key and value types
if (innerTypes.Count != 2)
{
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Map;
var keyType = ParseFqTypeName(innerTypes[0]);
var valueType = ParseFqTypeName(innerTypes[1]);
dataType.TypeInfo = new MapColumnInfo()
{
KeyTypeCode = keyType.TypeCode,
KeyTypeInfo = keyType.TypeInfo,
ValueTypeCode = valueType.TypeCode,
ValueTypeInfo = valueType.TypeInfo
};
return(dataType);
}
if (typeName.IndexOf(UdtTypeName, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += UdtTypeName.Length + 1;
length -= UdtTypeName.Length + 2;
var udtParams = ParseParams(typeName, startIndex, length);
if (udtParams.Count < 2)
{
//It should contain at least the keyspace, name of the udt and a type
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Udt;
dataType.Keyspace = udtParams[0];
dataType.Name = HexToUtf8(udtParams[1]);
var udtInfo = new UdtColumnInfo(dataType.Keyspace + "." + dataType.Name);
for (var i = 2; i < udtParams.Count; i++)
{
var p = udtParams[i];
var separatorIndex = p.IndexOf(':');
var c = ParseFqTypeName(p, separatorIndex + 1, p.Length - (separatorIndex + 1));
c.Name = HexToUtf8(p.Substring(0, separatorIndex));
udtInfo.Fields.Add(c);
}
dataType.TypeInfo = udtInfo;
return(dataType);
}
if (typeName.IndexOf(TupleTypeName, startIndex, comparison) == startIndex)
{
//move cursor across the name and bypass the parenthesis
startIndex += TupleTypeName.Length + 1;
length -= TupleTypeName.Length + 2;
var tupleParams = ParseParams(typeName, startIndex, length);
if (tupleParams.Count < 1)
{
//It should contain at least the keyspace, name of the udt and a type
throw GetTypeException(typeName);
}
dataType.TypeCode = ColumnTypeCode.Tuple;
var tupleInfo = new TupleColumnInfo();
foreach (var subTypeName in tupleParams)
{
tupleInfo.Elements.Add(ParseFqTypeName(subTypeName));
}
dataType.TypeInfo = tupleInfo;
return(dataType);
}
throw GetTypeException(typeName);
}
public ColumnTypeCode GetCqlType(Type type, out IColumnInfo typeInfo)
{
typeInfo = null;
ITypeSerializer typeSerializer;
if (_primitiveSerializers.TryGetValue(type, out typeSerializer))
{
return typeSerializer.CqlType;
}
if (_customSerializers.Count > 0 && _customSerializers.TryGetValue(type, out typeSerializer))
{
typeInfo = typeSerializer.TypeInfo;
return typeSerializer.CqlType;
}
if (type.IsArray)
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode = GetCqlType(type.GetElementType(), out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return ColumnTypeCode.List;
}
if (type.IsGenericType)
{
if (type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
return GetCqlType(type.GetGenericArguments()[0], out typeInfo);
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode;
var interfaces = type.GetInterfaces();
if (typeof(IDictionary).IsAssignableFrom(type) &&
interfaces.Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary<,>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetGenericArguments()[0], out keyTypeInfo);
valueTypeCode = GetCqlType(type.GetGenericArguments()[1], out valueTypeInfo);
typeInfo = new MapColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo,
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return ColumnTypeCode.Map;
}
if (interfaces.Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ISet<>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetGenericArguments()[0], out keyTypeInfo);
typeInfo = new SetColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo
};
return ColumnTypeCode.Set;
}
valueTypeCode = GetCqlType(type.GetGenericArguments()[0], out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return ColumnTypeCode.List;
}
if (typeof(IStructuralComparable).IsAssignableFrom(type) && type.FullName.StartsWith("System.Tuple"))
{
typeInfo = new TupleColumnInfo
{
Elements = type.GetGenericArguments().Select(t =>
{
IColumnInfo tupleSubTypeInfo;
var dataType = new ColumnDesc
{
TypeCode = GetCqlType(t, out tupleSubTypeInfo),
TypeInfo = tupleSubTypeInfo
};
return dataType;
}).ToList()
};
return ColumnTypeCode.Tuple;
}
}
//Determine if its a Udt type
var udtMap = _udtSerializer.GetUdtMap(type);
if (udtMap != null)
{
typeInfo = udtMap.Definition;
return ColumnTypeCode.Udt;
}
throw new InvalidTypeException("Unknown Cassandra target type for CLR type " + type.FullName);
}
