public static IDataType NativeTypeNameToDataType(Schema.DataTypes dataTypes, string nativeDataTypeName)
{
if (nativeDataTypeName.ToLower().StartsWith("row"))
{
var rowType = new RowType();
rowType.Columns.AddRange(ParseColumnTypes(dataTypes, nativeDataTypeName.Substring(4, nativeDataTypeName.Length - 5)));
return(rowType);
}
else if (nativeDataTypeName.ToLower().StartsWith("table"))
{
var tableType = new TableType();
tableType.Columns.AddRange(ParseColumnTypes(dataTypes, nativeDataTypeName.Substring(6, nativeDataTypeName.Length - 7)));
return(tableType);
}
else if (nativeDataTypeName.ToLower().StartsWith("list"))
{
var elementType = NativeTypeNameToDataType(dataTypes, nativeDataTypeName.Substring(5, nativeDataTypeName.Length - 6));
return(new ListType(elementType));
}
else
{
return(NativeScalarTypeNameToDataType(dataTypes, nativeDataTypeName));
}
}
public static Columns NativeColumnsToColumns(Schema.DataTypes dataTypes, NativeColumn[] nativeColumns)
{
Columns columns = new Columns();
for (int index = 0; index < nativeColumns.Length; index++)
{
columns.Add(new Column(nativeColumns[index].Name, NativeTypeNameToDataType(dataTypes, nativeColumns[index].DataTypeName)));
}
return(columns);
}
private void CacheCleared(LocalServer server)
{
if (_dataTypes != null)
{
_dataTypes.OnCatalogLookupFailed -= new Schema.CatalogLookupFailedEvent(CatalogLookupFailed);
}
_dataTypes = new Schema.DataTypes(server._internalServer.Catalog);
_dataTypes.OnCatalogLookupFailed += new Schema.CatalogLookupFailedEvent(CatalogLookupFailed);
_session._server.Catalog.ClassLoader.OnMiss += new ClassLoaderMissedEvent(ClassLoaderMissed);
}
private bool GetIsLong(TableVarColumn column, Schema.DataTypes dataTypes)
{
DAE.Language.D4.Tag tag = column.GetMetaDataTag("DAEDataReader.IsLong");
if (tag != null)
{
return(tag.Value.ToLower() == "true");
}
else
{
return(GetNativeType(column.DataType, column, dataTypes) == typeof(byte[]));
}
}
public static Type GetNativeType(IDataType dataType, TableVarColumn column, Schema.DataTypes dataTypes)
{
DAE.Language.D4.Tag tag = column.GetMetaDataTag("DAEDataReader.NativeType");
if (tag != Tag.None)
{
return(Type.GetType(tag.Value, true, true));
}
else
{
return(GetNativeType(dataType, dataTypes));
}
}
public static IDataType NativeScalarTypeNameToDataType(Schema.DataTypes dataTypes, string nativeDataTypeName)
{
switch (nativeDataTypeName.ToLower())
{
case "byte[]": return(dataTypes.SystemBinary);
case "bool":
case "boolean": return(dataTypes.SystemBoolean);
case "byte": return(dataTypes.SystemByte);
case "date": return(dataTypes.SystemDate);
case "datetime": return(dataTypes.SystemDateTime);
case "decimal": return(dataTypes.SystemDecimal);
case "exception": return(dataTypes.SystemError);
case "guid": return(dataTypes.SystemGuid);
case "int32":
case "integer": return(dataTypes.SystemInteger);
case "int64":
case "long": return(dataTypes.SystemLong);
case "money": return(dataTypes.SystemMoney);
case "int16":
case "short": return(dataTypes.SystemShort);
case "string": return(dataTypes.SystemString);
case "time": return(dataTypes.SystemTime);
case "timespan": return(dataTypes.SystemTimeSpan);
default:
if (nativeDataTypeName.EndsWith("[]"))
{
// Subtract off ending brackets
var arrayTypeName = nativeDataTypeName.Substring(0, nativeDataTypeName.Length - 2);
return(new ListType(NativeTypeNameToDataType(dataTypes, arrayTypeName)));
}
else
{
throw new ArgumentException(String.Format("Invalid native data type name: \"{0}\".", nativeDataTypeName));
}
}
}
public static NativeColumn[] ColumnsToNativeColumns(Schema.DataTypes dataTypes, Columns columns)
{
NativeColumn[] localColumns = new NativeColumn[columns.Count];
for (int index = 0; index < columns.Count; index++)
{
localColumns[index] =
new NativeColumn
{
Name = columns[index].Name,
DataTypeName = DataTypeToDataTypeName(dataTypes, columns[index].DataType)
}
}
;
return(localColumns);
}
public static Columns ParseColumnTypes(Schema.DataTypes dataTypes, string columnDefinitions)
{
var results = new Columns();
var current = 0;
var colon = columnDefinitions.IndexOf(':');
while (colon > 0)
{
var next = columnDefinitions.IndexOf(',', current);
if (next < 0)
{
next = columnDefinitions.Length;
}
results.Add
(
new Column
(
columnDefinitions.Substring(current, colon - current),
NativeTypeNameToDataType(dataTypes, columnDefinitions.Substring(colon + 1, next - colon - 1))
)
);
current = next + 1;
if (current < columnDefinitions.Length)
{
colon = columnDefinitions.IndexOf(':', current);
}
else
{
colon = -1;
}
}
return(results);
}
public static string ScalarTypeToDataTypeName(Schema.DataTypes dataTypes, IScalarType scalarType)
{
if (scalarType.IsClassType)
{
return(scalarType.FromClassDefinition.ClassName);
}
if (scalarType.NativeType == NativeAccessors.AsBoolean.NativeType)
{
return("Boolean");
}
if (scalarType.NativeType == NativeAccessors.AsByte.NativeType)
{
return("Byte");
}
if (scalarType.NativeType == NativeAccessors.AsByteArray.NativeType)
{
return("Byte[]");
}
if (scalarType.NativeType == NativeAccessors.AsDateTime.NativeType)
{
if (scalarType.Is(dataTypes.SystemDateTime) || scalarType.IsLike(dataTypes.SystemDateTime))
{
return("DateTime");
}
if (scalarType.Is(dataTypes.SystemDate) || scalarType.IsLike(dataTypes.SystemDate))
{
return("Date");
}
if (scalarType.Is(dataTypes.SystemTime) || scalarType.IsLike(dataTypes.SystemTime))
{
return("Time");
}
}
if (scalarType.NativeType == NativeAccessors.AsDecimal.NativeType)
{
return("Decimal");
}
if (scalarType.NativeType == NativeAccessors.AsException.NativeType)
{
return("Exception");
}
if (scalarType.NativeType == NativeAccessors.AsGuid.NativeType)
{
return("Guid");
}
if (scalarType.NativeType == NativeAccessors.AsInt16.NativeType)
{
return("Int16");
}
if (scalarType.NativeType == NativeAccessors.AsInt32.NativeType)
{
return("Int32");
}
if (scalarType.NativeType == NativeAccessors.AsInt64.NativeType)
{
return("Int64");
}
if (scalarType.NativeType == NativeAccessors.AsString.NativeType)
{
return("String");
}
if (scalarType.NativeType == NativeAccessors.AsTimeSpan.NativeType)
{
return("TimeSpan");
}
throw new ArgumentException(String.Format("Scalar type \"{0}\" has no native type.", scalarType.Name));
}
public static string DataTypeToDataTypeName(Schema.DataTypes dataTypes, IDataType dataType)
{
IScalarType scalarType = dataType as IScalarType;
if (scalarType != null)
{
return(ScalarTypeToDataTypeName(dataTypes, scalarType));
}
ListType listType = dataType as ListType;
if (listType != null)
{
return(String.Format("list({0})", DataTypeToDataTypeName(dataTypes, listType.ElementType)));
}
RowType rowType = dataType as RowType;
if (rowType != null)
{
var sb = new StringBuilder();
sb.Append("row{");
bool first = true;
foreach (Column column in rowType.Columns)
{
if (!first)
{
sb.Append(",");
}
else
{
first = false;
}
sb.AppendFormat("{0}:{1}", column.Name, DataTypeToDataTypeName(dataTypes, column.DataType));
}
sb.Append("}");
return(sb.ToString());
}
TableType tableType = dataType as TableType;
if (tableType != null)
{
var sb = new StringBuilder();
sb.Append("table{");
bool first = true;
foreach (Column column in tableType.Columns)
{
if (!first)
{
sb.Append(",");
}
else
{
first = false;
}
sb.AppendFormat("{0}:{1}", column.Name, DataTypeToDataTypeName(dataTypes, column.DataType));
}
sb.Append("}");
return(sb.ToString());
}
throw new NotSupportedException("Non-scalar-valued attributes are not supported.");
}
