//------------------------------------------------------------------------------
// <copyright file="SqlCommandBuilder.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
 
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;
 
    public 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;
        }
 
        /// <devnote>SqlServer only supports CatalogLocation.Start</devnote>
        [
        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");
                }
            }
        }
 
        /// <devnote>SqlServer only supports '.'</devnote>
        [
        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;
            }
        }
 
        /// <devnote>SqlServer only supports '.'</devnote>
        [
        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");
            }
            TdsParser bestEffortCleanupTarget = null;
            RuntimeHelpers.PrepareConstrainedRegions();
            try {
#if DEBUG
                TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection();
 
                RuntimeHelpers.PrepareConstrainedRegions();
                try {
                    tdsReliabilitySection.Start();
#else
                {
#endif
                    bestEffortCleanupTarget = SqlInternalConnection.GetBestEffortCleanupTarget(command.Connection);
                    command.DeriveParameters();
                }
#if DEBUG
                finally {
                    tdsReliabilitySection.Stop();
                }
#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);
                }
                SqlInternalConnection.BestEffortCleanup(bestEffortCleanupTarget);
                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;
       }
    }
}