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

• WebBrowsableAttribute.cs
• TranslateTransform3D.cs
• DataColumnMappingCollection.cs
• SocketAddress.cs
• OracleParameter.cs
• LinqDataSource.cs
• ReservationCollection.cs
• BitmapEffect.cs
• DoubleLink.cs
• BindableTemplateBuilder.cs
• ManagedIStream.cs
• PreProcessor.cs
• ObjectPropertyMapping.cs
• ExitEventArgs.cs
• KnownBoxes.cs
• TextEndOfParagraph.cs
• RijndaelManaged.cs
• SystemIPAddressInformation.cs
• FormsAuthentication.cs
• PopOutPanel.cs
• DriveNotFoundException.cs
• DropShadowEffect.cs
• AsymmetricSecurityBindingElement.cs
• ExtensionQuery.cs
• SendActivity.cs
• TagNameToTypeMapper.cs
• CreateSequence.cs
• Char.cs
• DoubleSumAggregationOperator.cs
• StorageAssociationTypeMapping.cs
• Size.cs
• SqlErrorCollection.cs
• DBAsyncResult.cs
• Point3DCollectionConverter.cs
• LinkDescriptor.cs
• RealizationDrawingContextWalker.cs
• DetailsViewUpdateEventArgs.cs
• CodeTypeConstructor.cs
• SchemaImporterExtension.cs
• SqlDeflator.cs
• PackWebRequest.cs
• CounterCreationDataCollection.cs
• ImageCollectionCodeDomSerializer.cs
• RecordBuilder.cs
• XXXOnTypeBuilderInstantiation.cs
• ListViewItem.cs
• EdmScalarPropertyAttribute.cs
• CachedBitmap.cs
• KeyToListMap.cs
• Bezier.cs
• Rectangle.cs
• FlowLayoutPanel.cs
• ResourceDefaultValueAttribute.cs
• QilTernary.cs
• Renderer.cs
• wgx_render.cs
• CommandDevice.cs
• DataTable.cs
• EventBuilder.cs
• AssemblyHelper.cs
• EntityViewGenerationAttribute.cs
• ConfigurationElementProperty.cs
• FormatterConverter.cs
• FormattedTextSymbols.cs
• ObjectAnimationUsingKeyFrames.cs
• DataKey.cs
• XNodeValidator.cs
• CacheMemory.cs
• StorageConditionPropertyMapping.cs
• BamlMapTable.cs
• DateTimeOffsetAdapter.cs
• IdentityHolder.cs
• CalendarDateChangedEventArgs.cs
• HttpWrapper.cs
• WebBrowserDocumentCompletedEventHandler.cs
• PopOutPanel.cs
• MethodToken.cs
• SecurityHeaderTokenResolver.cs
• AuthenticatedStream.cs
• CharacterMetrics.cs
• ObjectListFieldCollection.cs
• Accessors.cs
• RadioButtonFlatAdapter.cs
• SynchronizingStream.cs
• FlagsAttribute.cs
• Unit.cs
• Control.cs
• IDispatchConstantAttribute.cs
• CqlQuery.cs
• ToolStripOverflowButton.cs
• Sql8ConformanceChecker.cs
• HelloOperationAsyncResult.cs
• diagnosticsswitches.cs
• CancellationState.cs
• DataRowChangeEvent.cs
• CreateUserWizard.cs
• CompilationUtil.cs
• PrintEvent.cs
• Property.cs
• TemplateField.cs