public void Add(OdbcType type, Object objValue)
{
OdbcParameter parm = new OdbcParameter(type.ToString(), type);
parm.Value = objValue;
this.Add(parm);
}
/// <summary>
/// todoComment
/// </summary>
/// <param name="ADBFieldName"></param>
/// <param name="ADataRow"></param>
/// <param name="ACriteriaField"></param>
/// <param name="AMatchField"></param>
/// <param name="AOdbcType"></param>
/// <param name="AOdbcSize"></param>
/// <param name="AWhereClause"></param>
/// <param name="AIntParamArray"></param>
public TDynamicSearchHelper(String ADBFieldName,
DataRow ADataRow,
String ACriteriaField,
String AMatchField,
OdbcType AOdbcType,
Int32 AOdbcSize,
ref String AWhereClause,
ref ArrayList AIntParamArray)
{
object ParameterValue;
OdbcParameter miParam;
FDBFieldName = ADBFieldName;
FDataRow = ADataRow;
FCriteriaField = ACriteriaField;
FMatchField = AMatchField;
ParameterValue = GetParameterValue();
if (ParameterValue.ToString() != String.Empty)
{
miParam = new OdbcParameter("", AOdbcType, AOdbcSize);
miParam.Value = ParameterValue;
AIntParamArray.Add(miParam);
AWhereClause = AWhereClause + GetWhereString();
}
}
protected override Type?ToClrType(OdbcType dbType, bool isNullable, int?maxLength)
{
switch (dbType)
{
case OdbcType.BigInt:
return(isNullable ? typeof(long?) : typeof(long));
case OdbcType.Binary:
return(typeof(byte[]));
case OdbcType.Bit:
return(isNullable ? typeof(bool?) : typeof(bool));
case OdbcType.NChar:
case OdbcType.NVarChar:
case OdbcType.Char:
case OdbcType.VarChar:
return((maxLength == 1) ?
(isNullable ? typeof(char?) : typeof(char))
: typeof(string));
case OdbcType.Decimal:
case OdbcType.Numeric:
return(isNullable ? typeof(decimal?) : typeof(decimal));
case OdbcType.Double:
return(isNullable ? typeof(double?) : typeof(double));
case OdbcType.Int:
return(isNullable ? typeof(int?) : typeof(int));
case OdbcType.Text:
case OdbcType.NText:
return(typeof(string));
case OdbcType.Real:
return(isNullable ? typeof(float?) : typeof(float));
case OdbcType.UniqueIdentifier:
return(isNullable ? typeof(Guid?) : typeof(Guid));
case OdbcType.SmallInt:
return(isNullable ? typeof(ushort?) : typeof(ushort));
case OdbcType.TinyInt:
return(isNullable ? typeof(byte?) : typeof(byte));
case OdbcType.VarBinary:
case OdbcType.Image:
case OdbcType.Timestamp:
return(typeof(byte[]));
case OdbcType.Date:
case OdbcType.DateTime:
case OdbcType.SmallDateTime:
case OdbcType.Time:
return(typeof(DateTime));
}
return(null);
}
OdbcType GetOdbcType(DbColumnInfo column)
{
var dbtype = column.DbTypeText;
OdbcType ret = OdbcType.VarChar;
switch (dbtype?.ToLower().TrimStart('_'))
{
case "int8":
case "serial8":
case "bigserial":
case "bigint": ret = OdbcType.BigInt; break;
case "byte":
case "blob": ret = OdbcType.VarBinary; break;
case "nchar": ret = OdbcType.NChar; break;
case "char":
case "character": ret = OdbcType.Char; break;
case "date": ret = OdbcType.Date; break;
case "dec":
case "decimal": ret = OdbcType.Decimal; break;
case "double":
case "double precision":
case "float": ret = OdbcType.Double; break;
case "real":
case "smallfloat": ret = OdbcType.Real; break;
case "serial":
case "integer":
case "int": ret = OdbcType.Int; break;
case "numeric":
case "numeric precision": ret = OdbcType.Decimal; break;
case "smallint": ret = OdbcType.SmallInt; break;
case "interval": ret = OdbcType.Time; break;
case "datetime":
case "timestamp": ret = OdbcType.DateTime; break;
case "varchar":
case "char varying":
case "character varying": ret = OdbcType.VarChar; break;
case "nvarchar": ret = OdbcType.NVarChar; break;
case "text": ret = OdbcType.Text; break;
case "boolean": ret = OdbcType.Bit; break;
case "char(36)": ret = OdbcType.UniqueIdentifier; break;
}
return(ret);
}
/// <summary>
/// Convenience method for creating an OdbcParameter with an
/// appropriate <c>TDbListParameterValue</c> as a value.
/// </summary>
public static OdbcParameter OdbcListParameterValue(String name, OdbcType type, IEnumerable value)
{
return(new OdbcParameter(name, type)
{
Value = new TDbListParameterValue(name, type, value)
});
}
/// <summary>
/// Builds an Odbc Parameter object from the arguments.
/// </summary>
/// <param name="parameterElement">Parameter definition from the config.</param>
/// <param name="data">The event notification to pull the parameter's value from.</param>
/// <returns></returns>
private static OdbcParameter ParseParameter(ParameterElement parameterElement, EventNotificationData data)
{
try
{
// Need to convert the string representation of the type to the actual
// enum OdbcType.
string[] odbcTypes = Enum.GetNames(typeof(OdbcType));
string odbcTypeMatch = odbcTypes.First(t => t.Equals(parameterElement.DataType, StringComparison.InvariantCultureIgnoreCase));
OdbcType odbcType = (OdbcType)Enum.Parse(typeof(OdbcType), odbcTypeMatch);
// Get property from the data using the property DisplayName (source)
object value = HttpUtility.HtmlDecode(data.GetValueByDisplayName(parameterElement.Source));
// Build return object.
var parameter = new OdbcParameter
{
ParameterName = parameterElement.Name,
OdbcType = odbcType,
Size = parameterElement.LengthAsInt,
Value = value == null ? DBNull.Value : (string)value == string.Empty && odbcType == OdbcType.Int ? 0 : value
};
return(parameter);
}
catch (Exception ex)
{
throw new Exception("Failed to parse parameter.", ex);
}
}
protected AccessDataProvider_Odbc(string name, MappingSchema mappingSchema) : base(name, mappingSchema)
{
if (System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator != ".")
{
_decimalType = OdbcType.VarChar;
}
}
public OdbcParameter(string?name, OdbcType type, int size, string?sourcecolumn) : this()
{
ParameterName = name;
OdbcType = type;
Size = size;
SourceColumn = sourcecolumn;
}
public void AddFieldName(string fieldName,OdbcType type)
{
// isCallAddFieldName = true ;
ODBCDataField field = new ODBCDataField( fieldName,type ) ;
fieldList.Add(field) ;
}
public void AddFieldName(string fieldName, OdbcType type)
{
// isCallAddFieldName = true ;
ODBCDataField field = new ODBCDataField(fieldName, type);
fieldList.Add(field);
}
internal void UpdateTypes(SQL_TYPE sqlType)
{
SqlType = sqlType;
OdbcTypeMap map = OdbcTypeConverter.GetTypeMap(SqlType);
OdbcType = map.OdbcType;
SqlCType = map.NativeType;
}
public OdbcTypeMap(DbType dbType, OdbcType odbcType,
SQL_C_TYPE nativeType, SQL_TYPE sqlType)
{
DbType = dbType;
OdbcType = odbcType;
SqlType = sqlType;
NativeType = nativeType;
}
internal OdbcColumn(string Name, OdbcType Type)
{
this.ColumnName = Name;
this.OdbcType = Type;
AllowDBNull = false;
MaxLength = 0;
Digits = 0;
Value = null;
}
internal OdbcColumn(string Name, OdbcType Type)
{
this.ColumnName=Name;
this.OdbcType=Type;
AllowDBNull=false;
MaxLength=0;
Digits=0;
Value=null;
}
/*
* creates where clause for optimistic concurrency
*/
private string CreateOptWhereClause(OdbcCommand command, int paramCount)
{
string [] whereClause = new string [Schema.Rows.Count];
int partCount = 0;
foreach (DataRow schemaRow in Schema.Rows)
{
// exclude non updatable columns
if (!IsUpdatable(schemaRow))
{
continue;
}
string columnName = GetColumnName(schemaRow);
if (columnName == String.Empty)
{
throw new InvalidOperationException("Cannot form delete command. Column name is missing!");
}
bool allowNull = schemaRow.IsNull("AllowDBNull") || (bool)schemaRow ["AllowDBNull"];
OdbcType sqlDbType = schemaRow.IsNull("ProviderType") ? OdbcType.VarChar : (OdbcType)schemaRow ["ProviderType"];
int length = schemaRow.IsNull("ColumnSize") ? -1 : (int)schemaRow ["ColumnSize"];
if (allowNull)
{
whereClause [partCount++] = String.Format("((? = 1 AND {0} IS NULL) OR ({0} = ?))",
GetQuotedString(columnName));
OdbcParameter nullParam = AddParameter(
command,
GetParameterName(++paramCount),
OdbcType.Int,
length,
#if NET_2_0
columnName,
#else
string.Empty,
#endif
DataRowVersion.Original);
nullParam.Value = 1;
AddParameter(command, GetParameterName(++paramCount),
sqlDbType, length, columnName,
DataRowVersion.Original);
}
else
{
whereClause [partCount++] = String.Format("({0} = ?)",
GetQuotedString(columnName));
AddParameter(command, GetParameterName(++paramCount),
sqlDbType, length, columnName,
DataRowVersion.Original);
}
}
return(String.Join(" AND ", whereClause, 0, partCount));
}
public OdbcParameter(string name, OdbcType odbcType, int size,
ParameterDirection direction, bool isNullable,
byte precision, byte scale, string srcColumn,
DataRowVersion srcVersion, object value)
: this(name, odbcType, size, srcColumn)
{
this.Direction = direction;
this.IsNullable = isNullable;
this.SourceVersion = srcVersion;
}
/// <summary>
/// 为 OleDbParameter 实例配置属性值。
/// </summary>
/// <param name="param">参数。</param>
/// <param name="name">名称。</param>
/// <param name="odbcType">数据类型。</param>
/// <param name="size">数据长度。</param>
/// <param name="direction">参数类型。</param>
/// <param name="nullable">表示参数是否可以接受null值。</param>
/// <param name="sourceColumn">源列的名称。</param>
/// <param name="sourceVersion">数据行的版本。</param>
/// <param name="value">参数值。</param>
public void ConfigureParameter(OdbcParameter param, string name, OdbcType odbcType, int size, ParameterDirection direction, bool nullable, string sourceColumn, DataRowVersion sourceVersion, object value)
{
param.OdbcType = odbcType;
param.Size = size;
param.Value = value ?? DBNull.Value;
param.Direction = direction;
param.IsNullable = nullable;
param.SourceColumn = sourceColumn;
param.SourceVersion = sourceVersion;
}
internal static TypeMap FromOdbcType(OdbcType odbcType)
{
switch (odbcType)
{
case OdbcType.BigInt: return(s_bigInt);
case OdbcType.Binary: return(s_binary);
case OdbcType.Bit: return(s_bit);
case OdbcType.Char: return(_Char);
case OdbcType.DateTime: return(s_dateTime);
case OdbcType.Date: return(s_date);
case OdbcType.Time: return(s_time);
case OdbcType.Double: return(s_double);
case OdbcType.Decimal: return(s_decimal);
case OdbcType.Image: return(_Image);
case OdbcType.Int: return(s_int);
case OdbcType.NChar: return(s_NChar);
case OdbcType.NText: return(_NText);
case OdbcType.Numeric: return(s_numeric);
case OdbcType.NVarChar: return(_NVarChar);
case OdbcType.Real: return(s_real);
case OdbcType.UniqueIdentifier: return(s_uniqueId);
case OdbcType.SmallDateTime: return(s_smallDT);
case OdbcType.SmallInt: return(s_smallInt);
case OdbcType.Text: return(_Text);
case OdbcType.Timestamp: return(s_timestamp);
case OdbcType.TinyInt: return(s_tinyInt);
case OdbcType.VarBinary: return(s_varBinary);
case OdbcType.VarChar: return(_VarChar);
default: throw ODBC.UnknownOdbcType(odbcType);
}
}
static internal TypeMap FromOdbcType(OdbcType odbcType)
{
switch (odbcType)
{
case OdbcType.BigInt: return(_BigInt);
case OdbcType.Binary: return(_Binary);
case OdbcType.Bit: return(_Bit);
case OdbcType.Char: return(_Char);
case OdbcType.DateTime: return(_DateTime);
case OdbcType.Date: return(_Date);
case OdbcType.Time: return(_Time);
case OdbcType.Double: return(_Double);
case OdbcType.Decimal: return(_Decimal);
case OdbcType.Image: return(_Image);
case OdbcType.Int: return(_Int);
case OdbcType.NChar: return(_NChar);
case OdbcType.NText: return(_NText);
case OdbcType.Numeric: return(_Numeric);
case OdbcType.NVarChar: return(_NVarChar);
case OdbcType.Real: return(_Real);
case OdbcType.UniqueIdentifier: return(_UniqueId);
case OdbcType.SmallDateTime: return(_SmallDT);
case OdbcType.SmallInt: return(_SmallInt);
case OdbcType.Text: return(_Text);
case OdbcType.Timestamp: return(_Timestamp);
case OdbcType.TinyInt: return(_TinyInt);
case OdbcType.VarBinary: return(_VarBinary);
case OdbcType.VarChar: return(_VarChar);
default: throw ODC.UnknownOdbcType(odbcType);
}
}
private OdbcCommand CreateInsertCommand(bool option)
{
CreateNewCommand(ref _insertCommand);
string query = String.Format("INSERT INTO {0}", GetQuotedString(TableName));
string [] columns = new string [Schema.Rows.Count];
string [] values = new string [Schema.Rows.Count];
int count = 0;
foreach (DataRow schemaRow in Schema.Rows)
{
// exclude non updatable columns
if (!IsUpdatable(schemaRow))
{
continue;
}
string columnName = GetColumnName(schemaRow);
if (columnName == String.Empty)
{
throw new InvalidOperationException("Cannot form insert command. Column name is missing!");
}
// create column string & value string
columns [count] = GetQuotedString(columnName);
values [count++] = "?";
// create parameter and add
OdbcType sqlDbType = schemaRow.IsNull("ProviderType") ? OdbcType.VarChar : (OdbcType)schemaRow ["ProviderType"];
int length = schemaRow.IsNull("ColumnSize") ? -1 : (int)schemaRow ["ColumnSize"];
AddParameter(_insertCommand, GetParameterName(count),
sqlDbType, length, columnName, DataRowVersion.Current);
}
query = String.Format(
#if NET_2_0
"{0} ({1}) VALUES ({2})",
#else
"{0}( {1} ) VALUES ( {2} )",
#endif
query,
#if NET_2_0
String.Join(", ", columns, 0, count),
String.Join(", ", values, 0, count));
#else
String.Join(" , ", columns, 0, count),
String.Join(" , ", values, 0, count));
#endif
_insertCommand.CommandText = query;
return(_insertCommand);
}
public static Dictionary <string, OdbcType> GetsColumnsWithTypes(DataColumnCollection columns)
{
Dictionary <string, OdbcType> columnsWithTypes = new Dictionary <string, OdbcType>();
foreach (DataColumn col in columns)
{
OdbcType type = MapCsharpTypeToODBCType(col.DataType);
columnsWithTypes.Add(col.ColumnName, type);
}
return(columnsWithTypes);
}
/// <summary>
/// 创建一个新的 OleDbParameter 实例。
/// </summary>
/// <param name="name">名称。</param>
/// <param name="odbcType">数据类型。</param>
/// <param name="size">数据长度。</param>
/// <param name="direction">参数类型。</param>
/// <param name="nullable">表示参数是否可以接受null值。</param>
/// <param name="sourceColumn">源列的名称。</param>
/// <param name="sourceVersion">数据行的版本。</param>
/// <param name="value">参数值。</param>
/// <returns>返回一个新的 OracleParameter 实例。</returns>
public OdbcParameter CreateParameter(string name, OdbcType odbcType, int size, ParameterDirection direction, bool nullable, string sourceColumn, DataRowVersion sourceVersion, object value)
{
OdbcParameter param = CreateParameter(name) as OdbcParameter;
if (param == null)
{
throw new ArgumentNullException("command");
}
ConfigureParameter(param, name, odbcType, size, direction, nullable, sourceColumn, sourceVersion, value);
return(param);
}
private TypeMap(OdbcType odbcType, DbType dbType, Type type, ODBC32.SQL_TYPE sql_type, ODBC32.SQL_C sql_c, ODBC32.SQL_C param_sql_c, int bsize, int csize, bool signType)
{
this._odbcType = odbcType;
this._dbType = dbType;
this._type = type;
this._sql_type = sql_type;
this._sql_c = sql_c;
this._param_sql_c = param_sql_c;
this._bufferSize = bsize;
this._columnSize = csize;
this._signType = signType;
}
private OdbcCommand CreateUpdateCommand(bool option)
{
CreateNewCommand(ref _updateCommand);
string query = String.Format("UPDATE {0} SET", GetQuotedString(TableName));
string [] setClause = new string [Schema.Rows.Count];
int count = 0;
foreach (DataRow schemaRow in Schema.Rows)
{
// exclude non updatable columns
if (!IsUpdatable(schemaRow))
{
continue;
}
string columnName = GetColumnName(schemaRow);
if (columnName == String.Empty)
{
throw new InvalidOperationException("Cannot form update command. Column name is missing!");
}
OdbcType sqlDbType = schemaRow.IsNull("ProviderType") ? OdbcType.VarChar : (OdbcType)schemaRow ["ProviderType"];
int length = schemaRow.IsNull("ColumnSize") ? -1 : (int)schemaRow ["ColumnSize"];
// create column = value string
setClause [count++] = String.Format("{0} = ?", GetQuotedString(columnName));
AddParameter(_updateCommand, GetParameterName(count),
sqlDbType, length, columnName, DataRowVersion.Current);
}
// create where clause. odbc uses positional parameters. so where class
// is created seperate from the above loop.
string whereClause = CreateOptWhereClause(_updateCommand, count);
query = String.Format(
#if NET_2_0
"{0} {1} WHERE ({2})",
#else
"{0} {1} WHERE ( {2} )",
#endif
query,
#if NET_2_0
String.Join(", ", setClause, 0, count),
#else
String.Join(" , ", setClause, 0, count),
#endif
whereClause);
_updateCommand.CommandText = query;
return(_updateCommand);
}
private TypeMap(OdbcType odbcType, DbType dbType, Type type, ODBC32.SQL_TYPE sql_type, ODBC32.SQL_C sql_c, ODBC32.SQL_C param_sql_c, int bsize, int csize, bool signType)
{
this._odbcType = odbcType;
this._dbType = dbType;
this._type = type;
this._sql_type = sql_type;
this._sql_c = sql_c;
this._param_sql_c = param_sql_c;
this._bufferSize = bsize;
this._columnSize = csize;
this._signType = signType;
}
/*
* creates where clause for optimistic concurrency
*/
private string CreateOptWhereClause(OdbcCommand command, bool option)
{
string [] whereClause = new string [Schema.Rows.Count];
int count = 0;
foreach (DataRow schemaRow in Schema.Rows)
{
// exclude non updatable columns
if (!IsUpdatable(schemaRow))
{
continue;
}
string columnName = null;
if (option)
{
columnName = GetColumnName(schemaRow);
}
else
{
columnName = String.Format("@p{0}", count);
}
if (columnName == String.Empty)
{
throw new InvalidOperationException("Cannot form delete command. Column name is missing!");
}
bool allowNull = schemaRow.IsNull("AllowDBNull") || (bool)schemaRow ["AllowDBNull"];
OdbcType sqlDbType = schemaRow.IsNull("ProviderType") ? OdbcType.VarChar : (OdbcType)schemaRow ["ProviderType"];
int length = schemaRow.IsNull("ColumnSize") ? -1 : (int)schemaRow ["ColumnSize"];
if (allowNull)
{
whereClause [count] = String.Format("((? = 1 AND {0} IS NULL) OR ({0} = ?))",
columnName);
AddParameter(command, columnName, sqlDbType, length, columnName, DataRowVersion.Original);
AddParameter(command, columnName, sqlDbType, length, columnName, DataRowVersion.Original);
}
else
{
whereClause [count] = String.Format("({0} = ?)", columnName);
AddParameter(command, columnName, sqlDbType, length, columnName, DataRowVersion.Original);
}
count++;
}
return(String.Join(" AND ", whereClause, 0, count));
}
internal readonly bool _signType; // this type may be has signature information
private TypeMap(OdbcType odbcType, DbType dbType, Type type, ODBC32.SQL_TYPE sql_type, ODBC32.SQL_C sql_c, ODBC32.SQL_C param_sql_c, int bsize, int csize, bool signType)
{
_odbcType = odbcType;
_dbType = dbType;
_type = type;
_sql_type = sql_type;
_sql_c = sql_c;
_param_sql_c = param_sql_c; // alternative sql_c type for parameters
_bufferSize = bsize;
_columnSize = csize;
_signType = signType;
}
private OdbcParameter AddParameter(OdbcCommand cmd, string paramName, OdbcType odbcType,
int length, string sourceColumnName, DataRowVersion rowVersion)
{
OdbcParameter param;
if (length >= 0 && sourceColumnName != String.Empty)
{
param = cmd.Parameters.Add(paramName, odbcType, length, sourceColumnName);
}
else
{
param = cmd.Parameters.Add(paramName, odbcType);
}
param.SourceVersion = rowVersion;
return(param);
}
public static OdbcType MapCsharpTypeToODBCType(Type dataType)
{
OdbcType OdbcDbType = OdbcType.BigInt;
if (dataType == Type.GetType("System.Int32"))
{
OdbcDbType = OdbcType.BigInt;
}
else if (dataType == Type.GetType("System.String"))
{
OdbcDbType = OdbcType.Text;
}
else if (dataType == Type.GetType("System.Boolean"))
{
OdbcDbType = OdbcType.Bit;
}
else if (dataType == Type.GetType("System.TimeSpan"))
{
OdbcDbType = OdbcType.Time;
}
else if (dataType == Type.GetType("System.Int16"))
{
OdbcDbType = OdbcType.Int;
}
else if (dataType == Type.GetType("System.Double"))
{
OdbcDbType = OdbcType.Double;
}
else if (dataType == Type.GetType("System.Char"))
{
OdbcDbType = OdbcType.VarChar;
}
else if (dataType == Type.GetType("System.DateTime"))
{
OdbcDbType = OdbcType.DateTime;
}
else if (dataType == Type.GetType("System.Decimal"))
{
OdbcDbType = OdbcType.Decimal;
}
else if (dataType == Type.GetType("System.Byte[]"))
{
OdbcDbType = OdbcType.VarBinary;
}
return(OdbcDbType);
}
[EditorBrowsableAttribute(EditorBrowsableState.Advanced)] // MDAC 69508
public OdbcParameter(string parameterName,
OdbcType odbcType, int size,
ParameterDirection parameterDirection, Boolean isNullable,
Byte precision, Byte scale,
string srcColumn, DataRowVersion srcVersion,
object value)
{
this.ParameterName = parameterName;
this.OdbcType = odbcType;
this.Size = size;
this.Direction = parameterDirection;
this.IsNullable = isNullable;
this.Precision = precision;
this.Scale = scale;
this.SourceColumn = srcColumn;
this.SourceVersion = srcVersion;
this.Value = value;
}
[EditorBrowsableAttribute(EditorBrowsableState.Advanced)] // MDAC 69508
public OdbcParameter(string?parameterName,
OdbcType odbcType, int size,
ParameterDirection parameterDirection,
byte precision, byte scale,
string?sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping,
object?value) : this()
{ // V2.0 everything - round trip all browsable properties + precision/scale
this.ParameterName = parameterName;
this.OdbcType = odbcType;
this.Size = size;
this.Direction = parameterDirection;
this.PrecisionInternal = precision;
this.ScaleInternal = scale;
this.SourceColumn = sourceColumn;
this.SourceVersion = sourceVersion;
this.SourceColumnNullMapping = sourceColumnNullMapping;
this.Value = value;
}
public static OdbcType GetOdbcParameterType(DbType type)
{
OdbcType result = OdbcType.Int;
switch (type)
{
case DbType.DateTime:
result = OdbcType.DateTime;
break;
case DbType.Date:
result = OdbcType.DateTime;
break;
case DbType.Decimal:
result = OdbcType.Decimal;
break;
case DbType.Double:
result = OdbcType.Double;
break;
case DbType.Single:
result = OdbcType.Double;
break;
case DbType.Int32:
result = OdbcType.Int;
break;
case DbType.Int64:
result = OdbcType.BigInt;
break;
case DbType.Object:
result = OdbcType.Image;
break;
case DbType.String:
result = OdbcType.NVarChar;
break;
}
return(result);
}
///
/// 构造一个OdbcParameter参数值
///
/// 参数名
/// 参数类型
/// 参数类型大小
/// 输入/输出
/// 参数值
/// 返回一个OdbcParameter参数
public static OdbcParameter MakeParam(string ParamName, OdbcType DbType, Int32 Size, ParameterDirection Direction, object Value)
{
OdbcParameter param;
if (Size > 0)
{
param = new OdbcParameter(ParamName, DbType, Size);
}
else
{
param = new OdbcParameter(ParamName, DbType);
}
param.Direction = Direction;
if (!(Direction == ParameterDirection.Output && Value == null))
{
param.Value = Value;
}
return(param);
}
public OdbcParameter (string name, OdbcType type, int size, string sourcecolumn)
: this (name, type, size)
{
this.SourceColumn = sourcecolumn;
}
public OdbcParameter (string name, OdbcType type, int size)
: this (name, type)
{
this.Size = size;
}
public TypeMap (OdbcType odbcType, SQL_C_TYPE sqlCType, SQL_TYPE sqlType, short defaultFlags)
: this (odbcType, sqlCType, sqlType)
{
BitMask = defaultFlags;
}
public OdbcParameter(string name, OdbcType type, int size) : this() {
ParameterName = name;
OdbcType = type;
Size = size;
}
public OdbcParameter Add(string parameterName, OdbcType odbcType, int size)
{
return this.Add(new OdbcParameter(parameterName, odbcType, size));
}
public static DbType Parse(OdbcType dbType)
{
return DbTypeMap.Reverse(dbType);
}
public OdbcParameter Add (string parameterName, OdbcType odbcType)
{
return Add (new OdbcParameter (parameterName, odbcType));
}
internal readonly bool _signType; // this type may be has signature information
private TypeMap(OdbcType odbcType, DbType dbType, Type type, ODBC32.SQL_TYPE sql_type, ODBC32.SQL_C sql_c, ODBC32.SQL_C param_sql_c, int bsize, int csize, bool signType) {
_odbcType = odbcType;
_dbType = dbType;
_type = type;
_sql_type = sql_type;
_sql_c = sql_c;
_param_sql_c = param_sql_c; // alternative sql_c type for parameters
_bufferSize = bsize;
_columnSize = csize;
_signType = signType;
}
public TypeMap (OdbcType odbcType, SQL_C_TYPE sqlCType, SQL_TYPE sqlType)
{
OdbcType = odbcType;
SqlType = sqlType;
SqlCType = sqlCType;
BitMask = DefaultForOdbcType
| DefaultForSQLCType
| DefaultForSQLType
;
}
private OdbcParameter AddParameter (OdbcCommand cmd, string paramName, OdbcType odbcType,
int length, string sourceColumnName, DataRowVersion rowVersion)
{
OdbcParameter param;
if (length >= 0 && sourceColumnName != String.Empty)
param = cmd.Parameters.Add (paramName, odbcType, length, sourceColumnName);
else
param = cmd.Parameters.Add (paramName, odbcType);
param.SourceVersion = rowVersion;
return param;
}
public static SQL_TYPE ConvertToSqlType (OdbcType type)
{
return OdbcTypeMap [type].SqlType;
}
public int IndexOf (OdbcType odbcType)
{
for (int i=0; i < List.Count; i++) {
TypeMap map = (TypeMap) List [i];
if (map.OdbcType == odbcType
&& (map.BitMask & TypeMap.DefaultForOdbcType) > 0 )
return i;
}
return -1;
}
public TypeMap this [OdbcType odbcType]
{
get {
foreach (TypeMap map in List){
if (map.OdbcType == odbcType
&& (map.BitMask & TypeMap.DefaultForOdbcType) > 0 )
return map;
}
throw new ArgumentException (String.Format ("Type mapping for odbc type {0} is not found",
odbcType.ToString ()
)
);
}
set {
int i = IndexOf (odbcType);
if (i == -1)
Add (value);
List [i] = value;
}
}
private string GetFiledTypeString(OdbcType type)
{
string val = "" ;
switch ( type )
{
case OdbcType.Int :
case OdbcType.SmallInt :
{
val = " integer " ;
}
break;
case OdbcType.Real:
{
val = " REAL " ;
}
break;
case OdbcType.Text :
case OdbcType.NText :
case OdbcType.VarChar :
case OdbcType.NVarChar :
{
val = " VARCHAR (255) " ;
}
break;
default :
{
val = " integer " ;
}
break ;
}
return val ;
}
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
public OdbcParameter(string parameterName,
OdbcType odbcType,
int size,
ParameterDirection parameterDirection,
Boolean isNullable,
Byte precision,
Byte scale,
string srcColumn,
DataRowVersion srcVersion,
object value
) : this() { // V1.0 everything
this.ParameterName = parameterName;
this.OdbcType = odbcType;
this.Size = size;
this.Direction = parameterDirection;
this.IsNullable = isNullable;
PrecisionInternal = precision;
ScaleInternal = scale;
this.SourceColumn = srcColumn;
this.SourceVersion = srcVersion;
this.Value = value;
}
static internal Exception UnknownOdbcType(OdbcType odbctype) {
return ADP.InvalidEnumerationValue(typeof(OdbcType), (int) odbctype);
}
public OdbcParameter Add (string name, OdbcType type,
int width, string src_col)
{
return Add (new OdbcParameter (name, type, width, src_col));
}
static internal TypeMap FromOdbcType(OdbcType odbcType) {
switch(odbcType) {
case OdbcType.BigInt: return _BigInt;
case OdbcType.Binary: return _Binary;
case OdbcType.Bit: return _Bit;
case OdbcType.Char: return _Char;
case OdbcType.DateTime: return _DateTime;
case OdbcType.Date: return _Date;
case OdbcType.Time: return _Time;
case OdbcType.Double: return _Double;
case OdbcType.Decimal: return _Decimal;
case OdbcType.Image: return _Image;
case OdbcType.Int: return _Int;
case OdbcType.NChar: return _NChar;
case OdbcType.NText: return _NText;
case OdbcType.Numeric: return _Numeric;
case OdbcType.NVarChar: return _NVarChar;
case OdbcType.Real: return _Real;
case OdbcType.UniqueIdentifier: return _UniqueId;
case OdbcType.SmallDateTime: return _SmallDT;
case OdbcType.SmallInt: return _SmallInt;
case OdbcType.Text: return _Text;
case OdbcType.Timestamp: return _Timestamp;
case OdbcType.TinyInt: return _TinyInt;
case OdbcType.VarBinary: return _VarBinary;
case OdbcType.VarChar: return _VarChar;
default: throw ODBC.UnknownOdbcType(odbcType);
}
}
public OdbcParameter (string name, OdbcType type)
: this ()
{
this.ParameterName = name;
_typeMap = (OdbcTypeMap) OdbcTypeConverter.GetTypeMap (type);
}
public OdbcParameter Add(string parameterName, OdbcType odbcType, int size, string sourceColumn)
{
return this.Add(new OdbcParameter(parameterName, odbcType, size, sourceColumn));
}
public OdbcParameter (string name, OdbcType dataType, int size, string srcColumn)
: this (name, dataType, size)
{
this.SourceColumn = srcColumn;
}
public OdbcParameter Add (string name, OdbcType type)
{
return Add (new OdbcParameter (name, type));
}
public OdbcParameter(string name, OdbcType type, int size, string sourcecolumn) : this() {
ParameterName = name;
OdbcType = type;
Size = size;
SourceColumn = sourcecolumn;
}
public OdbcParameter(string name, OdbcType dataType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value)
: this (name, dataType, size, srcColumn)
{
this.Direction = direction;
this.IsNullable = isNullable;
this.Precision = precision;
this.Scale = scale;
this.SourceVersion = srcVersion;
this.Value = value;
}
public OdbcParameter (string parameterName, OdbcType odbcType, int size,
ParameterDirection parameterDirection, bool isNullable,
byte precision, byte scale, string srcColumn,
DataRowVersion srcVersion, object value)
: this (parameterName, odbcType, size, srcColumn)
{
this.Direction = parameterDirection;
this.IsNullable = isNullable;
this.SourceVersion = srcVersion;
}
public OdbcParameter(string name, OdbcType type) : this() {
ParameterName = name;
OdbcType = type;
}
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
public OdbcParameter(string parameterName,
OdbcType odbcType, int size,
ParameterDirection parameterDirection,
Byte precision, Byte scale,
string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping,
object value) : this() { // V2.0 everything - round trip all browsable properties + precision/scale
this.ParameterName = parameterName;
this.OdbcType = odbcType;
this.Size = size;
this.Direction = parameterDirection;
this.PrecisionInternal = precision;
this.ScaleInternal = scale;
this.SourceColumn = sourceColumn;
this.SourceVersion = sourceVersion;
this.SourceColumnNullMapping = sourceColumnNullMapping;
this.Value = value;
}
