/// DB2Prototypes class is a wrapper for the DB2.lib, IBM's Call Level Interface to DB2
/// </summary>
///
+ #region comented
+ /*internal class DB2CLIWrapper
+ {
+
+ #if (OS_LINUX)
+ private const string libname = "db2_36";
+ #endif
+
+ #if (OS_WINDOWS)
+ private const string libname = "db2cli";
+ #endif
+
+ [DllImport("db2cli", EntryPoint = "SQLAllocHandle")]
+ internal static extern short SQLAllocHandle(short handleType, IntPtr inputHandle, ref IntPtr outputHandle);
+
+ [DllImport("db2cli", EntryPoint = "SQLFreeHandle")]
+ internal static extern short SQLFreeHandle(short handleType, IntPtr inputHandle);
+
+ [DllImport("db2cli", EntryPoint = "SQLGetConnectAttrW")]
+ internal static extern short SQLGetConnectAttr(IntPtr ConnectionHandle, int Attribute, [Out] IntPtr ValuePtr, int BufferLength, out int StringLengthPtr);
+
+ [DllImport("db2cli", EntryPoint = "SQLGetConnectAttrW")]
+ internal static extern short SQLGetConnectAttr(IntPtr ConnectionHandle, int Attribute, out int Value, int BufferLength, IntPtr Zero);
+
+ [DllImport("db2cli", EntryPoint = "SQLFreeStmt")]
+ internal static extern short SQLFreeStmt(IntPtr StatementHandle, short option);
+
+ [DllImport("db2cli", EntryPoint = "SQLConnect")]
+ internal static extern short SQLConnect(IntPtr sqlHdbc, string serverName, short serverNameLength, string userName, short userNameLength, string authentication, short authenticationLength);
+ [DllImport("db2cli", EntryPoint = "SQLColAttribute")]
+ internal static extern short SQLColAttribute(IntPtr StatementHandle, short ColumnNumber, short FieldIdentifier, IntPtr CharacterAttribute, short BufferLength, ref short StringLength, ref int NumericAttribute);
+ //[DllImport("db2cli", EntryPoint = "SQLGetData")]
+ // internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, IntPtr TargetPtr, IntPtr BufferLength, ref IntPtr StrLen_or_Ind);
+ [DllImport("db2cli", EntryPoint="SQLMoreResults")]
+ internal static extern short SQLMoreResults(IntPtr StatementHandle);
+
+ //[DllImport("db2cli", EntryPoint = "SQLGetData")]
+ //internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, IntPtr TargetPtr, IntPtr BufferLength, out int StrLen_or_Ind);
+ [DllImport("db2cli", EntryPoint = "SQLGetData")]
+ internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, IntPtr TargetPtr, int BufferLength, out int StrLen_or_Ind);
+
+
+ //[DllImport("db2cli", EntryPoint = "SQLGetData")]
+ //internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, byte[] TargetPtr, IntPtr BufferLength, ref IntPtr StrLen_or_Ind);
+
+ [DllImport("db2cli", EntryPoint = "SQLGetData")]
+ internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, byte[] TargetPtr, int BufferLength, out int StrLen_or_Ind);
+
+ [DllImport("db2cli", EntryPoint = "SQLGetData")]
+ internal static extern short SQLGetData(IntPtr StatementHandle, short ColumnNumber, short TargetType, [Out] StringBuilder sb, int BufferLength, out int StrLen_or_Ind);
+
+ [DllImport("db2cli", EntryPoint = "SQLColAttributeW")]
+ internal static extern short SQLColAttribute(IntPtr StatementHandle, short ColumnNumber, short FieldIdentifier, [Out] StringBuilder CharacterAttribute, short BufferLength, out short StringLength, out int NumericAttribute);
+
+ [DllImport("db2cli", CharSet = CharSet.Auto, EntryPoint = "SQLDisconnect")]
+ internal static extern short SQLDisconnect(IntPtr sqlHdbc);
+ [DllImport("db2cli", EntryPoint = "SQLGetDiagRec")]
+ internal static extern short SQLGetDiagRec( short handleType, IntPtr handle, short recNum, [Out] StringBuilder sqlState, ref IntPtr nativeErrorPtr, [Out] StringBuilder errorMessage, short bufferLength, ref IntPtr shortTextLengthPtr);
+ [DllImport("db2cli", EntryPoint = "SQLSetConnectAttr")]
+ internal static extern short SQLSetConnectAttr(IntPtr sqlHdbc, long sqlAttr, [In] IntPtr sqlValuePtr, long sqlValueLength);
+ [DllImport("db2cli", EntryPoint = "SQLSetStmtAttr")]
+ internal static extern short SQLSetStmtAttr(IntPtr sqlHstmt, long sqlAttr, [In] IntPtr sqlValuePtr, long sqlValueLength);
+ [DllImport("db2cli", EntryPoint = "SQLEndTran")]
+ internal static extern short SQLEndTran (short handleType, IntPtr handle, short fType);
+ [DllImport("db2cli", EntryPoint = "SQLCancel")]
+ internal static extern short SQLCancel(IntPtr handle);
+ [DllImport("db2cli", EntryPoint = "SQLNumResultCols")]
+ internal static extern short SQLNumResultCols(IntPtr handle, ref int numCols);
+ [DllImport("db2cli", EntryPoint = "SQLFetch")]
+ internal static extern short SQLFetch(IntPtr handle);
+ [DllImport("db2cli", EntryPoint = "SQLRowCount")]
+ internal static extern short SQLRowCount(IntPtr stmtHandle, ref int numRows);
+ [DllImport("db2cli", EntryPoint = "SQLExecute")]
+ internal static extern short SQLExecute(IntPtr handle);
+ [DllImport ("db2cli", EntryPoint = "SQLExecDirect")]
+ internal static extern short SQLExecDirect(IntPtr stmtHandle, string stmt, int length);
+ [DllImport("db2cli", EntryPoint = "SQLDescribeCol")]
+ internal static extern short SQLDescribeCol(IntPtr stmtHandle, ushort colNum, StringBuilder colName, short colNameMaxLength, IntPtr colNameLength, ref IntPtr dataType, ref IntPtr colSizePtr, ref IntPtr scalePtr, ref IntPtr nullablePtr );
+ [DllImport("db2cli", EntryPoint = "SQLBindCol")]
+ internal static extern short SQLBindCol(IntPtr StatementHandle, short ColumnNumber, short TargetType, IntPtr TargetValue, IntPtr BufferLength, ref IntPtr StrLen_or_Ind);
+ [DllImport("db2cli", EntryPoint = "SQLDriverConnect")]
+ internal static extern short SQLDriverConnect(IntPtr hdbc, int centered, [In] string inConnectStr, [In] int inStrLength, [Out] StringBuilder outConnectStr, [Out] int outStrCapacity, [Out] IntPtr outStrLengthReturned, [In] int completion);
+ [DllImport("db2cli", EntryPoint = "SQLPrepare")]
+ internal static extern short SQLPrepare(IntPtr stmtHandle, string stmt, int length);
+ [DllImport("db2cli", EntryPoint = "SQLDescribeParam")]
+ internal static extern short SQLDescribeParam(IntPtr stmtHandle, short paramNumber,ref IntPtr dataType, ref IntPtr paramSize, ref IntPtr decimalDigits, ref IntPtr nullable);
+ [DllImport("db2cli", EntryPoint = "SQLNumParams")]
+ internal static extern short SQLNumParams(IntPtr stmtHandle, ref IntPtr numParams);
+
+ [DllImport("db2cli")]
+ internal static extern short SQLBindParameter(IntPtr stmtHandle, ushort paramNumber,
+ short dataType, short valueType, short paramType, uint colSize, short decDigits,
+ IntPtr dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport("db2cli")]
+ internal static extern short SQLBindParameter(IntPtr stmtHandle, ushort paramNumber,
+ short dataType, short valueType, short paramType, uint colSize, short decDigits,
+ byte[] dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport("db2cli", EntryPoint = "SQLBindParameter")]
+ internal static extern short SQLBindParameter(IntPtr stmtHandle, ushort paramNumber,
+ short dataType, short valueType, short paramType, uint colSize, short decDigits,
+ ref int dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport("db2cli", EntryPoint = "SQLBindParameter")]
+ internal static extern short SQLBindParameter(IntPtr stmtHandle, ushort paramNumber,
+ short dataType, short valueType, short paramType, uint colSize, short decDigits,
+ ref double dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport("db2cli", EntryPoint = "SQLDescribeParam")]
+ internal static extern short SQLDescribeParam(IntPtr stmtHandle, short ParameterNumber, IntPtr DataTypePtr, IntPtr ParameterSizePtr, IntPtr DecimalDigitsPtr, IntPtr NullablePtr);
+
+ [DllImport("db2cli", EntryPoint = "SQLGetLength")]
+ internal static extern short SQLGetLength( IntPtr stmtHandle, short locatorCType, int Locator,
+ IntPtr stringLength, IntPtr indicatorValue);
+ [DllImport("db2cli", EntryPoint = "SQLGetPosition")]
+ internal static extern short SQLGetPosition(IntPtr stmtHandle, short locatorCType, int sourceLocator, int searchLocator,
+ string searchLiteral, int searchLiteralLength, uint fromPosition, IntPtr locatedAt, IntPtr indicatorValue);
+ [DllImport("db2cli", EntryPoint = "SQLGetPosition")]
+ internal static extern short SQLBindFileToCol (IntPtr stmtHandle, ushort colNum, string fileName, IntPtr fileNameLength,
+ IntPtr fileOptions, short maxFileNameLength, IntPtr stringLength, IntPtr indicatorValue);
+ [DllImport("db2cli", EntryPoint = "SQLGetPosition")]
+ internal static extern short SQLBindFileToParam (IntPtr stmtHandle, ushort targetType, short dataType, string fileName,
+ IntPtr fileNameLength, short maxFileNameLength, IntPtr indicatorValue);
+
+
+ }*/
+ #endregion
internal class DB2CLIWrapper
{
static public short Initialize(ref IntPtr pEnvHandle)
{
- useLibCli = false;
- try
- {
- return DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_ENV, IntPtr.Zero, out pEnvHandle);
+ string OSVersion = Environment.OSVersion.ToString();
+ useLibCli = true;
+ if(OSVersion.Substring(0,4)=="Unix"){
+ useLibCli = false;
}
- catch {}
- useLibCli = false;
- return DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_ENV, IntPtr.Zero, out pEnvHandle);
+ return DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_ENV, IntPtr.Zero, out pEnvHandle);
}
-
+
static public short SQLAllocHandle(short handleType, IntPtr inputHandle, out IntPtr outputHandle)
{
if(useLibCli)
return StaticWrapperCli.SQLSetStmtAttr(sqlHdbc, sqlAttr, sqlValuePtr, sqlValueLength);
return StaticWrapper36.SQLSetStmtAttr(sqlHdbc, sqlAttr, sqlValuePtr, sqlValueLength);
}
+
+ //for bulk operations
+ static public short SQLSetStmtAttr(IntPtr sqlHdbc, int sqlAttr, ushort[] sqlValuePtr, int sqlValueLength)
+ {
+ if(useLibCli)
+ return StaticWrapperCli.SQLSetStmtAttr(sqlHdbc, sqlAttr, sqlValuePtr, sqlValueLength);
+ return StaticWrapper36.SQLSetStmtAttr(sqlHdbc, sqlAttr, sqlValuePtr, sqlValueLength);
+ }
+
static public short SQLEndTran (short handleType, IntPtr handle, short fType)
{
if(useLibCli)
return StaticWrapperCli.SQLBindParameter(stmtHandle, paramNumber, dataType, valueType, paramType, colSize, decDigits, dataBufferPtr, dataBufferLength, StrLen_or_IndPtr);
return StaticWrapper36.SQLBindParameter(stmtHandle, paramNumber, dataType, valueType, paramType, colSize, decDigits, dataBufferPtr, dataBufferLength, StrLen_or_IndPtr);
}
+
+ static public short SQLBindParameter(IntPtr stmtHandle, short paramNumber, short dataType, short valueType, short paramType, int colSize, short decDigits, int[] dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr)
+ {
+ if(useLibCli)
+ return StaticWrapperCli.SQLBindParameter(stmtHandle, paramNumber, dataType, valueType, paramType, colSize, decDigits, dataBufferPtr, dataBufferLength, StrLen_or_IndPtr);
+ return StaticWrapper36.SQLBindParameter(stmtHandle, paramNumber, dataType, valueType, paramType, colSize, decDigits, dataBufferPtr, dataBufferLength, StrLen_or_IndPtr);
+ }
public static short SQLGetInfo(IntPtr sqlHdbc, short fInfoType, [Out] StringBuilder rgbInfoValue, short cbInfoValueMax, out short pcbInfoValue)
{
if(useLibCli)
[DllImport(libname, EntryPoint = "SQLSetConnectAttr")]
public static extern short SQLSetConnectAttr(IntPtr sqlHdbc, int sqlAttr, [In] IntPtr sqlValuePtr, int sqlValueLength);
+
[DllImport(libname, EntryPoint = "SQLSetStmtAttr")]
public static extern short SQLSetStmtAttr(IntPtr sqlHdbc, int sqlAttr, [In] IntPtr sqlValuePtr, int sqlValueLength);
+
+ //For bulk operations
+ [DllImport(libname, EntryPoint = "SQLSetStmtAttr")]
+ public static extern short SQLSetStmtAttr(IntPtr sqlHdbc, int sqlAttr, ushort[] sqlValuePtr, int sqlValueLength);
+
[DllImport(libname, EntryPoint = "SQLEndTran")]
public static extern short SQLEndTran (short handleType, IntPtr handle, short fType);
[DllImport(libname, EntryPoint = "SQLCancel")]
public static extern short SQLBindParameter(IntPtr stmtHandle, short paramNumber,
short dataType, short valueType, short paramType, int colSize, short decDigits,
IntPtr dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport(libname)]
+ public static extern short SQLBindParameter(IntPtr stmtHandle, short paramNumber,
+ short dataType, short valueType, short paramType, int colSize, short decDigits,
+ int[] dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
[DllImport(libname, EntryPoint = "SQLGetInfoW", CharSet=CharSet.Unicode)]
public static extern short SQLGetInfo(IntPtr sqlHdbc, short fInfoType, [Out] StringBuilder rgbInfoValue, short cbInfoValueMax, out short pcbInfoValue);
}
[DllImport(libname, EntryPoint = "SQLFreeStmt")]
public static extern short SQLFreeStmt(IntPtr StatementHandle, short option);
- [DllImport(libname, EntryPoint = "SQLConnect")]
+ [DllImport(libname, EntryPoint = "SQLConnect", CharSet=CharSet.Ansi)]
public static extern short SQLConnect(IntPtr sqlHdbc, string serverName, short serverNameLength, string userName, short userNameLength, string authentication, short authenticationLength);
[DllImport(libname, EntryPoint = "SQLColAttributeW", CharSet=CharSet.Unicode)]
public static extern short SQLSetConnectAttr(IntPtr sqlHdbc, int sqlAttr, [In] IntPtr sqlValuePtr, int sqlValueLength);
[DllImport(libname, EntryPoint = "SQLSetStmtAttr")]
public static extern short SQLSetStmtAttr(IntPtr sqlHdbc, int sqlAttr, [In] IntPtr sqlValuePtr, int sqlValueLength);
+
+ //for bulk operations
+ [DllImport(libname, EntryPoint = "SQLSetStmtAttr")]
+ public static extern short SQLSetStmtAttr(IntPtr sqlHdbc, int sqlAttr, ushort[] sqlValuePtr, int sqlValueLength);
+
[DllImport(libname, EntryPoint = "SQLEndTran")]
public static extern short SQLEndTran (short handleType, IntPtr handle, short fType);
[DllImport(libname, EntryPoint = "SQLCancel")]
public static extern short SQLBindParameter(IntPtr stmtHandle, short paramNumber,
short dataType, short valueType, short paramType, int colSize, short decDigits,
IntPtr dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
- [DllImport(libname, EntryPoint = "SQLGetInfo")]
+
+ [DllImport(libname)]
+ public static extern short SQLBindParameter(IntPtr stmtHandle, short paramNumber,
+ short dataType, short valueType, short paramType, int colSize, short decDigits,
+ int[] dataBufferPtr, int dataBufferLength, IntPtr StrLen_or_IndPtr);
+
+ [DllImport(libname, EntryPoint = "SQLGetInfoW", CharSet=CharSet.Unicode)]
public static extern short SQLGetInfo(IntPtr sqlHdbc, short fInfoType, [Out] StringBuilder rgbInfoValue, short cbInfoValueMax, out short pcbInfoValue);
}
{
#region Private data members
- private WeakReference refDataReader;
- private string commandText;
- private CommandType commandType = CommandType.Text;
- private DB2Connection db2Conn;
- private DB2Transaction db2Trans;
- private int commandTimeout = 30;
- private bool prepared = false;
- private IntPtr hwndStmt = IntPtr.Zero; //Our statement handle
- private DB2ParameterCollection parameters = new DB2ParameterCollection();
- private bool disposed = false;
- private bool statementOpen;
- private CommandBehavior previousBehavior;
- private UpdateRowSource updatedRowSource = UpdateRowSource.Both;
- private IntPtr statementParametersMemory;
+ private WeakReference refDataReader;\r
+ private string commandText;\r
+ private CommandType commandType = CommandType.Text;\r
+ private DB2Connection db2Conn;\r
+ private DB2Transaction db2Trans;\r
+ private int commandTimeout = 30;\r
+ private bool prepared = false;\r
+ private bool binded = false;\r
+ private IntPtr hwndStmt = IntPtr.Zero; //Our statement handle\r
+ private DB2ParameterCollection parameters = new DB2ParameterCollection();\r
+ private bool disposed = false;\r
+ private bool statementOpen;\r
+ private CommandBehavior previousBehavior;\r
+ private UpdateRowSource updatedRowSource = UpdateRowSource.Both;\r
+ private IntPtr statementParametersMemory;\r
private int statementParametersMemorySize;
#endregion
{
hwndStmt = IntPtr.Zero;
}
- public DB2Command(string commandStr)
+ public DB2Command(string commandStr):this()
{
commandText = commandStr;
- hwndStmt = IntPtr.Zero;
}
- public DB2Command(string commandStr, DB2Connection con) :this()
+ public DB2Command(string commandStr, DB2Connection con) : this()
{
db2Conn = con;
commandText = commandStr;
- if(con != null)
- {
- con.AddCommand(this);
+ if(con != null)\r
+ {\r
+ con.AddCommand(this);\r
}
}
public DB2Command (string commandStr, DB2Connection con, DB2Transaction trans)
{
- commandText = commandStr;
- db2Conn = con;
- db2Trans = trans;
- if(con != null)
- {
- con.AddCommand(this);
+ commandText = commandStr;\r
+ db2Conn = con;\r
+ db2Trans = trans;\r
+ if(con != null)\r
+ {\r
+ con.AddCommand(this);\r
}
}
#endregion
- #region Dispose
- public new void Dispose()
- {
- Dispose(true);
- GC.SuppressFinalize(this);
- }
-
- protected override void Dispose(bool disposing)
- {
- if(!disposed)
- {
- if(disposing)
- {
- ConnectionClosed();
- if(db2Conn != null)
- {
- db2Conn.RemoveCommand(this);
- db2Conn = null;
- }
- }
- if(statementParametersMemory != IntPtr.Zero)
- {
- Marshal.FreeHGlobal(statementParametersMemory);
- statementParametersMemory = IntPtr.Zero;
- }
- }
- base.Dispose(disposing);
- disposed = true;
- }
-
-
- ~DB2Command()
- {
- Dispose(false);
- }
-
- internal void DataReaderClosed()
- {
- CloseStatementHandle(false);
- if((previousBehavior & CommandBehavior.CloseConnection) != 0)
- Connection.Close();
- refDataReader = null;
- }
-
- private void CloseStatementHandle(bool dispose)
- {
- if(hwndStmt != IntPtr.Zero)
- {
- if(statementOpen)
- {
- short sqlRet = DB2CLIWrapper.SQLFreeStmt(hwndStmt, DB2Constants.SQL_CLOSE);
- }
- if((!prepared && statementOpen) ||
- dispose)
- {
- short sqlRet = DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_STMT, hwndStmt);
-
- hwndStmt = IntPtr.Zero;
- prepared = false;
- }
- statementOpen = false;
- }
- }
-
- internal void ConnectionClosed()
- {
- DB2DataReader reader = null;
- if((refDataReader != null) && refDataReader.IsAlive)
- {
- reader = (DB2DataReader)refDataReader.Target;
- }
- if((reader != null) && refDataReader.IsAlive)
- {
- reader.Dispose();
- refDataReader = null;
- }
- CloseStatementHandle(true);
-
- db2Trans = null;
- }
-
+ #region Dispose\r
+ public new void Dispose()\r
+ {\r
+ Dispose(true);\r
+ GC.SuppressFinalize(this);\r
+ }\r
+\r
+ protected override void Dispose(bool disposing)\r
+ {\r
+ if(!disposed) \r
+ {\r
+ if(disposing)\r
+ {\r
+ ConnectionClosed();\r
+ if(db2Conn != null)\r
+ {\r
+ db2Conn.RemoveCommand(this);\r
+ db2Conn = null;\r
+ }\r
+ }\r
+ if(statementParametersMemory != IntPtr.Zero)\r
+ {\r
+ Marshal.FreeHGlobal(statementParametersMemory);\r
+ statementParametersMemory = IntPtr.Zero;\r
+ }\r
+ }\r
+ base.Dispose(disposing);\r
+ disposed = true;\r
+ }\r
+\r
+\r
+ ~DB2Command()\r
+ {\r
+ Dispose(false);\r
+ }\r
+\r
+ internal void DataReaderClosed()\r
+ {\r
+ CloseStatementHandle(false);\r
+ if((previousBehavior & CommandBehavior.CloseConnection) != 0)\r
+ Connection.Close();\r
+ refDataReader = null;\r
+ }\r
+\r
+ private void CloseStatementHandle(bool dispose)\r
+ {\r
+ if(hwndStmt != IntPtr.Zero)\r
+ {\r
+ if(statementOpen)\r
+ {\r
+ short sqlRet = DB2CLIWrapper.SQLFreeStmt(hwndStmt, DB2Constants.SQL_CLOSE);\r
+ }\r
+ if((!prepared && statementOpen) ||\r
+ dispose)\r
+ {\r
+ short sqlRet = DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_STMT, hwndStmt);\r
+\r
+ hwndStmt = IntPtr.Zero;\r
+ prepared = false;\r
+ }\r
+ statementOpen = false;\r
+ }\r
+ }\r
+\r
+ internal void ConnectionClosed()\r
+ {\r
+ DB2DataReader reader = null;\r
+ if((refDataReader != null) && refDataReader.IsAlive)\r
+ {\r
+ reader = (DB2DataReader)refDataReader.Target;\r
+ }\r
+ if((reader != null) && refDataReader.IsAlive)\r
+ {\r
+ reader.Dispose();\r
+ refDataReader = null;\r
+ }\r
+ CloseStatementHandle(true);\r
+\r
+ db2Trans = null;\r
+ }\r
+\r
#endregion
#region SelfDescribe property
///
/// The Timeout property states how long we wait for results to return
///
- public int CommandTimeout
- {
- get
- {
- return commandTimeout;
- }
- set
- {
- commandTimeout = value;
- if(hwndStmt != IntPtr.Zero)
- SetStatementTimeout();
- }
+ public int CommandTimeout\r
+ {\r
+ get\r
+ {\r
+ return commandTimeout;\r
+ }\r
+ set \r
+ {\r
+ commandTimeout = value;\r
+ if(hwndStmt != IntPtr.Zero)\r
+ SetStatementTimeout();\r
+ }\r
}
#endregion
}
}
- public DB2Connection Connection
- {
- get
- {
- return db2Conn;
- }
- set
- {
- if(db2Conn != null)
- {
- db2Conn.RemoveCommand(this);
- }
- db2Conn = value;
- if(db2Conn != null)
- {
- db2Conn.AddCommand(this);
- }
- }
+ public DB2Connection Connection\r
+ {\r
+ get\r
+ {\r
+ return db2Conn;\r
+ }\r
+ set\r
+ {\r
+ if(db2Conn != null)\r
+ {\r
+ db2Conn.RemoveCommand(this);\r
+ }\r
+ db2Conn = value;\r
+ if(db2Conn != null)\r
+ {\r
+ db2Conn.AddCommand(this);\r
+ }\r
+ }\r
}
#endregion
}
}
- public DB2Transaction Transaction
- {
- get
- {
- return db2Trans;
- }
- set
- {
- db2Trans = value;
- }
+ public DB2Transaction Transaction\r
+ {\r
+ get\r
+ {\r
+ return db2Trans;\r
+ }\r
+ set\r
+ {\r
+ db2Trans = value;\r
+ }\r
}
#endregion
#region UpdatedRowSource property
- public UpdateRowSource UpdatedRowSource
- {
- get { return updatedRowSource; }
- set { updatedRowSource = value; }
+ public UpdateRowSource UpdatedRowSource \r
+ {\r
+ get { return updatedRowSource; }\r
+ set { updatedRowSource = value; }\r
}
#endregion
#region AllocateStatement function
- internal void AllocateStatement(string location)
- {
- if (db2Conn.DBHandle.ToInt32() == 0) return;
- short sqlRet;
- sqlRet = DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_STMT, db2Conn.DBHandle, out hwndStmt);
- if ((sqlRet != DB2Constants.SQL_SUCCESS) && (sqlRet != DB2Constants.SQL_SUCCESS_WITH_INFO))
- throw new DB2Exception(DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, location +": Unable to allocate statement handle.");
-
- parameters.HwndStmt = hwndStmt;
-
- SetStatementTimeout();
+ internal void AllocateStatement(string location)\r
+ {\r
+ if (db2Conn.DBHandle.ToInt32() == 0) return;\r
+ short sqlRet;\r
+ sqlRet = DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_STMT, db2Conn.DBHandle, out hwndStmt);\r
+ if ((sqlRet != DB2Constants.SQL_SUCCESS) && (sqlRet != DB2Constants.SQL_SUCCESS_WITH_INFO))\r
+ throw new DB2Exception(DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, location +": Unable to allocate statement handle.");\r
+\r
+ parameters.HwndStmt = hwndStmt;\r
+\r
+ SetStatementTimeout();\r
}
- private void SetStatementTimeout()
- {
- short sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_QUERY_TIMEOUT, new IntPtr(commandTimeout), 0);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Set statement timeout.", db2Conn);
+ private void SetStatementTimeout()\r
+ {\r
+ short sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_QUERY_TIMEOUT, new IntPtr(commandTimeout), 0);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Set statement timeout.", db2Conn);\r
}
#endregion
/// <summary>
/// Attempt to cancel an executing command
/// </summary>
- public void Cancel()
- {
- if(hwndStmt == IntPtr.Zero)
- {
- throw new InvalidOperationException("Nothing to Cancel.");
- }
- DB2CLIWrapper.SQLCancel(hwndStmt);
+ public void Cancel()\r
+ {\r
+ if(hwndStmt == IntPtr.Zero)\r
+ {\r
+ throw new InvalidOperationException("Nothing to Cancel.");\r
+ }\r
+ DB2CLIWrapper.SQLCancel(hwndStmt);\r
}
#endregion
#region ExecuteNonQuery
- public int ExecuteNonQuery()
- {
- ExecuteNonQueryInternal(CommandBehavior.Default);
-
- int numRows;
-
- //How many rows affected. numRows will be -1 if we aren't dealing with an Insert, Delete or Update, or if the statement did not execute successfully
- short sqlRet = DB2CLIWrapper.SQLRowCount(hwndStmt, out numRows);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);
-
- do
- {
- sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLMoreResults", db2Conn);
- } while(sqlRet != DB2Constants.SQL_NO_DATA_FOUND);
-
- CloseStatementHandle(false);
-
- return numRows;
- }
-
- public void ExecuteNonQueryInternal(CommandBehavior behavior)
- {
- short sqlRet;
-
- if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))
- throw new InvalidOperationException("Prepare needs an open connection");
- if((refDataReader != null) &&
- (refDataReader.IsAlive))
- throw new InvalidOperationException("There is already an open DataReader associated with this Connection which must be closed first.");
- DB2Transaction connectionTransaction = null;
- if(db2Conn.WeakRefTransaction != null)
- connectionTransaction = (DB2Transaction)db2Conn.WeakRefTransaction.Target;
- if(!Object.ReferenceEquals(connectionTransaction, Transaction))
- {
- if(Transaction == null)
- throw new InvalidOperationException("A transaction was started in the connection, but the command doesn't specify a transaction");
- throw new InvalidOperationException("The transaction specified at the connection doesn't belong to the connection");
- }
-
- if (hwndStmt == IntPtr.Zero)
- {
- AllocateStatement("InternalExecuteNonQuery");
- previousBehavior = 0;
- }
- if(previousBehavior != behavior)
- {
-
- if(((previousBehavior ^ behavior) & CommandBehavior.SchemaOnly) != 0)
- {
- sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_DEFERRED_PREPARE,
- new IntPtr((behavior & CommandBehavior.SchemaOnly) != 0 ? 0 : 1), 0);
- // TODO: don't check. what if it is not supported???
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Defered prepare.", db2Conn);
-
- previousBehavior = (previousBehavior & ~CommandBehavior.SchemaOnly) | (behavior & CommandBehavior.SchemaOnly);
- }
-
- if(((previousBehavior ^ behavior) & CommandBehavior.SingleRow) != 0)
- {
- sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_MAX_ROWS,
- new IntPtr((behavior & CommandBehavior.SingleRow) == 0 ? 0 : 1), 0);
- // TODO: don't check. what if it is not supported???
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Set max rows", db2Conn);
-
- previousBehavior = (previousBehavior & ~CommandBehavior.SingleRow) | (behavior & CommandBehavior.SingleRow);
- }
- previousBehavior = behavior;
- }
- if((Transaction == null) &&
- !db2Conn.openConnection.autoCommit)
- {
- sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_AUTOCOMMIT, new IntPtr(DB2Constants.SQL_AUTOCOMMIT_ON), 0);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting AUTOCOMMIT ON in transaction CTOR.", db2Conn);
- db2Conn.openConnection.autoCommit = true;
-
- sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_TXN_ISOLATION, new IntPtr(DB2Constants.SQL_TXN_READ_COMMITTED), 0);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting isolation level.", db2Conn);
- }
-
-
- if ((commandText == null) ||(commandText.Length == 0))
- throw new InvalidOperationException("Command string is empty");
-
- if(CommandType.StoredProcedure == commandType && !commandText.StartsWith("CALL "))
- commandText = "CALL " + commandText;
-
- // if(!prepared)
- // {
- // Prepare();
- // }
-
- if((behavior & CommandBehavior.SchemaOnly) != 0)
- {
- if(!prepared)
- {
- Prepare();
- }
- }
- else
- {
- if(statementParametersMemory != IntPtr.Zero)
- {
- Marshal.FreeHGlobal(statementParametersMemory);
- statementParametersMemory = IntPtr.Zero;
- }
-
- if(parameters.Count > 0)
- {
- statementParametersMemorySize = 0;
- for(int i = 0; i < parameters.Count; i++)
- {
- DB2Parameter param = parameters[i];
- param.CalculateRequiredmemory();
- statementParametersMemorySize += param.requiredMemory + 8;
- }
- statementParametersMemory = Marshal.AllocHGlobal(statementParametersMemorySize);
- int offset = 0;
-
- for(int i = 0; i < parameters.Count; i++)
- {
- DB2Parameter param = parameters[i];
- //param.internalBuffer = new IntPtr(statementParametersMemory.ToInt64() + offset);
- int memSize = statementParametersMemory.ToInt32() + offset;
- param.internalBuffer = Marshal.AllocHGlobal(memSize);
- offset += param.requiredMemory;
- //param.internalLengthBuffer = new IntPtr(statementParametersMemory.ToInt32() + offset);
- param.internalLengthBuffer = Marshal.AllocHGlobal(4);
- offset += 8;
-
- sqlRet = param.Bind(this.hwndStmt, (short)(i + 1));
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Error binding parameter in DB2Command: ", db2Conn);
- }
-
- }
- if (prepared)
- {
- sqlRet = DB2CLIWrapper.SQLExecute(hwndStmt);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecute error.", db2Conn);
- }
- else
- {
- sqlRet = DB2CLIWrapper.SQLExecDirect(hwndStmt, commandText, commandText.Length);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);
- }
- statementOpen = true;
-
- parameters.GetOutValues();
-
- if(statementParametersMemory != IntPtr.Zero)
- {
- Marshal.FreeHGlobal(statementParametersMemory);
- statementParametersMemory = IntPtr.Zero;
- }
- }
+ public int ExecuteNonQuery()\r
+ {\r
+ ExecuteNonQueryInternal(CommandBehavior.Default);\r
+\r
+ int numRows;\r
+\r
+ //How many rows affected. numRows will be -1 if we aren't dealing with an Insert, Delete or Update, or if the statement did not execute successfully\r
+ short sqlRet = DB2CLIWrapper.SQLRowCount(hwndStmt, out numRows);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);\r
+\r
+ do\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLMoreResults", db2Conn);\r
+ } while(sqlRet != DB2Constants.SQL_NO_DATA_FOUND);\r
+\r
+ CloseStatementHandle(false);\r
+ \r
+ return numRows;\r
+ }\r
+\r
+ public void ExecuteNonQueryInternal(CommandBehavior behavior)\r
+ {\r
+ short sqlRet;\r
+\r
+ if(prepared && binded)\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLExecute(hwndStmt);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecute error.", db2Conn);\r
+ return;\r
+ }\r
+\r
+ if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))\r
+ throw new InvalidOperationException("Prepare needs an open connection");\r
+ if((refDataReader != null) &&\r
+ (refDataReader.IsAlive))\r
+ throw new InvalidOperationException("There is already an open DataReader associated with this Connection which must be closed first.");\r
+ DB2Transaction connectionTransaction = null;\r
+ if(db2Conn.WeakRefTransaction != null)\r
+ connectionTransaction = (DB2Transaction)db2Conn.WeakRefTransaction.Target;\r
+ if(!Object.ReferenceEquals(connectionTransaction, Transaction))\r
+ {\r
+ if(Transaction == null)\r
+ throw new InvalidOperationException("A transaction was started in the connection, but the command doesn't specify a transaction");\r
+ throw new InvalidOperationException("The transaction specified at the connection doesn't belong to the connection");\r
+ }\r
+\r
+ if (hwndStmt == IntPtr.Zero)\r
+ {\r
+ AllocateStatement("InternalExecuteNonQuery");\r
+ previousBehavior = 0;\r
+ }\r
+ if(previousBehavior != behavior)\r
+ {\r
+ if(((previousBehavior ^ behavior) & CommandBehavior.SchemaOnly) != 0)\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_DEFERRED_PREPARE, \r
+ new IntPtr((behavior & CommandBehavior.SchemaOnly) != 0 ? 0 : 1), 0);\r
+ // TODO: don't check. what if it is not supported???\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Defered prepare.", db2Conn);\r
+\r
+ previousBehavior = (previousBehavior & ~CommandBehavior.SchemaOnly) | (behavior & CommandBehavior.SchemaOnly);\r
+ }\r
+ if(((previousBehavior ^ behavior) & CommandBehavior.SingleRow) != 0)\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLSetStmtAttr(hwndStmt, DB2Constants.SQL_ATTR_MAX_ROWS, \r
+ new IntPtr((behavior & CommandBehavior.SingleRow) == 0 ? 0 : 1), 0);\r
+ // TODO: don't check. what if it is not supported???\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Set max rows", db2Conn);\r
+\r
+ previousBehavior = (previousBehavior & ~CommandBehavior.SingleRow) | (behavior & CommandBehavior.SingleRow);\r
+ }\r
+ previousBehavior = behavior;\r
+ }\r
+ if((Transaction == null) &&\r
+ !db2Conn.openConnection.autoCommit)\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_AUTOCOMMIT, new IntPtr(DB2Constants.SQL_AUTOCOMMIT_ON), 0);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting AUTOCOMMIT ON in transaction CTOR.", db2Conn);\r
+ db2Conn.openConnection.autoCommit = true;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_TXN_ISOLATION, new IntPtr(DB2Constants.SQL_TXN_READ_COMMITTED), 0);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting isolation level.", db2Conn);\r
+ }\r
+\r
+\r
+ if ((commandText == null) ||(commandText.Length == 0))\r
+ throw new InvalidOperationException("Command string is empty");\r
+ \r
+ if(CommandType.StoredProcedure == commandType && !commandText.StartsWith("CALL "))\r
+ commandText = "CALL " + commandText + " ()";\r
+ \r
+ if((behavior & CommandBehavior.SchemaOnly) != 0)\r
+ {\r
+ if(!prepared)\r
+ {\r
+ Prepare();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if(statementParametersMemory != IntPtr.Zero)\r
+ {\r
+ Marshal.FreeHGlobal(statementParametersMemory);\r
+ statementParametersMemory = IntPtr.Zero;\r
+ }\r
+\r
+ BindParams();\r
+ \r
+ if (prepared)\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLExecute(hwndStmt);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecute error.", db2Conn);\r
+ }\r
+ else\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLExecDirect(hwndStmt, commandText, commandText.Length);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);\r
+ }\r
+ statementOpen = true;\r
+\r
+ parameters.GetOutValues();\r
+\r
+ if(statementParametersMemory != IntPtr.Zero)\r
+ {\r
+ Marshal.FreeHGlobal(statementParametersMemory);\r
+ statementParametersMemory = IntPtr.Zero;\r
+ }\r
+ }\r
}
#endregion
///
///ExecuteReader
///
- IDataReader IDbCommand.ExecuteReader()
- {
- return ExecuteReader(CommandBehavior.Default);
- }
-
- IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior)
- {
- return ExecuteReader(behavior);
- }
-
- public DB2DataReader ExecuteReader()
- {
- return ExecuteReader(CommandBehavior.Default);
- }
-
- public DB2DataReader ExecuteReader(CommandBehavior behavior)
- {
- if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))
- throw new InvalidOperationException("Prepare needs an open connection");
-
- DB2DataReader reader;
-
- ExecuteNonQueryInternal(behavior);
- reader = new DB2DataReader(db2Conn, this, behavior);
-
- refDataReader = new WeakReference(reader);
-
- return reader;
+ IDataReader IDbCommand.ExecuteReader()\r
+ {\r
+ return ExecuteReader(CommandBehavior.Default);\r
+ }\r
+\r
+ IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior)\r
+ {\r
+ return ExecuteReader(behavior);\r
+ }\r
+\r
+ public DB2DataReader ExecuteReader()\r
+ {\r
+ return ExecuteReader(CommandBehavior.Default);\r
+ }\r
+\r
+ public DB2DataReader ExecuteReader(CommandBehavior behavior)\r
+ {\r
+ if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))\r
+ throw new InvalidOperationException("Prepare needs an open connection");\r
+\r
+ DB2DataReader reader;\r
+ \r
+ ExecuteNonQueryInternal(behavior);\r
+ reader = new DB2DataReader(db2Conn, this, behavior);\r
+ \r
+ refDataReader = new WeakReference(reader);\r
+\r
+ return reader;\r
}
#endregion
///
/// ExecuteScalar
///
- public object ExecuteScalar()
- {
- if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))
- throw new InvalidOperationException("Prepare needs an open connection");
-
- using(DB2DataReader reader = ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SingleRow))
- {
- if(reader.Read() && (reader.FieldCount > 0))
- {
- return reader[0];
- }
- }
- return null;
+ public object ExecuteScalar()\r
+ {\r
+ if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))\r
+ throw new InvalidOperationException("Prepare needs an open connection");\r
+\r
+ using(DB2DataReader reader = ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SingleRow))\r
+ {\r
+ if(reader.Read() && (reader.FieldCount > 0))\r
+ {\r
+ return reader[0];\r
+ }\r
+ }\r
+ return null;\r
}
#endregion
#region Prepare ()
-
- public void Prepare ()
- {
- if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))
- throw new InvalidOperationException("Prepare needs an open connection");
-
- CloseStatementHandle(false);
- if (hwndStmt == IntPtr.Zero)
- {
- AllocateStatement("InternalExecuteNonQuery");
- }
-
- short sqlRet = 0;
-
- IntPtr numParams = IntPtr.Zero;
- sqlRet = DB2CLIWrapper.SQLPrepare(hwndStmt, commandText, commandText.Length);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLPrepare error.", db2Conn);
-
- statementOpen = true;
- prepared=true;
+\r
+ public void Prepare ()\r
+ {\r
+ if((db2Conn == null) || (db2Conn.State != ConnectionState.Open))\r
+ throw new InvalidOperationException("Prepare needs an open connection");\r
+\r
+ CloseStatementHandle(false);\r
+ if (hwndStmt == IntPtr.Zero)\r
+ {\r
+ AllocateStatement("InternalExecuteNonQuery");\r
+ }\r
+\r
+ short sqlRet = 0;\r
+\r
+ IntPtr numParams = IntPtr.Zero;\r
+ sqlRet = DB2CLIWrapper.SQLPrepare(hwndStmt, commandText, commandText.Length);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLPrepare error.", db2Conn);\r
+ \r
+ \r
+ statementOpen = true;\r
+ prepared=true;\r
}
#endregion
- #region ICloneable Members
-
- object ICloneable.Clone()
- {
- DB2Command clone = new DB2Command();
-
- clone.Connection = Connection;
- clone.commandText = commandText;
- clone.commandType = commandType;
- clone.Transaction = db2Trans;
- clone.commandTimeout = commandTimeout;
- clone.updatedRowSource = updatedRowSource;
- clone.parameters = new DB2ParameterCollection();
- for(int i = 0; i < parameters.Count; i++)
- clone.Parameters.Add(((ICloneable)parameters[i]).Clone());
-
- return clone;
- }
-
+ private string AddCallParam( string _cmString)\r
+ {
+ if(_cmString.IndexOf("()") != -1)\r
+ {\r
+ return _cmString.Replace("()","(?)");\r
+ }\r
+ return _cmString.Replace(")", ",?)");
+ }
+
+ private void BindParams()\r
+ {
+ if(parameters.Count > 0)\r
+ {\r
+ statementParametersMemorySize = 0;\r
+ int offset = 0;\r
+ short sqlRet;\r
+ for(int i = 0; i < parameters.Count; i++) \r
+ {\r
+ if(commandType == CommandType.StoredProcedure)\r
+ {\r
+ commandText = AddCallParam(commandText);\r
+ }\r
+ DB2Parameter param = parameters[i];\r
+ param.CalculateRequiredmemory();\r
+ statementParametersMemorySize += param.requiredMemory + 8;\r
+ param.internalBuffer = Marshal.AllocHGlobal(param.requiredMemory);\r
+ offset += param.requiredMemory;\r
+ param.internalLengthBuffer = Marshal.AllocHGlobal(4);\r
+ Marshal.WriteInt32(param.internalLengthBuffer, param.requiredMemory);\r
+ sqlRet = param.Bind(this.hwndStmt, (short)(i + 1));\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Error binding parameter in DB2Command: ", db2Conn);\r
+ }\r
+ binded = true;\r
+ }
+ }
+
+ #region ICloneable Members\r
+\r
+ object ICloneable.Clone()\r
+ {\r
+ DB2Command clone = new DB2Command();\r
+\r
+ clone.Connection = Connection;\r
+ clone.commandText = commandText;\r
+ clone.commandType = commandType;\r
+ clone.Transaction = db2Trans;\r
+ clone.commandTimeout = commandTimeout;\r
+ clone.updatedRowSource = updatedRowSource;\r
+ clone.parameters = new DB2ParameterCollection();\r
+ for(int i = 0; i < parameters.Count; i++)\r
+ clone.Parameters.Add(((ICloneable)parameters[i]).Clone());\r
+\r
+ return clone;\r
+ }\r
+\r
#endregion
}
}
--- /dev/null
+using System;
+using System.Data;
+using System.ComponentModel;
+
+namespace IBM.Data.DB2
+{
+
+ public sealed class DB2CommandBuilder : Component
+ {
+
+ bool disposed = false;
+
+ private DB2DataAdapter dataAdapter;
+ private DB2Command insertCommand;
+ private DB2Command updateCommand;
+ private DB2Command deleteCommand;
+
+ private string tableName = String.Empty;
+
+ public DB2CommandBuilder ()
+ {}
+
+ public DB2CommandBuilder (DB2DataAdapter adapter)
+ {
+ DataAdapter = adapter;
+ }
+
+ public DB2DataAdapter DataAdapter \r
+ {
+ get
+ {
+ return dataAdapter;
+ }
+ set
+ {
+ if (dataAdapter != null)
+ {
+ throw new Exception ("DataAdapter is already set");
+ }
+ dataAdapter = value;
+ string select_text = dataAdapter.SelectCommand.CommandText;
+ string[] words = select_text.Split(new char [] {' '});
+ bool from_found = false;
+ for (int i = 0; i < words.Length; i++)
+ {
+ if (from_found && (words[i] != String.Empty))
+ {
+ tableName = words[i];
+ break;
+ }
+ if (words[i].ToLower() == "from")
+ {
+ from_found = true;
+ }
+ }
+ }
+ }
+
+ public string QuotePrefix \r
+ {
+ get
+ {
+ return "";
+ }
+ set
+ { }
+ }
+
+ public string QuoteSuffix \r
+ {
+ get
+ {
+ return "";
+ }
+ set
+ { }
+ }
+
+ public static void DeriveParameters (DB2Command command)
+ {}
+
+ public DB2Command GetInsertCommand ()
+ {
+ DataTable dt = GetSchema();
+ if (insertCommand == null)
+ {
+ string fields = "";
+ string values = "";
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ //DataColumn column = dt.Columns[i];
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+
+ if (fields.Length != 0 && !((bool)dr["IsAutoIncrement"]))
+ {
+ fields += ", ";
+ values += ", ";
+ }
+
+ if(!((bool)dr["IsAutoIncrement"]))\r
+ {
+ fields += column.ColumnName;
+ //values += ":v_" + column.ColumnName;
+ values += "?";
+ }
+ }
+ if (tableName == String.Empty)
+ {
+ tableName = dt.TableName;
+ }
+ DB2Command cmdaux = new DB2Command("insert into " + tableName + " (" + fields + ") values (" + values + ")", dataAdapter.SelectCommand.Connection);
+ for (int i = 0;i < dt.Rows.Count;i++)
+ {
+ //DataColumn column = dt.Columns[i];
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));\r
+ if (!((bool)dr["IsAutoIncrement"]))\r
+ {
+ DB2Parameter aux = new DB2Parameter("v_" + column.ColumnName, column.DataType);
+ aux.Direction = ParameterDirection.Input;
+ aux.SourceColumn = column.ColumnName;
+ cmdaux.Parameters.Add(aux);
+ }
+ }
+ insertCommand = cmdaux;
+ }
+ return insertCommand;
+ }
+
+ public DB2Command GetUpdateCommand ()
+ {
+ DataTable dt = GetSchema();
+ if (updateCommand == null)
+ {
+ string sets = "";
+ string wheres = "";
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ if (sets.Length != 0 && !((bool)dt.Rows[i]["IsAutoIncrement"]))\r
+ {
+ sets += ", ";
+ }
+ if (i != 0)
+ {
+ wheres += " and ";
+ }
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+ if(!((bool)dr["IsAutoIncrement"])){sets += String.Format("{0} = ? ", column.ColumnName);}
+ wheres += String.Format("(({0} is null) or ({0} = ?))", column.ColumnName);
+ }
+ if (tableName == String.Empty)
+ {
+ tableName = (string)dt.Rows[0]["BaseTableName"];
+ }
+ DB2Command cmdaux = new DB2Command("update " + tableName + " set " + sets + " where ( " + wheres + " )", dataAdapter.SelectCommand.Connection);
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+ if (!((bool)dr["IsAutoIncrement"]))\r
+ {
+ DB2Parameter aux = new DB2Parameter("s_" + column.ColumnName, column.DataType);
+ aux.Direction = ParameterDirection.Input;
+ aux.SourceColumn = column.ColumnName;
+ aux.SourceVersion = DataRowVersion.Current;
+ cmdaux.Parameters.Add(aux);
+ }
+ }
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+ DB2Parameter aux = new DB2Parameter("w_" + column.ColumnName, column.DataType);
+ aux.Direction = ParameterDirection.Input;
+ aux.SourceColumn = column.ColumnName;
+ aux.SourceVersion = DataRowVersion.Original;
+ cmdaux.Parameters.Add(aux);
+ }
+ updateCommand = cmdaux;
+
+ }
+ return updateCommand;
+ }
+
+ public DB2Command GetDeleteCommand ()
+ {
+ DataTable dt = GetSchema();
+ if (deleteCommand == null)
+ {
+ string wheres = "";
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ //DataColumn column = row.Table.Columns[i];
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+ if (i != 0)
+ {
+ wheres += " and ";
+ }
+ //wheres += String.Format("(({0} is null) or ({0} = v_{0}))", column.ColumnName);
+ wheres += String.Format("(({0} is null) or ({0} = ?))", column.ColumnName);
+ }
+ if (tableName == String.Empty)
+ {
+ tableName = (string)dt.Rows[0]["BaseTableName"];
+ }
+ DB2Command cmdaux = new DB2Command("delete from " + tableName + " where ( " + wheres + " )", dataAdapter.SelectCommand.Connection);
+ for (int i = 0; i < dt.Rows.Count; i++)
+ {
+ DataRow dr = dt.Rows[i];
+ DataColumn column = new DataColumn((string)dr["ColumnName"], DB2TypeConverter.GetManagedType((int)dr["ProviderType"]));
+
+ DB2Parameter aux = new DB2Parameter("v_" + column.ColumnName, column.DataType);
+ aux.Direction = ParameterDirection.Input;
+ aux.SourceColumn = column.ColumnName;
+ aux.SourceVersion = DataRowVersion.Original;
+ cmdaux.Parameters.Add(aux);
+ }
+ deleteCommand = cmdaux;
+ }
+ return deleteCommand;
+ }
+
+ public void RefreshSchema ()
+ {
+ insertCommand = null;
+ updateCommand = null;
+ deleteCommand = null;
+ }
+
+ private DataTable GetSchema()\r
+ {
+ dataAdapter.SelectCommand.Connection.Open();
+ DB2Command cmd = new DB2Command(dataAdapter.SelectCommand.CommandText, dataAdapter.SelectCommand.Connection);
+ DB2DataReader fake = cmd.ExecuteReader(CommandBehavior.KeyInfo);
+
+ DataTable dt = fake.GetSchemaTable();
+ fake.Close();
+ dataAdapter.SelectCommand.Connection.Close();
+
+ return dt;
+ }
+
+ protected override void Dispose (bool disposing)
+ {
+ if (!disposed)
+ {
+ if (disposing)
+ {
+ if (insertCommand != null)
+ {
+ insertCommand.Dispose();
+ }
+ if (updateCommand != null)
+ {
+ updateCommand.Dispose();
+ }
+ if (deleteCommand != null)
+ {
+ deleteCommand.Dispose();
+ }
+ }
+ }
+ }
+
+ }
+
+}
{
- public sealed class DB2Connection : System.ComponentModel.Component, IDbConnection, ICloneable
+ public class DB2Connection : System.ComponentModel.Component, IDbConnection, ICloneable
{
#region private data members
#region Constructors
public DB2Connection()
- {
+ {
+ connectionTimeout = 15;
+
}
public DB2Connection(string conString)
{
get
{
+ //if ((long)dbHandle.ToPointer() == DB2Constants.SQL_NULL_HANDLE)
if (openConnection == null)
return ConnectionState.Closed;
return ConnectionState.Open;
#endregion
#region Open
+
unsafe public void Open()\r
{\r
if(disposed)\r
-using System;
-using System.Collections;
-using System.Text;
-using System.Threading;
-
-namespace IBM.Data.DB2
-{
- /// <summary>
- ///
- /// </summary>
- /// <remarks>One connection pool per connectionstring</remarks>
- internal sealed class DB2ConnectionPool
- {
- private ArrayList openFreeConnections; // list of pooled connections sorted by age. First connection is present at index 'connectionsUsableOffset'
- private Queue openFreeMinimalAllocated;
- private int connectionsOpen; // total number of connections open (in pool, an in use by application)
- private int connectionsInUse; // total connection in use by application
- private int connectionsUsableOffset; // Offset to the first pooled connection in 'openFreeConnections'
- private Timer timer;
- public string databaseProductName;
- public string databaseVersion;
- public int majorVersion;
- public int minorVersion;
-
- private DB2ConnectionSettings connectionSettings;
-
- public DB2ConnectionPool(DB2ConnectionSettings connectionSettings)
- {
- this.connectionSettings = connectionSettings;
- openFreeConnections = new ArrayList();
- }
-
- public DB2ConnectionSettings ConnectionSettings
- {
- get { return connectionSettings; }
- }
-
- public DB2OpenConnection GetOpenConnection(DB2Connection db2Conn)
- {
- DB2OpenConnection connection = null;
- lock(openFreeConnections.SyncRoot)
- {
- if((connectionSettings.ConnectionPoolSizeMax > 0) &&
- (connectionsOpen >= connectionSettings.ConnectionPoolSizeMax))
- {
- throw new ArgumentException("Maximum connections reached for connectionstring");
- }
-
- while(connectionsOpen > connectionsInUse)
- {
- connection = (DB2OpenConnection)openFreeConnections[openFreeConnections.Count - 1];
- openFreeConnections.RemoveAt(openFreeConnections.Count - 1);
-
- // check if connection is dead
- int isDead;
- short sqlRet = DB2CLIWrapper.SQLGetConnectAttr(connection.DBHandle, DB2Constants.SQL_ATTR_CONNECTION_DEAD, out isDead, 0, IntPtr.Zero);
- if(((sqlRet == DB2Constants.SQL_SUCCESS_WITH_INFO) || (sqlRet == DB2Constants.SQL_SUCCESS)) &&
- (isDead == DB2Constants.SQL_CD_FALSE))
- {
- connectionsInUse++;
- break;
- }
- else
- {
- connectionsOpen--;
- connection.Dispose();
- connection = null;
- }
-
- }
- if(connectionsOpen == connectionsInUse)
- {
- if(timer != null)
- {
- timer.Dispose();
- timer = null;
- }
- }
- }
- if(connection == null)
- {
- openFreeConnections.Clear();
- connectionsUsableOffset = 0;
-
- connection = new DB2OpenConnection(connectionSettings, db2Conn);
-
- connectionsOpen++;
- connectionsInUse++;
- }
-
- return connection;
- }
-
- private void DisposeTimedoutConnections(object state)
- {
- lock(openFreeConnections.SyncRoot)
- {
- if(timer != null)
- {
- TimeSpan timeToDispose = TimeSpan.Zero;
- DB2OpenConnection connection;
- while(connectionsOpen > connectionsInUse)
- {
- connection = (DB2OpenConnection)openFreeConnections[connectionsUsableOffset];
- timeToDispose = connection.poolDisposalTime.Subtract(DateTime.Now);
- if((timeToDispose.Ticks < 0) || // time to die
- (timeToDispose > connectionSettings.ConnectionLifeTime)) // messing with system clock
- {
- connection.Dispose();
- openFreeConnections[connectionsUsableOffset] = null;
- connectionsOpen--;
- connectionsUsableOffset++;
- }
- else
- {
- break;
- }
- }
- if(connectionsOpen > connectionsInUse)
- {
- connection = (DB2OpenConnection)openFreeConnections[connectionsUsableOffset];
- timer.Change(timeToDispose, new TimeSpan(-1));
- }
- else
- {
- timer.Dispose();
- timer = null;
- }
- }
- if((connectionsUsableOffset > (openFreeConnections.Capacity / 2)) &&
- (connectionsOpen > connectionsInUse))
- {
- openFreeConnections.RemoveRange(0, connectionsUsableOffset); // cleanup once in a while
- connectionsUsableOffset = 0;
- }
- }
- }
-
- public void AddToFreeConnections(DB2OpenConnection connection)
- {
- lock(openFreeConnections.SyncRoot)
- {
- connection.poolDisposalTime = DateTime.Now.Add(connectionSettings.ConnectionLifeTime);
- if(timer == null)
- {
- timer = new Timer(new TimerCallback(DisposeTimedoutConnections), null,
- connectionSettings.ConnectionLifeTime, new TimeSpan(-1));
- }
- connectionsInUse--;
- openFreeConnections.Add(connection);
- }
- }
-
- public void OpenConnectionFinalized()
- {
- lock(openFreeConnections.SyncRoot)
- {
- connectionsOpen--;
- connectionsInUse--;
- }
- }
-
- /// <summary>
- /// Find a specific connection pool
- /// </summary>
- /// <param name="connectionString"></param>
- /// <returns></returns>
- static public DB2ConnectionPool FindConnectionPool(string connectionString)
- {
- return (DB2ConnectionPool)DB2Environment.Instance.connectionPools[connectionString];
- }
-
- /// <summary>
- /// Get a connection pool. If it doesn't exist yet, create it
- /// </summary>
- /// <param name="connectionSettings"></param>
- /// <returns></returns>
- static public DB2ConnectionPool GetConnectionPool(DB2ConnectionSettings connectionSettings)
- {
- DB2Environment environment = DB2Environment.Instance;
-
- lock(environment.connectionPools.SyncRoot)
- {
- DB2ConnectionPool pool = (DB2ConnectionPool)environment.connectionPools[connectionSettings.ConnectionString];
- if(pool == null)
- {
- pool = new DB2ConnectionPool(connectionSettings);
- environment.connectionPools.Add(connectionSettings.ConnectionString, pool);
- }
- return pool;
- }
- }
- }
-}
+using System;\r
+using System.Collections;\r
+using System.Text;\r
+using System.Threading;\r
+\r
+namespace IBM.Data.DB2\r
+{\r
+ /// <summary>\r
+ /// \r
+ /// </summary>\r
+ /// <remarks>One connection pool per connectionstring</remarks>\r
+ internal sealed class DB2ConnectionPool\r
+ {\r
+ private ArrayList openFreeConnections; // list of pooled connections sorted by age. First connection is present at index 'connectionsUsableOffset'\r
+ private Queue openFreeMinimalAllocated;\r
+ private int connectionsOpen; // total number of connections open (in pool, an in use by application)\r
+ private int connectionsInUse; // total connection in use by application\r
+ private int connectionsUsableOffset; // Offset to the first pooled connection in 'openFreeConnections'\r
+ private Timer timer;\r
+ public string databaseProductName;\r
+ public string databaseVersion;\r
+ public int majorVersion;\r
+ public int minorVersion;\r
+\r
+ private DB2ConnectionSettings connectionSettings;\r
+\r
+ public DB2ConnectionPool(DB2ConnectionSettings connectionSettings)\r
+ {\r
+ this.connectionSettings = connectionSettings;\r
+ openFreeConnections = new ArrayList();\r
+ }\r
+\r
+ public DB2ConnectionSettings ConnectionSettings\r
+ {\r
+ get { return connectionSettings; }\r
+ }\r
+\r
+ public DB2OpenConnection GetOpenConnection(DB2Connection db2Conn)\r
+ {\r
+ DB2OpenConnection connection = null;\r
+ lock(openFreeConnections.SyncRoot)\r
+ {\r
+ if((connectionSettings.ConnectionPoolSizeMax > 0) &&\r
+ (connectionsOpen >= connectionSettings.ConnectionPoolSizeMax))\r
+ {\r
+ throw new ArgumentException("Maximum connections reached for connectionstring");\r
+ }\r
+\r
+ while(connectionsOpen > connectionsInUse)\r
+ {\r
+ connection = (DB2OpenConnection)openFreeConnections[openFreeConnections.Count - 1];\r
+ openFreeConnections.RemoveAt(openFreeConnections.Count - 1);\r
+\r
+ // check if connection is dead\r
+ int isDead;\r
+ short sqlRet = DB2CLIWrapper.SQLGetConnectAttr(connection.DBHandle, DB2Constants.SQL_ATTR_CONNECTION_DEAD, out isDead, 0, IntPtr.Zero);\r
+ if(((sqlRet == DB2Constants.SQL_SUCCESS_WITH_INFO) || (sqlRet == DB2Constants.SQL_SUCCESS)) &&\r
+ (isDead == DB2Constants.SQL_CD_FALSE))\r
+ {\r
+ connectionsInUse++;\r
+ break;\r
+ }\r
+ else\r
+ {\r
+ connectionsOpen--;\r
+ connection.Dispose();\r
+ connection = null;\r
+ }\r
+\r
+ }\r
+ if(connectionsOpen == connectionsInUse)\r
+ {\r
+ if(timer != null)\r
+ {\r
+ timer.Dispose();\r
+ timer = null;\r
+ }\r
+ }\r
+ }\r
+ if(connection == null)\r
+ {\r
+ openFreeConnections.Clear();\r
+ connectionsUsableOffset = 0;\r
+\r
+ connection = new DB2OpenConnection(connectionSettings, db2Conn);\r
+ connectionsOpen++;\r
+ connectionsInUse++;\r
+ }\r
+\r
+ return connection;\r
+ }\r
+\r
+ private void DisposeTimedoutConnections(object state)\r
+ {\r
+ lock(openFreeConnections.SyncRoot)\r
+ {\r
+ if(timer != null)\r
+ {\r
+ TimeSpan timeToDispose = TimeSpan.Zero;\r
+ DB2OpenConnection connection;\r
+ while(connectionsOpen > connectionsInUse)\r
+ {\r
+ connection = (DB2OpenConnection)openFreeConnections[connectionsUsableOffset];\r
+ timeToDispose = connection.poolDisposalTime.Subtract(DateTime.Now);\r
+ if((timeToDispose.Ticks < 0) || // time to die\r
+ (timeToDispose > connectionSettings.ConnectionLifeTime)) // messing with system clock\r
+ {\r
+ connection.Dispose();\r
+ openFreeConnections[connectionsUsableOffset] = null;\r
+ connectionsOpen--;\r
+ connectionsUsableOffset++;\r
+ }\r
+ else\r
+ {\r
+ break;\r
+ }\r
+ }\r
+ if(connectionsOpen > connectionsInUse)\r
+ {\r
+ connection = (DB2OpenConnection)openFreeConnections[connectionsUsableOffset];\r
+ timer.Change(timeToDispose, new TimeSpan(-1));\r
+ }\r
+ else\r
+ {\r
+ timer.Dispose();\r
+ timer = null;\r
+ }\r
+ }\r
+ if((connectionsUsableOffset > (openFreeConnections.Capacity / 2)) &&\r
+ (connectionsOpen > connectionsInUse))\r
+ {\r
+ openFreeConnections.RemoveRange(0, connectionsUsableOffset); // cleanup once in a while\r
+ connectionsUsableOffset = 0;\r
+ }\r
+ }\r
+ }\r
+\r
+ public void AddToFreeConnections(DB2OpenConnection connection)\r
+ {\r
+ lock(openFreeConnections.SyncRoot)\r
+ {\r
+ connection.poolDisposalTime = DateTime.Now.Add(connectionSettings.ConnectionLifeTime);\r
+ if(timer == null)\r
+ {\r
+ timer = new Timer(new TimerCallback(DisposeTimedoutConnections), null, \r
+ connectionSettings.ConnectionLifeTime, new TimeSpan(-1));\r
+ }\r
+ connectionsInUse--;\r
+ openFreeConnections.Add(connection);\r
+ }\r
+ }\r
+\r
+ public void OpenConnectionFinalized()\r
+ {\r
+ lock(openFreeConnections.SyncRoot)\r
+ {\r
+ connectionsOpen--;\r
+ connectionsInUse--;\r
+ }\r
+ }\r
+\r
+ /// <summary>\r
+ /// Find a specific connection pool\r
+ /// </summary>\r
+ /// <param name="connectionString"></param>\r
+ /// <returns></returns>\r
+ static public DB2ConnectionPool FindConnectionPool(string connectionString)\r
+ {\r
+ return (DB2ConnectionPool)DB2Environment.Instance.connectionPools[connectionString];\r
+ }\r
+\r
+ /// <summary>\r
+ /// Get a connection pool. If it doesn't exist yet, create it\r
+ /// </summary>\r
+ /// <param name="connectionSettings"></param>\r
+ /// <returns></returns>\r
+ static public DB2ConnectionPool GetConnectionPool(DB2ConnectionSettings connectionSettings)\r
+ {\r
+ DB2Environment environment = DB2Environment.Instance;\r
+\r
+ lock(environment.connectionPools.SyncRoot)\r
+ {\r
+ DB2ConnectionPool pool = (DB2ConnectionPool)environment.connectionPools[connectionSettings.ConnectionString];\r
+ if(pool == null)\r
+ {\r
+ pool = new DB2ConnectionPool(connectionSettings);\r
+ environment.connectionPools.Add(connectionSettings.ConnectionString, pool);\r
+ }\r
+ return pool;\r
+ }\r
+ }\r
+ }\r
+}\r
-using System;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace IBM.Data.DB2
-{
- internal sealed class DB2ConnectionSettings
- {
- private string connectionString;
- private string userName = "";
- private string passWord = "";
- private string databaseAlias = "";
- private string server = "";
- private bool pooling = true;
- private TimeSpan connectTimeout = new TimeSpan(0, 0, 15);
- private TimeSpan connectionLifeTime = new TimeSpan(0, 0, 15); // 15 seconds
- private int connectionPoolSizeMin = 0;
- private int connectionPoolSizeMax = -1; // no maximum
-
- private DB2ConnectionPool pool;
-
- private DB2ConnectionSettings(string connectionString)
- {
- this.connectionString = connectionString;
- this.Parse();
- }
-
- public static DB2ConnectionSettings GetConnectionSettings(string connectionString)
- {
- DB2ConnectionPool pool = DB2ConnectionPool.FindConnectionPool(connectionString);
- if(pool != null)
- {
- return pool.ConnectionSettings;
- }
- DB2ConnectionSettings settings = new DB2ConnectionSettings(connectionString);
- if(settings.Pooling)
- {
- settings.pool = DB2ConnectionPool.GetConnectionPool(settings);
- }
- return settings;
- }
-
- public DB2OpenConnection GetRealOpenConnection(DB2Connection connection)
- {
- if(pool != null)
- {
- return pool.GetOpenConnection(connection);
- }
- else
- {
- return new DB2OpenConnection(this, connection);
- }
- }
-
- public DB2ConnectionPool Pool
- {
- get { return pool; }
- }
-
- public string ConnectionString
- {
- get { return connectionString; }
- }
-
- public string UserName
- {
- get { return userName; }
- }
-
- public string PassWord
- {
- get { return passWord; }
- }
-
- /// <summary>
- /// database alias (for cataloged database)
- /// </summary>
- public string DatabaseAlias
- {
- get { return databaseAlias; }
- }
-
- /// <summary>
- /// server name with optional port number for direct connection (<server name/ip address>[:<port>])
- /// </summary>
- public string Server
- {
- get { return server; }
- }
-
- public TimeSpan ConnectTimeout
- {
- get { return connectTimeout; }
- }
-
- /// <summary>
- /// Connection pooling yes/no
- /// </summary>
- public bool Pooling
- {
- get { return pooling; }
- }
-
- public int ConnectionPoolSizeMin
- {
- get { return connectionPoolSizeMin; }
- }
-
- public int ConnectionPoolSizeMax
- {
- get { return connectionPoolSizeMin; }
- }
-
- public TimeSpan ConnectionLifeTime
- {
- get { return connectionLifeTime; }
- }
-
-
- /// <summary>
- /// parsed according to IBM DB2 .NET data provider help
- /// </summary>
- public void Parse()
- {
- string[] parts = connectionString.Split(new char[]{';'});
- foreach(string part in parts)
- {
- string[] pairs = part.Split(new char[]{'='});
- switch(pairs[0].ToLower())
- {
- case "database":
- case "dsn":
- databaseAlias = pairs[1];
- break;
- case "uid":
- case "user id":
- userName = pairs[1];
- break;
- case "pwd":
- case "password":
- passWord = pairs[1];
- break;
- case "server":
- server = pairs[1];
- break;
- case "pooling":
- pooling = (pairs[1].ToLower() == "true") || (pairs[1]== "1");
- break;
- case "connect timeout":
- case "timeout":
- case "connection timeout":
- connectTimeout = new TimeSpan(0, 0, int.Parse(pairs[1]));
- break;
- case "min pool size":
- connectionPoolSizeMin = int.Parse(pairs[1]);
- break;
- case "max pool size":
- connectionPoolSizeMax = int.Parse(pairs[1]);
- break;
- case "connection lifetime":
- connectionLifeTime = new TimeSpan(0, 0, int.Parse(pairs[1]));
- break;
- }
- }
- if(connectionLifeTime.Ticks <= 0)
- {
- pooling = false;
- }
- }
-
- public override int GetHashCode()
- {
- return connectionString.GetHashCode ();
- }
-
- public override bool Equals(object obj)
- {
- return connectionString.Equals (obj);
- }
- }
-}
+using System;\r
+using System.Runtime.InteropServices;\r
+using System.Text;\r
+\r
+namespace IBM.Data.DB2\r
+{\r
+ internal sealed class DB2ConnectionSettings\r
+ {\r
+ private string connectionString;\r
+ private string userName = "";\r
+ private string passWord = "";\r
+ private string databaseAlias = "";\r
+ private string server = "";\r
+ private bool pooling = true;\r
+ private TimeSpan connectTimeout = new TimeSpan(0, 0, 15);\r
+ private TimeSpan connectionLifeTime = new TimeSpan(0, 0, 15); // 15 seconds\r
+ private int connectionPoolSizeMin = 0;\r
+ private int connectionPoolSizeMax = -1; // no maximum\r
+\r
+ private DB2ConnectionPool pool;\r
+\r
+ private DB2ConnectionSettings(string connectionString)\r
+ {\r
+ this.connectionString = connectionString;\r
+ this.Parse();\r
+ }\r
+\r
+ public static DB2ConnectionSettings GetConnectionSettings(string connectionString)\r
+ {\r
+ DB2ConnectionPool pool = DB2ConnectionPool.FindConnectionPool(connectionString);\r
+ if(pool != null)\r
+ {\r
+ return pool.ConnectionSettings;\r
+ }\r
+ DB2ConnectionSettings settings = new DB2ConnectionSettings(connectionString);\r
+ if(settings.Pooling)\r
+ {\r
+ settings.pool = DB2ConnectionPool.GetConnectionPool(settings);\r
+ }\r
+ return settings;\r
+ }\r
+\r
+ public DB2OpenConnection GetRealOpenConnection(DB2Connection connection)\r
+ {\r
+ if(pool != null)\r
+ {\r
+ return pool.GetOpenConnection(connection);\r
+ }\r
+ else\r
+ {\r
+ return new DB2OpenConnection(this, connection);\r
+ }\r
+ }\r
+\r
+ public DB2ConnectionPool Pool\r
+ {\r
+ get { return pool; }\r
+ }\r
+\r
+ public string ConnectionString\r
+ {\r
+ get { return connectionString; }\r
+ }\r
+\r
+ public string UserName\r
+ {\r
+ get { return userName; }\r
+ }\r
+ \r
+ public string PassWord\r
+ {\r
+ get { return passWord; }\r
+ }\r
+\r
+ /// <summary>\r
+ /// database alias (for cataloged database)\r
+ /// </summary>\r
+ public string DatabaseAlias\r
+ {\r
+ get { return databaseAlias; }\r
+ }\r
+\r
+ /// <summary>\r
+ /// server name with optional port number for direct connection (<server name/ip address>[:<port>])\r
+ /// </summary>\r
+ public string Server\r
+ {\r
+ get { return server; }\r
+ }\r
+\r
+ public TimeSpan ConnectTimeout\r
+ {\r
+ get { return connectTimeout; }\r
+ }\r
+\r
+ /// <summary>\r
+ /// Connection pooling yes/no\r
+ /// </summary>\r
+ public bool Pooling\r
+ {\r
+ get { return pooling; }\r
+ }\r
+\r
+ public int ConnectionPoolSizeMin\r
+ {\r
+ get { return connectionPoolSizeMin; }\r
+ }\r
+\r
+ public int ConnectionPoolSizeMax\r
+ {\r
+ get { return connectionPoolSizeMin; }\r
+ }\r
+\r
+ public TimeSpan ConnectionLifeTime\r
+ {\r
+ get { return connectionLifeTime; }\r
+ }\r
+\r
+\r
+ /// <summary>\r
+ /// parsed according to IBM DB2 .NET data provider help\r
+ /// </summary>\r
+ public void Parse()\r
+ {\r
+ string[] parts = connectionString.Split(new char[]{';'});\r
+ foreach(string part in parts)\r
+ {\r
+ string[] pairs = part.Split(new char[]{'='});\r
+ switch(pairs[0].ToLower())\r
+ {\r
+ case "database":\r
+ case "dsn":\r
+ databaseAlias = pairs[1];\r
+ break;\r
+ case "uid":\r
+ case "user id":\r
+ userName = pairs[1];\r
+ break;\r
+ case "pwd":\r
+ case "password":\r
+ passWord = pairs[1];\r
+ break;\r
+ case "server":\r
+ server = pairs[1];\r
+ break;\r
+ case "pooling":\r
+ pooling = (pairs[1].ToLower() == "true") || (pairs[1]== "1");\r
+ break;\r
+ case "connect timeout":\r
+ case "timeout":\r
+ case "connection timeout":\r
+ connectTimeout = new TimeSpan(0, 0, int.Parse(pairs[1]));\r
+ break;\r
+ case "min pool size":\r
+ connectionPoolSizeMin = int.Parse(pairs[1]);\r
+ break;\r
+ case "max pool size":\r
+ connectionPoolSizeMax = int.Parse(pairs[1]);\r
+ break;\r
+ case "connection lifetime":\r
+ connectionLifeTime = new TimeSpan(0, 0, int.Parse(pairs[1]));\r
+ break;\r
+ }\r
+ }\r
+ if(connectionLifeTime.Ticks <= 0)\r
+ {\r
+ pooling = false;\r
+ }\r
+ }\r
+ \r
+ public override int GetHashCode()\r
+ {\r
+ return connectionString.GetHashCode ();\r
+ }\r
+ \r
+ public override bool Equals(object obj)\r
+ {\r
+ return connectionString.Equals (obj);\r
+ }\r
+ }\r
+}\r
public const int SQL_ATTR_MAX_ROWS = 1;\r
public const int SQL_ATTR_DEFERRED_PREPARE = 1277;\r
\r
+ /*Used for batch operations*/\r
+ public const int SQL_ATTR_PARAMSET_SIZE = 22;\r
+ public const int SQL_ATTR_PARAM_STATUS_PTR = 20;\r
+ public const int SQL_ATTR_PARAMS_PROCESSED_PTR = 21;\r
+ public const int SQL_ATTR_PARAM_BIND_TYPE = 18;\r
+\r
public const int SQL_IS_POINTER = -4;\r
public const int SQL_IS_UINTEGER = -5;\r
public const int SQL_IS_INTEGER = -6;\r
public const int SQL_NULLABLE = 1;\r
public const int SQL_NULLABLE_UNKNOWN = 2;\r
\r
+ public const int SQL_PARAM_BIND_BY_COLUMN = 0;\r
+\r
/* Defines for SQLBindParameter and SQLProcedureColumns */\r
public const int SQL_PARAM_TYPE_UNKNOWN = 0;\r
public const int SQL_PARAM_INPUT = 1;\r
--- /dev/null
+using System;
+using System.ComponentModel;
+using System.Data;
+using System.Data.Common;
+
+namespace IBM.Data.DB2 {
+
+ public sealed class DB2DataAdapter : DbDataAdapter, IDbDataAdapter
+ {
+ #region Fields
+
+ bool disposed = false;
+ DB2Command deleteCommand;
+ DB2Command insertCommand;
+ DB2Command selectCommand;
+ DB2Command updateCommand;
+
+ #endregion
+
+ #region Constructors
+
+ public DB2DataAdapter ()
+ : this (new DB2Command ())
+ {
+ }
+
+ public DB2DataAdapter (DB2Command selectCommand)
+ {
+ DeleteCommand = null;
+ InsertCommand = null;
+ SelectCommand = selectCommand;
+ UpdateCommand = null;
+ }
+
+ public DB2DataAdapter (string selectCommandText, DB2Connection selectConnection)
+ : this (new DB2Command (selectCommandText, selectConnection))
+ {
+ }
+
+ public DB2DataAdapter (string selectCommandText, string selectConnectionString)
+ : this (selectCommandText, new DB2Connection (selectConnectionString))
+ {
+ }
+
+ #endregion
+
+ #region Properties
+
+
+ public DB2Command DeleteCommand {
+ get { return deleteCommand; }
+ set { deleteCommand = value; }
+ }
+
+
+ public DB2Command InsertCommand {
+ get { return insertCommand; }
+ set { insertCommand = value; }
+ }
+
+
+ public DB2Command SelectCommand {
+ get { return selectCommand; }
+ set { selectCommand = value; }
+ }
+
+
+ public DB2Command UpdateCommand {
+ get { return updateCommand; }
+ set { updateCommand = value; }
+ }
+
+ IDbCommand IDbDataAdapter.DeleteCommand {
+ get { return DeleteCommand; }
+ set {
+ if (!(value is DB2Command))
+ throw new ArgumentException ();
+ DeleteCommand = (DB2Command)value;
+ }
+ }
+
+ IDbCommand IDbDataAdapter.InsertCommand {
+ get { return InsertCommand; }
+ set {
+ if (!(value is DB2Command))
+ throw new ArgumentException ();
+ InsertCommand = (DB2Command)value;
+ }
+ }
+
+ IDbCommand IDbDataAdapter.SelectCommand {
+ get { return SelectCommand; }
+ set {
+ if (!(value is DB2Command))
+ throw new ArgumentException ();
+ SelectCommand = (DB2Command)value;
+ }
+ }
+
+ IDbCommand IDbDataAdapter.UpdateCommand {
+ get { return UpdateCommand; }
+ set {
+ if (!(value is DB2Command))
+ throw new ArgumentException ();
+ UpdateCommand = (DB2Command)value;
+ }
+ }
+
+
+ ITableMappingCollection IDataAdapter.TableMappings {
+ get { return TableMappings; }
+ }
+
+ #endregion
+
+ #region Methods
+
+ protected override RowUpdatedEventArgs CreateRowUpdatedEvent (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping)
+ {
+ return new DB2RowUpdatedEventArgs (dataRow, command, statementType, tableMapping);
+ }
+
+
+ protected override RowUpdatingEventArgs CreateRowUpdatingEvent (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping)
+ {
+ return new DB2RowUpdatingEventArgs (dataRow, command, statementType, tableMapping);
+ }
+
+ protected override void Dispose (bool disposing)
+ {
+ if (!disposed) {
+ if (disposing) {
+
+ }
+
+ disposed = true;
+ }
+ }
+
+ protected override void OnRowUpdated (RowUpdatedEventArgs value)
+ {
+ if (RowUpdated != null)
+ RowUpdated (this, (DB2RowUpdatedEventArgs) value);
+ }
+
+ protected override void OnRowUpdating (RowUpdatingEventArgs value)
+ {
+ if (RowUpdating != null)
+ RowUpdating (this, (DB2RowUpdatingEventArgs) value);
+ }
+
+ #endregion
+
+ #region Events and Delegates
+
+ public event DB2RowUpdatedEventHandler RowUpdated;
+
+ public event DB2RowUpdatingEventHandler RowUpdating;
+
+ #endregion
+
+ }
+}
/// </summary>
public sealed class DB2DataReader : MarshalByRefObject, IDataReader
{
- private struct ColumnInfo
- {
- public string Colname;
- public int Sqltype;
+ private struct ColumnInfo\r
+ {\r
+ public string Colname;\r
+ public int Sqltype;\r
}
- private object[] _resultSet;
- private ColumnInfo[] columnInfo;
- private Hashtable columnsNames;
- private const int internalBufferSize = 100;
- private IntPtr internalBuffer;
- internal DB2Connection db2Conn;
- internal DB2Command db2Comm;
- internal IntPtr hwndStmt;
- private int recordsAffected;
- private bool hasData;
- private int fieldCount = -1;
- private CommandBehavior behavior;
- private bool hasRows;
- private bool skipReadOnce;
+ private object[] _resultSet;\r
+ private ColumnInfo[] columnInfo;\r
+ private Hashtable columnsNames;\r
+ private const int internalBufferSize = 100;\r
+ private IntPtr internalBuffer;\r
+ internal DB2Connection db2Conn; \r
+ internal DB2Command db2Comm; \r
+ internal IntPtr hwndStmt;\r
+ private int recordsAffected;\r
+ private bool hasData = false;\r
+ private int fieldCount = -1;\r
+ private CommandBehavior behavior;\r
+ private bool hasRows;\r
+ private bool skipReadOnce;\r
- #region Constructors and destructors
- /// <summary>
- ///
- /// </summary>
- /// <param name="con"></Connection object to Db2>
- /// <param name="com"></Command object>
- internal DB2DataReader(DB2Connection con, DB2Command com, CommandBehavior behavior)
- {
- db2Conn = con;
- db2Comm = com;
- this.behavior = behavior;
- hwndStmt = com.statementHandle; //We have access to the results through the statement handle
-
- _resultSet = null;
-
- GetFieldCountAndAffectedRows();
- internalBuffer = Marshal.AllocHGlobal(internalBufferSize);
-
- isClosed = false;
- }
-
- #endregion
-
- private void GetFieldCountAndAffectedRows()
- {
- short sqlRet;
- recordsAffected = -1;
- if((behavior & CommandBehavior.SchemaOnly) == 0)
- {
- //How many rows affected. numRows will be -1 if we aren't dealing with an Insert, Delete or Update, or if the statement did not execute successfully
- sqlRet = DB2CLIWrapper.SQLRowCount(hwndStmt, out recordsAffected);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);
- }
- short colCount;
- sqlRet = DB2CLIWrapper.SQLNumResultCols(hwndStmt, out colCount);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLNumResultCols", db2Conn);
- fieldCount = colCount;
+ #region Constructors and destructors\r
+ /// <summary>\r
+ /// \r
+ /// </summary>\r
+ /// <param name="con"></Connection object to Db2>\r
+ /// <param name="com"></Command object>\r
+ internal DB2DataReader(DB2Connection con, DB2Command com, CommandBehavior behavior)\r
+ {\r
+ db2Conn = con;\r
+ db2Comm = com;\r
+ this.behavior = behavior;\r
+ hwndStmt = com.statementHandle; //We have access to the results through the statement handle\r
+ \r
+ _resultSet = null;\r
+ \r
+ GetFieldCountAndAffectedRows();\r
+ internalBuffer = Marshal.AllocHGlobal(internalBufferSize);\r
+\r
+ isClosed = false;\r
+ }\r
+\r
+ #endregion\r
+
+ private void GetFieldCountAndAffectedRows()\r
+ {\r
+ short sqlRet;\r
+ recordsAffected = -1;\r
+ if((behavior & CommandBehavior.SchemaOnly) == 0)\r
+ {\r
+ //How many rows affected. numRows will be -1 if we aren't dealing with an Insert, Delete or Update, or if the statement did not execute successfully\r
+ sqlRet = DB2CLIWrapper.SQLRowCount(hwndStmt, out recordsAffected);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "SQLExecDirect error.", db2Conn);\r
+ } \r
+ short colCount;\r
+ sqlRet = DB2CLIWrapper.SQLNumResultCols(hwndStmt, out colCount);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLNumResultCols", db2Conn);\r
+ fieldCount = colCount;\r
}
#region Properties
{
get
{
- if(isClosed)
- {
- throw new InvalidOperationException("Reader is closed");
+ if(isClosed)\r
+ {\r
+ throw new InvalidOperationException("Reader is closed");\r
}
return depth;
}
- #region Close method
-
- public void Close()
- {
- Dispose();
- }
-
- public void Dispose()
- {
- Dispose(true);
- GC.SuppressFinalize(this);
- }
-
- void Dispose(bool disposing)
- {
- if(!isClosed)
- {
- if(disposing)
- {
- short sqlRet;
- do
- {
- sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);
- } while(sqlRet != DB2Constants.SQL_NO_DATA_FOUND);
-
- _resultSet = null;
- hasData = false;
- isClosed=true;
-
- if(db2Comm != null)
- {
- db2Comm.DataReaderClosed();
- db2Comm = null;
- }
- }
- Marshal.FreeHGlobal(internalBuffer);
- }
- isClosed = true;
- }
-
- ~DB2DataReader()
- {
- Dispose(false);
- }
-
+ #region Close method\r
+\r
+ public void Close()\r
+ {\r
+ Dispose();\r
+ }\r
+\r
+ public void Dispose()\r
+ {\r
+ Dispose(true);\r
+ GC.SuppressFinalize(this);\r
+ }\r
+\r
+ void Dispose(bool disposing)\r
+ {\r
+ if(!isClosed) \r
+ {\r
+ if(disposing)\r
+ {\r
+ short sqlRet;\r
+ do\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);\r
+ } while(sqlRet != DB2Constants.SQL_NO_DATA_FOUND);\r
+\r
+ _resultSet = null;\r
+ hasData = false;\r
+ isClosed=true;\r
+\r
+ if(db2Comm != null)\r
+ {\r
+ db2Comm.DataReaderClosed();\r
+ db2Comm = null;\r
+ }\r
+ }\r
+ Marshal.FreeHGlobal(internalBuffer);\r
+ }\r
+ isClosed = true;\r
+ }\r
+\r
+ ~DB2DataReader()\r
+ {\r
+ Dispose(false);\r
+ }\r
+\r
#endregion
#region GetSchemaTable
- public DataTable GetSchemaTable()
- {
- if(isClosed)
- {
- throw new InvalidOperationException("No data exists for the row/column.");
- }
-
- DataTable _schemaTable = BuildNewSchemaTable();
-
- short sqlRet;
- IntPtr ptrCharacterAttribute = IntPtr.Zero;
- InitMem(256, ref ptrCharacterAttribute);
- short buflen = 256;
- short strlen = 256;
- int numericattr = 0;
- int colsize;
- string colname;
- int sqltype;
- int precision;
- int scale;
- int nullable;
- int updatable;
- int isautoincrement;
- string baseschemaname;
- //string basecatalogname;
- string basetablename;
- string basecolumnname;
-
- string previousTableName = null;
- string previousSchemaName = null;
- bool differentTablesUsed = false;
-
- for (short i=1; i<=fieldCount; i++)
- {
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- colname = Marshal.PtrToStringUni(ptrCharacterAttribute);
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_CONCISE_TYPE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- sqltype = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_OCTET_LENGTH, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- colsize = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_PRECISION, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- precision = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCALE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- scale = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_NULLABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- nullable = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_UPDATABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- updatable = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_AUTO_UNIQUE_VALUE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- isautoincrement = numericattr;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- basecolumnname = Marshal.PtrToStringUni(ptrCharacterAttribute);
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_TABLE_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- basetablename = Marshal.PtrToStringUni(ptrCharacterAttribute);
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCHEMA_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);
- baseschemaname = Marshal.PtrToStringUni(ptrCharacterAttribute);
- DataRow r = _schemaTable.NewRow();
-
-
- r["ColumnName"] = colname;
- r["ColumnOrdinal"] = i - 1;
- r["ColumnSize"] = colsize;
- r["NumericPrecision"] = precision;
- r["NumericScale"] = scale;
- r["DataType"] = GetManagedType((short)sqltype);
- r["ProviderType"] = sqltype;
- r["IsLong"] = IsLong((short)sqltype);
- r["AllowDBNull"] = (nullable==0) ? false : true;
- r["IsReadOnly"] = (basecolumnname == null) || (basecolumnname == "");
- r["IsRowVersion"] = false;
- r["IsUnique"] = false;
- r["IsKeyColumn"] = false;
- r["IsAutoIncrement"] = (isautoincrement==0) ? false : true;
- r["BaseSchemaName"] = baseschemaname;
- r["BaseCatalogName"] = "";
- r["BaseTableName"] = basetablename;
- r["BaseColumnName"] = basecolumnname;
-
-
- _schemaTable.Rows.Add(r);
-
-
- if(!differentTablesUsed)
- {
- if(((previousSchemaName == baseschemaname) && (previousTableName == basetablename)) ||
- (previousTableName == null))
- {
- previousTableName = basetablename;
- previousSchemaName = baseschemaname;
- }
- else
- {
- differentTablesUsed = true;
- }
- }
- }
- if(!differentTablesUsed &&
- ((behavior & CommandBehavior.KeyInfo) != 0) &&
- (db2Comm.Transaction == null) &&
- (previousTableName != null) &&
- (previousTableName != ""))
- {
- DB2Command schemaInfoCommand = db2Conn.CreateCommand();
- schemaInfoCommand.CommandText =
- "select concat(concat(INDSCHEMA,'.'),INDNAME), COLNAMES, UNIQUERULE from syscat.INDEXES " +
- "where TABSCHEMA=? and TABNAME=? and uniquerule in ('P','U') order by UNIQUERULE";
- schemaInfoCommand.Parameters.Add("TABSCHEMA", previousSchemaName);
- schemaInfoCommand.Parameters.Add("TABNAME", previousTableName);
- using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())
- {
- bool keyColumnSet = false;
- while(reader.Read())
- {
- string indexName = reader.GetString(0);
- string[] indexColumns = reader.GetString(1).TrimStart('-', '+').Split('-', '+');
- bool primary = reader.GetString(2) == "P";
-
- bool allColumnsFound = true;
- for(int i= 0; i < indexColumns.Length; i++)
- {
- int ordinal = FieldNameLookup(_schemaTable, indexColumns[i]);
- if(ordinal < 0)
- {
- allColumnsFound = false;
- break;
- }
- if(indexColumns.Length == 1)
- _schemaTable.Rows[ordinal]["IsUnique"] = true;
- }
- if(allColumnsFound && !keyColumnSet)
- {
- for(int i= 0; i < indexColumns.Length; i++)
- _schemaTable.Rows[FieldNameLookup(_schemaTable, indexColumns[i])]["IsKeyColumn"] = true;
- keyColumnSet = true;
- }
- }
- }
- if(db2Conn.openConnection.MajorVersion >= 8)
- {
- try
- {
- schemaInfoCommand.CommandText =
- "select COLNAME from SYSCAT.COLIDENTATTRIBUTES where TABSCHEMA=? and TABNAME=?";
- using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())
- {
- while(reader.Read())
- {
- string columnName = reader.GetString(0);
-
- int ordinal = FieldNameLookup(_schemaTable, columnName);
- if(ordinal >= 0)
- _schemaTable.Rows[ordinal]["IsAutoIncrement"] = true;
- }
- }
- }
- catch{}
- }
- }
- return _schemaTable;
+ public DataTable GetSchemaTable()\r
+ {\r
+ if(isClosed)\r
+ {\r
+ throw new InvalidOperationException("No data exists for the row/column.");\r
+ }\r
+\r
+ DataTable _schemaTable = BuildNewSchemaTable();\r
+ \r
+ short sqlRet;\r
+ IntPtr ptrCharacterAttribute = IntPtr.Zero;\r
+ InitMem(256, ref ptrCharacterAttribute);\r
+ short buflen = 256;\r
+ short strlen = 256;\r
+ int numericattr = 0;\r
+ int colsize;\r
+ string colname;\r
+ int sqltype;\r
+ int precision;\r
+ int scale;\r
+ int nullable;\r
+ int updatable;\r
+ int isautoincrement;\r
+ string baseschemaname;\r
+ //string basecatalogname;\r
+ string basetablename;\r
+ string basecolumnname;\r
+\r
+ string previousTableName = null;\r
+ string previousSchemaName = null;\r
+ bool differentTablesUsed = false;\r
+\r
+ for (short i=1; i<=fieldCount; i++) \r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ colname = Marshal.PtrToStringUni(ptrCharacterAttribute);\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_CONCISE_TYPE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ sqltype = numericattr;\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_OCTET_LENGTH, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ colsize = numericattr;\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_PRECISION, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ precision = numericattr;\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCALE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ scale = numericattr;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_NULLABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ nullable = numericattr;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_UPDATABLE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ updatable = numericattr;\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_AUTO_UNIQUE_VALUE, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ isautoincrement = numericattr;\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ basecolumnname = Marshal.PtrToStringUni(ptrCharacterAttribute);\r
+\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_BASE_TABLE_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ basetablename = Marshal.PtrToStringUni(ptrCharacterAttribute);\r
+ \r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)i, (short)DB2Constants.SQL_DESC_SCHEMA_NAME, ptrCharacterAttribute, buflen, ref strlen, ref numericattr);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable", db2Conn);\r
+ baseschemaname = Marshal.PtrToStringUni(ptrCharacterAttribute);\r
+ DataRow r = _schemaTable.NewRow();\r
+ \r
+ r["ColumnName"] = colname;\r
+ r["ColumnOrdinal"] = i - 1;\r
+ r["ColumnSize"] = colsize;\r
+ r["NumericPrecision"] = precision;\r
+ r["NumericScale"] = scale;\r
+ r["DataType"] = GetManagedType((short)sqltype);\r
+ r["ProviderType"] = sqltype;\r
+ r["IsLong"] = IsLong((short)sqltype);\r
+ r["AllowDBNull"] = (nullable==0) ? false : true;\r
+ r["IsReadOnly"] = (basecolumnname == null) || (basecolumnname == "");\r
+ r["IsRowVersion"] = false;\r
+ r["IsUnique"] = false;\r
+ r["IsKeyColumn"] = false;\r
+ r["IsAutoIncrement"] = (isautoincrement==0) ? false : true;\r
+ r["BaseSchemaName"] = baseschemaname;\r
+ r["BaseCatalogName"] = "";\r
+ r["BaseTableName"] = basetablename;\r
+ r["BaseColumnName"] = basecolumnname;\r
+ \r
+ _schemaTable.Rows.Add(r);\r
+\r
+ if(!differentTablesUsed)\r
+ {\r
+ if(((previousSchemaName == baseschemaname) && (previousTableName == basetablename)) || \r
+ (previousTableName == null))\r
+ {\r
+ previousTableName = basetablename;\r
+ previousSchemaName = baseschemaname;\r
+ }\r
+ else\r
+ {\r
+ differentTablesUsed = true;\r
+ }\r
+ }\r
+ }\r
+ if(!differentTablesUsed && \r
+ ((behavior & CommandBehavior.KeyInfo) != 0) &&\r
+ (db2Comm.Transaction == null) &&\r
+ (previousTableName != null) &&\r
+ (previousTableName != ""))\r
+ {\r
+ DB2Command schemaInfoCommand = db2Conn.CreateCommand();\r
+ schemaInfoCommand.CommandText = \r
+ "select concat(concat(INDSCHEMA,'.'),INDNAME), COLNAMES, UNIQUERULE from syscat.INDEXES " +\r
+ "where TABSCHEMA=? and TABNAME=? and uniquerule in ('P','U') order by UNIQUERULE";\r
+ schemaInfoCommand.Parameters.Add("TABSCHEMA", previousSchemaName);\r
+ schemaInfoCommand.Parameters.Add("TABNAME", previousTableName);\r
+ using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())\r
+ {\r
+ bool keyColumnSet = false;\r
+ while(reader.Read())\r
+ {\r
+ string indexName = reader.GetString(0);\r
+ string[] indexColumns = reader.GetString(1).TrimStart('-', '+').Split('-', '+');\r
+ bool primary = reader.GetString(2) == "P";\r
+\r
+ bool allColumnsFound = true;\r
+ for(int i= 0; i < indexColumns.Length; i++)\r
+ {\r
+ int ordinal = FieldNameLookup(_schemaTable, indexColumns[i]);\r
+ if(ordinal < 0)\r
+ {\r
+ allColumnsFound = false;\r
+ break;\r
+ }\r
+ if(indexColumns.Length == 1)\r
+ _schemaTable.Rows[ordinal]["IsUnique"] = true;\r
+ }\r
+ if(allColumnsFound && !keyColumnSet)\r
+ {\r
+ for(int i= 0; i < indexColumns.Length; i++)\r
+ _schemaTable.Rows[FieldNameLookup(_schemaTable, indexColumns[i])]["IsKeyColumn"] = true;\r
+ keyColumnSet = true;\r
+ }\r
+ }\r
+ }\r
+ if(db2Conn.openConnection.MajorVersion >= 8)\r
+ {\r
+ try\r
+ {\r
+ schemaInfoCommand.CommandText = \r
+ "select COLNAME from SYSCAT.COLIDENTATTRIBUTES where TABSCHEMA=? and TABNAME=?";\r
+ using(DB2DataReader reader = schemaInfoCommand.ExecuteReader())\r
+ {\r
+ while(reader.Read())\r
+ {\r
+ string columnName = reader.GetString(0);\r
+\r
+ int ordinal = FieldNameLookup(_schemaTable, columnName);\r
+ if(ordinal >= 0)\r
+ _schemaTable.Rows[ordinal]["IsAutoIncrement"] = true;\r
+ }\r
+ }\r
+ }\r
+ catch{}\r
+ }\r
+ }\r
+ return _schemaTable;\r
}
#endregion
#region NextResult
- public bool NextResult()
- {
- hasRows = false;
- skipReadOnce = false;
- hasData = false;
- columnInfo = null;
- _resultSet = null;
-
- if((behavior & (CommandBehavior.SchemaOnly | CommandBehavior.SingleResult)) != 0)
- return false;
-
- short sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);
- if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND)
- return false;
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);
- return true;
+ public bool NextResult()\r
+ {\r
+ hasRows = false;\r
+ skipReadOnce = false;\r
+ hasData = false;\r
+ columnInfo = null;\r
+ _resultSet = null;\r
+ \r
+ if((behavior & (CommandBehavior.SchemaOnly | CommandBehavior.SingleResult)) != 0)\r
+ return false;\r
+\r
+ short sqlRet = DB2CLIWrapper.SQLMoreResults(this.hwndStmt);\r
+ if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND) \r
+ return false;\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "Db2ClientDataReader - SQLMoreResults", db2Conn);\r
+ return true;\r
}
#endregion
#region Read
-#if !NET_1_0
- public bool HasRows
- {
- get
- {
- if(hasData)
- return true;
-
- hasRows = Read();
- hasData = false;
- skipReadOnce = true;
- return hasRows;
- }
- }
+#if !NET_1_0\r
+ public bool HasRows\r
+ {\r
+ get\r
+ {\r
+ if(hasData)\r
+ return true;\r
+\r
+ hasRows = Read();\r
+ hasData = false;\r
+ skipReadOnce = true;\r
+ return hasRows;\r
+ }\r
+ }\r
#endif
- public bool Read()
- {
- if (isClosed)
- throw new InvalidOperationException("Reader is closed");
- if((behavior & CommandBehavior.SchemaOnly) != 0)
- return false;
-
- if(skipReadOnce)
- {
- skipReadOnce = false;
- hasData = hasRows;
- return hasRows;
- }
-
- _resultSet = null;
- hasData = false;
-
- short sqlRet = DB2CLIWrapper.SQLFetch(hwndStmt);
- if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND)
- return false;
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLFetch 1", db2Conn);
-
- hasData = true;
- return true;
+ public bool Read()\r
+ {\r
+ if (isClosed)\r
+ throw new InvalidOperationException("Reader is closed");\r
+ if((behavior & CommandBehavior.SchemaOnly) != 0)\r
+ return false;\r
+\r
+ if(skipReadOnce)\r
+ {\r
+ skipReadOnce = false;\r
+ hasData = hasRows;\r
+ return hasRows;\r
+ }\r
+\r
+ _resultSet = null;\r
+ hasData = false;\r
+\r
+ short sqlRet = DB2CLIWrapper.SQLFetch(hwndStmt);\r
+ if(sqlRet == DB2Constants.SQL_NO_DATA_FOUND)\r
+ return false;\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "DB2ClientDataReader - SQLFetch 1", db2Conn);\r
+\r
+ hasData = true;\r
+ return true;\r
}
#endregion
#region GetColumnInfo
- private void GetColumnInfo()
- {
- if(isClosed)
- throw new InvalidOperationException("Reader is closed");
- if(fieldCount <= 0)
- throw new InvalidOperationException("No Fields found"); // TODO: check error
- if(columnInfo != null)
- return;
-
- columnInfo = new ColumnInfo[fieldCount];
- columnsNames = new Hashtable(fieldCount);
-
- StringBuilder sb = new StringBuilder(400);
- for(int i = 0; i < columnInfo.Length; i++)
- {
- short sqlRet;
- short strlen;
- int numericAttribute;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, sb, (short)sb.Capacity, out strlen, out numericAttribute);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");
- columnInfo[i].Colname = sb.ToString();
- columnsNames[columnInfo[i].Colname.ToUpper()] = i;
-
- sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_CONCISE_TYPE, sb, (short)sb.Capacity, out strlen, out columnInfo[i].Sqltype);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");
-
-
- }
+ private void GetColumnInfo()\r
+ {\r
+ if(isClosed)\r
+ throw new InvalidOperationException("Reader is closed");\r
+ if(fieldCount <= 0)\r
+ throw new InvalidOperationException("No Fields found"); // TODO: check error\r
+ if(columnInfo != null)\r
+ return;\r
+ \r
+ columnInfo = new ColumnInfo[fieldCount];\r
+ columnsNames = new Hashtable(fieldCount);\r
+ \r
+ StringBuilder sb = new StringBuilder(400);\r
+ for(int i = 0; i < columnInfo.Length; i++)\r
+ {\r
+ short sqlRet;\r
+ short strlen;\r
+ int numericAttribute;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_BASE_COLUMN_NAME, sb, (short)sb.Capacity, out strlen, out numericAttribute);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");\r
+ columnInfo[i].Colname = sb.ToString();\r
+ columnsNames[columnInfo[i].Colname.ToUpper()] = i;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLColAttribute(hwndStmt, (short)(i + 1), (short)DB2Constants.SQL_DESC_CONCISE_TYPE, sb, (short)sb.Capacity, out strlen, out columnInfo[i].Sqltype);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_STMT, hwndStmt, "GetSchemaTable");\r
+\r
+\r
+ }\r
}
#endregion
/// <param name="dbVals"></param>
/// <param name="sqlLen_or_IndPtr"></param>
/// <param name="_resultSet"></param>
- private int FieldNameLookup(DataTable _schemaTable, string name)
- {
- for(int i = 0; i < _schemaTable.Rows.Count; i++)
- {
- if(CultureInfo.CurrentCulture.CompareInfo.Compare(name, (string)_schemaTable.Rows[i]["BaseColumnName"],
- CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase) == 0)
- {
- return i;
- }
- }
- return -1;
+ private int FieldNameLookup(DataTable _schemaTable, string name)\r
+ {\r
+ for(int i = 0; i < _schemaTable.Rows.Count; i++)\r
+ {\r
+ if(CultureInfo.CurrentCulture.CompareInfo.Compare(name, (string)_schemaTable.Rows[i]["BaseColumnName"],\r
+ CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase) == 0)\r
+ {\r
+ return i;\r
+ }\r
+ }\r
+ return -1;\r
}
#endregion
#region FieldCount
///
///
- public int FieldCount
- {
- get
- {
- if (isClosed)
- throw new InvalidOperationException("Reader is closed");
-
- return fieldCount;
- }
+ public int FieldCount\r
+ {\r
+ get\r
+ {\r
+ if (isClosed)\r
+ throw new InvalidOperationException("Reader is closed");\r
+\r
+ return fieldCount;\r
+ }\r
}
#endregion
#region Item accessors
- public object this[string name]
- {
- get
- {
- int ordinal = GetOrdinal(name);
- return this[ordinal];
- }
- }
- public object this[int col]
- {
- get
- {
- if(columnInfo == null)
- {
- GetColumnInfo();
- }
- switch(columnInfo[col].Sqltype)
- {
- case DB2Constants.SQL_INTEGER:
- return GetInt32Internal(col);
- case DB2Constants.SQL_SMALLINT:
- return GetInt16Internal(col);
- case DB2Constants.SQL_BIGINT:
- return GetInt64Internal(col);
- case DB2Constants.SQL_DOUBLE:
- return GetDoubleInternal(col);
- case DB2Constants.SQL_REAL:
- return GetFloatInternal(col);
- case DB2Constants.SQL_DECIMAL:
- return GetDecimalInternal(col);
- case DB2Constants.SQL_DATETIME:
- case DB2Constants.SQL_TYPE_TIMESTAMP:
- return GetDateTimeInternal(col);
- case DB2Constants.SQL_TYPE_DATE:
- return GetDateInternal(col);
- case DB2Constants.SQL_TYPE_TIME:
- return GetTimeInternal(col);
- case DB2Constants.SQL_TYPE_CLOB:
- case DB2Constants.SQL_CHAR:
- case DB2Constants.SQL_VARCHAR:
- return GetStringInternal(col);
- case DB2Constants.SQL_TYPE_BLOB:
- case DB2Constants.SQL_TYPE_BINARY:
- case DB2Constants.SQL_LONGVARBINARY:
- case DB2Constants.SQL_VARBINARY:
- return GetBlobDataInternal(col);
- }
- throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);
- }
+ public object this[string name]\r
+ {\r
+ get\r
+ {\r
+ int ordinal = GetOrdinal(name);\r
+ return this[ordinal];\r
+ }\r
+ }\r
+ public object this[int col]\r
+ {\r
+ get\r
+ {\r
+ if(columnInfo == null)\r
+ {\r
+ GetColumnInfo();\r
+ }\r
+ switch(columnInfo[col].Sqltype)\r
+ {\r
+ case DB2Constants.SQL_INTEGER:\r
+ return GetInt32Internal(col);\r
+ case DB2Constants.SQL_SMALLINT:\r
+ return GetInt16Internal(col);\r
+ case DB2Constants.SQL_BIGINT:\r
+ return GetInt64Internal(col);\r
+ case DB2Constants.SQL_DOUBLE:\r
+ return GetDoubleInternal(col);\r
+ case DB2Constants.SQL_REAL:\r
+ return GetFloatInternal(col);\r
+ case DB2Constants.SQL_DECIMAL:\r
+ return GetDecimalInternal(col);\r
+ case DB2Constants.SQL_DATETIME:\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ return GetDateTimeInternal(col);\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ return GetDateInternal(col);\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ return GetTimeInternal(col);\r
+ case DB2Constants.SQL_TYPE_CLOB:\r
+ case DB2Constants.SQL_CHAR:\r
+ case DB2Constants.SQL_VARCHAR:\r
+ return GetStringInternal(col);\r
+ case DB2Constants.SQL_TYPE_BLOB:\r
+ case DB2Constants.SQL_TYPE_BINARY:\r
+ case DB2Constants.SQL_LONGVARBINARY:\r
+ case DB2Constants.SQL_VARBINARY:\r
+ return GetBlobDataInternal(col);\r
+ }\r
+ throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);\r
+ }\r
}
#endregion
- #region GetBytes
- ///
- /// GetBytes, return a stream of bytes
- ///
- public long GetBytes(int col, long fieldOffset, byte[] buffer, int bufferOffset, int length)
- {
- // TODO: need better implementation for big BLOBs
-
- byte[] sourceArray = (byte[])this[col];
-#if NET_1_0
- if(buffer == null)
- {
- Array.Copy(sourceArray, (int)fieldOffset, buffer, bufferOffset, length);
- }
- return sourceArray.Length;
-#else
- if(buffer == null)
- {
- Array.Copy(sourceArray, fieldOffset, buffer, bufferOffset, length);
- }
- return sourceArray.LongLength;
-#endif
- }
+ #region GetBytes\r
+ ///\r
+ /// GetBytes, return a stream of bytes\r
+ ///\r
+ public long GetBytes(int col, long fieldOffset, byte[] buffer, int bufferOffset, int length)\r
+ {\r
+ // TODO: need better implementation for big BLOBs\r
+\r
+ byte[] sourceArray = (byte[])this[col];\r
+#if NET_1_0\r
+ if(buffer == null)\r
+ {\r
+ Array.Copy(sourceArray, (int)fieldOffset, buffer, bufferOffset, length);\r
+ }\r
+ return sourceArray.Length;\r
+#else\r
+ if(buffer == null)\r
+ {\r
+ Array.Copy(sourceArray, fieldOffset, buffer, bufferOffset, length);\r
+ }\r
+ return sourceArray.LongLength;\r
+#endif\r
+ }\r
#endregion
- #region GetChars
- ///
- ///GetChars, returns char array
- ///
- public long GetChars(int col, long fieldOffset, char[] buffer, int bufferOffset, int length)
- {
- // TODO: need better implementation for big CLOBs
-
- string sourceString = GetString(col);
- if(buffer == null)
- {
- sourceString.CopyTo((int)fieldOffset, buffer, bufferOffset, length);
- }
- return (long)sourceString.Length;
- }
+ #region GetChars\r
+ ///\r
+ ///GetChars, returns char array\r
+ ///\r
+ public long GetChars(int col, long fieldOffset, char[] buffer, int bufferOffset, int length)\r
+ {\r
+ // TODO: need better implementation for big CLOBs\r
+\r
+ string sourceString = GetString(col);\r
+ if(buffer == null)\r
+ {\r
+ sourceString.CopyTo((int)fieldOffset, buffer, bufferOffset, length);\r
+ }\r
+ return (long)sourceString.Length;\r
+ }\r
#endregion
#region GetBoolean method
- public Boolean GetBoolean(int col)
- {
- return (Boolean)GetBooleanInternal(col);
- }
- internal object GetBooleanInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_BIT, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.ReadByte(internalBuffer) != 0;
- }
- }
- return _resultSet[col];
+ public Boolean GetBoolean(int col)\r
+ {\r
+ return (Boolean)GetBooleanInternal(col);\r
+ }\r
+ internal object GetBooleanInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_BIT, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.ReadByte(internalBuffer) != 0;\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
- #region GetGuid
- ///
- /// GetDateTime method
- ///
- public Guid GetGuid(int col)
- {
- return (Guid)GetGuidInternal(col);
- }
- internal object GetGuidInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_GUID, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(Guid));
- }
- }
- return _resultSet[col];
- }
-
+ #region GetGuid\r
+ ///\r
+ /// GetDateTime method\r
+ /// \r
+ public Guid GetGuid(int col)\r
+ {\r
+ return (Guid)GetGuidInternal(col);\r
+ }\r
+ internal object GetGuidInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_GUID, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(Guid)); \r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
+\r
#endregion
#region GetByte
///
///GetByte
///
- public Byte GetByte(int col)
- {
- return (Byte)GetByteInternal(col);
- }
- internal object GetByteInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_UTINYINT, internalBuffer, 10, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.ReadByte(internalBuffer);
- }
- }
- return _resultSet[col];
+ public Byte GetByte(int col)\r
+ {\r
+ return (Byte)GetByteInternal(col);\r
+ }\r
+ internal object GetByteInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_UTINYINT, internalBuffer, 10, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.ReadByte(internalBuffer);\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
///
///GetChar, return column as a char
///
- public Char GetChar(int col)
- {
- return (Char)GetCharInternal(col);
- }
- internal object GetCharInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_WCHAR, internalBuffer, 10, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(char));
- }
- }
- return _resultSet[col];
+ public Char GetChar(int col)\r
+ {\r
+ return (Char)GetCharInternal(col);\r
+ }\r
+ internal object GetCharInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_WCHAR, internalBuffer, 10, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(char));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
///
///GetDataTypeName return the type of data
///
- public string GetDataTypeName(int col)
- {
- if(columnInfo == null)
- {
- GetColumnInfo();
- }
- switch(columnInfo[col].Sqltype)
- {
- case DB2Constants.SQL_INTEGER:
- return "INTEGER";
- case DB2Constants.SQL_SMALLINT:
- return "SMALLINT";
- case DB2Constants.SQL_BIGINT:
- return "BIGINT";
- case DB2Constants.SQL_DOUBLE:
- return "DOUBLE";
- case DB2Constants.SQL_REAL:
- return "REAL";
- case DB2Constants.SQL_DECIMAL:
- return "DECIMAL";
- case DB2Constants.SQL_DATETIME:
- return "DATETIME";
- case DB2Constants.SQL_TYPE_TIMESTAMP:
- return "TIMESTAMP";
- case DB2Constants.SQL_TYPE_DATE:
- return "DATE";
- case DB2Constants.SQL_TYPE_TIME:
- return "TIME";
- case DB2Constants.SQL_TYPE_CLOB:
- return "CLOB";
- case DB2Constants.SQL_CHAR:
- return "CHAR";
- case DB2Constants.SQL_VARCHAR:
- return "VARCHAR";
- case DB2Constants.SQL_TYPE_BLOB:
- return "BLOB";
- case DB2Constants.SQL_TYPE_BINARY:
- return "BINARY";
- case DB2Constants.SQL_LONGVARBINARY:
- return "LONGVARBINARY";
- case DB2Constants.SQL_VARBINARY:
- return "VARBINARY";
- }
- throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);
+ public string GetDataTypeName(int col)\r
+ {\r
+ if(columnInfo == null)\r
+ {\r
+ GetColumnInfo();\r
+ }\r
+ switch(columnInfo[col].Sqltype)\r
+ {\r
+ case DB2Constants.SQL_INTEGER:\r
+ return "INTEGER";\r
+ case DB2Constants.SQL_SMALLINT:\r
+ return "SMALLINT";\r
+ case DB2Constants.SQL_BIGINT:\r
+ return "BIGINT";\r
+ case DB2Constants.SQL_DOUBLE:\r
+ return "DOUBLE";\r
+ case DB2Constants.SQL_REAL:\r
+ return "REAL";\r
+ case DB2Constants.SQL_DECIMAL:\r
+ return "DECIMAL";\r
+ case DB2Constants.SQL_DATETIME:\r
+ return "DATETIME";\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ return "TIMESTAMP";\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ return "DATE";\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ return "TIME";\r
+ case DB2Constants.SQL_TYPE_CLOB:\r
+ return "CLOB";\r
+ case DB2Constants.SQL_CHAR:\r
+ return "CHAR";\r
+ case DB2Constants.SQL_VARCHAR:\r
+ return "VARCHAR";\r
+ case DB2Constants.SQL_TYPE_BLOB:\r
+ return "BLOB";\r
+ case DB2Constants.SQL_TYPE_BINARY:\r
+ return "BINARY";\r
+ case DB2Constants.SQL_LONGVARBINARY:\r
+ return "LONGVARBINARY";\r
+ case DB2Constants.SQL_VARBINARY:\r
+ return "VARBINARY";\r
+ }\r
+ throw new NotImplementedException("Unknown SQL type " + columnInfo[col].Sqltype);\r
}
#endregion
/// GetDateTime method
///
- public DateTime GetDateTime(int col)
- {
- return (DateTime)GetDateTimeInternal(col);
- }
- internal object GetDateTimeInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIMESTAMP, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- DateTime ret = new DateTime(
- Marshal.ReadInt16(internalBuffer, 0), // year
- Marshal.ReadInt16(internalBuffer, 2), // month
- Marshal.ReadInt16(internalBuffer, 4), // day
- Marshal.ReadInt16(internalBuffer, 6), // hour
- Marshal.ReadInt16(internalBuffer, 8), // minute
- Marshal.ReadInt16(internalBuffer, 10));// second
- _resultSet[col] = ret.AddTicks(Marshal.ReadInt32(internalBuffer, 12) / 100); // nanoseconds
- }
- }
- return _resultSet[col];
+ public DateTime GetDateTime(int col)\r
+ {\r
+ return (DateTime)GetDateTimeInternal(col);\r
+ }\r
+ internal object GetDateTimeInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIMESTAMP, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ DateTime ret = new DateTime(\r
+ Marshal.ReadInt16(internalBuffer, 0), // year\r
+ Marshal.ReadInt16(internalBuffer, 2), // month\r
+ Marshal.ReadInt16(internalBuffer, 4), // day\r
+ Marshal.ReadInt16(internalBuffer, 6), // hour\r
+ Marshal.ReadInt16(internalBuffer, 8), // minute\r
+ Marshal.ReadInt16(internalBuffer, 10));// second\r
+ _resultSet[col] = ret.AddTicks(Marshal.ReadInt32(internalBuffer, 12) / 100); // nanoseconds \r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
- #region GetDate
- ///
- /// GetDate method
- ///
- public DateTime GetDate(int col)
- {
- return (DateTime)GetDateInternal(col);
- }
- internal object GetDateInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_DATE, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = new DateTime(
- Marshal.ReadInt16(internalBuffer, 0), // year
- Marshal.ReadInt16(internalBuffer, 2), // month
- Marshal.ReadInt16(internalBuffer, 4)); // day
- }
- }
- return _resultSet[col];
- }
-
+ #region GetDate\r
+ ///\r
+ /// GetDate method\r
+ /// \r
+ public DateTime GetDate(int col)\r
+ {\r
+ return (DateTime)GetDateInternal(col);\r
+ }\r
+ internal object GetDateInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_DATE, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = new DateTime(\r
+ Marshal.ReadInt16(internalBuffer, 0), // year\r
+ Marshal.ReadInt16(internalBuffer, 2), // month\r
+ Marshal.ReadInt16(internalBuffer, 4)); // day\r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
+\r
#endregion
- #region GetTime
- ///
- /// GetTime method
- ///
- public TimeSpan GetTimeSpan(int col)
- {
- return (TimeSpan)GetTimeInternal(col);
- }
- public TimeSpan GetTime(int col)
- {
- return (TimeSpan)GetTimeInternal(col);
- }
- internal object GetTimeInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIME, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = new TimeSpan(
- Marshal.ReadInt16(internalBuffer, 0), // Hour
- Marshal.ReadInt16(internalBuffer, 2), // Minute
- Marshal.ReadInt16(internalBuffer, 4)); // Second
- }
- }
- return _resultSet[col];
- }
-
+ #region GetTime\r
+ ///\r
+ /// GetTime method\r
+ /// \r
+ public TimeSpan GetTimeSpan(int col)\r
+ {\r
+ return (TimeSpan)GetTimeInternal(col);\r
+ }\r
+ public TimeSpan GetTime(int col)\r
+ {\r
+ return (TimeSpan)GetTimeInternal(col);\r
+ }\r
+ internal object GetTimeInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_TIME, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = new TimeSpan(\r
+ Marshal.ReadInt16(internalBuffer, 0), // Hour\r
+ Marshal.ReadInt16(internalBuffer, 2), // Minute\r
+ Marshal.ReadInt16(internalBuffer, 4)); // Second\r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
+\r
#endregion
///
///GetDecimal method
///
-
- public Decimal GetDecimal(int col)
- {
- return (Decimal)GetDecimalInternal(col);
- }
- internal object GetDecimalInternal(int col)
- {
- object tmp = GetStringInternal(col);
- if(tmp is string)
- {
- _resultSet[col] = decimal.Parse(((string)_resultSet[col]).Replace(',','.'), // sometimes we get a '.' and sometimes we get a ','
- System.Globalization.CultureInfo.InvariantCulture);
- }
- // if((col < 0) || (col >= fieldCount)) // only works on windows UDB DB2 V8?
- // {
- // throw new IndexOutOfRangeException("col");
- // }
- // if(!hasData)
- // {
- // throw new InvalidOperationException("No data");
- // }
- // if(_resultSet == null)
- // {
- // _resultSet = new object[fieldCount];
- // }
- // if(_resultSet[col] == null)
- // {
- // int len;
- // short sqlRet = Db2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)Db2Constants.SQL_C_DECIMAL_OLEDB, internalBuffer, internalBufferSize, out len);
- // if(len == Db2Constants.SQL_NULL_DATA)
- // {
- // _resultSet[col] = DBNull.Value;
- // }
- // else
- // {
- // _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(decimal));
- // }
- // }
- return _resultSet[col];
+\r
+ public Decimal GetDecimal(int col)\r
+ {\r
+ return (Decimal)GetDecimalInternal(col);\r
+ }\r
+ internal object GetDecimalInternal(int col)\r
+ {\r
+ object tmp = GetStringInternal(col);\r
+ if(tmp is string)\r
+ {\r
+ _resultSet[col] = decimal.Parse(((string)_resultSet[col]).Replace(',','.'), // sometimes we get a '.' and sometimes we get a ','\r
+ System.Globalization.CultureInfo.InvariantCulture);\r
+ }\r
+ // if((col < 0) || (col >= fieldCount)) // only works on windows UDB DB2 V8?\r
+ // {\r
+ // throw new IndexOutOfRangeException("col");\r
+ // }\r
+ // if(!hasData)\r
+ // {\r
+ // throw new InvalidOperationException("No data");\r
+ // }\r
+ // if(_resultSet == null)\r
+ // {\r
+ // _resultSet = new object[fieldCount];\r
+ // }\r
+ // if(_resultSet[col] == null)\r
+ // {\r
+ // int len;\r
+ // short sqlRet = Db2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)Db2Constants.SQL_C_DECIMAL_OLEDB, internalBuffer, internalBufferSize, out len);\r
+ // if(len == Db2Constants.SQL_NULL_DATA)\r
+ // {\r
+ // _resultSet[col] = DBNull.Value;\r
+ // }\r
+ // else\r
+ // {\r
+ // _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(decimal));\r
+ // }\r
+ // } \r
+ return _resultSet[col];\r
}
#endregion
///
/// GetDouble
///
- public Double GetDouble(int col)
- {
- return (Double)GetDoubleInternal(col);
- }
- internal object GetDoubleInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_DOUBLE, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(double));
- }
- }
- return _resultSet[col];
+ public Double GetDouble(int col)\r
+ {\r
+ return (Double)GetDoubleInternal(col);\r
+ }\r
+ internal object GetDoubleInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_DOUBLE, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(double));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
///
/// Type GetFieldType
///
- public Type GetFieldType(int col)
- {
- if(columnInfo == null)
- {
- GetColumnInfo();
- }
- return GetManagedType(columnInfo[col].Sqltype);
+ public Type GetFieldType(int col)\r
+ {\r
+ if(columnInfo == null)\r
+ {\r
+ GetColumnInfo();\r
+ }\r
+ return GetManagedType(columnInfo[col].Sqltype);\r
}
#endregion
///
/// GetFloat
///
- public float GetFloat(int col)
- {
- return (float)GetFloatInternal(col);
- }
- internal object GetFloatInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_REAL, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(float));
- }
- }
- return _resultSet[col];
+ public float GetFloat(int col)\r
+ {\r
+ return (float)GetFloatInternal(col);\r
+ }\r
+ internal object GetFloatInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_REAL, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(float));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
///
///GetInt16
///
- public short GetInt16(int col)
- {
- return (short)GetInt16Internal(col);
- }
-
- internal object GetInt16Internal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SSHORT, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(short));
- }
- }
- return _resultSet[col];
- }
- ///
- ///GetInt32
- ///
- public int GetInt32(int col)
- {
- return (int)GetInt32Internal(col);
- }
-
- internal object GetInt32Internal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SLONG, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(int));
- }
- }
- return _resultSet[col];
- }
-
- ///
- ///GetInt64
- ///
- public long GetInt64(int col)
- {
- return (long)GetInt64Internal(col);
- }
-
- internal object GetInt64Internal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int len;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SBIGINT, internalBuffer, internalBufferSize, out len);
- if(len == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(long));
- }
- }
- return _resultSet[col];
- }
+ public short GetInt16(int col)\r
+ {\r
+ return (short)GetInt16Internal(col);\r
+ }\r
+\r
+ internal object GetInt16Internal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SSHORT, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(short));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
+ ///\r
+ ///GetInt32\r
+ ///\r
+ public int GetInt32(int col)\r
+ {\r
+ return (int)GetInt32Internal(col);\r
+ }\r
+\r
+ internal object GetInt32Internal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SLONG, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(int));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
+\r
+ ///\r
+ ///GetInt64\r
+ ///\r
+ public long GetInt64(int col)\r
+ {\r
+ return (long)GetInt64Internal(col);\r
+ }\r
+\r
+ internal object GetInt64Internal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int len;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_SBIGINT, internalBuffer, internalBufferSize, out len);\r
+ if(len == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ _resultSet[col] = Marshal.PtrToStructure(internalBuffer, typeof(long));\r
+ }\r
+ } \r
+ return _resultSet[col];\r
+ }\r
#endregion
///
///GetName, returns the name of the field
///
- public string GetName(int col)
- {
- if(columnInfo == null)
- {
- GetColumnInfo();
- }
- return columnInfo[col].Colname;
+ public string GetName(int col)\r
+ {\r
+ if(columnInfo == null)\r
+ {\r
+ GetColumnInfo();\r
+ }\r
+ return columnInfo[col].Colname;\r
}
#endregion
///
/// GetOrdinal, return the index of the named column
///
- public int GetOrdinal(string name)
- {
- if(columnInfo == null)
- {
- GetColumnInfo();
- }
- object ordinal = columnsNames[name.ToUpper()];
- if(ordinal == null)
- {
- throw new IndexOutOfRangeException("name");
- }
- return (int)ordinal;
+ public int GetOrdinal(string name)\r
+ {\r
+ if(columnInfo == null)\r
+ {\r
+ GetColumnInfo();\r
+ }\r
+ object ordinal = columnsNames[name.ToUpper()];\r
+ if(ordinal == null)\r
+ {\r
+ throw new IndexOutOfRangeException("name");\r
+ }\r
+ return (int)ordinal;\r
}
#endregion
///
/// GetString returns a string
///
- public string GetString(int col)
- {
- return (string)GetStringInternal(col);
- }
-
- public object GetStringInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int length;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, (StringBuilder)null, 0, out length);
- if(length == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- IntPtr mem = Marshal.AllocHGlobal(length + 2);
- sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, mem, length + 2, out length);
- _resultSet[col] = Marshal.PtrToStringUni(mem);
- Marshal.FreeHGlobal(mem);
- }
- }
- return _resultSet[col];
+ public string GetString(int col)\r
+ {\r
+ return (string)GetStringInternal(col);\r
+ }\r
+\r
+ public object GetStringInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int length;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, (StringBuilder)null, 0, out length);\r
+ if(length == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ IntPtr mem = Marshal.AllocHGlobal(length + 2);\r
+ sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_WCHAR, mem, length + 2, out length);\r
+ _resultSet[col] = Marshal.PtrToStringUni(mem);\r
+ Marshal.FreeHGlobal(mem);\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
#endregion
///
/// GetValues returns all columns in the row through the argument, and the number of columns in the return value
///
- public int GetValues(object[] values)
- {
- int count = Math.Min(fieldCount, values.Length);
-
- for (int i = 0; i < count; i++)
- {
- values[i] = this[i];
-
- }
-
- return count;
+ public int GetValues(object[] values)\r
+ {\r
+ int count = Math.Min(fieldCount, values.Length);\r
+\r
+ for (int i = 0; i < count; i++)\r
+ {\r
+ values[i] = this[i];\r
+ \r
+ }\r
+ \r
+ return count;\r
}
#endregion
///
/// IsDBNull Is the column null
///
- public bool IsDBNull(int col)
- {
- //Proper implementation once I get the SQLDescribe/SQLBind/SQLFetch stuff in place
- return Convert.IsDBNull(this[col]);
+ public bool IsDBNull(int col)\r
+ {\r
+ //Proper implementation once I get the SQLDescribe/SQLBind/SQLFetch stuff in place\r
+ return Convert.IsDBNull(this[col]);\r
}
#endregion
#region private methods
- private DataTable BuildNewSchemaTable()
- {
- DataTable schemaTable = new DataTable("SchemaTable");
-
- schemaTable.Columns.Add(new DataColumn("ColumnName", typeof(string)));
- schemaTable.Columns.Add(new DataColumn("ColumnOrdinal", typeof(int)));
- schemaTable.Columns.Add(new DataColumn("ColumnSize", typeof(int)));
- schemaTable.Columns.Add(new DataColumn("NumericPrecision", typeof(short)));
- schemaTable.Columns.Add(new DataColumn("NumericScale", typeof(short)));
- schemaTable.Columns.Add(new DataColumn("DataType", typeof(System.Type)));
- schemaTable.Columns.Add(new DataColumn("ProviderType", typeof(int)));
- schemaTable.Columns.Add(new DataColumn("IsLong", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("AllowDBNull", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsReadOnly", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsRowVersion", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsUnique", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsKey", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsKeyColumn", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("IsAutoIncrement", typeof(bool)));
- schemaTable.Columns.Add(new DataColumn("BaseSchemaName", typeof(string)));
- schemaTable.Columns.Add(new DataColumn("BaseCatalogName", typeof(string)));
- schemaTable.Columns.Add(new DataColumn("BaseTableName", typeof(string)));
- schemaTable.Columns.Add(new DataColumn("BaseColumnName", typeof(string)));
-
- return schemaTable;
+ private DataTable BuildNewSchemaTable()\r
+ {\r
+ DataTable schemaTable = new DataTable("SchemaTable");\r
+\r
+ schemaTable.Columns.Add(new DataColumn("ColumnName", typeof(string)));\r
+ schemaTable.Columns.Add(new DataColumn("ColumnOrdinal", typeof(int)));\r
+ schemaTable.Columns.Add(new DataColumn("ColumnSize", typeof(int)));\r
+ schemaTable.Columns.Add(new DataColumn("NumericPrecision", typeof(short)));\r
+ schemaTable.Columns.Add(new DataColumn("NumericScale", typeof(short)));\r
+ schemaTable.Columns.Add(new DataColumn("DataType", typeof(System.Type)));\r
+ schemaTable.Columns.Add(new DataColumn("ProviderType", typeof(int)));\r
+ schemaTable.Columns.Add(new DataColumn("IsLong", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("AllowDBNull", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsReadOnly", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsRowVersion", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsUnique", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsKey", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsKeyColumn", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("IsAutoIncrement", typeof(bool)));\r
+ schemaTable.Columns.Add(new DataColumn("BaseSchemaName", typeof(string)));\r
+ schemaTable.Columns.Add(new DataColumn("BaseCatalogName", typeof(string)));\r
+ schemaTable.Columns.Add(new DataColumn("BaseTableName", typeof(string)));\r
+ schemaTable.Columns.Add(new DataColumn("BaseColumnName", typeof(string)));\r
+\r
+ return schemaTable;\r
}
#endregion
}
}
- private Type GetManagedType(int sql_type)
- {
- switch(sql_type)
- {
- case DB2Constants.SQL_INTEGER:
- return typeof(int);
- case DB2Constants.SQL_SMALLINT:
- return typeof(short);
- case DB2Constants.SQL_BIGINT:
- return typeof(long);
- case DB2Constants.SQL_DOUBLE:
- return typeof(double);
- case DB2Constants.SQL_DECIMAL:
- return typeof(decimal);
- case DB2Constants.SQL_DATETIME:
- case DB2Constants.SQL_TYPE_DATE:
- case DB2Constants.SQL_TYPE_TIMESTAMP:
- return typeof(DateTime);
- case DB2Constants.SQL_TYPE_TIME:
- return typeof(TimeSpan);
- case DB2Constants.SQL_CHAR:
- case DB2Constants.SQL_VARCHAR:
- case DB2Constants.SQL_TYPE_CLOB:
- return typeof(string);
- case DB2Constants.SQL_TYPE_BLOB:
- case DB2Constants.SQL_TYPE_BINARY:
- case DB2Constants.SQL_LONGVARBINARY:
- case DB2Constants.SQL_VARBINARY:
- return typeof(byte[]);
- }
- throw new NotImplementedException("Unknown SQL type " + sql_type);
+ private Type GetManagedType(int sql_type)\r
+ {\r
+ switch(sql_type)\r
+ {\r
+ case DB2Constants.SQL_INTEGER:\r
+ return typeof(int);\r
+ case DB2Constants.SQL_SMALLINT:\r
+ return typeof(short);\r
+ case DB2Constants.SQL_BIGINT:\r
+ return typeof(long);\r
+ case DB2Constants.SQL_DOUBLE:\r
+ return typeof(double);\r
+ case DB2Constants.SQL_DECIMAL:\r
+ return typeof(decimal);\r
+ case DB2Constants.SQL_DATETIME:\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ return typeof(DateTime);\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ return typeof(TimeSpan);\r
+ case DB2Constants.SQL_CHAR:\r
+ case DB2Constants.SQL_VARCHAR:\r
+ case DB2Constants.SQL_TYPE_CLOB:\r
+ return typeof(string);\r
+ case DB2Constants.SQL_TYPE_BLOB:\r
+ case DB2Constants.SQL_TYPE_BINARY:\r
+ case DB2Constants.SQL_LONGVARBINARY:\r
+ case DB2Constants.SQL_VARBINARY:\r
+ return typeof(byte[]);\r
+ }\r
+ throw new NotImplementedException("Unknown SQL type " + sql_type);\r
}
- private bool IsLong(short sql_type)
- {
- switch(sql_type)
- {
- case DB2Constants.SQL_TYPE_CLOB:
- case DB2Constants.SQL_TYPE_BLOB:
- return true;
- }
- return false;
+ private bool IsLong(short sql_type)\r
+ {\r
+ switch(sql_type)\r
+ {\r
+ case DB2Constants.SQL_TYPE_CLOB:\r
+ case DB2Constants.SQL_TYPE_BLOB:\r
+ return true;\r
+ }\r
+ return false;\r
}
- private object GetBlobDataInternal(int col)
- {
- if((col < 0) || (col >= fieldCount))
- {
- throw new IndexOutOfRangeException("col");
- }
- if(!hasData)
- {
- throw new InvalidOperationException("No data");
- }
- if(_resultSet == null)
- {
- _resultSet = new object[fieldCount];
- }
- if(_resultSet[col] == null)
- {
- int length;
- short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, (StringBuilder)null, 0, out length);
- if(length == DB2Constants.SQL_NULL_DATA)
- {
- _resultSet[col] = DBNull.Value;
- }
- else
- {
- byte[] result = new byte[length];
- sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, result, length, out length);
- _resultSet[col] = result;
- }
- }
- return _resultSet[col];
+ private object GetBlobDataInternal(int col)\r
+ {\r
+ if((col < 0) || (col >= fieldCount))\r
+ {\r
+ throw new IndexOutOfRangeException("col");\r
+ }\r
+ if(!hasData)\r
+ {\r
+ throw new InvalidOperationException("No data");\r
+ }\r
+ if(_resultSet == null)\r
+ {\r
+ _resultSet = new object[fieldCount];\r
+ }\r
+ if(_resultSet[col] == null)\r
+ {\r
+ int length;\r
+ short sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, (StringBuilder)null, 0, out length);\r
+ if(length == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ _resultSet[col] = DBNull.Value;\r
+ }\r
+ else\r
+ {\r
+ byte[] result = new byte[length];\r
+ sqlRet = DB2CLIWrapper.SQLGetData(this.hwndStmt, (short)(col + 1), (short)DB2Constants.SQL_C_TYPE_BINARY, result, length, out length);\r
+ _resultSet[col] = result;\r
+ }\r
+ } \r
+ return _resultSet[col];\r
}
}
--- /dev/null
+using System;\r
+using System.Data;\r
+using System.Runtime.InteropServices;\r
+\r
+namespace IBM.Data.DB2\r
+{\r
+ public delegate void DB2InfoMessageEventHandler(object sender, DB2InfoMessageEventArgs e);\r
+\r
+ public sealed class DB2InfoMessageEventArgs : EventArgs\r
+ {\r
+ private DB2ErrorCollection errors;\r
+\r
+ public DB2InfoMessageEventArgs(DB2ErrorCollection errors)\r
+ {\r
+ this.errors = errors;\r
+ }\r
+\r
+ public DB2ErrorCollection Errors\r
+ {\r
+ get\r
+ {\r
+ return errors;\r
+ }\r
+ }\r
+ public string Message\r
+ {\r
+ get\r
+ {\r
+ if(errors.Count > 0)\r
+ {\r
+ string result = "";\r
+ for(int i = 0; i < errors.Count; i++)\r
+ {\r
+ if(i > 0)\r
+ {\r
+ result += " ";\r
+ }\r
+ result += "INFO [" + errors[i].SQLState + "] " + errors[i].Message;\r
+ }\r
+ return result;\r
+ }\r
+ return "No information";\r
+ }\r
+ }\r
+\r
+ }\r
+}\r
+\r
-using System;
-using System.Collections;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-
-namespace IBM.Data.DB2
-{
-
- internal sealed class DB2OpenConnection : IDisposable
- {
- private IntPtr dbHandle = IntPtr.Zero;
-
- private DB2ConnectionSettings settings;
- private bool disposed = false;
- internal DateTime poolDisposalTime; // time to live used for disposal of connections in the connection pool
- public bool transactionOpen;
- public bool autoCommit = true;
- private string databaseProductName;
- private string databaseVersion;
- private int majorVersion;
- private int minorVersion;
-
- public IntPtr DBHandle
- {
- get { return dbHandle; }
- }
- public string DatabaseProductName
- {
- get { return databaseProductName; }
- }
- public string DatabaseVersion
- {
- get { return databaseVersion; }
- }
- public int MajorVersion
- {
- get { return majorVersion; }
- }
- public int MinorVersion
- {
- get { return minorVersion; }
- }
-
- public DB2OpenConnection(DB2ConnectionSettings settings, DB2Connection connection)
- {
- this.settings = settings;
- try
- {
- short sqlRet = DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_DBC, DB2Environment.Instance.penvHandle, out dbHandle);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, DB2Environment.Instance.penvHandle, "Unable to allocate database handle in DB2Connection.", connection);
-
- if(settings.Server.Length > 0)
- {
- StringBuilder outConnectStr = new StringBuilder(60); // TODO: ????
- short numOutCharsReturned;
-
- sqlRet = DB2CLIWrapper.SQLDriverConnect(dbHandle, IntPtr.Zero,
- settings.ConnectionString, (short)settings.ConnectionString.Length,
- outConnectStr, (short)outConnectStr.Length, out numOutCharsReturned,
- DB2Constants.SQL_DRIVER_NOPROMPT /*SQL_DRIVER_COMPLETE*/);
-
- }
- else
- {
- sqlRet = DB2CLIWrapper.SQLConnect(dbHandle,
- settings.DatabaseAlias, (short)settings.DatabaseAlias.Length,
- settings.UserName, (short)settings.UserName.Length,
- settings.PassWord, (short)settings.PassWord.Length);
- DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, dbHandle, "Unable to connect to the database.", connection);
- }
-
-
-
- if((settings.Pool == null) || (settings.Pool.databaseProductName == null))
- {
- StringBuilder sb = new StringBuilder(256);
- short stringLength;
- sqlRet = DB2CLIWrapper.SQLGetInfo(dbHandle, /*SQL_DBMS_NAME*/17, sb, (short)(sb.Capacity / 2), out stringLength);
- new DB2ErrorCollection(DB2Constants.SQL_HANDLE_DBC, dbHandle).ToString();
-
-
-
- if(sqlRet == 0)
- databaseProductName = sb.ToString(); //(0, Math.Min(sb.Capacity, stringLength / 2));
- sqlRet = DB2CLIWrapper.SQLGetInfo(dbHandle, /*SQL_DBMS_VER*/18, sb, (short)(sb.Capacity / 2), out stringLength);
- if(sqlRet == 0)
- {
- databaseVersion = sb.ToString(0, Math.Min(sb.Capacity, stringLength / 2));
- try
- {
- string[] splitVersion = databaseVersion.Split('.');
- majorVersion = int.Parse(splitVersion[0]);
- minorVersion = int.Parse(splitVersion[1]);
- }
- catch{}
- }
- if(settings.Pool != null)
- {
- settings.Pool.databaseProductName = databaseProductName;
- settings.Pool.databaseVersion = databaseVersion;
- settings.Pool.majorVersion = majorVersion;
- settings.Pool.minorVersion = minorVersion;
- }
- }
- else if(settings.Pool != null)
- {
- if(settings.Pool != null)
- {
- databaseProductName = settings.Pool.databaseProductName;
- databaseVersion = settings.Pool.databaseVersion;
- majorVersion = settings.Pool.majorVersion;
- minorVersion = settings.Pool.minorVersion;
- }
- }
- }
- catch
- {
- if(dbHandle != IntPtr.Zero)
- {
- DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_DBC, dbHandle);
- dbHandle = IntPtr.Zero;
- }
- throw;
- }
- }
-
- public void RollbackDeadTransaction()
- {
- DB2CLIWrapper.SQLEndTran(DB2Constants.SQL_HANDLE_DBC, DBHandle, DB2Constants.SQL_ROLLBACK);
- transactionOpen = false;
- }
-
- public void Close()
- {
- if(transactionOpen)
- RollbackDeadTransaction();
-
- if(settings.Pool != null)
- {
- settings.Pool.AddToFreeConnections(this);
- }
- else
- {
- Dispose();
- }
- }
-
- private void FreeHandles()
- {
- if(dbHandle != IntPtr.Zero)
- {
- short sqlRet = DB2CLIWrapper.SQLDisconnect(dbHandle);
- // Note that SQLDisconnect() automatically drops any statements and
- // descriptors open on the connection.
- sqlRet = DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_DBC, dbHandle);
-
- dbHandle = IntPtr.Zero;
- }
- }
-
- #region IDisposable Members
-
- public void Dispose()
- {
- Dispose(true);
- GC.SuppressFinalize(this);
- }
-
- private void Dispose(bool disposing)
- {
- if(!disposed)
- {
- if(disposing)
- {
- // dispose managed resources
- }
- FreeHandles();
- }
- disposed = true;
- }
-
-
- ~DB2OpenConnection()
- {
- if(settings.Pool != null)
- {
- settings.Pool.OpenConnectionFinalized();
- }
- Dispose(false);
- }
- #endregion
- }
-
-
-}
+using System;\r
+using System.Collections;\r
+using System.Runtime.InteropServices;\r
+using System.Text;\r
+using System.Threading;\r
+\r
+namespace IBM.Data.DB2\r
+{\r
+\r
+ internal sealed class DB2OpenConnection : IDisposable\r
+ {\r
+ private IntPtr dbHandle = IntPtr.Zero;\r
+\r
+ private DB2ConnectionSettings settings;\r
+ private bool disposed = false;\r
+ internal DateTime poolDisposalTime; // time to live used for disposal of connections in the connection pool\r
+ public bool transactionOpen;\r
+ public bool autoCommit = true;\r
+ private string databaseProductName;\r
+ private string databaseVersion;\r
+ private int majorVersion;\r
+ private int minorVersion;\r
+\r
+ public IntPtr DBHandle\r
+ {\r
+ get { return dbHandle; }\r
+ }\r
+ public string DatabaseProductName\r
+ {\r
+ get { return databaseProductName; }\r
+ }\r
+ public string DatabaseVersion\r
+ {\r
+ get { return databaseVersion; }\r
+ }\r
+ public int MajorVersion\r
+ {\r
+ get { return majorVersion; }\r
+ }\r
+ public int MinorVersion\r
+ {\r
+ get { return minorVersion; }\r
+ }\r
+\r
+ public DB2OpenConnection(DB2ConnectionSettings settings, DB2Connection connection)\r
+ {\r
+ this.settings = settings;\r
+ try\r
+ {\r
+ short sqlRet = DB2CLIWrapper.SQLAllocHandle(DB2Constants.SQL_HANDLE_DBC, DB2Environment.Instance.penvHandle, out dbHandle);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, DB2Environment.Instance.penvHandle, "Unable to allocate database handle in DB2Connection.", connection);\r
+\r
+ if(settings.Server.Length > 0)\r
+ {\r
+ StringBuilder outConnectStr = new StringBuilder(60); // TODO: ????\r
+ short numOutCharsReturned;\r
+\r
+ sqlRet = DB2CLIWrapper.SQLDriverConnect(dbHandle, IntPtr.Zero, \r
+ settings.ConnectionString, (short)settings.ConnectionString.Length,\r
+ outConnectStr, (short)outConnectStr.Length, out numOutCharsReturned, \r
+ DB2Constants.SQL_DRIVER_NOPROMPT /*SQL_DRIVER_COMPLETE*/);\r
+ }\r
+ else\r
+ {\r
+ sqlRet = DB2CLIWrapper.SQLConnect(dbHandle, \r
+ settings.DatabaseAlias, (short)settings.DatabaseAlias.Length, \r
+ settings.UserName, (short)settings.UserName.Length,\r
+ settings.PassWord, (short)settings.PassWord.Length);\r
+ DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, dbHandle, "Unable to connect to the database.", connection);\r
+ }\r
+\r
+ if((settings.Pool == null) || (settings.Pool.databaseProductName == null))\r
+ {\r
+ StringBuilder sb = new StringBuilder(256);\r
+ short stringLength;\r
+ sqlRet = DB2CLIWrapper.SQLGetInfo(dbHandle, /*SQL_DBMS_NAME*/17, sb, (short)(sb.Capacity / 2), out stringLength);\r
+ new DB2ErrorCollection(DB2Constants.SQL_HANDLE_DBC, dbHandle).ToString();\r
+ if(sqlRet == 0)\r
+ databaseProductName = sb.ToString(0, Math.Min(sb.Capacity, stringLength / 2));\r
+ sqlRet = DB2CLIWrapper.SQLGetInfo(dbHandle, /*SQL_DBMS_VER*/18, sb, (short)(sb.Capacity / 2), out stringLength);\r
+ if(sqlRet == 0)\r
+ {\r
+ databaseVersion = sb.ToString(0, Math.Min(sb.Capacity, stringLength / 2));\r
+ try\r
+ {\r
+ string[] splitVersion = databaseVersion.Split('.');\r
+ majorVersion = int.Parse(splitVersion[0]);\r
+ minorVersion = int.Parse(splitVersion[1]);\r
+ }\r
+ catch{}\r
+ }\r
+ if(settings.Pool != null)\r
+ {\r
+ settings.Pool.databaseProductName = databaseProductName;\r
+ settings.Pool.databaseVersion = databaseVersion;\r
+ settings.Pool.majorVersion = majorVersion;\r
+ settings.Pool.minorVersion = minorVersion;\r
+ }\r
+ }\r
+ else if(settings.Pool != null)\r
+ {\r
+ if(settings.Pool != null)\r
+ {\r
+ databaseProductName = settings.Pool.databaseProductName;\r
+ databaseVersion = settings.Pool.databaseVersion;\r
+ majorVersion = settings.Pool.majorVersion;\r
+ minorVersion = settings.Pool.minorVersion;\r
+ }\r
+ }\r
+ }\r
+ catch\r
+ {\r
+ if(dbHandle != IntPtr.Zero)\r
+ {\r
+ DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_DBC, dbHandle);\r
+ dbHandle = IntPtr.Zero;\r
+ }\r
+ throw;\r
+ }\r
+ }\r
+\r
+ public void RollbackDeadTransaction()\r
+ {\r
+ DB2CLIWrapper.SQLEndTran(DB2Constants.SQL_HANDLE_DBC, DBHandle, DB2Constants.SQL_ROLLBACK);\r
+ transactionOpen = false;\r
+ }\r
+\r
+ public void Close()\r
+ {\r
+ if(transactionOpen)\r
+ RollbackDeadTransaction();\r
+\r
+ if(settings.Pool != null)\r
+ {\r
+ settings.Pool.AddToFreeConnections(this);\r
+ }\r
+ else\r
+ {\r
+ Dispose();\r
+ }\r
+ }\r
+\r
+ private void FreeHandles()\r
+ {\r
+ if(dbHandle != IntPtr.Zero)\r
+ {\r
+ short sqlRet = DB2CLIWrapper.SQLDisconnect(dbHandle);\r
+ // Note that SQLDisconnect() automatically drops any statements and\r
+ // descriptors open on the connection.\r
+ sqlRet = DB2CLIWrapper.SQLFreeHandle(DB2Constants.SQL_HANDLE_DBC, dbHandle);\r
+\r
+ dbHandle = IntPtr.Zero;\r
+ }\r
+ }\r
+\r
+ #region IDisposable Members\r
+\r
+ public void Dispose()\r
+ {\r
+ Dispose(true);\r
+ GC.SuppressFinalize(this);\r
+ }\r
+\r
+ private void Dispose(bool disposing)\r
+ {\r
+ if(!disposed) \r
+ {\r
+ if(disposing)\r
+ {\r
+ // dispose managed resources\r
+ }\r
+ FreeHandles();\r
+ }\r
+ disposed = true;\r
+ }\r
+\r
+\r
+ ~DB2OpenConnection()\r
+ {\r
+ if(settings.Pool != null)\r
+ {\r
+ settings.Pool.OpenConnectionFinalized();\r
+ }\r
+ Dispose(false);\r
+ }\r
+ #endregion\r
+ }\r
+\r
+\r
+}
\ No newline at end of file
-using System;
-using System.Data;
-using System.Runtime.InteropServices;
-
-namespace IBM.Data.DB2
-{
-
- public sealed class DB2Parameter : MarshalByRefObject, IDbDataParameter, IDataParameter, ICloneable
- {
- private DbType dbType = DbType.Object;
- private DB2Type db2Type = DB2Type.Invalid;
- private short db2DataType = DB2Constants.SQL_UNKNOWN_TYPE;
- private short db2LastUsedDataType = DB2Constants.SQL_UNKNOWN_TYPE;
-
- private ParameterDirection direction;
- private short db2Direction = DB2Constants.SQL_PARAM_INPUT;
- private bool nullable = true;
- private string parameterName;
- private string sourceColumn;
- private DataRowVersion sourceVersion;
- private object dataVal;
- private byte scale, precision;
- private int size;
- internal IntPtr internalBuffer;
- internal IntPtr internalLengthBuffer;
- internal int requiredMemory;
-
- #region Contructors and destructors
- public DB2Parameter()
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- }
-
- public DB2Parameter(string name, DB2Type type)
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- this.ParameterName = name;
- this.DB2Type = type;
- }
-
- public DB2Parameter(string name, DB2Type type, int size)
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- this.ParameterName = name;
- this.DB2Type = type;
- this.Size = size;
- }
-
- public DB2Parameter(string name, DB2Type type, int size, string sourceColumn)
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- this.ParameterName = name;
- this.DB2Type = type;
- this.Size = size;
- this.SourceColumn = sourceColumn;
- }
-
- //only for testing purposes!!!
- public DB2Parameter(string name, short type, int size, string sourceColumn)
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- this.ParameterName = name;
- this.db2DataType = type;
- this.Size = size;
- this.SourceColumn = sourceColumn;
- }
-
- public DB2Parameter(string parameterName, object value)
- {
- direction = ParameterDirection.Input;
- sourceVersion = DataRowVersion.Current;
- this.ParameterName = parameterName;
- this.Value = value;
- }
-
- public DB2Parameter(string parameterName, DB2Type db2Type, int size, ParameterDirection parameterDirection, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value)
- {
- this.ParameterName = parameterName;
- this.DB2Type = db2Type;
- this.Size = size;
- this.Direction = parameterDirection;
- this.IsNullable = isNullable;
- this.Precision = precision;
- this.Scale = scale;
- this.SourceColumn = srcColumn;
- this.SourceVersion = srcVersion;
- this.Value = value;
- }
-
- #endregion
- #region Properties
- #region DbType Property
- public DB2Type DB2Type
- {
- get
- {
- return db2Type;
- }
- set
- {
- db2Type = value;
- switch(db2Type)
- {
- case DB2Type.Invalid: dbType = DbType.Object; db2DataType = DB2Constants.SQL_UNKNOWN_TYPE; break;
- case DB2Type.SmallInt: dbType = DbType.Int16; db2DataType = DB2Constants.SQL_SMALLINT; break;
- case DB2Type.Integer: dbType = DbType.Int32; db2DataType = DB2Constants.SQL_INTEGER; break;
- case DB2Type.BigInt: dbType = DbType.Int64; db2DataType = DB2Constants.SQL_BIGINT; break;
- case DB2Type.Real: dbType = DbType.Single; db2DataType = DB2Constants.SQL_REAL; break;
- case DB2Type.Double: dbType = DbType.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;
- case DB2Type.Float: dbType = DbType.Single; db2DataType = DB2Constants.SQL_REAL; break;
- case DB2Type.Decimal: dbType = DbType.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;
- case DB2Type.Numeric: dbType = DbType.VarNumeric; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Date: dbType = DbType.Date; db2DataType = DB2Constants.SQL_TYPE_DATE; break;
- case DB2Type.Time: dbType = DbType.Time; db2DataType = DB2Constants.SQL_TYPE_TIME; break;
- case DB2Type.Timestamp: dbType = DbType.DateTime; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;
- case DB2Type.Char: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.VarChar: dbType = DbType.StringFixedLength; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.LongVarChar: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Binary: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;
- case DB2Type.VarBinary: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;
- case DB2Type.LongVarBinary: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Graphic: dbType = DbType.StringFixedLength; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.VarGraphic: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.LongVarGraphic: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Clob: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Blob: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;
- case DB2Type.DbClob: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DB2Type.Datalink: dbType = DbType.Byte; db2DataType = DB2Constants.SQL_VARBINARY; break;
- case DB2Type.RowId: dbType = DbType.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;
- case DB2Type.XmlReader: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;
- default:
- throw new NotSupportedException("Value is of unknown data type");
- }
- }
- }
- ///
- /// Parameter data type
- ///
- public DbType DbType
- {
- get
- {
- return dbType;
- }
- set
- {
- dbType = value;
- switch(dbType)
- {
- case DbType.AnsiString: db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DbType.AnsiStringFixedLength: db2Type = DB2Type.Char; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DbType.Binary: db2Type = DB2Type.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;
- case DbType.Boolean: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_BIT; break;
- case DbType.Byte: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;
- case DbType.Currency: db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;
- case DbType.Date: db2Type = DB2Type.Date; db2DataType = DB2Constants.SQL_TYPE_DATE; break;
- case DbType.DateTime: db2Type = DB2Type.Timestamp; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;
- case DbType.Decimal: db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;
- case DbType.Double: db2Type = DB2Type.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;
- case DbType.Guid: db2Type = DB2Type.Binary; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DbType.Int16: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;
- case DbType.Int32: db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;
- case DbType.Int64: db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;
- case DbType.Object: db2Type = DB2Type.Invalid; db2DataType = DB2Constants.SQL_UNKNOWN_TYPE; break;
- case DbType.SByte: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;
- case DbType.Single: db2Type = DB2Type.Float; db2DataType = DB2Constants.SQL_REAL; break;
- case DbType.String: db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DbType.StringFixedLength: db2Type = DB2Type.Char; db2DataType = DB2Constants.SQL_WCHAR; break;
- case DbType.Time: db2Type = DB2Type.Time; db2DataType = DB2Constants.SQL_TYPE_TIME; break;
- case DbType.UInt16: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;
- case DbType.UInt32: db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;
- case DbType.UInt64: db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;
- case DbType.VarNumeric: db2Type = DB2Type.Numeric; db2DataType = DB2Constants.SQL_WCHAR; break;
- default:
- throw new NotSupportedException("Value is of unknown data type");
- }
- }
- }
-
- #endregion
- #region Direction
- ///
- /// In or out parameter, or both
- ///
- public ParameterDirection Direction
- {
- get
- {
- return direction;
- }
- set
- {
- direction = value;
- switch(direction)
- {
- default:
- case ParameterDirection.Input: db2Direction = DB2Constants.SQL_PARAM_INPUT; break;
- case ParameterDirection.Output: db2Direction = DB2Constants.SQL_PARAM_OUTPUT; break;
- case ParameterDirection.InputOutput: db2Direction = DB2Constants.SQL_PARAM_INPUT_OUTPUT; break;
- case ParameterDirection.ReturnValue: db2Direction = DB2Constants.SQL_RETURN_VALUE; break;
- }
- }
- }
- #endregion
- #region IsNullable
- ///
- /// Does this parameter support a null value
- ///
- public bool IsNullable
- {
- get
- {
- return nullable;
- }
- set
- {
- nullable = value;
- }
- }
- #endregion
- #region ParameterName
- public string ParameterName
- {
- get
- {
- return parameterName;
- }
- set
- {
- parameterName = value;
- }
- }
- #endregion
- #region SourceColumn
- ///
- /// Gets or sets the name of the source column that is mapped to the DataSet
- ///
- public string SourceColumn
- {
- get
- {
- return sourceColumn;
- }
- set
- {
- sourceColumn = value;
- }
- }
- #endregion
- #region SourceVersion
- ///
- /// DataRowVersion property
- ///
- public DataRowVersion SourceVersion
- {
- get
- {
- return sourceVersion;
- }
- set
- {
- sourceVersion = value;
- }
- }
- #endregion
- #region IDbDataParameter properties
- public byte Precision
- {
- get
- {
- return precision;
- }
- set
- {
- precision = value;
- }
- }
-
- public byte Scale
- {
- get
- {
- return scale;
- }
- set
- {
- scale = value;
- }
- }
-
- public int Size
- {
- get
- {
- return size;
- }
- set
- {
- size = value;
- }
- }
- #endregion
- #region Value
- ///
- /// The actual parameter data
- ///
- public object Value
- {
- get
- {
- return dataVal;
- }
- set
- {
- this.dataVal = value;
- }
- }
- #endregion
- #endregion
- #region inferType Method
- /// <summary>
- /// Determine the data type based on the value
- /// </summary>
- private void InferType()
- {
- if(Value == null)
- throw new ArgumentException("No DB2Parameter.Value found");
-
- if(Value is IConvertible)
- {
- switch(((IConvertible)Value).GetTypeCode())
- {
- case TypeCode.Char: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_WCHAR; break;
- case TypeCode.Boolean: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_BIT; break;
- case TypeCode.SByte:
- case TypeCode.Byte: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;
- case TypeCode.UInt16:
- case TypeCode.Int16: dbType = DbType.Int16; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;
- case TypeCode.UInt32:
- case TypeCode.Int32: dbType = DbType.Int32; db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;
- case TypeCode.UInt64:
- case TypeCode.Int64: dbType = DbType.Int64; db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;
- case TypeCode.Single: dbType = DbType.Single; db2Type = DB2Type.Float; db2DataType = DB2Constants.SQL_REAL; break;
- case TypeCode.Double: dbType = DbType.Double; db2Type = DB2Type.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;
- case TypeCode.Decimal: dbType = DbType.Decimal; db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;
- case TypeCode.DateTime: dbType = DbType.DateTime; db2Type = DB2Type.Timestamp; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;
- case TypeCode.String: dbType = DbType.String; db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;
-
- case TypeCode.Object:
- case TypeCode.DBNull:
- case TypeCode.Empty:
- throw new SystemException("Unknown data type");
- default:
- throw new SystemException("Value is of unknown data type");
- }
- }
- else if(Value is byte[])
- {
- dbType = DbType.Binary;
- db2Type = DB2Type.VarBinary;
- db2DataType = DB2Constants.SQL_VARBINARY;
- }
- else if(Value is TimeSpan)
- {
- dbType = DbType.Time;
- db2Type = DB2Type.Time;
- db2DataType = DB2Constants.SQL_TYPE_TIME;
- }
- else
- {
- throw new NotSupportedException("Value is of unsupported data type");
- }
- }
- #endregion
-
- internal void CalculateRequiredmemory()
- {
- if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))
- {
- if(Value == null)
- throw new ArgumentException("Value missing");
- }
- if(dbType == DbType.Object)
- {
- if((direction == ParameterDirection.Output) || (direction == ParameterDirection.ReturnValue))
- throw new ArgumentException("Unknown type");
-
- if((direction != ParameterDirection.Input) || !Convert.IsDBNull(Value))
- {
- InferType();
- }
- }
-
- if((db2DataType == DB2Constants.SQL_VARBINARY) ||
- (db2DataType == DB2Constants.SQL_WCHAR))
- {
- if(Size <= 0)
- {
- if(direction != ParameterDirection.Input)
- throw new ArgumentException("Size not specified");
- if(Value == DBNull.Value)
- requiredMemory = 0;
- else if(Value is string)
- requiredMemory = ((string)Value).Length;
- else if(Value is byte[])
- requiredMemory = ((byte[])Value).Length;
- else
- throw new ArgumentException("wrong type!?");
- }
- else
- {
- requiredMemory = Size;
- }
- if(db2DataType == DB2Constants.SQL_WCHAR)
- requiredMemory = (requiredMemory * 2) + 2;
- requiredMemory = (requiredMemory | 0xf) + 1;
- }
- requiredMemory = Math.Max(128, requiredMemory);
- }
-
- #region Bind
- ///
- /// Bind this parameter
- ///
- internal short Bind(IntPtr hwndStmt, short paramNum)
- {
- int inLength = requiredMemory;
- db2LastUsedDataType = db2DataType;
- short db2CType = DB2Constants.SQL_C_DEFAULT;
- if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))
- {
- if(Convert.IsDBNull(Value))
- {
- inLength = DB2Constants.SQL_NULL_DATA;
- if((db2DataType == DB2Constants.SQL_UNKNOWN_TYPE) ||
- (db2DataType == DB2Constants.SQL_DECIMAL))
- {
- db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;
- db2CType = DB2Constants.SQL_C_WCHAR;
- }
- }
- }
- if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))
- {
-
- switch (db2DataType)
- {
-
- case DB2Constants.SQL_WCHAR:
- string tmpString = Convert.ToString(Value);
- inLength = tmpString.Length;
- if((Size > 0) && (inLength > Size))
- inLength = Size;
-
-
- Marshal.Copy(tmpString.ToCharArray(), 0, internalBuffer, inLength);
- inLength *= 2;
-
- db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;
- db2CType = DB2Constants.SQL_C_WCHAR;
- break;
- case DB2Constants.SQL_VARBINARY:
- byte[] tmpBytes = (byte[])Value;
- inLength = tmpBytes.Length;
- if((Size > 0) && (inLength > Size))
- inLength = Size;
-
- Marshal.Copy(tmpBytes, 0, internalBuffer, inLength);
- db2CType = DB2Constants.SQL_TYPE_BINARY;
- break;
- case DB2Constants.SQL_BIT:
- case DB2Constants.SQL_UTINYINT:
- case DB2Constants.SQL_SMALLINT:
-
- Marshal.WriteInt16(internalBuffer, Convert.ToInt16(Value));
- db2CType = DB2Constants.SQL_C_SSHORT;
- break;
- case DB2Constants.SQL_INTEGER:
-
- Marshal.WriteInt32(internalBuffer, Convert.ToInt32(Value));
- db2CType = DB2Constants.SQL_C_SLONG;
- break;
- case DB2Constants.SQL_BIGINT:
-
- Marshal.WriteInt64(internalBuffer, Convert.ToInt64(Value));
- db2CType = DB2Constants.SQL_C_SBIGINT;
- break;
- case DB2Constants.SQL_REAL:
-
- Marshal.StructureToPtr((float)Convert.ToDouble(Value), internalBuffer, false);
- db2CType = DB2Constants.SQL_C_TYPE_REAL;
- break;
- case DB2Constants.SQL_DOUBLE:
-
- Marshal.StructureToPtr(Convert.ToDouble(Value), internalBuffer, false);
- db2CType = DB2Constants.SQL_C_DOUBLE;
- break;
- case DB2Constants.SQL_DECIMAL:
- byte[] tmpDecimalData = System.Text.Encoding.UTF8.GetBytes(
- Convert.ToDecimal(Value).ToString(System.Globalization.CultureInfo.InvariantCulture));
- inLength = Math.Min(tmpDecimalData.Length, requiredMemory);
-
- Marshal.Copy(tmpDecimalData, 0, internalBuffer, inLength);
- db2LastUsedDataType = DB2Constants.SQL_VARCHAR;
- db2CType = DB2Constants.SQL_C_CHAR;
- break;
- case DB2Constants.SQL_TYPE_DATE:
- DateTime tmpDate = Convert.ToDateTime(Value);
- Marshal.WriteInt16(internalBuffer, 0, (short)tmpDate.Year);
- Marshal.WriteInt16(internalBuffer, 2, (short)tmpDate.Month);
- Marshal.WriteInt16(internalBuffer, 4, (short)tmpDate.Day);
- db2CType = DB2Constants.SQL_C_TYPE_DATE;
- break;
- case DB2Constants.SQL_TYPE_TIMESTAMP:
- DateTime tmpDateTime = Convert.ToDateTime(Value);
- Marshal.WriteInt16(internalBuffer, 0, (short)tmpDateTime.Year);
- Marshal.WriteInt16(internalBuffer, 2, (short)tmpDateTime.Month);
- Marshal.WriteInt16(internalBuffer, 4, (short)tmpDateTime.Day);
- Marshal.WriteInt16(internalBuffer, 6, (short)tmpDateTime.Hour);
- Marshal.WriteInt16(internalBuffer, 8, (short)tmpDateTime.Minute);
- Marshal.WriteInt16(internalBuffer, 10, (short)tmpDateTime.Second);
- Marshal.WriteInt32(internalBuffer, 12, (int)((tmpDateTime.Ticks % 10000000) * 100));
- db2CType = DB2Constants.SQL_C_TYPE_TIMESTAMP;
- break;
- case DB2Constants.SQL_TYPE_TIME:
- TimeSpan tmpTime = (TimeSpan)Value;
- Marshal.WriteInt16(internalBuffer, 0, (short)tmpTime.Hours);
- Marshal.WriteInt16(internalBuffer, 2, (short)tmpTime.Minutes);
- Marshal.WriteInt16(internalBuffer, 4, (short)tmpTime.Seconds);
- db2CType = DB2Constants.SQL_C_TYPE_TIME;
- break;
- }
- }
- else
- {
- switch (db2DataType)
- {
- case DB2Constants.SQL_WCHAR:
- db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;
- db2CType = DB2Constants.SQL_C_WCHAR;
- break;
- case DB2Constants.SQL_VARBINARY:
- db2CType = DB2Constants.SQL_TYPE_BINARY;
- break;
- case DB2Constants.SQL_BIT:
- case DB2Constants.SQL_UTINYINT:
- case DB2Constants.SQL_SMALLINT:
- db2CType = DB2Constants.SQL_C_SSHORT;
- break;
- case DB2Constants.SQL_INTEGER:
- db2CType = DB2Constants.SQL_C_SLONG;
- break;
- case DB2Constants.SQL_BIGINT:
- db2CType = DB2Constants.SQL_C_SBIGINT;
- break;
- case DB2Constants.SQL_REAL:
- db2CType = DB2Constants.SQL_C_TYPE_REAL;
- break;
- case DB2Constants.SQL_DOUBLE:
- db2CType = DB2Constants.SQL_C_DOUBLE;
- break;
- case DB2Constants.SQL_DECIMAL:
- db2LastUsedDataType = DB2Constants.SQL_VARCHAR;
- db2CType = DB2Constants.SQL_C_CHAR;
- break;
- case DB2Constants.SQL_TYPE_DATE:
- db2CType = DB2Constants.SQL_C_TYPE_DATE;
- break;
- case DB2Constants.SQL_TYPE_TIMESTAMP:
- db2CType = DB2Constants.SQL_C_TYPE_TIMESTAMP;
- break;
- case DB2Constants.SQL_TYPE_TIME:
- db2CType = DB2Constants.SQL_C_TYPE_TIME;
- break;
- }
- }
- Marshal.WriteInt32(internalLengthBuffer, inLength);
- short sqlRet = DB2CLIWrapper.SQLBindParameter(hwndStmt, paramNum, db2Direction,
- db2CType, db2LastUsedDataType, Size, Scale,
- internalBuffer, requiredMemory, internalLengthBuffer);
-
- return sqlRet;
- }
- #endregion
- object ICloneable.Clone ()
- {
- DB2Parameter clone = new DB2Parameter();
- clone.dbType = dbType;
- clone.db2Type = db2Type;
- clone.db2DataType = db2DataType;
- clone.db2LastUsedDataType = db2LastUsedDataType;
- clone.direction = direction;
- clone.db2Direction = db2Direction;
- clone.nullable = nullable;
- clone.parameterName = parameterName;
- clone.sourceColumn = sourceColumn;
- clone.sourceVersion = sourceVersion;
- clone.dataVal = dataVal;
- clone.scale = scale;
- clone.precision = precision;
- clone.size = size;
- if(dataVal is ICloneable)
- {
- clone.dataVal = ((ICloneable)dataVal).Clone();
- }
- return clone;
- }
-
- internal void GetOutValue()
- {
- int length = Marshal.ReadInt32(internalLengthBuffer);
- if(length == DB2Constants.SQL_NULL_DATA)
- {
- dataVal = DBNull.Value;
- return;
- }
- switch(DB2Type)
- {
- case DB2Type.SmallInt:
- dataVal = Marshal.ReadInt16(internalBuffer);
- break;
- case DB2Type.Integer:
- dataVal = Marshal.ReadInt32(internalBuffer);
- break;
- case DB2Type.BigInt:
- dataVal = Marshal.ReadInt64(internalBuffer);
- break;
- case DB2Type.Double:
- dataVal = Marshal.PtrToStructure(internalBuffer, typeof(Double));
- break;
- case DB2Type.Float:
- dataVal = Marshal.PtrToStructure(internalBuffer, typeof(Single));
- break;
- case DB2Type.Char:
- case DB2Type.VarChar:
- case DB2Type.LongVarChar:
- case DB2Type.Graphic:
- case DB2Type.VarGraphic:
- case DB2Type.LongVarGraphic:
- case DB2Type.Clob:
- case DB2Type.DbClob:
- dataVal = Marshal.PtrToStringUni(internalBuffer, Math.Min(Size, length / 2));
- break;
- case DB2Type.Binary:
- case DB2Type.VarBinary:
- case DB2Type.LongVarBinary:
- case DB2Type.Blob:
- case DB2Type.Datalink:
- length = Math.Min(Size, length);
- dataVal = new byte[length];
- Marshal.Copy(internalBuffer, (byte[])dataVal, 0, length);
- break;
- case DB2Type.Decimal:
- dataVal = decimal.Parse(Marshal.PtrToStringAnsi(internalBuffer, length),
- System.Globalization.CultureInfo.InvariantCulture);
- break;
- case DB2Type.Timestamp:
- DateTime dtTmp = new DateTime(
- Marshal.ReadInt16(internalBuffer, 0), // year
- Marshal.ReadInt16(internalBuffer, 2), // month
- Marshal.ReadInt16(internalBuffer, 4), // day
- Marshal.ReadInt16(internalBuffer, 6), // hour
- Marshal.ReadInt16(internalBuffer, 8), // minute
- Marshal.ReadInt16(internalBuffer, 10));// second
- dataVal = dtTmp.AddTicks(Marshal.ReadInt32(internalBuffer, 12) / 100); // nanoseconds
- break;
- case DB2Type.Date:
- dataVal = new DateTime(
- Marshal.ReadInt16(internalBuffer, 0),
- Marshal.ReadInt16(internalBuffer, 2),
- Marshal.ReadInt16(internalBuffer, 4));
- break;
- case DB2Type.Time:
- dataVal = new TimeSpan(
- Marshal.ReadInt16(internalBuffer, 0), // Hour
- Marshal.ReadInt16(internalBuffer, 2), // Minute
- Marshal.ReadInt16(internalBuffer, 4)); // Second
- break;
-
- case DB2Type.Invalid:
- case DB2Type.Real:
- case DB2Type.Numeric:
- case DB2Type.RowId:
- case DB2Type.XmlReader:
- throw new NotImplementedException();
- default:
- throw new NotSupportedException("unknown data type");
- }
- }
- }
-}
+using System;\r
+using System.Data;\r
+using System.Runtime.InteropServices;\r
+\r
+namespace IBM.Data.DB2\r
+{\r
+\r
+ public sealed class DB2Parameter : MarshalByRefObject, IDbDataParameter, IDataParameter, ICloneable\r
+ {\r
+ private DbType dbType = DbType.Object;\r
+ private DB2Type db2Type = DB2Type.Invalid;\r
+ private short db2DataType = DB2Constants.SQL_UNKNOWN_TYPE;\r
+ private short db2LastUsedDataType = DB2Constants.SQL_UNKNOWN_TYPE;\r
+\r
+ private ParameterDirection direction;\r
+ private short db2Direction = DB2Constants.SQL_PARAM_INPUT;\r
+ private bool nullable = true;\r
+ private string parameterName;\r
+ private string sourceColumn;\r
+ private DataRowVersion sourceVersion;\r
+ private object dataVal;\r
+ private byte scale, precision;\r
+ private int size;\r
+ internal IntPtr internalBuffer;\r
+ internal IntPtr internalLengthBuffer;\r
+ internal int requiredMemory;\r
+\r
+ #region Contructors and destructors\r
+ public DB2Parameter()\r
+ {\r
+ direction = ParameterDirection.Input;\r
+ sourceVersion = DataRowVersion.Current;\r
+ } \r
+\r
+ public DB2Parameter(string name, DB2Type type)\r
+ {\r
+ direction = ParameterDirection.Input;\r
+ sourceVersion = DataRowVersion.Current;\r
+ this.ParameterName = name;\r
+ this.DB2Type = type;\r
+ } \r
+\r
+ public DB2Parameter(string name, DB2Type type, int size)\r
+ {\r
+ direction = ParameterDirection.Input;\r
+ sourceVersion = DataRowVersion.Current;\r
+ this.ParameterName = name;\r
+ this.DB2Type = type;\r
+ this.Size = size;\r
+ }\r
+\r
+ public DB2Parameter(string name, DB2Type type, int size, string sourceColumn)\r
+ {\r
+ direction = ParameterDirection.Input;\r
+ sourceVersion = DataRowVersion.Current;\r
+ this.ParameterName = name;\r
+ this.DB2Type = type;\r
+ this.Size = size;\r
+ this.SourceColumn = sourceColumn;\r
+ }\r
+\r
+ public DB2Parameter(string parameterName, object value)\r
+ {\r
+ direction = ParameterDirection.Input;\r
+ sourceVersion = DataRowVersion.Current;\r
+ this.ParameterName = parameterName;\r
+ this.Value = value;\r
+ }\r
+\r
+ public DB2Parameter(string parameterName, DB2Type db2Type, int size, ParameterDirection parameterDirection, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value)\r
+ {\r
+ this.ParameterName = parameterName;\r
+ this.DB2Type = db2Type;\r
+ this.Size = size;\r
+ this.Direction = parameterDirection;\r
+ this.IsNullable = isNullable;\r
+ this.Precision = precision;\r
+ this.Scale = scale;\r
+ this.SourceColumn = srcColumn;\r
+ this.SourceVersion = srcVersion;\r
+ this.Value = value;\r
+ }\r
+\r
+ #endregion\r
+\r
+ #region Properties\r
+ #region DbType Property\r
+ public DB2Type DB2Type\r
+ {\r
+ get \r
+ {\r
+ return db2Type;\r
+ }\r
+ set \r
+ {\r
+ db2Type = value;\r
+ switch(db2Type)\r
+ {\r
+ case DB2Type.Invalid: dbType = DbType.Object; db2DataType = DB2Constants.SQL_UNKNOWN_TYPE; break;\r
+ case DB2Type.SmallInt: dbType = DbType.Int16; db2DataType = DB2Constants.SQL_SMALLINT; break;\r
+ case DB2Type.Integer: dbType = DbType.Int32; db2DataType = DB2Constants.SQL_INTEGER; break;\r
+ case DB2Type.BigInt: dbType = DbType.Int64; db2DataType = DB2Constants.SQL_BIGINT; break;\r
+ case DB2Type.Real: dbType = DbType.Single; db2DataType = DB2Constants.SQL_REAL; break;\r
+ case DB2Type.Double: dbType = DbType.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;\r
+ case DB2Type.Float: dbType = DbType.Single; db2DataType = DB2Constants.SQL_REAL; break;\r
+ case DB2Type.Decimal: dbType = DbType.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;\r
+ case DB2Type.Numeric: dbType = DbType.VarNumeric; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Date: dbType = DbType.Date; db2DataType = DB2Constants.SQL_TYPE_DATE; break;\r
+ case DB2Type.Time: dbType = DbType.Time; db2DataType = DB2Constants.SQL_TYPE_TIME; break;\r
+ case DB2Type.Timestamp: dbType = DbType.DateTime; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;\r
+ case DB2Type.Char: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.VarChar: dbType = DbType.StringFixedLength; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.LongVarChar: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Binary: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;\r
+ case DB2Type.VarBinary: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;\r
+ case DB2Type.LongVarBinary: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Graphic: dbType = DbType.StringFixedLength; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.VarGraphic: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.LongVarGraphic: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Clob: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Blob: dbType = DbType.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;\r
+ case DB2Type.DbClob: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DB2Type.Datalink: dbType = DbType.Byte; db2DataType = DB2Constants.SQL_VARBINARY; break;\r
+ case DB2Type.RowId: dbType = DbType.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;\r
+ case DB2Type.XmlReader: dbType = DbType.String; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ default:\r
+ throw new NotSupportedException("Value is of unknown data type");\r
+ }\r
+ }\r
+ }\r
+ ///\r
+ /// Parameter data type\r
+ /// \r
+ public DbType DbType\r
+ {\r
+ get \r
+ {\r
+ return dbType;\r
+ }\r
+ set \r
+ {\r
+ dbType = value;\r
+ switch(dbType)\r
+ {\r
+ case DbType.AnsiString: db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DbType.AnsiStringFixedLength: db2Type = DB2Type.Char; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DbType.Binary: db2Type = DB2Type.Binary; db2DataType = DB2Constants.SQL_VARBINARY; break;\r
+ case DbType.Boolean: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_BIT; break;\r
+ case DbType.Byte: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;\r
+ case DbType.Currency: db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;\r
+ case DbType.Date: db2Type = DB2Type.Date; db2DataType = DB2Constants.SQL_TYPE_DATE; break;\r
+ case DbType.DateTime: db2Type = DB2Type.Timestamp; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;\r
+ case DbType.Decimal: db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;\r
+ case DbType.Double: db2Type = DB2Type.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;\r
+ case DbType.Guid: db2Type = DB2Type.Binary; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DbType.Int16: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;\r
+ case DbType.Int32: db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;\r
+ case DbType.Int64: db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;\r
+ case DbType.Object: db2Type = DB2Type.Invalid; db2DataType = DB2Constants.SQL_UNKNOWN_TYPE; break;\r
+ case DbType.SByte: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;\r
+ case DbType.Single: db2Type = DB2Type.Float; db2DataType = DB2Constants.SQL_REAL; break;\r
+ case DbType.String: db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DbType.StringFixedLength: db2Type = DB2Type.Char; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case DbType.Time: db2Type = DB2Type.Time; db2DataType = DB2Constants.SQL_TYPE_TIME; break;\r
+ case DbType.UInt16: db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;\r
+ case DbType.UInt32: db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;\r
+ case DbType.UInt64: db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;\r
+ case DbType.VarNumeric: db2Type = DB2Type.Numeric; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ default:\r
+ throw new NotSupportedException("Value is of unknown data type");\r
+ }\r
+ }\r
+ }\r
+\r
+ #endregion\r
+ #region Direction\r
+ ///\r
+ /// In or out parameter, or both\r
+ /// \r
+ public ParameterDirection Direction\r
+ {\r
+ get \r
+ {\r
+ return direction;\r
+ }\r
+ set \r
+ {\r
+ direction = value;\r
+ switch(direction)\r
+ {\r
+ default:\r
+ case ParameterDirection.Input: db2Direction = DB2Constants.SQL_PARAM_INPUT; break;\r
+ case ParameterDirection.Output: db2Direction = DB2Constants.SQL_PARAM_OUTPUT; break;\r
+ case ParameterDirection.InputOutput: db2Direction = DB2Constants.SQL_PARAM_INPUT_OUTPUT; break;\r
+ case ParameterDirection.ReturnValue: db2Direction = DB2Constants.SQL_RETURN_VALUE; break;\r
+ }\r
+ }\r
+ }\r
+ #endregion\r
+ #region IsNullable\r
+ ///\r
+ /// Does this parameter support a null value\r
+ /// \r
+ public bool IsNullable \r
+ {\r
+ get \r
+ {\r
+ return nullable;\r
+ }\r
+ set \r
+ {\r
+ nullable = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #region ParameterName\r
+ public string ParameterName\r
+ {\r
+ get \r
+ {\r
+ return parameterName;\r
+ }\r
+ set \r
+ {\r
+ parameterName = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #region SourceColumn\r
+ ///\r
+ /// Gets or sets the name of the source column that is mapped to the DataSet\r
+ /// \r
+ public string SourceColumn\r
+ {\r
+ get \r
+ {\r
+ return sourceColumn;\r
+ }\r
+ set \r
+ {\r
+ sourceColumn = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #region SourceVersion\r
+ ///\r
+ /// DataRowVersion property\r
+ /// \r
+ public DataRowVersion SourceVersion \r
+ {\r
+ get \r
+ {\r
+ return sourceVersion;\r
+ }\r
+ set \r
+ {\r
+ sourceVersion = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #region IDbDataParameter properties\r
+ public byte Precision \r
+ {\r
+ get \r
+ { \r
+ return precision;\r
+ }\r
+ set \r
+ { \r
+ precision = value; \r
+ }\r
+ }\r
+ \r
+ public byte Scale \r
+ {\r
+ get \r
+ { \r
+ return scale;\r
+ }\r
+ set \r
+ { \r
+ scale = value; \r
+ }\r
+ }\r
+ \r
+ public int Size \r
+ {\r
+ get \r
+ {\r
+ return size;\r
+ }\r
+ set \r
+ { \r
+ size = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #region Value\r
+ ///\r
+ /// The actual parameter data\r
+ /// \r
+ public object Value \r
+ {\r
+ get\r
+ {\r
+ return dataVal;\r
+ }\r
+ set \r
+ {\r
+ this.dataVal = value;\r
+ }\r
+ }\r
+ #endregion\r
+ #endregion\r
+ \r
+ #region inferType Method\r
+ /// <summary>\r
+ /// Determine the data type based on the value\r
+ /// </summary>\r
+ private void InferType()\r
+ {\r
+ if(Value == null)\r
+ throw new ArgumentException("No DB2Parameter.Value found");\r
+\r
+ if(Value is IConvertible)\r
+ {\r
+ switch(((IConvertible)Value).GetTypeCode())\r
+ {\r
+ case TypeCode.Char: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+ case TypeCode.Boolean: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_BIT; break;\r
+ case TypeCode.SByte:\r
+ case TypeCode.Byte: dbType = DbType.Byte; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_UTINYINT; break;\r
+ case TypeCode.UInt16:\r
+ case TypeCode.Int16: dbType = DbType.Int16; db2Type = DB2Type.SmallInt; db2DataType = DB2Constants.SQL_SMALLINT; break;\r
+ case TypeCode.UInt32:\r
+ case TypeCode.Int32: dbType = DbType.Int32; db2Type = DB2Type.Integer; db2DataType = DB2Constants.SQL_INTEGER; break;\r
+ case TypeCode.UInt64:\r
+ case TypeCode.Int64: dbType = DbType.Int64; db2Type = DB2Type.BigInt; db2DataType = DB2Constants.SQL_BIGINT; break;\r
+ case TypeCode.Single: dbType = DbType.Single; db2Type = DB2Type.Float; db2DataType = DB2Constants.SQL_REAL; break;\r
+ case TypeCode.Double: dbType = DbType.Double; db2Type = DB2Type.Double; db2DataType = DB2Constants.SQL_DOUBLE; break;\r
+ case TypeCode.Decimal: dbType = DbType.Decimal; db2Type = DB2Type.Decimal; db2DataType = DB2Constants.SQL_DECIMAL; break;\r
+ case TypeCode.DateTime: dbType = DbType.DateTime; db2Type = DB2Type.Timestamp; db2DataType = DB2Constants.SQL_TYPE_TIMESTAMP; break;\r
+ case TypeCode.String: dbType = DbType.String; db2Type = DB2Type.VarChar; db2DataType = DB2Constants.SQL_WCHAR; break;\r
+\r
+ case TypeCode.Object:\r
+ case TypeCode.DBNull:\r
+ case TypeCode.Empty:\r
+ throw new SystemException("Unknown data type");\r
+ default:\r
+ throw new SystemException("Value is of unknown data type");\r
+ }\r
+ }\r
+ else if(Value is byte[])\r
+ {\r
+ dbType = DbType.Binary;\r
+ db2Type = DB2Type.VarBinary;\r
+ db2DataType = DB2Constants.SQL_VARBINARY;\r
+ }\r
+ else if(Value is TimeSpan)\r
+ {\r
+ dbType = DbType.Time;\r
+ db2Type = DB2Type.Time;\r
+ db2DataType = DB2Constants.SQL_TYPE_TIME;\r
+ }\r
+ else\r
+ {\r
+ throw new NotSupportedException("Value is of unsupported data type");\r
+ }\r
+ }\r
+ #endregion\r
+ \r
+ internal void CalculateRequiredmemory()\r
+ {\r
+ //if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))\r
+ //{\r
+ // if(Value == null)\r
+ // throw new ArgumentException("Value missing");\r
+ //}\r
+ if(dbType == DbType.Object)\r
+ {\r
+ if((direction == ParameterDirection.Output) || (direction == ParameterDirection.ReturnValue))\r
+ throw new ArgumentException("Unknown type");\r
+\r
+ if((direction != ParameterDirection.Input) || !Convert.IsDBNull(Value))\r
+ {\r
+ InferType();\r
+ }\r
+ }\r
+ if (db2DataType == DB2Constants.SQL_INTEGER)\r
+ {\r
+ requiredMemory = 4;\r
+ }\r
+ if((db2DataType == DB2Constants.SQL_VARBINARY) ||\r
+ (db2DataType == DB2Constants.SQL_WCHAR))\r
+ {\r
+ if(Size <= 0)\r
+ {\r
+ if(direction != ParameterDirection.Input)\r
+ throw new ArgumentException("Size not specified");\r
+ if(Value == DBNull.Value)\r
+ requiredMemory = 0;\r
+ else if(Value is string)\r
+ requiredMemory = ((string)Value).Length;\r
+ else if(Value is byte[])\r
+ requiredMemory = ((byte[])Value).Length;\r
+ else\r
+ throw new ArgumentException("wrong type!?");\r
+ }\r
+ else\r
+ {\r
+ requiredMemory = Size;\r
+ }\r
+ if(db2DataType == DB2Constants.SQL_WCHAR)\r
+ requiredMemory = (requiredMemory * 2) + 2;\r
+ requiredMemory = (requiredMemory | 0xf) + 1;\r
+ }\r
+ requiredMemory = Math.Max(128, requiredMemory);\r
+ }\r
+\r
+ #region Bind \r
+ ///\r
+ /// Bind this parameter\r
+ /// \r
+ internal short Bind(IntPtr hwndStmt, short paramNum)\r
+ {\r
+ int inLength = requiredMemory;\r
+ db2LastUsedDataType = db2DataType;\r
+ short db2CType = DB2Constants.SQL_C_DEFAULT;\r
+ if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))\r
+ {\r
+ if(Convert.IsDBNull(Value))\r
+ {\r
+ inLength = DB2Constants.SQL_NULL_DATA;\r
+ if((db2DataType == DB2Constants.SQL_UNKNOWN_TYPE) || \r
+ (db2DataType == DB2Constants.SQL_DECIMAL))\r
+ {\r
+ db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;\r
+ db2CType = DB2Constants.SQL_C_WCHAR;\r
+ }\r
+ }\r
+ }\r
+ if((direction == ParameterDirection.Input) || (direction == ParameterDirection.InputOutput))\r
+ {\r
+ switch (db2DataType) \r
+ {\r
+ case DB2Constants.SQL_WCHAR:\r
+ string tmpString = Convert.ToString(Value);\r
+ inLength = tmpString.Length;\r
+ if((Size > 0) && (inLength > Size))\r
+ inLength = Size;\r
+ Marshal.Copy(tmpString.ToCharArray(), 0, internalBuffer, inLength);\r
+ inLength *= 2;\r
+ db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;\r
+ db2CType = DB2Constants.SQL_C_WCHAR;\r
+ if(inLength > 32000)\r
+ {\r
+ db2LastUsedDataType = DB2Constants.SQL_TYPE_BLOB;\r
+ }\r
+ break;\r
+ case DB2Constants.SQL_VARBINARY:\r
+ byte[] tmpBytes = (byte[])Value;\r
+ inLength = tmpBytes.Length;\r
+ if((Size > 0) && (inLength > Size))\r
+ inLength = Size;\r
+ Marshal.Copy(tmpBytes, 0, internalBuffer, inLength);\r
+ db2CType = DB2Constants.SQL_TYPE_BINARY;\r
+ break;\r
+ case DB2Constants.SQL_BIT:\r
+ case DB2Constants.SQL_UTINYINT:\r
+ case DB2Constants.SQL_SMALLINT:\r
+ Marshal.WriteInt16(internalBuffer, Convert.ToInt16(Value));\r
+ db2CType = DB2Constants.SQL_C_SSHORT;\r
+ break;\r
+ case DB2Constants.SQL_INTEGER:\r
+ Marshal.WriteInt32(internalBuffer, Convert.ToInt32(Value));\r
+ db2CType = DB2Constants.SQL_C_SLONG;\r
+ break;\r
+ case DB2Constants.SQL_BIGINT:\r
+ Marshal.WriteInt64(internalBuffer, Convert.ToInt64(Value));\r
+ db2CType = DB2Constants.SQL_C_SBIGINT;\r
+ break;\r
+ case DB2Constants.SQL_REAL:\r
+ Marshal.StructureToPtr((float)Convert.ToDouble(Value), internalBuffer, false);\r
+ db2CType = DB2Constants.SQL_C_TYPE_REAL;\r
+ break;\r
+ case DB2Constants.SQL_DOUBLE:\r
+ Marshal.StructureToPtr(Convert.ToDouble(Value), internalBuffer, false);\r
+ db2CType = DB2Constants.SQL_C_DOUBLE;\r
+ break;\r
+ case DB2Constants.SQL_DECIMAL:\r
+ byte[] tmpDecimalData = System.Text.Encoding.UTF8.GetBytes(\r
+ Convert.ToDecimal(Value).ToString(System.Globalization.CultureInfo.InvariantCulture));\r
+ inLength = Math.Min(tmpDecimalData.Length, requiredMemory);\r
+ Marshal.Copy(tmpDecimalData, 0, internalBuffer, inLength);\r
+ db2LastUsedDataType = DB2Constants.SQL_VARCHAR;\r
+ db2CType = DB2Constants.SQL_C_CHAR;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ DateTime tmpDate = Convert.ToDateTime(Value);\r
+ Marshal.WriteInt16(internalBuffer, 0, (short)tmpDate.Year);\r
+ Marshal.WriteInt16(internalBuffer, 2, (short)tmpDate.Month);\r
+ Marshal.WriteInt16(internalBuffer, 4, (short)tmpDate.Day);\r
+ db2CType = DB2Constants.SQL_C_TYPE_DATE;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ DateTime tmpDateTime = Convert.ToDateTime(Value);\r
+ Marshal.WriteInt16(internalBuffer, 0, (short)tmpDateTime.Year);\r
+ Marshal.WriteInt16(internalBuffer, 2, (short)tmpDateTime.Month);\r
+ Marshal.WriteInt16(internalBuffer, 4, (short)tmpDateTime.Day);\r
+ Marshal.WriteInt16(internalBuffer, 6, (short)tmpDateTime.Hour);\r
+ Marshal.WriteInt16(internalBuffer, 8, (short)tmpDateTime.Minute);\r
+ Marshal.WriteInt16(internalBuffer, 10, (short)tmpDateTime.Second);\r
+ Marshal.WriteInt32(internalBuffer, 12, (int)((tmpDateTime.Ticks % 10000000) * 100));\r
+ db2CType = DB2Constants.SQL_C_TYPE_TIMESTAMP;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ TimeSpan tmpTime = (TimeSpan)Value;\r
+ Marshal.WriteInt16(internalBuffer, 0, (short)tmpTime.Hours);\r
+ Marshal.WriteInt16(internalBuffer, 2, (short)tmpTime.Minutes);\r
+ Marshal.WriteInt16(internalBuffer, 4, (short)tmpTime.Seconds);\r
+ db2CType = DB2Constants.SQL_C_TYPE_TIME;\r
+ break;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ switch (db2DataType) \r
+ {\r
+ case DB2Constants.SQL_WCHAR:\r
+ db2LastUsedDataType = DB2Constants.SQL_VARGRAPHIC;\r
+ db2CType = DB2Constants.SQL_C_WCHAR;\r
+ break;\r
+ case DB2Constants.SQL_VARBINARY:\r
+ db2CType = DB2Constants.SQL_TYPE_BINARY;\r
+ break;\r
+ case DB2Constants.SQL_BIT:\r
+ case DB2Constants.SQL_UTINYINT:\r
+ case DB2Constants.SQL_SMALLINT:\r
+ db2CType = DB2Constants.SQL_C_SSHORT;\r
+ break;\r
+ case DB2Constants.SQL_INTEGER:\r
+ db2CType = DB2Constants.SQL_C_SLONG;\r
+ break;\r
+ case DB2Constants.SQL_BIGINT:\r
+ db2CType = DB2Constants.SQL_C_SBIGINT;\r
+ break;\r
+ case DB2Constants.SQL_REAL:\r
+ db2CType = DB2Constants.SQL_C_TYPE_REAL;\r
+ break;\r
+ case DB2Constants.SQL_DOUBLE:\r
+ db2CType = DB2Constants.SQL_C_DOUBLE;\r
+ break;\r
+ case DB2Constants.SQL_DECIMAL:\r
+ db2LastUsedDataType = DB2Constants.SQL_VARCHAR;\r
+ db2CType = DB2Constants.SQL_C_CHAR;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ db2CType = DB2Constants.SQL_C_TYPE_DATE;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ db2CType = DB2Constants.SQL_C_TYPE_TIMESTAMP;\r
+ break;\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ db2CType = DB2Constants.SQL_C_TYPE_TIME;\r
+ break;\r
+ }\r
+ }\r
+ Marshal.WriteInt32(internalLengthBuffer, inLength);\r
+ short sqlRet = DB2CLIWrapper.SQLBindParameter(hwndStmt, paramNum, db2Direction, \r
+ db2CType, db2LastUsedDataType, Size, Scale,\r
+ internalBuffer, requiredMemory, internalLengthBuffer);\r
+\r
+ return sqlRet;\r
+ }\r
+ #endregion\r
+ object ICloneable.Clone ()\r
+ {\r
+ DB2Parameter clone = new DB2Parameter();\r
+ clone.dbType = dbType;\r
+ clone.db2Type = db2Type;\r
+ clone.db2DataType = db2DataType;\r
+ clone.db2LastUsedDataType = db2LastUsedDataType;\r
+ clone.direction = direction;\r
+ clone.db2Direction = db2Direction;\r
+ clone.nullable = nullable;\r
+ clone.parameterName = parameterName;\r
+ clone.sourceColumn = sourceColumn;\r
+ clone.sourceVersion = sourceVersion;\r
+ clone.dataVal = dataVal;\r
+ clone.scale = scale;\r
+ clone.precision = precision;\r
+ clone.size = size;\r
+ if(dataVal is ICloneable)\r
+ {\r
+ clone.dataVal = ((ICloneable)dataVal).Clone();\r
+ }\r
+ return clone;\r
+ }\r
+ \r
+ internal void GetOutValue()\r
+ {\r
+ int length = Marshal.ReadInt32(internalLengthBuffer);\r
+ if(length == DB2Constants.SQL_NULL_DATA)\r
+ {\r
+ dataVal = DBNull.Value;\r
+ return;\r
+ }\r
+ switch(DB2Type) \r
+ {\r
+ case DB2Type.SmallInt:\r
+ dataVal = Marshal.ReadInt16(internalBuffer);\r
+ break;\r
+ case DB2Type.Integer:\r
+ dataVal = Marshal.ReadInt32(internalBuffer);\r
+ break;\r
+ case DB2Type.BigInt:\r
+ dataVal = Marshal.ReadInt64(internalBuffer);\r
+ break;\r
+ case DB2Type.Double:\r
+ dataVal = Marshal.PtrToStructure(internalBuffer, typeof(Double));\r
+ break;\r
+ case DB2Type.Float:\r
+ dataVal = Marshal.PtrToStructure(internalBuffer, typeof(Single));\r
+ break;\r
+ case DB2Type.Char:\r
+ case DB2Type.VarChar:\r
+ case DB2Type.LongVarChar:\r
+ case DB2Type.Graphic:\r
+ case DB2Type.VarGraphic:\r
+ case DB2Type.LongVarGraphic:\r
+ case DB2Type.Clob:\r
+ case DB2Type.DbClob:\r
+ dataVal = Marshal.PtrToStringUni(internalBuffer, Math.Min(Size, length / 2));\r
+ break;\r
+ case DB2Type.Binary:\r
+ case DB2Type.VarBinary:\r
+ case DB2Type.LongVarBinary:\r
+ case DB2Type.Blob:\r
+ case DB2Type.Datalink:\r
+ length = Math.Min(Size, length);\r
+ dataVal = new byte[length];\r
+ Marshal.Copy(internalBuffer, (byte[])dataVal, 0, length);\r
+ break;\r
+ case DB2Type.Decimal:\r
+ dataVal = decimal.Parse(Marshal.PtrToStringAnsi(internalBuffer, length), \r
+ System.Globalization.CultureInfo.InvariantCulture);\r
+ break;\r
+ case DB2Type.Timestamp:\r
+ DateTime dtTmp = new DateTime(\r
+ Marshal.ReadInt16(internalBuffer, 0), // year\r
+ Marshal.ReadInt16(internalBuffer, 2), // month\r
+ Marshal.ReadInt16(internalBuffer, 4), // day\r
+ Marshal.ReadInt16(internalBuffer, 6), // hour\r
+ Marshal.ReadInt16(internalBuffer, 8), // minute\r
+ Marshal.ReadInt16(internalBuffer, 10));// second\r
+ dataVal = dtTmp.AddTicks(Marshal.ReadInt32(internalBuffer, 12) / 100); // nanoseconds \r
+ break;\r
+ case DB2Type.Date:\r
+ dataVal = new DateTime(\r
+ Marshal.ReadInt16(internalBuffer, 0),\r
+ Marshal.ReadInt16(internalBuffer, 2),\r
+ Marshal.ReadInt16(internalBuffer, 4));\r
+ break;\r
+ case DB2Type.Time:\r
+ dataVal = new TimeSpan(\r
+ Marshal.ReadInt16(internalBuffer, 0), // Hour\r
+ Marshal.ReadInt16(internalBuffer, 2), // Minute\r
+ Marshal.ReadInt16(internalBuffer, 4)); // Second\r
+ break;\r
+\r
+ case DB2Type.Invalid:\r
+ case DB2Type.Real:\r
+ case DB2Type.Numeric:\r
+ case DB2Type.RowId:\r
+ case DB2Type.XmlReader:\r
+ throw new NotImplementedException();\r
+ default:\r
+ throw new NotSupportedException("unknown data type");\r
+ }\r
+ }\r
+ }\r
+}\r
RowId = 25,\r
XmlReader = 26,\r
}\r
+ public class DB2TypeConverter\r
+ {\r
+ public static Type GetManagedType(int sql_type)\r
+ {\r
+ switch(sql_type)\r
+ {\r
+ case DB2Constants.SQL_INTEGER:\r
+ return typeof(int);\r
+ case DB2Constants.SQL_SMALLINT:\r
+ return typeof(short);\r
+ case DB2Constants.SQL_BIGINT:\r
+ return typeof(long);\r
+ case DB2Constants.SQL_DOUBLE:\r
+ return typeof(double);\r
+ case DB2Constants.SQL_DECIMAL:\r
+ return typeof(decimal);\r
+ case DB2Constants.SQL_DATETIME:\r
+ case DB2Constants.SQL_TYPE_DATE:\r
+ case DB2Constants.SQL_TYPE_TIMESTAMP:\r
+ return typeof(DateTime);\r
+ case DB2Constants.SQL_TYPE_TIME:\r
+ return typeof(TimeSpan);\r
+ case DB2Constants.SQL_CHAR:\r
+ case DB2Constants.SQL_VARCHAR:\r
+ case DB2Constants.SQL_TYPE_CLOB:\r
+ return typeof(string);\r
+ case DB2Constants.SQL_TYPE_BLOB:\r
+ case DB2Constants.SQL_TYPE_BINARY:\r
+ case DB2Constants.SQL_LONGVARBINARY:\r
+ case DB2Constants.SQL_VARBINARY:\r
+ return typeof(byte[]);\r
+ }\r
+ throw new NotImplementedException("Unknown SQL type " + sql_type);\r
+ }\r
+ }\r
}\r
projects / mono.git / commitdiff