public DataSourceInformation(DataTable dt)
        {
            //DataTable dt = Connection.GetSchema(
            //   DbMetaDataCollectionNames.DataSourceInformation);
            foreach (DataRow r in dt.Rows)
            {
                foreach (DataColumn c in dt.Columns)
                {
                    string s = c.ColumnName;
                    object o = r[c.ColumnName];
                    //just for safety
                    if (o == DBNull.Value)
                    {
                        o = null;
                    }
                    if (!string.IsNullOrEmpty(s) && o != null)
                    {
                        switch (s)
                        {
                        case "QuotedIdentifierCase":
                            _quotedIdentifierCase = new Regex(o.ToString());
                            break;

                        case "StringLiteralPattern":
                            _stringLiteralPattern = new Regex(o.ToString());
                            break;

                        case "GroupByBehavior":
                            o = Convert.ChangeType(o, _GroupByBehaviorType);
                            _groupByBehavior = (GroupByBehavior)o;
                            break;

                        case "IdentifierCase":
                            o = Convert.ChangeType(o, _IdentifierCaseType);
                            _identifierCase = (IdentifierCase)o;
                            break;

                        case "SupportedJoinOperators":
                            o = Convert.ChangeType(o, _SupportedJoinOperatorsType);
                            _supportedJoinOperators = (SupportedJoinOperators)o;
                            // (o as SupportedJoinOperators?) ??
                            //    SupportedJoinOperators.None;
                            break;

                        default:
                            FieldInfo fi = _Type.GetField("_" + s,
                                                          BindingFlags.IgnoreCase | BindingFlags.NonPublic |
                                                          BindingFlags.Instance);
                            if (fi != null)
                            {
                                fi.SetValue(this, o);
                            }
                            break;
                        }
                    }
                }
                //there should only ever be a single row.
                break;
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Adds a row to the given <c>DataSourceInformationCollection</c> table.
        /// </summary>
        /// <param name="table">
        /// The table to which to add the row.
        /// </param>
        /// <param name="compositeIdentifierSeparatorPattern">
        /// The composite identifier separator pattern.
        /// </param>
        /// <param name="dataSourceProductName">
        /// Name of the data source product.
        /// </param>
        /// <param name="dataSourceProductVersion">
        /// The data source product version.
        /// </param>
        /// <param name="dataSourceProductVersionNormalized">
        /// The data source product version normalized.
        /// </param>
        /// <param name="groupByBehavior">
        /// The group by behavior.
        /// </param>
        /// <param name="identifierPattern">
        /// The identifier pattern.
        /// </param>
        /// <param name="identifierCase">
        /// The identifier case.
        /// </param>
        /// <param name="orderByColumnsInSelect">
        /// if set to <c>true</c> [order by columns in select].
        /// </param>
        /// <param name="parameterMarkerFormat">
        /// The parameter marker format.
        /// </param>
        /// <param name="parameterMarkerPattern">
        /// The parameter marker pattern.
        /// </param>
        /// <param name="parameterNameMaxLength">
        /// Length of the parameter name max.
        /// </param>
        /// <param name="parameterNamePattern">
        /// The parameter name pattern.
        /// </param>
        /// <param name="quotedIdentifierPattern">
        /// The quoted identifier pattern.
        /// </param>
        /// <param name="quotedIdentifierCase">
        /// The quoted identifier case.
        /// </param>
        /// <param name="statementSeparatorPattern">
        /// The statement separator pattern.
        /// </param>
        /// <param name="stringLiteralPattern">
        /// The string literal pattern.
        /// </param>
        /// <param name="supportedJoinOperators">
        /// The supported join operators.
        /// </param>
        public static void AddRow(
            DataTable table,
            string compositeIdentifierSeparatorPattern,
            string dataSourceProductName,
            string dataSourceProductVersion,
            string dataSourceProductVersionNormalized,
            GroupByBehavior groupByBehavior,
            string identifierPattern,
            IdentifierCase identifierCase,
            bool orderByColumnsInSelect,
            string parameterMarkerFormat,
            string parameterMarkerPattern,
            int parameterNameMaxLength,
            string parameterNamePattern,
            string quotedIdentifierPattern,
            IdentifierCase quotedIdentifierCase,
            string statementSeparatorPattern,
            string stringLiteralPattern,
            SupportedJoinOperators supportedJoinOperators)
        {
            DataRow row = table.NewRow();

            row[MDCN.CompositeIdentifierSeparatorPattern]
                = compositeIdentifierSeparatorPattern;
            row[MDCN.DataSourceProductName]    = dataSourceProductName;
            row[MDCN.DataSourceProductVersion] = dataSourceProductVersion;
            row[MDCN.DataSourceProductVersionNormalized]
                = dataSourceProductVersionNormalized;
            row[MDCN.GroupByBehavior]           = groupByBehavior;
            row[MDCN.IdentifierPattern]         = identifierPattern;
            row[MDCN.IdentifierCase]            = identifierCase;
            row[MDCN.OrderByColumnsInSelect]    = orderByColumnsInSelect;
            row[MDCN.ParameterMarkerFormat]     = parameterMarkerFormat;
            row[MDCN.ParameterMarkerPattern]    = parameterMarkerPattern;
            row[MDCN.ParameterNameMaxLength]    = parameterNameMaxLength;
            row[MDCN.ParameterNamePattern]      = parameterNamePattern;
            row[MDCN.QuotedIdentifierPattern]   = quotedIdentifierPattern;
            row[MDCN.QuotedIdentifierCase]      = quotedIdentifierCase;
            row[MDCN.StatementSeparatorPattern] = statementSeparatorPattern;
            row[MDCN.StringLiteralPattern]      = stringLiteralPattern;
            row[MDCN.SupportedJoinOperators]    = supportedJoinOperators;

            table.Rows.Add(row);
        }
 public DataSourceInformation(DataTable dt)
 {
     //DataTable dt = Connection.GetSchema(
     //   DbMetaDataCollectionNames.DataSourceInformation);
     foreach (DataRow r in dt.Rows)
     {
         foreach (DataColumn c in dt.Columns)
         {
             string s = c.ColumnName;
             object o = r[c.ColumnName];
             //just for safety
             if (o == DBNull.Value)
             {
                 o = null;
             }
             if (!string.IsNullOrEmpty(s) && o != null)
             {
                 switch (s)
                 {
                     case "QuotedIdentifierCase":
                         _quotedIdentifierCase = new Regex(o.ToString());
                         break;
                     case "StringLiteralPattern":
                         _stringLiteralPattern = new Regex(o.ToString());
                         break;
                     case "GroupByBehavior":
                         o = Convert.ChangeType(o, _GroupByBehaviorType);
                         _groupByBehavior = (GroupByBehavior)o;
                         break;
                     case "IdentifierCase":
                         o = Convert.ChangeType(o, _IdentifierCaseType);
                         _identifierCase = (IdentifierCase)o;
                         break;
                     case "SupportedJoinOperators":
                         o = Convert.ChangeType(o, _SupportedJoinOperatorsType);
                         _supportedJoinOperators = (SupportedJoinOperators)o;
                         // (o as SupportedJoinOperators?) ??
                         //    SupportedJoinOperators.None;
                         break;
                     default:
                         FieldInfo fi = _Type.GetField("_" + s,
                           BindingFlags.IgnoreCase | BindingFlags.NonPublic |
                           BindingFlags.Instance);
                         if (fi != null)
                         {
                             fi.SetValue(this, o);
                         }
                         break;
                 }
             }
         }
         //there should only ever be a single row.
         break;
     }
 }
        /// <summary>
        /// Adds a row to the given <c>DataSourceInformationCollection</c> table.
        /// </summary>
        /// <param name="table">
        /// The table to which to add the row.
        /// </param>
        /// <param name="compositeIdentifierSeparatorPattern">
        /// The composite identifier separator pattern.
        /// </param>
        /// <param name="dataSourceProductName">
        /// Name of the data source product.
        /// </param>
        /// <param name="dataSourceProductVersion">
        /// The data source product version.
        /// </param>
        /// <param name="dataSourceProductVersionNormalized">
        /// The data source product version normalized.
        /// </param>
        /// <param name="groupByBehavior">
        /// The group by behavior.
        /// </param>
        /// <param name="identifierPattern">
        /// The identifier pattern.
        /// </param>
        /// <param name="identifierCase">
        /// The identifier case.
        /// </param>
        /// <param name="orderByColumnsInSelect">
        /// if set to <c>true</c> [order by columns in select].
        /// </param>
        /// <param name="parameterMarkerFormat">
        /// The parameter marker format.
        /// </param>
        /// <param name="parameterMarkerPattern">
        /// The parameter marker pattern.
        /// </param>
        /// <param name="parameterNameMaxLength">
        /// Length of the parameter name max.
        /// </param>
        /// <param name="parameterNamePattern">
        /// The parameter name pattern.
        /// </param>
        /// <param name="quotedIdentifierPattern">
        /// The quoted identifier pattern.
        /// </param>
        /// <param name="quotedIdentifierCase">
        /// The quoted identifier case.
        /// </param>
        /// <param name="statementSeparatorPattern">
        /// The statement separator pattern.
        /// </param>
        /// <param name="stringLiteralPattern">
        /// The string literal pattern.
        /// </param>
        /// <param name="supportedJoinOperators">
        /// The supported join operators.
        /// </param>
        public static void AddRow(
            DataTable table,
            string compositeIdentifierSeparatorPattern,
            string dataSourceProductName,
            string dataSourceProductVersion,
            string dataSourceProductVersionNormalized,
            GroupByBehavior groupByBehavior,
            string identifierPattern,
            IdentifierCase identifierCase,
            bool orderByColumnsInSelect,
            string parameterMarkerFormat,
            string parameterMarkerPattern,
            int parameterNameMaxLength,
            string parameterNamePattern,
            string quotedIdentifierPattern,
            IdentifierCase quotedIdentifierCase,
            string statementSeparatorPattern,
            string stringLiteralPattern,
            SupportedJoinOperators supportedJoinOperators)
        {
            DataRow row = table.NewRow();

            row[MDCN.CompositeIdentifierSeparatorPattern]
                = compositeIdentifierSeparatorPattern;
            row[MDCN.DataSourceProductName] = dataSourceProductName;
            row[MDCN.DataSourceProductVersion] = dataSourceProductVersion;
            row[MDCN.DataSourceProductVersionNormalized]
                = dataSourceProductVersionNormalized;
            row[MDCN.GroupByBehavior] = groupByBehavior;
            row[MDCN.IdentifierPattern] = identifierPattern;
            row[MDCN.IdentifierCase] = identifierCase;
            row[MDCN.OrderByColumnsInSelect] = orderByColumnsInSelect;
            row[MDCN.ParameterMarkerFormat] = parameterMarkerFormat;
            row[MDCN.ParameterMarkerPattern] = parameterMarkerPattern;
            row[MDCN.ParameterNameMaxLength] = parameterNameMaxLength;
            row[MDCN.ParameterNamePattern] = parameterNamePattern;
            row[MDCN.QuotedIdentifierPattern] = quotedIdentifierPattern;
            row[MDCN.QuotedIdentifierCase] = quotedIdentifierCase;
            row[MDCN.StatementSeparatorPattern] = statementSeparatorPattern;
            row[MDCN.StringLiteralPattern] = stringLiteralPattern;
            row[MDCN.SupportedJoinOperators] = supportedJoinOperators;

            table.Rows.Add(row);
        }
        private DataTable GetDataSourceInformationCollection(string[] restrictions, OdbcConnection connection)
        {
            ODBC32.RetCode code;
            int            num;
            short          num2;

            if (!ADP.IsEmptyArray(restrictions))
            {
                throw ADP.TooManyRestrictions(DbMetaDataCollectionNames.DataSourceInformation);
            }
            if (base.CollectionDataSet.Tables[DbMetaDataCollectionNames.DataSourceInformation] == null)
            {
                throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataSourceInformation);
            }
            DataTable table = base.CloneAndFilterCollection(DbMetaDataCollectionNames.DataSourceInformation, null);

            if (table.Rows.Count != 1)
            {
                throw ADP.IncorrectNumberOfDataSourceInformationRows();
            }
            DataRow row = table.Rows[0];
            string  infoStringUnhandled = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.CATALOG_NAME_SEPARATOR);

            if (!ADP.IsEmpty(infoStringUnhandled))
            {
                StringBuilder escapedString = new StringBuilder();
                ADP.EscapeSpecialCharacters(infoStringUnhandled, escapedString);
                row[DbMetaDataColumnNames.CompositeIdentifierSeparatorPattern] = escapedString.ToString();
            }
            infoStringUnhandled = connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.DBMS_NAME);
            if (infoStringUnhandled != null)
            {
                row[DbMetaDataColumnNames.DataSourceProductName] = infoStringUnhandled;
            }
            row[DbMetaDataColumnNames.DataSourceProductVersion]           = base.ServerVersion;
            row[DbMetaDataColumnNames.DataSourceProductVersionNormalized] = base.ServerVersionNormalized;
            row[DbMetaDataColumnNames.ParameterMarkerFormat]  = "?";
            row[DbMetaDataColumnNames.ParameterMarkerPattern] = @"\?";
            row[DbMetaDataColumnNames.ParameterNameMaxLength] = 0;
            if (connection.IsV3Driver)
            {
                code = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_30, out num);
            }
            else
            {
                code = connection.GetInfoInt32Unhandled(ODBC32.SQL_INFO.SQL_OJ_CAPABILITIES_20, out num);
            }
            if ((code == ODBC32.RetCode.SUCCESS) || (code == ODBC32.RetCode.SUCCESS_WITH_INFO))
            {
                SupportedJoinOperators none = SupportedJoinOperators.None;
                if ((num & 1) != 0)
                {
                    none |= SupportedJoinOperators.LeftOuter;
                }
                if ((num & 2) != 0)
                {
                    none |= SupportedJoinOperators.RightOuter;
                }
                if ((num & 4) != 0)
                {
                    none |= SupportedJoinOperators.FullOuter;
                }
                if ((num & 0x20) != 0)
                {
                    none |= SupportedJoinOperators.Inner;
                }
                row[DbMetaDataColumnNames.SupportedJoinOperators] = none;
            }
            code = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.GROUP_BY, out num2);
            GroupByBehavior unknown = GroupByBehavior.Unknown;

            if ((code == ODBC32.RetCode.SUCCESS) || (code == ODBC32.RetCode.SUCCESS_WITH_INFO))
            {
                switch (num2)
                {
                case 0:
                    unknown = GroupByBehavior.NotSupported;
                    break;

                case 1:
                    unknown = GroupByBehavior.ExactMatch;
                    break;

                case 2:
                    unknown = GroupByBehavior.MustContainAll;
                    break;

                case 3:
                    unknown = GroupByBehavior.Unrelated;
                    break;
                }
            }
            row[DbMetaDataColumnNames.GroupByBehavior] = unknown;
            code = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.IDENTIFIER_CASE, out num2);
            IdentifierCase insensitive = IdentifierCase.Unknown;

            if ((code == ODBC32.RetCode.SUCCESS) || (code == ODBC32.RetCode.SUCCESS_WITH_INFO))
            {
                switch (num2)
                {
                case 1:
                case 2:
                case 4:
                    insensitive = IdentifierCase.Insensitive;
                    break;

                case 3:
                    insensitive = IdentifierCase.Sensitive;
                    break;
                }
            }
            row[DbMetaDataColumnNames.IdentifierCase] = insensitive;
            switch (connection.GetInfoStringUnhandled(ODBC32.SQL_INFO.ORDER_BY_COLUMNS_IN_SELECT))
            {
            case "Y":
                row[DbMetaDataColumnNames.OrderByColumnsInSelect] = true;
                break;

            case "N":
                row[DbMetaDataColumnNames.OrderByColumnsInSelect] = false;
                break;
            }
            infoStringUnhandled = connection.QuoteChar("GetSchema");
            if (((infoStringUnhandled != null) && (infoStringUnhandled != " ")) && (infoStringUnhandled.Length == 1))
            {
                StringBuilder builder = new StringBuilder();
                ADP.EscapeSpecialCharacters(infoStringUnhandled, builder);
                string str2 = builder.ToString();
                builder.Length = 0;
                ADP.EscapeSpecialCharacters(infoStringUnhandled, builder);
                builder.Append("(([^");
                builder.Append(str2);
                builder.Append("]|");
                builder.Append(str2);
                builder.Append(str2);
                builder.Append(")*)");
                builder.Append(str2);
                row[DbMetaDataColumnNames.QuotedIdentifierPattern] = builder.ToString();
            }
            code = connection.GetInfoInt16Unhandled(ODBC32.SQL_INFO.QUOTED_IDENTIFIER_CASE, out num2);
            IdentifierCase sensitive = IdentifierCase.Unknown;

            if ((code == ODBC32.RetCode.SUCCESS) || (code == ODBC32.RetCode.SUCCESS_WITH_INFO))
            {
                switch (num2)
                {
                case 1:
                case 2:
                case 4:
                    sensitive = IdentifierCase.Insensitive;
                    break;

                case 3:
                    sensitive = IdentifierCase.Sensitive;
                    break;
                }
            }
            row[DbMetaDataColumnNames.QuotedIdentifierCase] = sensitive;
            table.AcceptChanges();
            return(table);
        }