| public static Resolve ( SqlTypeCode sqlType, string typeName ) : SqlType | ||
| sqlType | SqlTypeCode | |
| typeName | string | |
| return | SqlType | |
public static SqlType Resolve(SqlTypeCode typeCode, string typeName, DataTypeMeta[] metadata, ITypeResolver resolver)
{
if (PrimitiveTypes.IsPrimitive(typeCode))
{
return(PrimitiveTypes.Resolve(typeCode, typeName, metadata));
}
if (resolver == null)
{
throw new NotSupportedException(String.Format("Cannot resolve type '{0}' without context.", typeName));
}
var resolveCcontext = new TypeResolveContext(typeCode, typeName, metadata);
return(resolver.ResolveType(resolveCcontext));
}
public static SqlType ResolveType(this IContext context, string typeName, params DataTypeMeta[] meta)
{
if (PrimitiveTypes.IsPrimitive(typeName))
{
return(PrimitiveTypes.Resolve(typeName, meta));
}
var resolvers = context.ResolveAllServices <ITypeResolver>();
foreach (var resolver in resolvers)
{
var sqlType = resolver.ResolveType(new TypeResolveContext(SqlTypeCode.Unknown, typeName, meta));
if (sqlType != null)
{
return(sqlType);
}
}
return(null);
}
/// <summary>
/// Parses a SQL formatted string that defines a data-type into
/// a constructed <see cref="SqlType"/> object equivalent.
/// </summary>
/// <param name="context">A context used to resolve the SQL parser.</param>
/// <param name="s">The SQL formatted data-type string, defining the properties of the type.</param>
/// <remarks>
/// If the <paramref name="context"/> is not provided, this will fail in case of
/// non-primitive types.
/// </remarks>
/// <returns>
/// Returns an instance of <see cref="SqlType"/> that corresponds to the
/// string provided.
/// </returns>
/// <exception cref="FormatException">
/// If the provided string does not resolve to any valid <see cref="SqlType"/>
/// </exception>
/// <exception cref="FormatException">
/// If the string does not resolve to any primitive types and the <paramref name="context"/>
/// is <c>null</c> or the type is not found in the context.
/// </exception>
/// <seealso cref="PrimitiveTypes.IsPrimitive(SqlTypeCode)"/>
/// <seealso cref="ToString()"/>
public static SqlType Parse(IContext context, string s)
{
try {
IDataTypeParser parser = null;
if (context != null)
{
parser = context.ResolveService <IDataTypeParser>();
}
if (parser == null)
{
parser = DataTypeInfo.DefaultParser;
}
var info = parser.Parse(s);
if (info == null)
{
throw new InvalidOperationException("Invalid response from parser.");
}
if (info.IsPrimitive)
{
return(PrimitiveTypes.Resolve(info.TypeName, info.Metadata));
}
if (context == null)
{
throw new NotSupportedException(String.Format("The type '{0}' is not primitive and no resolve context is provided.", info.TypeName));
}
return(context.TypeResolver().ResolveType(new TypeResolveContext(SqlTypeCode.Unknown, info.TypeName, info.Metadata)));
} catch (Exception ex) {
throw new FormatException(String.Format("Unable to parse the string '{0}' to a valid data type.", s), ex);
}
}
