public static void SetDbType(DbParameter param, string type)
{
if (param == null) return;
if (string.IsNullOrWhiteSpace(type)) return;
var paramType = param.GetType();
PropertyInfo dbTypeProp = null;
if (!_DbTypePropertyCache.TryGetValue(paramType, out dbTypeProp))
{
dbTypeProp = paramType.GetProperties().Where(x => x.GetCustomAttributes(typeof(DbProviderSpecificTypePropertyAttribute), true).Any()).FirstOrDefault();
_DbTypePropertyCache[paramType] = dbTypeProp;
}
if (dbTypeProp == null) return;
try { dbTypeProp.SetValue(param, Enum.Parse(dbTypeProp.PropertyType, type)); }
catch (ArgumentException) { }
}
/// <summary>
/// Converts a system type name into a database type.
/// </summary>
/// <param name="systemType">A system type</param>
/// <param name="factory">A system database factory</param>
/// <returns>The database name.</returns>
/// <exception cref="Tenor.TenorException">Throws TenorException when cannot convert the desired system type.</exception>
/// <exception cref="System.ArgumentNullException">Throws ArgumentNullException when a null parameter was supplied.</exception>
/// <remarks></remarks>
public static string GetDbTypeName(Type systemType, DbProviderFactory factory)
{
if (systemType == null)
{
throw (new ArgumentNullException("systemType"));
}
else if (factory == null)
{
throw (new ArgumentNullException("factory"));
}
string typeName = string.Empty;
DbType tipo = DbType.String;
System.ComponentModel.TypeConverter conversor = System.ComponentModel.TypeDescriptor.GetConverter(tipo);
if (conversor == null)
{
throw (new TenorException("GetDbTypeName: Cannot create converter."));
}
tipo = (DbType)(conversor.ConvertFrom(systemType.Name));
System.Data.Common.DbParameter param = factory.CreateParameter();
if (param == null)
{
throw (new TenorException("GetDbTypeName: Cannot create parameter."));
}
param.DbType = tipo;
foreach (System.Reflection.PropertyInfo prop in param.GetType().GetProperties())
{
//This loop is necessary to set dbms specific Parameter properties.
if (prop.Name.Contains("DbType") && !prop.Name.Equals("DbType"))
{
typeName = prop.GetValue(param, new object[] { }).ToString();
break;
}
}
return(typeName);
}
internal override void InitializeParameter(ProviderType type, DbParameter parameter, object value)
{
SqlType sqlType = (SqlType)type;
if(sqlType.IsRuntimeOnlyType)
{
throw Error.BadParameterType(sqlType.GetClosestRuntimeType());
}
SqlClient.SqlParameter sParameter = parameter as SqlClient.SqlParameter;
if(sParameter != null)
{
sParameter.SqlDbType = sqlType.SqlDbType;
if(sqlType.HasPrecisionAndScale)
{
sParameter.Precision = (byte)sqlType.Precision;
sParameter.Scale = (byte)sqlType.Scale;
}
}
else
{
PropertyInfo piSqlDbType = parameter.GetType().GetProperty("SqlDbType");
if(piSqlDbType != null)
{
piSqlDbType.SetValue(parameter, sqlType.SqlDbType, null);
}
if(sqlType.HasPrecisionAndScale)
{
PropertyInfo piPrecision = parameter.GetType().GetProperty("Precision");
if(piPrecision != null)
{
piPrecision.SetValue(parameter, Convert.ChangeType(sqlType.Precision, piPrecision.PropertyType, CultureInfo.InvariantCulture), null);
}
PropertyInfo piScale = parameter.GetType().GetProperty("Scale");
if(piScale != null)
{
piScale.SetValue(parameter, Convert.ChangeType(sqlType.Scale, piScale.PropertyType, CultureInfo.InvariantCulture), null);
}
}
}
parameter.Value = GetParameterValue(sqlType, value);
int? determinedSize = DetermineParameterSize(sqlType, parameter);
if(determinedSize.HasValue)
{
parameter.Size = determinedSize.Value;
}
}
void DatabaseInfo.SetParameterType( DbParameter parameter, string dbTypeString )
{
var oracleDbTypeProperty = parameter.GetType().GetProperty( "OracleDbType" );
oracleDbTypeProperty.SetValue( parameter, Enum.Parse( factory.GetType().Assembly.GetType( "Oracle.DataAccess.Client.OracleDbType" ), dbTypeString ), null );
}
/// <summary>
/// 添加游标参数（针对Oracle数据库）
/// </summary>
/// <param name="param">参数对象</param>
public override void SetCursorParam(DbParameter param)
{
param.Direction = System.Data.ParameterDirection.Output;
var dbTypeProperty = param.GetType().GetProperty("OracleDbType");
var typeValue = EnumHelper.ToEnum("Oracle.ManagedDataAccess.Client.OracleDbType,Oracle.ManagedDataAccess", "RefCursor");
dbTypeProperty.SetValue(param, typeValue, null);
}
public static void AssignParameterDbType(DbParameter parameter, string systemType)
{
if (systemType == "SByte")
parameter.DbType = DbType.Int16;
else
if (systemType == "TimeSpan")
parameter.DbType = DbType.String;
else
if ((systemType == "Guid") && parameter.GetType().Name.Contains("Oracle"))
parameter.DbType = DbType.Binary;
else
parameter.DbType = ((DbType)(TypeDescriptor.GetConverter(typeof(DbType)).ConvertFrom(systemType)));
}
private void AddDbParameterStatements (CodeMemberMethod m,
CodeExpression expr,
DbParameter param)
{
object dbType = param.FrameworkDbType;
string srcColumn = null;
if (param.SourceColumn != String.Empty)
srcColumn = param.SourceColumn;
CodeExpression[] args = new CodeExpression[] {
Const (param.ParameterName),
PropRef (Local(dbType.GetType().FullName), dbType.ToString ()),
Const (param.Size),
PropRef(Local(typeof (ParameterDirection).FullName), param.Direction.ToString ()),
Const (param.IsNullable),
Const (((IDbDataParameter)param).Precision),
Const (((IDbDataParameter)param).Scale),
Const (srcColumn),
PropRef (Local (typeof (DataRowVersion).FullName), param.SourceVersion.ToString ()),
/* Const (param.SourceColumnNullMapping), */ // TODO: Investigate with other providers
Const (param.Value)
};
m.Statements.Add (Eval (MethodInvoke (expr, "Add", New (param.GetType (), args))));
}
private static void AddRefCursorParameter(DbParameter parameter)
{
//we don't want a direct dependency, so we use reflection
var fullName = parameter.GetType().FullName;
if (fullName == "System.Data.OracleClient.OracleParameter")
{
var prop = parameter.GetType().GetProperty("OracleType");
if (prop != null)
{
//OracleType.Cursor
prop.SetValue(parameter, 5, null);
}
}
else if (fullName == "Oracle.DataAccess.Client.OracleParameter")
{
var prop = parameter.GetType().GetProperty("OracleDbType");
if (prop != null)
{
//OracleDbType.RefCursor
prop.SetValue(parameter, 121, null);
}
}
}
void DatabaseInfo.SetParameterType( DbParameter parameter, string dbTypeString )
{
var mySqlDbTypeProperty = parameter.GetType().GetProperty( "MySqlDbType" );
mySqlDbTypeProperty.SetValue( parameter, Enum.Parse( factory.GetType().Assembly.GetType( "MySql.Data.MySqlClient.MySqlDbType" ), dbTypeString ), null );
}
