/// <summary>
/// 转换成SqlParameter
/// </summary>
/// <param name="parameters">参数集合</param>
/// <returns>返回转换成SqlParameter集合</returns>
private Dictionary <string, DB2Parameter> ConvertToSqlParameter(KdtParameterCollection parameters)
{
Dictionary <string, DB2Parameter> result = new Dictionary <string, DB2Parameter>(StringComparer.OrdinalIgnoreCase);
if (parameters != null && parameters.Count > 0)
{
foreach (var item in parameters)
{
DB2Parameter param = new DB2Parameter("{0}{1}".ToFormat(ParamPrifix, item.Name), item.Value);
switch (item._InPutType)
{
case ProcInPutEnum.OutPut: param.Direction = ParameterDirection.Output; break;
case ProcInPutEnum.ReturnValue: param.Direction = ParameterDirection.ReturnValue; break;
case ProcInPutEnum.InputOutPut: param.Direction = ParameterDirection.InputOutput; break;
default: param.Direction = ParameterDirection.Input; break;
}
result[item.Name] = param;
}
}
// 返回转换集合
return(result);
}
/// <summary>
/// 创建一个 <see cref="DbParameter"/> 脚本查询参数对象。
/// </summary>
/// <param name="name">表示被加入的查询参数的参数名。</param>
/// <param name="dbType">表示被加入的查询参数的参数数据类型。</param>
/// <param name="size">参数长度。</param>
/// <param name="direction">一个表示参数为输入还是输出类型的枚举值。</param>
/// <param name="nullable">参数是否可为空(DBNull.Value)。</param>
/// <param name="precision">表示查询参数的小数精度。</param>
/// <param name="scale">表述参数的 Scale 属性。</param>
/// <param name="sourceColumn">参数的源列名称，该源列映射到 <see cref="System.Data.DataSet"/> 并用于加载或返回 <seealso cref="System.Data.Common.DbParameter.Value"/>。</param>
/// <param name="sourceVersion">指示参数在加载 <seealso cref="System.Data.Common.DbParameter.Value"/> 时使用的 <see cref="System.Data.DataRowVersion"/>。</param>
/// <param name="value">表示被加入的查询参数的参数值。</param>
/// <returns>一个 <see cref="DbParameter"/> 脚本查询参数对象。</returns>
protected DbParameter CreateParameter(string name, DB2Type dbType, int size, ParameterDirection direction, bool nullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value)
{
DB2Parameter parameter = this.CreateParameter(name) as DB2Parameter;
ConfigureParameter(parameter, name, dbType, size, direction, nullable, precision, scale, sourceColumn, sourceVersion, value);
return(parameter);
}
public override IDbDataParameter CreateDbParameter(string parameterName)
{
IDbDataParameter parameter = new DB2Parameter();
parameter.ParameterName = parameterName.Replace("?", "@").Replace(":", "@");
return(parameter);
}
public void AddParameter(string name, DB2Type db2Type, int size, ParameterDirection direction, bool nullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value)
{
DB2Parameter param = CreateParameter(name, DbType.AnsiString, size, direction, nullable, precision, scale, sourceColumn, sourceVersion, value);
param.DB2Type = db2Type;
this.command.Parameters.Add(param);
}
public int NonQuery(string sql, byte[] blob)
{
DB2Connection ncc = OpenConnection();
DB2Command com = new DB2Command(sql, ncc);
try
{
DB2Parameter parm1 = new DB2Parameter();
parm1.DbType = DbType.Binary;
parm1.ParameterName = "@blob";
parm1.Value = (byte[])blob;
com.Parameters.Add(parm1);
affectedRows = com.ExecuteNonQuery();
HistorialSeguimientoTabla(TABLA_SEGUIR, sql); //Almacenamiento historial de seguimiento a tabla.
}
catch (Exception e)
{
//AdministradorCarpetasRegistro.GrabarLogs(TipoRegistro.Error, sql, e, e.Message);
//exceptions += e.Message + cambioLinea;
affectedRows = 0;
}
finally
{
CloseConnection(ncc);
}
return(affectedRows);
}
public int ToRealDbType(DbType dbType, long length)
{
DB2Parameter prm = new DB2Parameter();
prm.DbType = dbType;
prm.ParameterName = "name";
return((int)prm.DB2Type);
}
public IDataParameter CreateParameter(string parameterName, DbType dbType, ParameterDirection parameterDirection)
{
IDataParameter p = new DB2Parameter(parameterName, GetDB2Type(dbType), GetDbSize(dbType))
{
Direction = parameterDirection
};
return(p);
}
///// <summary>
///// 获取变量列表
///// </summary>
//public ParamList BQLSelectParamList
//{
// get
// {
// return new ParamList();
// }
//}
/// <summary>
/// 获取参数类
/// </summary>
/// <param name="paramName">参数名</param>
/// <param name="type">参数数据库类型</param>
/// <param name="paramValue">参数值</param>
/// <param name="paramDir">参数进出类型</param>
/// <returns></returns>
public IDataParameter GetDataParameter(string paramName, DbType type, object paramValue, ParameterDirection paramDir)
{
IDataParameter newParam = new DB2Parameter();
newParam.ParameterName = paramName;
newParam.DbType = FormatDbType(type);
newParam.Value = FormatValue(paramValue);
newParam.Direction = paramDir;
return(newParam);
}
private void tabControl1_Selected(object sender, TabControlEventArgs e)
{
// Move the input focus to the query builder.
// This will fire Leave event in the text box and update the query builder
// with modified query text.
queryBuilder1.Focus();
Application.DoEvents();
// Try to execute the query using current database connection
if (e.TabPage == tabPageData)
{
dataGridView1.DataSource = null;
if (queryBuilder1.MetadataProvider != null && queryBuilder1.MetadataProvider.Connected)
{
DB2Command command = (DB2Command)queryBuilder1.MetadataProvider.Connection.CreateCommand();
command.CommandText = queryBuilder1.SQL;
// handle the query parameters
if (queryBuilder1.Parameters.Count > 0)
{
for (int i = 0; i < queryBuilder1.Parameters.Count; i++)
{
if (!command.Parameters.Contains(queryBuilder1.Parameters[i].FullName))
{
DB2Parameter parameter = new DB2Parameter();
parameter.ParameterName = queryBuilder1.Parameters[i].FullName;
parameter.DbType = queryBuilder1.Parameters[i].DataType;
command.Parameters.Add(parameter);
}
}
using (QueryParametersForm qpf = new QueryParametersForm(command))
{
qpf.ShowDialog();
}
}
DB2DataAdapter adapter = new DB2DataAdapter(command);
DataSet dataset = new DataSet();
try
{
adapter.Fill(dataset, "QueryResult");
dataGridView1.DataSource = dataset.Tables["QueryResult"];
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SQL query error");
}
}
}
}
/// <summary>
/// 设置 <see cref="DB2Parameter"/> 参数对象的值。
/// </summary>
/// <param name="parameter">一个<see cref="DB2Parameter"/> 参数对象</param>
/// <param name="name">表示被加入的查询参数的参数名。</param>
/// <param name="dbType">表示被加入的查询参数的参数数据类型。</param>
/// <param name="size">参数长度。</param>
/// <param name="direction">一个表示参数为输入还是输出类型的枚举值。</param>
/// <param name="nullable">参数是否可为空(DBNull.Value)。</param>
/// <param name="precision">表示查询参数的小数精度。</param>
/// <param name="scale">表述参数的 Scale 属性。</param>
/// <param name="sourceColumn">参数的源列名称，该源列映射到 <see cref="System.Data.DataSet"/> 并用于加载或返回 <seealso cref="System.Data.Common.DbParameter.Value"/>。</param>
/// <param name="sourceVersion">指示参数在加载 <seealso cref="System.Data.Common.DbParameter.Value"/> 时使用的 <see cref="System.Data.DataRowVersion"/>。</param>
/// <param name="value">表示被加入的查询参数的参数值。</param>
protected virtual void ConfigureParameter(DB2Parameter parameter, string name, DB2Type dbType, int size, ParameterDirection direction, bool nullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value)
{
parameter.DB2Type = dbType;
parameter.Size = size;
parameter.Value = value ?? DBNull.Value;
parameter.Direction = direction;
parameter.IsNullable = nullable;
parameter.Precision = precision;
parameter.Scale = scale;
parameter.SourceColumn = sourceColumn;
parameter.SourceVersion = sourceVersion;
}
public override DbDataAdapter GetAdapter(string selectCommand, DbConnection connection,
CommandParameterCollection parameters)
{
DB2DataAdapter adapter = new DB2DataAdapter(selectCommand, connection as DB2Connection);
foreach (CommandParameter p in parameters)
{
DB2Parameter parameter = adapter.SelectCommand.Parameters.Add(p.Name, (DB2Type)p.DataType, p.Size);
parameter.Value = p.Value;
}
return(adapter);
}
public override void Visit(DbConstantExpression expression)
{
if (_insertParametersValuesInSql)
{
_commandText.Append(VisitConstantExpression(expression));
}
else
{
DB2Parameter parameter = CreateParameter(expression.Value, expression.ResultType);
_commandText.Append(parameter.ParameterName);
}
}
public IDataParameter CreateParameter <TValue>(String parameterName, TValue paramValue,
ParameterDirection parameterDirection)
{
DB2Parameter p = Equals(null, paramValue)
? new DB2Parameter(
ParameterNameForQueries(parameterName), DBNull.Value)
: new DB2Parameter(
ParameterNameForQueries(parameterName), paramValue);
p.Direction = parameterDirection;
return(p);
}
/// <summary>
/// Add a parameter to the Sql Command
/// </summary>
/// <param name="name">Parameter name</param>
/// <param name="value">Value for the parameter</param>
/// <param name="dbType">Type of parameter in SQL Server</param>
/// <param name="direction">Parameter direction (default is input)</param>
public void AddParameter(string name, object value, DB2Type dbType, ParameterDirection direction = ParameterDirection.Input)
{
DB2Parameter parameter = new DB2Parameter();
parameter.Direction = direction;
parameter.ParameterName = name;
parameter.DB2Type = dbType;
parameter.Value = value;
if (!Parameters.Contains(parameter))
{
Parameters.Add(parameter);
}
}
/// <summary>
/// Returns a boolean indicating if the two parameters are equivalent
/// (same direction, type, and value); Out params are always false.
/// </summary>
/// <param name="param1">DbParameter1</param>
/// <param name="param2">DbParameter2</param>
/// <returns>true or false</returns>
public override bool CompareParamEquality(DbParameter dbParam1, DbParameter dbParam2)
{
DB2Parameter db2Param1 = (DB2Parameter)dbParam1;
DB2Parameter db2Param2 = (DB2Parameter)dbParam2;
switch (db2Param1.DB2Type)
{
case DB2Type.SmallInt:
return(Convert.ToInt16(db2Param1.Value) == Convert.ToInt16(db2Param2.Value));
case DB2Type.Integer:
return(Convert.ToInt32(db2Param1.Value) == Convert.ToInt32(db2Param2.Value));
case DB2Type.BigInt:
return(Convert.ToInt64(db2Param1.Value) == Convert.ToInt64(db2Param2.Value));
case DB2Type.Decimal:
case DB2Type.Numeric:
return(Convert.ToDecimal(db2Param1.Value) == Convert.ToDecimal(db2Param2.Value));
case DB2Type.Real:
case DB2Type.Real370:
return(Convert.ToSingle(db2Param1.Value) == Convert.ToSingle(db2Param2.Value));
case DB2Type.Time:
case DB2Type.DecimalFloat:
case DB2Type.Double:
case DB2Type.Float:
return(Convert.ToDouble(db2Param1.Value) == Convert.ToDouble(db2Param2.Value));
case DB2Type.Char:
case DB2Type.Clob:
case DB2Type.VarChar:
case DB2Type.Xml:
case DB2Type.Graphic:
case DB2Type.VarGraphic:
case DB2Type.LongVarChar:
case DB2Type.LongVarGraphic:
case DB2Type.DbClob:
case DB2Type.RowId:
return(db2Param1.Value.ToString().ToLower() == db2Param2.Value.ToString().ToLower());
case DB2Type.Date:
case DB2Type.Timestamp:
case DB2Type.TimeStampWithTimeZone:
return(Convert.ToDateTime(db2Param1.Value) == Convert.ToDateTime(db2Param2.Value));
default:
return(db2Param1.Value == db2Param2.Value);
}
}
private Dictionary <string, DbParameterAccessor> ReadIntoParams(String[] queryParameters, String query, String addPrefix)
{
DbCommand dc = CurrentConnection.CreateCommand();
dc.Transaction = CurrentTransaction;
dc.CommandText = query;
dc.CommandType = CommandType.Text;
for (int i = 0; i < queryParameters.Length; i++)
{
AddInput(dc, i.ToString(), queryParameters[i].ToLower());
}
DbDataReader reader = dc.ExecuteReader();
Dictionary <String, DbParameterAccessor>
allParams = new Dictionary <string, DbParameterAccessor>();
int position = 0;
while (reader.Read())
{
String paramName = (reader.IsDBNull(0)) ? null : reader.GetString(0).ToUpper();
String dataType = reader.GetString(1);
int length = (reader.IsDBNull(2)) ? 0 : reader.GetInt32(2);
String direction = reader.GetString(3);
DB2Parameter dp = new DB2Parameter();
dp.Direction = GetParameterDirection(direction);
if (paramName != null)
{
dp.ParameterName = addPrefix + paramName; dp.SourceColumn = paramName;
}
else
{
dp.Direction = ParameterDirection.ReturnValue;
}
dp.DB2Type = GetDBType(dataType);
if (length > 0)
{
dp.Size = length;
}
else
{
if (!ParameterDirection.Input.Equals(dp.Direction) || typeof(String).Equals(GetDotNetType(dataType)))
{
dp.Size = 4000;
}
}
allParams[NameNormaliser.NormaliseName(paramName)] =
new DbParameterAccessor(dp, GetDotNetType(dataType), position++, dataType);
}
return(allParams);
}
public int InputBlob(string strSql, byte[] ImageData)
{
DB2Command command = null;
command = new DB2Command();
command.Connection = this.dbConnection as DB2Connection;
command.Transaction = dbTrans as DB2Transaction;
command.CommandType = System.Data.CommandType.Text;
command.Parameters.Clear();
command.CommandText = strSql + "";
string strParam = "";
int i = strSql.IndexOf(":", 0);
if (i <= 0)
{
this.Err = "未指定参数！" + strSql;
this.WriteErr();
return(-1);
}
//strParam = strSql.Substring(i + 1, 1);
//{F94ACBC1-D0D1-4f70-AED8-8045E4062EF3}
strParam = strSql.Substring(i, 2);
DB2Parameter param = command.Parameters.Add(strParam, DB2Type.Blob);
param.Direction = System.Data.ParameterDirection.Input;
// Assign Byte Array to Oracle Parameter
param.Value = ImageData;
try
{
command.ExecuteNonQuery();
}
catch (DB2Exception ex)
{
this.Err = "执行产生错误!" + ex.Message;
this.ErrCode = strSql;
this.DBErrCode = ex.ErrorCode;
this.WriteErr();
return(-1);
}
catch (Exception ex)
{
this.Err = ex.Message;
this.WriteErr();
return(-1);
}
return(0);
}
public int NonQuery(string sql, byte[] blob)
{
DB2Command com = new DB2Command(sql, connection);
DB2Parameter parm1 = new DB2Parameter();
parm1.DbType = DbType.Binary;
parm1.ParameterName = "@blob";
parm1.Value = (byte[])blob;
com.Parameters.Add(parm1);
return(com.ExecuteNonQuery());
}
/// <summary>
/// Creates a DB2Parameter given a name, type, and direction
/// </summary>
internal static DB2Parameter CreateDB2Parameter(string name, TypeUsage type, ParameterMode mode, object value)
{
int?size;
if (type.GetPrimitiveTypeKind() == PrimitiveTypeKind.Guid)
{
type = TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
false, true);
}
DB2Parameter result = new DB2Parameter(name, value);
// .Direction
ParameterDirection direction = MetadataHelpers.ParameterModeToParameterDirection(mode);
if (result.Direction != direction)
{
result.Direction = direction;
}
// .Size and .DbType
// output parameters are handled differently (we need to ensure there is space for return
// values where the user has not given a specific Size/MaxLength)
bool isOutParam = mode != ParameterMode.In;
DbType sqlDbType = GetDB2DbType(type, isOutParam, out size);
if (result.DbType != sqlDbType)
{
result.DbType = sqlDbType;
}
// Note that we overwrite 'facet' parameters where either the value is different or
// there is an output parameter.
if (size.HasValue && (isOutParam || result.Size != size.Value))
{
result.Size = size.Value;
}
// .IsNullable
bool isNullable = type.GetIsNullable();
if (isOutParam || isNullable != result.IsNullable)
{
result.IsNullable = isNullable;
}
return(result);
}
/// <summary>
/// Please refer to the documentation of <see cref="GentleSqlFactory"/> for details.
/// </summary>
public override void AddParameter(IDbCommand cmd, string name, long dbType)
{
try
{
DB2Command myc = (DB2Command)cmd;
DB2Parameter param = new DB2Parameter(name, (DB2Type)dbType);
param.Direction = ParameterDirection.Input;
myc.Parameters.Add(param);
}
catch (Exception e)
{
Check.Fail(Error.Unspecified, e.Message);
throw new GentleException(Error.Unspecified, "Unreachable code.");
}
}
/// <summary>
/// Returns a copy of the given DbParameter that was added to the given collection.
/// </summary>
/// <param name="dbParameters">A DbParameter collection to add the parameter clone to</param>
/// <param name="dbParam">A DbParameter to clone</param>
/// <returns>The DbParameter clone</returns>
public override DbParameter CopyParameterToCollection(DbParameterCollection dbParameters
, DbParameter dbParam)
{
DB2ParameterCollection db2Parameters = (DB2ParameterCollection)dbParameters;
DB2Parameter db2Param = (DB2Parameter)dbParam;
if (db2Parameters.Contains(db2Param.ParameterName))
{
throw new ExceptionEvent(enumExceptionEventCodes.DbParameterExistsInCollection
, string.Format("Parameter {0} already belongs to this collection; use Set to change value."
, db2Param.ParameterName));
}
db2Parameters.Add(CloneParameter(db2Param));
return(db2Parameters[db2Param.ParameterName]);
}
private static DB2Parameter ValidateParam(DB2Parameter dbParam, Int32 size, DbType dbType)
{
if (dbParam.Direction == ParameterDirection.InputOutput ||
dbParam.Direction == ParameterDirection.Output)
{
dbParam.Size = size;
}
if (dbParam.Value == null)
{
dbParam.Value = DBNull.Value;
dbParam.DbType = dbType;
}
return(dbParam);
}
/// <summary>
/// Clones a parameter so that it can be used with another command.
/// </summary>
/// <param name="command">The command to use.</param>
/// <param name="parameter">The parameter to clone.</param>
/// <returns>The clone.</returns>
public override IDataParameter CloneParameter(IDbCommand command, IDataParameter parameter)
{
DB2Parameter p = (DB2Parameter)base.CloneParameter(command, parameter);
DB2Parameter db2p = (DB2Parameter)parameter;
p.ArrayLength = db2p.ArrayLength;
p.DB2Type = db2p.DB2Type;
p.DB2TypeOutput = db2p.DB2TypeOutput;
p.InternalProperty1 = db2p.InternalProperty1;
p.IsDefault = db2p.IsDefault;
p.IsUnassigned = db2p.IsUnassigned;
p.Precision = db2p.Precision;
p.Scale = db2p.Scale;
return(p);
}
/// <summary>
/// <para>Sets the value of a parameter for the given <paramref name="name"/>.</para>
/// </summary>
/// <param name="name"><para>The name of the parameter to set the value.</para></param>
/// <param name="value"><para>The new value of the parameter.</para></param>
public override void SetParameterValue(string name, object value)
{
DB2Parameter parameter = command.Parameters[BuildParameterName(name)];
if (value is Guid)
{
parameter.Value = ((Guid)value).ToByteArray();
}
string tmpVal = value as string;
if ((tmpVal != null) && (tmpVal.Length == 0))
{
parameter.Value = Convert.DBNull;
}
parameter.Value = (value == null) ? DBNull.Value : value;
}
/// <summary>
/// 从DataTable导入数据到数据库表（适用于小批量数据导入）
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="dt">数据表（字段名通过ColumnName来指定）</param>
/// <returns></returns>
public override int LoadDataInDataTable(string tableName, DataTable dt)
{
Log.BLog.Write(Log.BLog.LogLevel.DEBUG, "00");
if (dt == null || dt.Rows.Count < 1)
{
return(0);
}
int rowsCount = dt.Rows.Count;
int colsCount = dt.Columns.Count;
List <string> columnNames = new List <string>();
//行列转换
object[][] allData = new object[colsCount][];
for (int col = 0; col < colsCount; col++)
{
allData[col] = new object[rowsCount];
columnNames.Add(dt.Columns[col].ColumnName);
}
for (int row = 0; row < rowsCount; row++)
{
for (int col = 0; col < colsCount; col++)
{
allData[col][row] = dt.Rows[row][col];
}
}
DB2Command command = _conn.CreateCommand();
command.CommandTimeout = base.CommandTimeout;
command.CommandType = CommandType.Text;
command.ArrayBindCount = rowsCount;
command.CommandText = string.Format("INSERT INTO {0} ({1}) VALUES({2})", tableName, string.Join(", ", columnNames), "@" + string.Join(", @", columnNames));
int colIndex = 0;
Dictionary <string, int> dicMaxLength = GetColumnsMaxLength(dt);
foreach (DataColumn col in dt.Columns)
{
int maxLength = 0;
dicMaxLength.TryGetValue(col.ColumnName, out maxLength);
DB2Type type = GetDbType(dt, col, maxLength);
DB2Parameter colParameter = new DB2Parameter(col.ColumnName, type);
colParameter.Direction = ParameterDirection.Input;
colParameter.Value = allData[colIndex];
command.Parameters.Add(colParameter);
colIndex++;
}
return(command.ExecuteNonQuery());
}
protected override string InsertClause(IDbCommand cmd)
{
List <string> sets = new List <string>();
//Columnnames
DataColumnCollection dcc = GetSchemaTable().Columns;
foreach (DataColumn dc in dcc)
{
sets.Add(string.Format(" \"{0}\"", dc.ColumnName));
}
String columNames = string.Format("({0}, \"{1}\")", String.Join(",", sets.ToArray()).Trim(), GeometryColumn);
sets.Clear();
//Parameter
foreach (DataColumn dc in dcc)
{
IDataParameter param = null;
sets.Add(string.Format("{0}", ParamForColumn(dc, out param)));
DB2Parameter par = param as DB2Parameter;
switch (par.DB2Type)
{
case DB2Type.VarChar:
sets[sets.Count - 1] = string.Format("CAST({0} AS VARCHAR(250))", par.ParameterName);
break;
default:
break;
}
cmd.Parameters.Add(param);
}
//Geometry
sets.Add(string.Format(GeomFromWkbFormatString, "@PGeo"));
// string.Format("CAST(@PGeo AS {0}.{1})",
// TableSchema,
// DB2SpatialExtenderProviderStatic.ToDb2GeometryType(_validGeometryType))
//)));
//cmd.Parameters.Add(DbUtility.CreateParameterByType("PGeo", toDbType(typeof(byte[])), ParameterDirection.Input));
cmd.Parameters.Add(DbUtility.CreateParameter <byte[]>("@PGeo", ParameterDirection.Input));
return(String.Format("{0} VALUES({1})", columNames, string.Join(",", sets.ToArray()).Trim()));
}
private void DisplayDataForQuery()
{
dataGridView1.DataSource = null;
if (queryBuilder.MetadataProvider != null && queryBuilder.MetadataProvider.Connected)
{
if (queryBuilder.MetadataProvider is DB2MetadataProvider)
{
DB2Command command = (DB2Command)queryBuilder.MetadataProvider.Connection.CreateCommand();
command.CommandText = queryBuilder.SQL;
// handle the query parameters
if (queryBuilder.Parameters.Count > 0)
{
for (int i = 0; i < queryBuilder.Parameters.Count; i++)
{
if (!command.Parameters.Contains(queryBuilder.Parameters[i].FullName))
{
DB2Parameter parameter = new DB2Parameter();
parameter.ParameterName = queryBuilder.Parameters[i].FullName;
parameter.DbType = queryBuilder.Parameters[i].DataType;
command.Parameters.Add(parameter);
}
}
using (QueryParametersForm qpf = new QueryParametersForm(command))
{
qpf.ShowDialog();
}
}
DB2DataAdapter adapter = new DB2DataAdapter(command);
DataSet dataset = new DataSet();
try
{
adapter.Fill(dataset, "QueryResult");
dataGridView1.DataSource = dataset.Tables["QueryResult"];
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SQL query error");
}
} //end db2
} //end check if connected
} //end method
private static void SetOutValueInternal <TKey>(this DB2ParametersWrapper <TKey> paramWrapper, TKey key, TypeCode typeCode)
{
var p = new DB2Parameter
{
Direction = ParameterDirection.Output,
ParameterName = "@par_" + key
};
switch (typeCode)
{
case TypeCode.Int16:
p.DB2Type = DB2Type.SmallInt;
break;
case TypeCode.Int32:
p.DB2Type = DB2Type.Integer;
break;
case TypeCode.Int64:
p.DB2Type = DB2Type.Int8;
break;
case TypeCode.Decimal:
p.DB2Type = DB2Type.Decimal;
break;
case TypeCode.Double:
p.DB2Type = DB2Type.Double;
break;
case TypeCode.String:
p.DB2Type = DB2Type.VarChar;
break;
case TypeCode.DateTime:
p.DB2Type = DB2Type.Date;
break;
default:
throw new ArgumentException("Error to map specified type to an DB2Type.");
}
paramWrapper[key] = p;
}
public override void PrepareCommand(System.Data.IDbCommand cmd, System.Data.IDbConnection conn, string cmdText, CmdParameterCollection cmdParms)
{
cmd.Connection = _conn;
cmd.CommandText = cmdText;
cmd.Transaction = Trans;
cmd.CommandTimeout = 600;
cmd.CommandType = CommandType.Text;
if (cmdParms != null)
{
foreach (CmdParameter param in cmdParms)
{
DB2Parameter paras = new DB2Parameter(param.Name, param.Value);
paras.Direction = param.Direction;
paras.Size = param.Size;
paras.DbType = param.DbType;
cmd.Parameters.Add(paras);
}
}
}
public IDbDataParameter MakeParam(string parameterName, object parameterValue, DbType dbType, int parameterSize, ParameterDirection parameterDirection)
{
DB2Parameter parameter;
if (parameterSize > 0)
{
parameter = new DB2Parameter(parameterName, (DB2Type)dbType, parameterSize);
}
else
{
parameter = new DB2Parameter(parameterName, (DB2Type)dbType);
}
parameter.Direction = parameterDirection;
if ((parameterDirection != ParameterDirection.Output) || (parameterValue != null))
{
parameter.Value = parameterValue;
}
return(parameter);
}
/// <summary>
/// 获取参数
/// </summary>
/// <param name="paramName">参数名</param>
/// <param name="dbType">数据类型</param>
/// <param name="size">长度</param>
/// <param name="direction">参数类型</param>
/// <param name="value">值</param>
/// <returns></returns>
public IDbDataParameter MakeParameter(string parameterName, object parameterValue, DbType dbType, Int32 parameterSize, ParameterDirection parameterDirection)
{
DB2Parameter parameter;
if (parameterSize > 0)
{
parameter = new DB2Parameter(parameterName, (DB2Type)dbType, parameterSize);
}
else
{
parameter = new DB2Parameter(parameterName, (DB2Type)dbType);
}
parameter.Direction = parameterDirection;
if (!(parameterDirection == ParameterDirection.Output && parameterValue == null))
{
parameter.Value = parameterValue;
}
return parameter;
}
