SqlIdentifier.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DLinq / Dlinq / SqlClient / Query / SqlIdentifier.cs / 1 / SqlIdentifier.cs
                        

                        
                            using System; 
using System.Collections.Generic;
using System.Data;
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider; 
using System.Data.SqlClient;
using System.Globalization; 
using System.Linq; 
using System.Text;
using System.Text.RegularExpressions; 

namespace System.Data.Linq.SqlClient {

    internal static class SqlIdentifier 
    {
        private static SqlCommandBuilder builder = new SqlCommandBuilder(); 
 
        const string ParameterPrefix = "@";
        const string QuotePrefix = "["; 
        const string QuoteSuffix = "]";
        const string SchemaSeparator = ".";
        const char SchemaSeparatorChar = '.';
 
        private static bool IsQuoted(string s) {
            if (s == null) { 
                throw Error.ArgumentNull("s"); 
            }
 
            if (s.Length < 2) {
                return false;
            }
 
            return s.StartsWith(QuotePrefix, StringComparison.Ordinal)
                && s.EndsWith(QuoteSuffix, StringComparison.Ordinal); 
        } 

        // This is MSSQL-specific quoting. 
        // If the string begins and ends with [ and ], it will be assumed to already be quoted.
        // Otherwise periods are assumed to be namespace delimiters, and the string is split on each.
        // Each string from the split is then check to see if it is already quoted, and if
        // not, it is replaced with the result of SqlCommandBuilder.QuoteIdentifier. 
        // Then the set of strings is rejoined with periods.
        internal static string QuoteCompoundIdentifier(string s) { 
            if (s == null) { 
                throw Error.ArgumentNull("s");
            } 

            // if it starts with @, then return unprocessed
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) {
                return s; 
            } else if (IsQuoted(s)) {
                return s; 
            } 
            else if (!s.StartsWith(QuotePrefix, StringComparison.Ordinal) && s.EndsWith(QuoteSuffix, StringComparison.Ordinal)) {
                //A.[B] => [A].[B] 
                int splitPosition = s.IndexOf(SchemaSeparatorChar);
                if (splitPosition < 0){ //no . in the string
                    return builder.QuoteIdentifier(s);
                } 
                string left = s.Substring(0, splitPosition);
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1); 
                if (!IsQuoted(right)) { 
                    right = builder.QuoteIdentifier(right);
                } 
                return String.Concat(QuoteCompoundIdentifier(left), SchemaSeparatorChar + right);
            }
            else if (s.StartsWith(QuotePrefix, StringComparison.Ordinal) && !s.EndsWith(QuoteSuffix, StringComparison.Ordinal)) {
                //[A].B => [A].[B] 
                int splitPosition = s.LastIndexOf(SchemaSeparatorChar);
                if (splitPosition < 0){ //no . in the string 
                    return builder.QuoteIdentifier(s); 
                }
                string left = s.Substring(0, splitPosition); 
                if (!IsQuoted(left)) {
                    left = builder.QuoteIdentifier(left);
                }
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1); 
                return String.Concat(left + SchemaSeparatorChar, QuoteCompoundIdentifier(right));
            } 
            else { 
                int splitPosition = s.IndexOf(SchemaSeparatorChar);
                if (splitPosition < 0) { //no . in the string 
                    //A => [A]
                    return builder.QuoteIdentifier(s);
                }
                string left = s.Substring(0, splitPosition); 
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1);
                return String.Concat(QuoteCompoundIdentifier(left) + SchemaSeparatorChar, QuoteCompoundIdentifier(right)); 
            } 
        }
 
        // This is MSSQL-specific quoting.
        // This is the same as above, but it doesn't consider anything compound.
        internal static string QuoteIdentifier(string s) {
            if (s == null) { 
                throw Error.ArgumentNull("s");
            } 
 
            // if it starts with @, then return unprocessed
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) { 
                return s;
            } else if (IsQuoted(s)) {
                return s;
            } else { 
                return builder.QuoteIdentifier(s);
            } 
        } 

        // turns "[ABC].[PQR].[XYZ]" into {"[ABC]", "[PQR]", "[XYZ]"} 
        internal static IEnumerable GetCompoundIdentifierParts(string s) {
            if (s == null) {
                throw Error.ArgumentNull("s");
            } 

            // can't do this to parameters 
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) { 
                throw Error.ArgumentWrongValue("s");
            } 

            string quotedS = QuoteCompoundIdentifier(s);
            string pattern = @"^(?\[([^\]]|\]\])*\])(\.(?\[([^\]]|\]\])*\]))*$";
 
            // This pattern matches "."-delimited quoted SQL identifiers. Here's how:
            // 
            // 1. It is wrapped in "^" and "$", which match the begining and end of text, so it will match 
            //    only the entire text and not any sub-part.
            // 2. The group "(?\[([^\]]|\]\])*\])" captures a single quoted segment of the text. 
            //    It's a literal "[" followed by any number of non-"]" characters or "]]" strings, followed
            //    by a literal "]". The "?" bit names the capture so we can refer to it.
            // 3. After the first component, we will allow any number of groups which consist of a literal
            //    "." followed by a component (and the component part is a repeat of the part described in 2). 

            Match m = Regex.Match(quotedS, pattern); 
            if (!m.Success) 
            {
                throw Error.ArgumentWrongValue("s"); 
            }

            foreach (Capture cap in m.Groups["component"].Captures)
            { 
                yield return cap.Value;
            } 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Collections.Generic;
using System.Data;
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider; 
using System.Data.SqlClient;
using System.Globalization; 
using System.Linq; 
using System.Text;
using System.Text.RegularExpressions; 

namespace System.Data.Linq.SqlClient {

    internal static class SqlIdentifier 
    {
        private static SqlCommandBuilder builder = new SqlCommandBuilder(); 
 
        const string ParameterPrefix = "@";
        const string QuotePrefix = "["; 
        const string QuoteSuffix = "]";
        const string SchemaSeparator = ".";
        const char SchemaSeparatorChar = '.';
 
        private static bool IsQuoted(string s) {
            if (s == null) { 
                throw Error.ArgumentNull("s"); 
            }
 
            if (s.Length < 2) {
                return false;
            }
 
            return s.StartsWith(QuotePrefix, StringComparison.Ordinal)
                && s.EndsWith(QuoteSuffix, StringComparison.Ordinal); 
        } 

        // This is MSSQL-specific quoting. 
        // If the string begins and ends with [ and ], it will be assumed to already be quoted.
        // Otherwise periods are assumed to be namespace delimiters, and the string is split on each.
        // Each string from the split is then check to see if it is already quoted, and if
        // not, it is replaced with the result of SqlCommandBuilder.QuoteIdentifier. 
        // Then the set of strings is rejoined with periods.
        internal static string QuoteCompoundIdentifier(string s) { 
            if (s == null) { 
                throw Error.ArgumentNull("s");
            } 

            // if it starts with @, then return unprocessed
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) {
                return s; 
            } else if (IsQuoted(s)) {
                return s; 
            } 
            else if (!s.StartsWith(QuotePrefix, StringComparison.Ordinal) && s.EndsWith(QuoteSuffix, StringComparison.Ordinal)) {
                //A.[B] => [A].[B] 
                int splitPosition = s.IndexOf(SchemaSeparatorChar);
                if (splitPosition < 0){ //no . in the string
                    return builder.QuoteIdentifier(s);
                } 
                string left = s.Substring(0, splitPosition);
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1); 
                if (!IsQuoted(right)) { 
                    right = builder.QuoteIdentifier(right);
                } 
                return String.Concat(QuoteCompoundIdentifier(left), SchemaSeparatorChar + right);
            }
            else if (s.StartsWith(QuotePrefix, StringComparison.Ordinal) && !s.EndsWith(QuoteSuffix, StringComparison.Ordinal)) {
                //[A].B => [A].[B] 
                int splitPosition = s.LastIndexOf(SchemaSeparatorChar);
                if (splitPosition < 0){ //no . in the string 
                    return builder.QuoteIdentifier(s); 
                }
                string left = s.Substring(0, splitPosition); 
                if (!IsQuoted(left)) {
                    left = builder.QuoteIdentifier(left);
                }
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1); 
                return String.Concat(left + SchemaSeparatorChar, QuoteCompoundIdentifier(right));
            } 
            else { 
                int splitPosition = s.IndexOf(SchemaSeparatorChar);
                if (splitPosition < 0) { //no . in the string 
                    //A => [A]
                    return builder.QuoteIdentifier(s);
                }
                string left = s.Substring(0, splitPosition); 
                string right = s.Substring(splitPosition + 1, s.Length - splitPosition - 1);
                return String.Concat(QuoteCompoundIdentifier(left) + SchemaSeparatorChar, QuoteCompoundIdentifier(right)); 
            } 
        }
 
        // This is MSSQL-specific quoting.
        // This is the same as above, but it doesn't consider anything compound.
        internal static string QuoteIdentifier(string s) {
            if (s == null) { 
                throw Error.ArgumentNull("s");
            } 
 
            // if it starts with @, then return unprocessed
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) { 
                return s;
            } else if (IsQuoted(s)) {
                return s;
            } else { 
                return builder.QuoteIdentifier(s);
            } 
        } 

        // turns "[ABC].[PQR].[XYZ]" into {"[ABC]", "[PQR]", "[XYZ]"} 
        internal static IEnumerable GetCompoundIdentifierParts(string s) {
            if (s == null) {
                throw Error.ArgumentNull("s");
            } 

            // can't do this to parameters 
            if (s.StartsWith(ParameterPrefix, StringComparison.Ordinal)) { 
                throw Error.ArgumentWrongValue("s");
            } 

            string quotedS = QuoteCompoundIdentifier(s);
            string pattern = @"^(?\[([^\]]|\]\])*\])(\.(?\[([^\]]|\]\])*\]))*$";
 
            // This pattern matches "."-delimited quoted SQL identifiers. Here's how:
            // 
            // 1. It is wrapped in "^" and "$", which match the begining and end of text, so it will match 
            //    only the entire text and not any sub-part.
            // 2. The group "(?\[([^\]]|\]\])*\])" captures a single quoted segment of the text. 
            //    It's a literal "[" followed by any number of non-"]" characters or "]]" strings, followed
            //    by a literal "]". The "?" bit names the capture so we can refer to it.
            // 3. After the first component, we will allow any number of groups which consist of a literal
            //    "." followed by a component (and the component part is a repeat of the part described in 2). 

            Match m = Regex.Match(quotedS, pattern); 
            if (!m.Success) 
            {
                throw Error.ArgumentWrongValue("s"); 
            }

            foreach (Capture cap in m.Groups["component"].Captures)
            { 
                yield return cap.Value;
            } 
        } 
    }
} 

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

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• TextInfo.cs
• SqlTriggerContext.cs
• XmlAggregates.cs
• RoleManagerSection.cs
• CodeTryCatchFinallyStatement.cs
• UnsignedPublishLicense.cs
• WindowsFormsLinkLabel.cs
• SqlBulkCopy.cs
• MDIClient.cs
• TreeNodeEventArgs.cs
• RenderingEventArgs.cs
• ToolStripDropDownClosingEventArgs.cs
• JsonSerializer.cs
• ToolStripContainerActionList.cs
• StyleModeStack.cs
• XmlILConstructAnalyzer.cs
• Utility.cs
• COMException.cs
• AspNetHostingPermission.cs
• RuleConditionDialog.Designer.cs
• DropDownButton.cs
• XmlSchemaIdentityConstraint.cs
• StoreContentChangedEventArgs.cs
• ObjectManager.cs
• GeometryDrawing.cs
• ConstraintStruct.cs
• StreamUpdate.cs
• SerializationInfoEnumerator.cs
• CheckableControlBaseAdapter.cs
• BadImageFormatException.cs
• Connection.cs
• AddInBase.cs
• WeakReferenceEnumerator.cs
• MinMaxParagraphWidth.cs
• RelatedPropertyManager.cs
• ApplicationDirectory.cs
• ComponentEditorPage.cs
• UnsafeNativeMethods.cs
• MaxMessageSizeStream.cs
• MessageAction.cs
• DataListItemCollection.cs
• ObfuscateAssemblyAttribute.cs
• HeaderedContentControl.cs
• OpenTypeLayout.cs
• AppliesToBehaviorDecisionTable.cs
• MultiBindingExpression.cs
• CollectionContainer.cs
• DrawTreeNodeEventArgs.cs
• ContainerControlDesigner.cs
• RestHandler.cs
• DirectoryNotFoundException.cs
• RadioButton.cs
• SessionStateModule.cs
• KeyNotFoundException.cs
• ErasingStroke.cs
• CaseStatement.cs
• DeploymentSection.cs
• IndividualDeviceConfig.cs
• SpanIndex.cs
• PropertyTab.cs
• DataGridComboBoxColumn.cs
• TemplateBuilder.cs
• ErrorRuntimeConfig.cs
• ImageMap.cs
• CodeDOMUtility.cs
• PerformanceCountersElement.cs
• BorderGapMaskConverter.cs
• LeaseManager.cs
• ProfileEventArgs.cs
• ConfigurationElement.cs
• IPipelineRuntime.cs
• ExpressionSelection.cs
• ValidationHelpers.cs
• DebugView.cs
• PrimaryKeyTypeConverter.cs
• ValidationErrorCollection.cs
• Camera.cs
• CompressStream.cs
• DaylightTime.cs
• CurrentChangedEventManager.cs
• AnnotationAdorner.cs
• CodeCompileUnit.cs
• PreloadedPackages.cs
• StructuredTypeInfo.cs
• RestHandler.cs
• DispatcherFrame.cs
• GeneratedView.cs
• Repeater.cs
• EntityDataSourceChangedEventArgs.cs
• ShapingEngine.cs
• ClientData.cs
• TextMessageEncodingBindingElement.cs
• ProfileBuildProvider.cs
• DataContractSerializerSection.cs
• DocumentXPathNavigator.cs
• ConfigDefinitionUpdates.cs
• TraceHandlerErrorFormatter.cs
• TableStyle.cs
• TextBoxLine.cs
• UnsignedPublishLicense.cs