SqlCommandBuilder.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / Data / System / Data / SqlClient / SqlCommandBuilder.cs / 1 / SqlCommandBuilder.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
//----------------------------------------------------------------------------- 
 
namespace System.Data.SqlClient {
 
    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Data; 
    using System.Data.Common;
    using System.Data.Sql; 
    using System.Data.SqlTypes; 
    using System.Diagnostics;
    using System.Globalization; 
    using System.Text;
    using System.Runtime.CompilerServices;
    using System.Threading;
 
#if WINFSInternalOnly
    internal 
#else 
    public
#endif 
    sealed class SqlCommandBuilder : DbCommandBuilder {

        public SqlCommandBuilder() : base() {
            GC.SuppressFinalize(this); 
            base.QuotePrefix = "["; // initialize base with defaults
            base.QuoteSuffix = "]"; 
        } 

        public SqlCommandBuilder(SqlDataAdapter adapter) : this() { 
            DataAdapter = adapter;
        }

        /// SqlServer only supports CatalogLocation.Start 
        [
        Browsable(false), 
        EditorBrowsableAttribute(EditorBrowsableState.Never) , 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ] 
        public override CatalogLocation CatalogLocation {
            get {
                return CatalogLocation.Start;
            } 
            set {
                if (CatalogLocation.Start != value) { 
                    throw ADP.SingleValuedProperty("CatalogLocation", "Start"); 
                }
            } 
        }

        /// SqlServer only supports '.'
        [ 
        Browsable(false),
        EditorBrowsableAttribute(EditorBrowsableState.Never), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public override string CatalogSeparator { 
            get {
                return ".";
            }
            set { 
                if ("." != value) {
                    throw ADP.SingleValuedProperty("CatalogSeparator", "."); 
                } 
            }
        } 

        [
        DefaultValue(null),
        ResCategoryAttribute(Res.DataCategory_Update), 
        ResDescriptionAttribute(Res.SqlCommandBuilder_DataAdapter), // MDAC 60524
        ] 
        new public SqlDataAdapter DataAdapter { 
            get {
                return (SqlDataAdapter)base.DataAdapter; 
            }
            set {
                base.DataAdapter = value;
            } 
        }
 
        /// SqlServer only supports '.' 
        [
        Browsable(false), 
        EditorBrowsableAttribute(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public override string QuotePrefix { 
            get {
                return base.QuotePrefix; 
            } 
            set {
                if (("[" != value) && ("\"" != value)){ 
                    throw ADP.DoubleValuedProperty("QuotePrefix", "[", "\"");
                }
                base.QuotePrefix = value;
            } 
        }
 
        [ 
        Browsable(false),
        EditorBrowsableAttribute(EditorBrowsableState.Never), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public override string QuoteSuffix {
            get { 
                return base.QuoteSuffix;
            } 
            set { 
                if (("]" != value) && ("\"" != value)) {
                    throw ADP.DoubleValuedProperty("QuoteSuffix", "]", "\""); 
                }
                base.QuoteSuffix = value;
            }
        } 

        [ 
        Browsable(false), 
        EditorBrowsableAttribute(EditorBrowsableState.Never),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), 
        ]
        public override string SchemaSeparator {
            get {
                return "."; 
            }
            set { 
                if ("." != value) { 
                    throw ADP.SingleValuedProperty("SchemaSeparator",".");
                } 
            }
        }

        private void SqlRowUpdatingHandler(object sender, SqlRowUpdatingEventArgs ruevent) { 
            base.RowUpdatingHandler(ruevent);
        } 
 
        new public SqlCommand GetInsertCommand() {
            return (SqlCommand) base.GetInsertCommand(); 
        }
        new public SqlCommand GetInsertCommand(bool useColumnsForParameterNames) {
            return (SqlCommand) base.GetInsertCommand(useColumnsForParameterNames);
        } 

        new public SqlCommand GetUpdateCommand() { 
            return (SqlCommand) base.GetUpdateCommand(); 
        }
        new public SqlCommand GetUpdateCommand(bool useColumnsForParameterNames) { 
            return (SqlCommand) base.GetUpdateCommand(useColumnsForParameterNames);
        }

        new public SqlCommand GetDeleteCommand() { 
            return (SqlCommand) base.GetDeleteCommand();
        } 
        new public SqlCommand GetDeleteCommand(bool useColumnsForParameterNames) { 
            return (SqlCommand) base.GetDeleteCommand(useColumnsForParameterNames);
        } 

        override protected void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause) {
            SqlParameter p = (SqlParameter) parameter;
            object valueType = datarow[SchemaTableColumn.ProviderType]; 
            p.SqlDbType = (SqlDbType) valueType;
            p.Offset    = 0; 
 
            if ((p.SqlDbType == SqlDbType.Udt) && !p.SourceColumnNullMapping) {
                p.UdtTypeName = datarow["DataTypeName"] as string; 
            }
            else {
                p.UdtTypeName = String.Empty;
            } 

            object bvalue = datarow[SchemaTableColumn.NumericPrecision]; 
            if (DBNull.Value != bvalue) { 
                byte bval = (byte)(short)bvalue;
                p.PrecisionInternal = ((0xff != bval) ? bval : (byte)0); 
            }

            bvalue = datarow[SchemaTableColumn.NumericScale];
            if (DBNull.Value != bvalue) { 
                byte bval = (byte)(short)bvalue;
                p.ScaleInternal = ((0xff != bval) ? bval : (byte)0); 
            } 
        }
 
        override protected string GetParameterName(int parameterOrdinal) {
            return "@p" + parameterOrdinal.ToString(System.Globalization.CultureInfo.InvariantCulture);
        }
        override protected string GetParameterName(string parameterName) { 
            return "@" + parameterName;
        } 
 
        override protected string GetParameterPlaceholder(int parameterOrdinal) {
            return "@p" + parameterOrdinal.ToString(System.Globalization.CultureInfo.InvariantCulture); 
        }

        private void ConsistentQuoteDelimiters(string quotePrefix, string quoteSuffix){
 
            Debug.Assert(quotePrefix == "\"" || quotePrefix == "[");
            if ((("\"" == quotePrefix) && ("\"" != quoteSuffix)) || 
                (("[" == quotePrefix) && ("]" != quoteSuffix))) { 
                throw ADP.InvalidPrefixSuffix();
            } 

        }
        static public void DeriveParameters(SqlCommand command) { // MDAC 65927\
            SqlConnection.ExecutePermission.Demand(); 

            if (null == command) { 
                throw ADP.ArgumentNull("command"); 
            }
            RuntimeHelpers.PrepareConstrainedRegions(); 
            try {
#if DEBUG
                object initialReliabilitySlotValue = Thread.GetData(TdsParser.ReliabilitySlot);
                RuntimeHelpers.PrepareConstrainedRegions(); 
                try {
                    Thread.SetData(TdsParser.ReliabilitySlot, true); 
#endif 
                    command.DeriveParameters();
#if DEBUG 
                }
                finally {
                    Thread.SetData(TdsParser.ReliabilitySlot, initialReliabilitySlotValue);
                } 
#endif
            } 
            catch (System.OutOfMemoryException e) { 
                if (null != command && null != command.Connection) {
                    command.Connection.Abort(e); 
                }
                throw;
            }
            catch (System.StackOverflowException e) { 
                if (null != command && null != command.Connection) {
                    command.Connection.Abort(e); 
                } 
                throw;
            } 
            catch (System.Threading.ThreadAbortException e)  {
                if (null != command && null != command.Connection) {
                    command.Connection.Abort(e);
                } 
                throw;
            } 
        } 

 
/*        private static void GetLiteralInfo (DataRow dataTypeRow, out string literalPrefix, out string literalSuffix) {

            Object tempValue = dataTypeRow[DbMetaDataColumnNames.LiteralPrefix];
            if (tempValue == DBNull.Value) { 
                literalPrefix = "";
            } 
            else { 
                literalPrefix = (string)dataTypeRow[DbMetaDataColumnNames.LiteralPrefix];
            } 
            tempValue = dataTypeRow[DbMetaDataColumnNames.LiteralSuffix];
            if (tempValue == DBNull.Value) {
                literalSuffix = "";
            } 
            else {
                literalSuffix = (string)dataTypeRow[DbMetaDataColumnNames.LiteralSuffix]; 
            } 
        }
*/ 

        protected override DataTable GetSchemaTable (DbCommand srcCommand) {
            SqlCommand sqlCommand = srcCommand as SqlCommand;
            SqlNotificationRequest  notificationRequest     = sqlCommand.Notification; 
            bool                    notificationAutoEnlist  = sqlCommand.NotificationAutoEnlist;
 
            sqlCommand.Notification             = null; 
            sqlCommand.NotificationAutoEnlist   = false;
 
            try {
                using (SqlDataReader dataReader = sqlCommand.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo)){
                    return dataReader.GetSchemaTable();
                } 
            }
            finally { 
                sqlCommand.Notification             = notificationRequest; 
                sqlCommand.NotificationAutoEnlist   = notificationAutoEnlist;
            } 

        }

        protected override DbCommand InitializeCommand(DbCommand command) { 
            SqlCommand cmd = (SqlCommand) base.InitializeCommand(command);
            cmd.NotificationAutoEnlist = false; 
            return cmd; 
        }
 
        public override string QuoteIdentifier(string unquotedIdentifier){
            ADP.CheckArgumentNull(unquotedIdentifier, "unquotedIdentifier");
            string quoteSuffixLocal = QuoteSuffix;
            string quotePrefixLocal = QuotePrefix; 
            ConsistentQuoteDelimiters(quotePrefixLocal, quoteSuffixLocal);
            return ADP.BuildQuotedString(quotePrefixLocal,quoteSuffixLocal,unquotedIdentifier);; 
        } 

        override protected void SetRowUpdatingHandler(DbDataAdapter adapter) { 
            Debug.Assert(adapter is SqlDataAdapter, "!SqlDataAdapter");
            if (adapter == base.DataAdapter) { // removal case
                ((SqlDataAdapter)adapter).RowUpdating -= SqlRowUpdatingHandler;
            } 
            else { // adding case
                ((SqlDataAdapter)adapter).RowUpdating += SqlRowUpdatingHandler; 
            } 
        }
 
        public override string UnquoteIdentifier(string quotedIdentifier){

            ADP.CheckArgumentNull(quotedIdentifier, "quotedIdentifier");
            String unquotedIdentifier; 
            string quoteSuffixLocal = QuoteSuffix;
            string quotePrefixLocal = QuotePrefix; 
            ConsistentQuoteDelimiters(quotePrefixLocal, quoteSuffixLocal); 
            // ignoring the return value becasue an unquoted source string is OK here
            ADP.RemoveStringQuotes(quotePrefixLocal, quoteSuffixLocal, quotedIdentifier, out unquotedIdentifier); 
            return unquotedIdentifier;
       }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK