path: root/mcs/class/referencesource/System.Data/System/Data/Odbc/OdbcConnection.cs

//------------------------------------------------------------------------------
// <copyright file="OdbcConnection.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">[....]</owner>
// <owner current="true" primary="false">[....]</owner>
//------------------------------------------------------------------------------

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using SysTx = System.Transactions;

namespace System.Data.Odbc {

    [DefaultEvent("InfoMessage")]
    public sealed partial class OdbcConnection : DbConnection, ICloneable {
        private int connectionTimeout = ADP.DefaultConnectionTimeout;

        private OdbcInfoMessageEventHandler infoMessageEventHandler;
        private WeakReference weakTransaction;

        private OdbcConnectionHandle _connectionHandle;
        private ConnectionState _extraState;    // extras, like Executing and Fetching, that we add to the State.

        public OdbcConnection(string connectionString) : this() {
            ConnectionString = connectionString;
        }

        private OdbcConnection(OdbcConnection connection) : this() { // Clone
            CopyFrom(connection);
            connectionTimeout = connection.connectionTimeout;
        }

        internal OdbcConnectionHandle ConnectionHandle {
            get {
                return _connectionHandle;
            }
            set {
                Debug.Assert(null == _connectionHandle, "reopening a connection?");
                _connectionHandle = value;
            }
        }

        [
        DefaultValue(""),
        Editor("Microsoft.VSDesigner.Data.Odbc.Design.OdbcConnectionStringEditor, " + AssemblyRef.MicrosoftVSDesigner, "System.Drawing.Design.UITypeEditor, " + AssemblyRef.SystemDrawing),
#pragma warning disable 618 // ignore obsolete warning about RecommendedAsConfigurable to use SettingsBindableAttribute
        RecommendedAsConfigurable(true),
#pragma warning restore 618
        SettingsBindableAttribute(true),
        RefreshProperties(RefreshProperties.All),
        ResCategoryAttribute(Res.DataCategory_Data),
        ResDescriptionAttribute(Res.OdbcConnection_ConnectionString),
        ]
        override public string ConnectionString {
            get {
                return ConnectionString_Get();
            }
            set {
                ConnectionString_Set(value);
            }
        }

        [
        DefaultValue(ADP.DefaultConnectionTimeout),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResCategoryAttribute(Res.DataCategory_Data),
        ResDescriptionAttribute(Res.OdbcConnection_ConnectionTimeout),
        ]
        new public int ConnectionTimeout {
            get {
                return connectionTimeout;
            }
            set {
                if (value < 0)
                    throw ODBC.NegativeArgument();
                if (IsOpen)
                    throw ODBC.CantSetPropertyOnOpenConnection();
                connectionTimeout = value;
            }
        }

        [
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResDescriptionAttribute(Res.OdbcConnection_Database),
        ]
        override public string Database {
            get {
                if (IsOpen && !ProviderInfo.NoCurrentCatalog) {
                    //Note: CURRENT_CATALOG may not be supported by the current driver.  In which
                    //case we ignore any error (without throwing), and just return string.empty.
                    //As we really don't want people to have to have try/catch around simple properties
                    return GetConnectAttrString(ODBC32.SQL_ATTR.CURRENT_CATALOG);
                }
                //Database is not available before open, and its not worth parsing the
                //connection string over.
                return String.Empty;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResDescriptionAttribute(Res.OdbcConnection_DataSource),
        ]
        override public string DataSource {
            get {
                if (IsOpen) {
                    // note: This will return an empty string if the driver keyword was used to connect
                    // see ODBC3.0 Programmers Reference, SQLGetInfo
                    //
                    return GetInfoStringUnhandled(ODBC32.SQL_INFO.SERVER_NAME, true);
                }
                return String.Empty;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResDescriptionAttribute(Res.OdbcConnection_ServerVersion),
        ]
        override public string ServerVersion {
            get {
                return InnerConnection.ServerVersion;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResDescriptionAttribute(Res.DbConnection_State),
        ]
        override public ConnectionState State {
            get {
                return InnerConnection.State;
            }
        }

        internal OdbcConnectionPoolGroupProviderInfo ProviderInfo {
            get {
                Debug.Assert(null != this.PoolGroup, "PoolGroup must never be null when accessing ProviderInfo");
                return (OdbcConnectionPoolGroupProviderInfo)this.PoolGroup.ProviderInfo;
            }
        }

        internal ConnectionState InternalState {
            get {
                return (this.State | _extraState);
            }
        }

        internal bool IsOpen {
            get {
                return (InnerConnection is OdbcConnectionOpen);
            }
        }

        internal OdbcTransaction LocalTransaction {

            get {
                OdbcTransaction result = null;
                if (null != weakTransaction) {
                    result = ((OdbcTransaction)weakTransaction.Target);
                }
                return result;
            }

            set {
                weakTransaction = null;

                if (null != value) {
                    weakTransaction = new WeakReference((OdbcTransaction)value);
                }
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ResDescriptionAttribute(Res.OdbcConnection_Driver),
        ]
        public string Driver {
            get {
                if(IsOpen) {
                    if (ProviderInfo.DriverName == null) {
                        ProviderInfo.DriverName = GetInfoStringUnhandled(ODBC32.SQL_INFO.DRIVER_NAME);
                    }
                    return ProviderInfo.DriverName;
                }
                return ADP.StrEmpty;
            }
        }

        internal bool IsV3Driver {
            get {
                if (ProviderInfo.DriverVersion == null) {
                    ProviderInfo.DriverVersion = GetInfoStringUnhandled(ODBC32.SQL_INFO.DRIVER_ODBC_VER);
                    // protected against null and index out of range. Number cannot be bigger than 99
                    if (ProviderInfo.DriverVersion != null && ProviderInfo.DriverVersion.Length>=2) {
                        try {   // mdac 89269: driver may return malformatted string
                            ProviderInfo.IsV3Driver = (int.Parse(ProviderInfo.DriverVersion.Substring(0,2), CultureInfo.InvariantCulture) >= 3);
                        }
                        catch (System.FormatException e) {
                            ProviderInfo.IsV3Driver = false;
                            ADP.TraceExceptionWithoutRethrow(e);
                        }
                    }
                    else {
                        ProviderInfo.DriverVersion = "";
                    }
                }
                return ProviderInfo.IsV3Driver;
            }
        }

        [
        ResCategoryAttribute(Res.DataCategory_InfoMessage),
        ResDescriptionAttribute(Res.DbConnection_InfoMessage),
        ]
        public event OdbcInfoMessageEventHandler InfoMessage {
            add {
                infoMessageEventHandler += value;
            }
            remove {
                infoMessageEventHandler -= value;
            }
        }

        internal char EscapeChar(string method) {
            CheckState(method);
            if (!ProviderInfo.HasEscapeChar) {
                string escapeCharString;
                escapeCharString = GetInfoStringUnhandled(ODBC32.SQL_INFO.SEARCH_PATTERN_ESCAPE);
                Debug.Assert((escapeCharString.Length <= 1), "Can't handle multichar quotes");
                ProviderInfo.EscapeChar = (escapeCharString.Length==1)?escapeCharString[0]:QuoteChar(method)[0];
            }
            return ProviderInfo.EscapeChar;
        }

        internal string QuoteChar(string method) {
            CheckState(method);
            if (!ProviderInfo.HasQuoteChar) {
                string quoteCharString;
                quoteCharString = GetInfoStringUnhandled(ODBC32.SQL_INFO.IDENTIFIER_QUOTE_CHAR);
                Debug.Assert((quoteCharString.Length <= 1), "Can't handle multichar quotes");
                ProviderInfo.QuoteChar = (1==quoteCharString.Length)?quoteCharString:"\0";
            }
            return ProviderInfo.QuoteChar;
        }

        new public OdbcTransaction BeginTransaction() {
            return BeginTransaction(IsolationLevel.Unspecified);
            }

        new public OdbcTransaction BeginTransaction(IsolationLevel isolevel) {
            return (OdbcTransaction)InnerConnection.BeginTransaction(isolevel);
            }

        private void RollbackDeadTransaction() {
            WeakReference weak = weakTransaction;
            if ((null != weak) && !weak.IsAlive) {
                weakTransaction = null;
                ConnectionHandle.CompleteTransaction(ODBC32.SQL_ROLLBACK);
            }
        }

        override public void ChangeDatabase(string value) {
            InnerConnection.ChangeDatabase(value);
            }

        internal void CheckState(string method) {
            ConnectionState state = InternalState;
            if (ConnectionState.Open != state) {
                throw ADP.OpenConnectionRequired(method, state); // MDAC 68323
            }
        }

        object ICloneable.Clone() {
            OdbcConnection clone = new OdbcConnection(this);
            Bid.Trace("<odbc.OdbcConnection.Clone|API> %d#, clone=%d#\n", ObjectID, clone.ObjectID);
            return clone;
        }

        internal bool ConnectionIsAlive(Exception innerException) {
            if (IsOpen) {
                if (!ProviderInfo.NoConnectionDead) {
                    int isDead = GetConnectAttr(ODBC32.SQL_ATTR.CONNECTION_DEAD, ODBC32.HANDLER.IGNORE);
                    if (ODBC32.SQL_CD_TRUE == isDead) {
                        Close();
                        throw ADP.ConnectionIsDisabled(innerException);
                    }
                }
                // else connection is still alive or attribute not supported
                return true;
            }
            return false;
        }

        new public OdbcCommand CreateCommand() {
            return new OdbcCommand(String.Empty, this);
            }

        internal OdbcStatementHandle CreateStatementHandle() {
            return new OdbcStatementHandle(ConnectionHandle);
        }

        override public void Close() {
            InnerConnection.CloseConnection(this, ConnectionFactory);

            OdbcConnectionHandle connectionHandle = _connectionHandle;

            if (null != connectionHandle) {
                _connectionHandle = null;

                // If there is a pending transaction, automatically rollback.
                WeakReference weak = this.weakTransaction;
                if (null != weak) {
                    this.weakTransaction = null;
                    IDisposable transaction = weak.Target as OdbcTransaction;
                    if ((null != transaction) && weak.IsAlive) {
                        transaction.Dispose();
                    }
                    // else transaction will be rolled back when handle is disposed
                }
                connectionHandle.Dispose();
            }
        }

        private void DisposeMe(bool disposing) { // MDAC 65459
        }

        public void EnlistDistributedTransaction(System.EnterpriseServices.ITransaction transaction) {
            EnlistDistributedTransactionHelper(transaction);
        }        
        
        internal string GetConnectAttrString(ODBC32.SQL_ATTR attribute) {
            string value = "";
            Int32 cbActual = 0;
            byte[] buffer = new byte[100];
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            if (null != connectionHandle) {
                ODBC32.RetCode retcode = connectionHandle.GetConnectionAttribute(attribute, buffer, out cbActual);
                if (buffer.Length+2 <= cbActual) {
                    // 2 bytes for unicode null-termination character
                    // retry with cbActual because original buffer was too small
                    buffer = new byte[cbActual + 2];
                    retcode = connectionHandle.GetConnectionAttribute(attribute, buffer, out cbActual);
                }
                if ((ODBC32.RetCode.SUCCESS == retcode) || (ODBC32.RetCode.SUCCESS_WITH_INFO == retcode)) {
                    value = Encoding.Unicode.GetString(buffer, 0, Math.Min(cbActual, buffer.Length));
                }
                else if (retcode == ODBC32.RetCode.ERROR) {
                    string sqlstate = GetDiagSqlState();
                    if (("HYC00" == sqlstate) || ("HY092" == sqlstate) || ("IM001" == sqlstate)) {
                        FlagUnsupportedConnectAttr(attribute);
                    }
                    // not throwing errors if not supported or other failure
                }
            }
            return value;
        }

        internal int GetConnectAttr(ODBC32.SQL_ATTR attribute, ODBC32.HANDLER handler) {
            Int32 retval = -1;
            Int32 cbActual = 0;
            byte[] buffer = new byte[4];
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            if (null != connectionHandle) {
                ODBC32.RetCode retcode = connectionHandle.GetConnectionAttribute(attribute, buffer, out cbActual);
                
                if ((ODBC32.RetCode.SUCCESS == retcode) || (ODBC32.RetCode.SUCCESS_WITH_INFO == retcode)) {
                    retval = BitConverter.ToInt32(buffer, 0);
                }
                else {
                    if (retcode == ODBC32.RetCode.ERROR) {
                        string sqlstate = GetDiagSqlState();
                        if (("HYC00" == sqlstate) || ("HY092" == sqlstate) || ("IM001" == sqlstate)) {
                            FlagUnsupportedConnectAttr(attribute);
                        }
                    }
                    if (handler == ODBC32.HANDLER.THROW) {
                        this.HandleError(connectionHandle, retcode);
                    }
                }
            }
            return retval;
        }

        private string GetDiagSqlState () {
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            string sqlstate;
            connectionHandle.GetDiagnosticField(out sqlstate);
            return sqlstate;
        }

        internal ODBC32.RetCode GetInfoInt16Unhandled(ODBC32.SQL_INFO info, out Int16 resultValue) {
            byte[] buffer = new byte[2];
            ODBC32.RetCode retcode = ConnectionHandle.GetInfo1(info, buffer);
            resultValue = BitConverter.ToInt16(buffer, 0);
            return retcode;
        }

        internal ODBC32.RetCode GetInfoInt32Unhandled(ODBC32.SQL_INFO info, out Int32 resultValue) {
            byte[] buffer = new byte[4];
            ODBC32.RetCode retcode = ConnectionHandle.GetInfo1(info, buffer);
            resultValue = BitConverter.ToInt32(buffer, 0);
            return retcode;
        }

        private Int32 GetInfoInt32Unhandled(ODBC32.SQL_INFO infotype) {
            byte[] buffer = new byte[4];
            ConnectionHandle.GetInfo1(infotype, buffer);
            return BitConverter.ToInt32(buffer, 0);
        }
        
        internal string GetInfoStringUnhandled(ODBC32.SQL_INFO info) {
            return GetInfoStringUnhandled(info, false);
        }

        private string GetInfoStringUnhandled(ODBC32.SQL_INFO info, bool handleError) {
            //SQLGetInfo
            string value = null;
            Int16 cbActual  = 0;
            byte[] buffer = new byte[100];
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            if (null != connectionHandle) {
                ODBC32.RetCode retcode = connectionHandle.GetInfo2(info, buffer, out cbActual);
                if (buffer.Length < cbActual-2) {
                    // 2 bytes for unicode null-termination character
                    // retry with cbActual because original buffer was too small
                    buffer = new byte[cbActual + 2];
                    retcode = connectionHandle.GetInfo2(info, buffer, out cbActual);
                }
                if (retcode == ODBC32.RetCode.SUCCESS || retcode == ODBC32.RetCode.SUCCESS_WITH_INFO) {
                    value = Encoding.Unicode.GetString(buffer, 0, Math.Min(cbActual, buffer.Length));
                }
                else if (handleError) {
                    this.HandleError(ConnectionHandle, retcode);
                }
            }
            else if (handleError) {
                value = "";
            }
            return value;
        }

        // non-throwing HandleError
        internal Exception HandleErrorNoThrow(OdbcHandle hrHandle, ODBC32.RetCode retcode) {

            Debug.Assert(retcode!=ODBC32.RetCode.INVALID_HANDLE, "retcode must never be ODBC32.RetCode.INVALID_HANDLE");

            switch(retcode) {
            case ODBC32.RetCode.SUCCESS:
                break;
            case ODBC32.RetCode.SUCCESS_WITH_INFO: {
                //Optimize to only create the event objects and obtain error info if
                //the user is really interested in retriveing the events...
                if (infoMessageEventHandler != null) {
                    OdbcErrorCollection errors = ODBC32.GetDiagErrors(null, hrHandle, retcode);
                    errors.SetSource(this.Driver);
                    OnInfoMessage(new OdbcInfoMessageEventArgs(errors));
                }
                break;
            }
            default:
                OdbcException e = OdbcException.CreateException(ODBC32.GetDiagErrors(null, hrHandle, retcode), retcode);
                if (e != null) {
                    e.Errors.SetSource(this.Driver);
                }
                ConnectionIsAlive(e);        // this will close and throw if the connection is dead
                return (Exception)e;
            }
            return null;
        }

        internal void HandleError(OdbcHandle hrHandle, ODBC32.RetCode retcode) {
            Exception e = HandleErrorNoThrow(hrHandle, retcode);
            switch(retcode) {
            case ODBC32.RetCode.SUCCESS:
            case ODBC32.RetCode.SUCCESS_WITH_INFO:
                Debug.Assert(null == e, "success exception");
                break;
            default:
                Debug.Assert(null != e, "failure without exception");
                throw e;
            }
        }

        override public void Open() {
            InnerConnection.OpenConnection(this, ConnectionFactory);

            // SQLBUDT #276132 - need to manually enlist in some cases, because
            // native ODBC doesn't know about SysTx transactions.
            if (ADP.NeedManualEnlistment()) {
                EnlistTransaction(SysTx.Transaction.Current);
            }
        }

        private void OnInfoMessage(OdbcInfoMessageEventArgs args) {
            if (null != infoMessageEventHandler) {
                try {
                    infoMessageEventHandler(this, args);
                }
                catch (Exception e) {
                    // 
                    if (!ADP.IsCatchableOrSecurityExceptionType(e)) {
                        throw;
                    }
                    ADP.TraceExceptionWithoutRethrow(e);
                }
            }
        }

        static public void ReleaseObjectPool() {
            (new OdbcPermission(PermissionState.Unrestricted)).Demand();
            OdbcEnvironment.ReleaseObjectPool();
        }

        internal OdbcTransaction SetStateExecuting(string method, OdbcTransaction transaction) { // MDAC 69003
            if (null != weakTransaction) { // transaction may exist
                OdbcTransaction weak = (weakTransaction.Target as OdbcTransaction);
                if (transaction != weak) { // transaction doesn't exist
                    if (null == transaction) { // transaction exists
                        throw ADP.TransactionRequired(method);
                    }
                    if (this!= transaction.Connection) {
                        // transaction can't have come from this connection
                        throw ADP.TransactionConnectionMismatch();
                    }
                    // if transaction is zombied, we don't know the original connection
                    transaction = null; // MDAC 69264
                }
            }
            else if (null != transaction) { // no transaction started
                if (null != transaction.Connection) {
                    // transaction can't have come from this connection
                    throw ADP.TransactionConnectionMismatch();
                }
                // if transaction is zombied, we don't know the original connection
                transaction = null; // MDAC 69264
            }
            ConnectionState state = InternalState;
            if (ConnectionState.Open != state) {
                NotifyWeakReference(OdbcReferenceCollection.Recover); // recover for a potentially finalized reader

                state = InternalState;
                if (ConnectionState.Open != state) {
                    if (0 != (ConnectionState.Fetching & state)) {
                        throw ADP.OpenReaderExists();
                    }
                    throw ADP.OpenConnectionRequired(method, state);
                }
            }
            return transaction;
        }

        // This adds a type to the list of types that are supported by the driver
        // (don't need to know that for all the types)
        //

        internal void SetSupportedType (ODBC32.SQL_TYPE sqltype) {
            ODBC32.SQL_CVT sqlcvt;

            switch (sqltype) {
                case ODBC32.SQL_TYPE.NUMERIC: {
                    sqlcvt = ODBC32.SQL_CVT.NUMERIC;
                    break;
                }
                case ODBC32.SQL_TYPE.WCHAR: {
                    sqlcvt = ODBC32.SQL_CVT.WCHAR;
                    break;
                }
                case ODBC32.SQL_TYPE.WVARCHAR: {
                    sqlcvt = ODBC32.SQL_CVT.WVARCHAR;
                    break;
                }
                case ODBC32.SQL_TYPE.WLONGVARCHAR: {
                    sqlcvt = ODBC32.SQL_CVT.WLONGVARCHAR;
                    break;
                }
                default:
                    // other types are irrelevant at this time
                    return;
            }
            ProviderInfo.TestedSQLTypes |= (int)sqlcvt;
            ProviderInfo.SupportedSQLTypes |= (int)sqlcvt;
        }

        internal void FlagRestrictedSqlBindType(ODBC32.SQL_TYPE sqltype) {
            ODBC32.SQL_CVT sqlcvt;

            switch (sqltype) {
                case ODBC32.SQL_TYPE.NUMERIC: {
                    sqlcvt = ODBC32.SQL_CVT.NUMERIC;
                    break;
                }
                case ODBC32.SQL_TYPE.DECIMAL: {
                    sqlcvt = ODBC32.SQL_CVT.DECIMAL;
                    break;
                }
                default:
                    // other types are irrelevant at this time
                    return;
            }
            ProviderInfo.RestrictedSQLBindTypes |= (int)sqlcvt;
        }

        internal void FlagUnsupportedConnectAttr (ODBC32.SQL_ATTR Attribute) {
            switch (Attribute) {
                case ODBC32.SQL_ATTR.CURRENT_CATALOG:
                    ProviderInfo.NoCurrentCatalog = true;
                    break;
                case ODBC32.SQL_ATTR.CONNECTION_DEAD:
                    ProviderInfo.NoConnectionDead = true;
                    break;
                default:
                    Debug.Assert (false, "Can't flag unknown Attribute");
                    break;
            }
        }

        internal void FlagUnsupportedStmtAttr (ODBC32.SQL_ATTR Attribute) {
            switch (Attribute) {
                case ODBC32.SQL_ATTR.QUERY_TIMEOUT:
                    ProviderInfo.NoQueryTimeout = true;
                    break;
                case (ODBC32.SQL_ATTR)ODBC32.SQL_SOPT_SS.NOBROWSETABLE:
                    ProviderInfo.NoSqlSoptSSNoBrowseTable = true;
                    break;
                case (ODBC32.SQL_ATTR)ODBC32.SQL_SOPT_SS.HIDDEN_COLUMNS:
                    ProviderInfo.NoSqlSoptSSHiddenColumns = true;
                    break;
                default:
                    Debug.Assert (false, "Can't flag unknown Attribute");
                    break;
            }
        }

        internal void FlagUnsupportedColAttr (ODBC32.SQL_DESC v3FieldId, ODBC32.SQL_COLUMN v2FieldId) {
            if (IsV3Driver) {
                switch ( v3FieldId){
                    case (ODBC32.SQL_DESC)ODBC32.SQL_CA_SS.COLUMN_KEY:
                        // SSS_WARNINGS_OFF
                        ProviderInfo.NoSqlCASSColumnKey = true;
                        break;
                        // SSS_WARNINGS_ON
                    default:
                        Debug.Assert (false, "Can't flag unknown Attribute");
                        break;
                }
            }
            else {
                switch ( v2FieldId) {
                    default:
                        Debug.Assert (false, "Can't flag unknown Attribute");
                        break;
                }
            }
        }

        internal Boolean SQLGetFunctions(ODBC32.SQL_API odbcFunction) {
            //SQLGetFunctions
            ODBC32.RetCode retcode;
            Int16 fExists;
            Debug.Assert ((Int16) odbcFunction != 0,"SQL_API_ALL_FUNCTIONS is not supported");
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            if (null != connectionHandle) {
                retcode = connectionHandle.GetFunctions(odbcFunction, out fExists);
            }
            else {
                Debug.Assert (false, "GetFunctions called and ConnectionHandle is null (connection is disposed?)");
                throw ODBC.ConnectionClosed();
            }

            if(retcode != ODBC32.RetCode.SUCCESS)
                this.HandleError(connectionHandle, retcode);

            if (fExists == 0){
                return false;
            }
            else {
                return true;
            }

        }

        internal bool TestTypeSupport (ODBC32.SQL_TYPE sqltype){
            ODBC32.SQL_CONVERT sqlconvert;
            ODBC32.SQL_CVT sqlcvt;

            // we need to convert the sqltype to sqlconvert and sqlcvt first
            //
            switch (sqltype) {
                case ODBC32.SQL_TYPE.NUMERIC: {
                    sqlconvert = ODBC32.SQL_CONVERT.NUMERIC;
                    sqlcvt = ODBC32.SQL_CVT.NUMERIC;
                    break;
                }
                case ODBC32.SQL_TYPE.WCHAR: {
                    sqlconvert = ODBC32.SQL_CONVERT.CHAR;
                    sqlcvt = ODBC32.SQL_CVT.WCHAR;
                    break;
                }
                case ODBC32.SQL_TYPE.WVARCHAR: {
                    sqlconvert = ODBC32.SQL_CONVERT.VARCHAR;
                    sqlcvt = ODBC32.SQL_CVT.WVARCHAR;
                    break;
                }
                case ODBC32.SQL_TYPE.WLONGVARCHAR: {
                    sqlconvert = ODBC32.SQL_CONVERT.LONGVARCHAR;
                    sqlcvt = ODBC32.SQL_CVT.WLONGVARCHAR;
                    break;
                }
                default:
                    Debug.Assert(false, "Testing that sqltype is currently not supported");
                    return false;
            }
            // now we can check if we have already tested that type
            // if not we need to do so
            if (0 == (ProviderInfo.TestedSQLTypes & (int)sqlcvt)) {
                int flags;

                flags = GetInfoInt32Unhandled((ODBC32.SQL_INFO)sqlconvert);
                flags = flags & (int)sqlcvt;

                ProviderInfo.TestedSQLTypes |= (int)sqlcvt;
                ProviderInfo.SupportedSQLTypes |= flags;
            }

            // now check if the type is supported and return the result
            //
            return (0 != (ProviderInfo.SupportedSQLTypes & (int)sqlcvt));
        }

        internal bool TestRestrictedSqlBindType (ODBC32.SQL_TYPE sqltype){
            ODBC32.SQL_CVT sqlcvt;
            switch (sqltype) {
                case ODBC32.SQL_TYPE.NUMERIC: {
                    sqlcvt = ODBC32.SQL_CVT.NUMERIC;
                    break;
                }
                case ODBC32.SQL_TYPE.DECIMAL: {
                    sqlcvt = ODBC32.SQL_CVT.DECIMAL;
                    break;
                }
                default:
                    Debug.Assert(false, "Testing that sqltype is currently not supported");
                    return false;
            }
            return (0 != (ProviderInfo.RestrictedSQLBindTypes & (int)sqlcvt));
        }

        // suppress this message - we cannot use SafeHandle here. Also, see notes in the code (VSTFDEVDIV# 560355)
        [SuppressMessage("Microsoft.Reliability", "CA2004:RemoveCallsToGCKeepAlive")]
        override protected DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) {
            IntPtr hscp;

            Bid.ScopeEnter(out hscp, "<prov.OdbcConnection.BeginDbTransaction|API> %d#, isolationLevel=%d{ds.IsolationLevel}", ObjectID, (int)isolationLevel);
            try {

                DbTransaction transaction = InnerConnection.BeginTransaction(isolationLevel);

                // VSTFDEVDIV# 560355 - InnerConnection doesn't maintain a ref on the outer connection (this) and 
                //   subsequently leaves open the possibility that the outer connection could be GC'ed before the DbTransaction
                //   is fully hooked up (leaving a DbTransaction with a null connection property). Ensure that this is reachable
                //   until the completion of BeginTransaction with KeepAlive
                GC.KeepAlive(this);

                return transaction;
            }
            finally {
                Bid.ScopeLeave(ref hscp);
            }
        }

        internal OdbcTransaction Open_BeginTransaction(IsolationLevel isolevel) {
            OdbcConnection.ExecutePermission.Demand();

            CheckState(ADP.BeginTransaction); // MDAC 68323

            RollbackDeadTransaction();

            if ((null != this.weakTransaction) && this.weakTransaction.IsAlive) { // regression from Dispose/Finalize work
                throw ADP.ParallelTransactionsNotSupported(this);
            }

            //Use the default for unspecified.
            switch(isolevel) {
            case IsolationLevel.Unspecified:
            case IsolationLevel.ReadUncommitted:
            case IsolationLevel.ReadCommitted:
            case IsolationLevel.RepeatableRead:
            case IsolationLevel.Serializable:
            case IsolationLevel.Snapshot:
                break;
            case IsolationLevel.Chaos:
                throw ODBC.NotSupportedIsolationLevel(isolevel);
            default:
                throw ADP.InvalidIsolationLevel(isolevel);
            };

            //Start the transaction
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            ODBC32.RetCode retcode = connectionHandle.BeginTransaction(ref isolevel);
            if (retcode == ODBC32.RetCode.ERROR) {
                HandleError(connectionHandle, retcode);
            }
            OdbcTransaction transaction = new OdbcTransaction(this, isolevel, connectionHandle);
            this.weakTransaction = new WeakReference(transaction); // MDAC 69188
            return transaction;
        }

        internal void Open_ChangeDatabase(string value) {
            OdbcConnection.ExecutePermission.Demand();

            CheckState(ADP.ChangeDatabase);

            // Database name must not be null, empty or whitspace
            if ((null == value) || (0 == value.Trim().Length)) { // MDAC 62679
                throw ADP.EmptyDatabaseName();
            }
            if (1024 < value.Length*2+2) {
                throw ADP.DatabaseNameTooLong();
            }
            RollbackDeadTransaction();

            //Set the database
            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            ODBC32.RetCode retcode = connectionHandle.SetConnectionAttribute3(ODBC32.SQL_ATTR.CURRENT_CATALOG, value, checked((Int32)value.Length*2));

            if (retcode != ODBC32.RetCode.SUCCESS) {
                HandleError(connectionHandle, retcode);
            }
        }

        internal void Open_EnlistTransaction(SysTx.Transaction transaction) {
            OdbcConnection.VerifyExecutePermission();

            if ((null != this.weakTransaction) && this.weakTransaction.IsAlive) {
                throw ADP.LocalTransactionPresent();
            }

            SysTx.IDtcTransaction oleTxTransaction = ADP.GetOletxTransaction(transaction);

            OdbcConnectionHandle connectionHandle = ConnectionHandle;
            ODBC32.RetCode retcode;
            if (null == oleTxTransaction) {
                retcode = connectionHandle.SetConnectionAttribute2(ODBC32.SQL_ATTR.SQL_COPT_SS_ENLIST_IN_DTC, (IntPtr) ODBC32.SQL_DTC_DONE, ODBC32.SQL_IS_PTR);
            }
            else {
                retcode = connectionHandle.SetConnectionAttribute4(ODBC32.SQL_ATTR.SQL_COPT_SS_ENLIST_IN_DTC,  oleTxTransaction, ODBC32.SQL_IS_PTR);
            }

            if (retcode != ODBC32.RetCode.SUCCESS) {
                HandleError(connectionHandle, retcode);
            }

            // Tell the base class about our enlistment
            ((OdbcConnectionOpen)InnerConnection).EnlistedTransaction = transaction;
        }

        internal string Open_GetServerVersion() {
            //SQLGetInfo - SQL_DBMS_VER
            return GetInfoStringUnhandled(ODBC32.SQL_INFO.DBMS_VER, true);
        }
    }
}