Monthly Archive for: ‘May, 2007’

Wooah, every day we get a little closer to the world of Star Trek

http://www.microsoft.com/surface/

Needless to say, I want one… 

As discussed recently, I’ve been trying to knock together a class struct to represent a UK postcode, provide a means of parsing a string as potentially being a valid postcode (or optionally just an outer code), and split that postcode into “outer” and “inner” code.  The result of my efforts is shown below

I say potentially because, as you’ll know if you’ve looked into this topic at all, it’s impossible to validate whether a string truly does represent a postcode without querying the (copyrighted and expensive-to-license) Postcode Address File.  As a result, my solution is not very stringent – it is possible to persuade it to successfully parse an invalid postcode, but hopefully there should be no occasions when a valid postcode is rejected.

The code validates strings by checking for compliance with the standards defined in BS7666, followed by checking for BFPO postcodes, and finally for a handful of notable exceptions (e.g. Girobank).  If you know of any valid postcodes that are rejected by this routine, do let me know.

Oh, and incidentally, this was the first time I’ve used Visual Studio Orcas in anger to develop anything meatier than a Hello World.  Although I wasn’t exactly pushing the technological envelope, I found the IDE to be pretty fast and stable, considering it’s a beta 1.

Source available on GitHub at https://github.com/ianfnelson/Postcode

using System;
using System.Text.RegularExpressions;

namespace IanFNelson.Utilities
{
    /// <summary>
    /// Represents a United Kingdom postcode.
    /// </summary>
    ///
    /// For more details, see http://ianfnelson.com/archives/2007/05/29/postcodestruct
    ///
    [Serializable]
    public struct Postcode
    {
        private static string regexBS7666Outer =
            "(?[A-PR-UWYZ]" +
            "([0-9]{1,2}|([A-HK-Y]
[0-9]|[A-HK-Y]
[0-9]([0-9]|[ABEHMNPRV-Y]))|[0-9]
[A-HJKS-UW]))";

        private static string regexBS7666Inner = "(?[0-9]
[ABD-HJLNP-UW-Z]{2})";
        private static readonly string regexBS7666Full = regexBS7666Outer + regexBS7666Inner;
        private static readonly string regexBS7666OuterStandAlone = string.Concat(regexBS7666Outer + "\\s*$");
        private static string regexBfpoOuter = "(?BFPO)";
        private static string regexBfpoInner = "(?[0-9]{1,3})";
        private static readonly string regexBfpoFull = regexBfpoOuter + regexBfpoInner;
        private static readonly string regexBfpoOuterStandalone = string.Concat(regexBfpoOuter + "\\s*$");

        private static readonly string[,] exceptionsToTheRule =
            {
                {"GIR", "0AA"}, // Girobank
                {"SAN", "TA1"}, // Santa Claus
                {"ASCN", "1ZZ"}, // Ascension Island
                {"BIQQ", "1ZZ"}, // British Antarctic Territory
                {"BBND", "1ZZ"}, // British Indian Ocean Territory
                {"FIQQ", "1ZZ"}, // Falkland Islands
                {"PCRN", "1ZZ"}, // Pitcairn Islands
                {"STHL", "1ZZ"}, // Saint Helena
                {"SIQQ", "1ZZ"}, // South Georgia and the Sandwich Islands
                {"TDCU", "1ZZ"}, // Tristan da Cunha
                {"TKCA", "1ZZ"} // Turks and Caicos Islands
            };

        private string _inCode;
        private string _outCode;

        /// <summary>
        /// Outer portion of the Postcode
        /// </summary>
        public string OutCode
        {
            get { return _outCode; }
            private set { _outCode = value; }
        }

        /// <summary>
        /// Inner portion of the Postcode
        /// </summary>
        public string InCode
        {
            get { return _inCode; }
            private set { _inCode = value; }
        }

        /// <summary>
        /// Parses a string as a Postcode.
        /// </summary>
        ///String to be parsed
        /// Postcode object
        ///
        /// If the passed string cannot be parsed as a UK postcode
        ///
        /// Using this overload, the inner code is not mandatory.
        public static Postcode Parse(string s)
        {
            return Parse(s, false);
        }

        /// <summary>
        /// Parses a string as a Postcode.
        /// </summary>
        ///String to be parsed
        ///
        /// Indicates that the string passed must include a valid inner code.
        ///
        /// Postcode object
        ///
        /// If the passed string cannot be parsed as a UK postcode
        ///
        public static Postcode Parse(string s, bool incodeMandatory)
        {
            var p = new Postcode();
            if (TryParse(s, out p, incodeMandatory))
                return p;
            throw new FormatException();
        }

        /// <summary>
        /// Attempts to parse a string as a Postcode.
        /// </summary>
        ///String to be parsed
        ///Postcode object
        ///
        /// Boolean indicating whether the string was successfully parsed as a UK Postcode
        ///
        /// Using this overload, the inner code is not mandatory.
        public static bool TryParse(string s, out Postcode result)
        {
            return TryParse(s, out result, false);
        }

        /// <summary>
        /// Attempts to parse a string as a Postcode.
        /// </summary>
        ///String to be parsed
        ///Postcode object
        ///
        /// Indicates that the string passed must include a valid inner code.
        ///
        ///
        /// Boolean indicating whether the string was successfully parsed as a UK Postcode
        ///
        public static bool TryParse(string s, out Postcode result, bool incodeMandatory)
        {
            // Set output to new Postcode
            result = new Postcode();
            // Copy the input before messing with it
            var input = s;
            // Guard clause - check for null or empty string
            if (string.IsNullOrEmpty(input)) return false;
            // uppercase input and strip undesirable characters
            input = Regex.Replace(input.ToUpperInvariant(), "[^A-Z0-9]", string.Empty);
            // guard clause - input is more than seven characters
            if (input.Length > 7) return false;

            #region BS7666 Matching

            // Try to match full standard postcode
            var fullMatch = Regex.Match(input, regexBS7666Full);
            if (fullMatch.Success)
            {
                result.OutCode = fullMatch.Groups["outCode"].Value;
                result.InCode = fullMatch.Groups["inCode"].Value;
                return true;
            }
            // Try to match outer standard postcode only
            var outerMatch = Regex.Match(input, regexBS7666OuterStandAlone);
            if (outerMatch.Success)
            {
                if (incodeMandatory) return false;
                result.OutCode = outerMatch.Groups["outCode"].Value;
                return true;
            }

            #endregion

            #region BFPO Matching

            // Try to match full BFPO postcode
            var bfpoFullMatch = Regex.Match(input, regexBfpoFull);
            if (bfpoFullMatch.Success)
            {
                result.OutCode = bfpoFullMatch.Groups["outCode"].Value;
                result.InCode = bfpoFullMatch.Groups["inCode"].Value;
                return true;
            }
            // Try to match outer BFPO postcode
            var bfpoOuterMatch = Regex.Match(input, regexBfpoOuterStandalone);
            if (bfpoOuterMatch.Success)
            {
                if (incodeMandatory) return false;
                result.OutCode = bfpoOuterMatch.Groups["outCode"].Value;
                return true;
            }

            #endregion

            #region Exceptions to the rule matching

            // Loop through exceptions to the rule
            for (var i = 0; i < exceptionsToTheRule.GetLength(0); i++)
            {
                // Check for a full match
                if (input == string.Concat(exceptionsToTheRule[i, 0], exceptionsToTheRule[i, 1]))
                {
                    result.OutCode = exceptionsToTheRule[i, 0];
                    result.InCode = exceptionsToTheRule[i, 1];
                    return true;
                }
                // Check for partial match only
                if (input == exceptionsToTheRule[i, 0])
                {
                    if (incodeMandatory) return false;
                    result.OutCode = exceptionsToTheRule[i, 0];
                    return true;
                }
            }

            #endregion

            return false;
        }

        /// <summary>
        /// Returns a string representation of this postcode
        /// </summary>
        ///
        public override string ToString()
        {
            if (string.IsNullOrEmpty(InCode))
            {
                return OutCode;
            }
            else
            {
                return string.Concat(OutCode, " ", InCode);
            }
        }
    }
}

Wikipedia cracks me up sometimes.  I’m sat here at my desk, trying to knock together some C# code to quickly validate an entered string as being a UK postcode.  Naturally I turned to this Wikipedia article for assistance, where I find this quip:

"Automatic validation of postcodes on the basis of pattern feasibility is therefore almost impossible to design, and the system contains no self-validating feature such as a check digit. Completely accurate validation is only possible by attempting to deliver mail to the address, and verifying with the recipient."

I think that’s what is known as a long-running transaction!!

Update – the C# code that I wrote to handle this issue is available here.

Many moons (and about four jobs) ago, a wise DBA by the name of David Hanson once recommended to me a book called Microsoft SQL Server 2000 Unleashed.  I took his advice, bought a copy, and it rapidly became one of the most dog-eared and oft-thumbed computing books I have ever owned.  It is comprehensive, deep, broad, well-written and covers everything one might ever wish to know about SQL Server 2000. With its help and guidance I came to love and respect Microsoft’s premier database product, passing the 70-229 exam by a comfortable margin.

So, following the release of SQL Server 2005, I was hoping that SAMS would publish a similar tome about that new platform.  Once said book was announced, I pre-ordered* a copy, and I’m delighted to report that after many months of patient waiting, the sequel (sorry) landed on my desk last week – and for a computing book, it’s simply awesome.

Microsoft SQL Server 2005 Unleashed is even bigger than it’s predecessor.  In fact, it’s so large that eight chapters have been left out of the physical book, and are included only in a PDF version supplied on CD-ROM.  These aren’t just padding or filler, either – they’re solid chapters on interesting topics as Notification Services, Service Broker, Recovery Planning, and T-SQL Tips n Tricks.  Including the bonus chapters, the whole package weighs in at over 2,000 pages – no wonder I had to wait a while for its publication!

I think you would be hard-pressed to find any other single SQL 2005 book which covers quite so much material to such depth. While perhaps not being suitable for beginners, for those with some experience of SQL Server or other relational database products, this book works on many levels – reference, tutorial, guidance, or just as an interesting read.  If you work with, or anticipate working with, SQL 2005, then you owe it to yourself to get a copy now!

* I hate this term, but that’s what Amazon call it – “pre-order”.  Whilst I understand the implication, I don’t think there’s any real linguistic difference between “ordering” and “pre-ordering”.  Even less so the distinction between to “book” and to “pre-book”, a service offered by some cinemas…