THE SQL Server Blog Spot on the Web

Welcome to - The SQL Server blog spot on the web Sign in | |
in Search

Rob Farley

- Owner/Principal with LobsterPot Solutions (a MS Gold Partner consulting firm), Microsoft Certified Master, Microsoft MVP (SQL Server), APS/PDW trainer and leader of the SQL User Group in Adelaide, Australia. Rob is a former director of PASS, and provides consulting and training courses around the world in SQL Server and BI topics.

  • Learning through others

    This PASS Summit was a different experience for me – I wasn’t speaking. I’ve presented at three of the five PASS Summits I’ve been to, where the previous one I’d not spoken at was 2012, while I was a PASS Director (and had been told I shouldn’t submit talks – advice that I’d ignored in 2013). I have to admit that I really missed presenting, both in 2012 and this year, and I will need to improve my session abstracts to make sure I get selected in future years.

    I’m not a very good ‘session attendee’ on the whole – it’s not my preferred style of learning – but I still wanted to go, because of the learning involved. Sometimes I will learn a lot from the various things that are mentioned in the few sessions I go to, but more significantly, I learn a lot from discussions with other people. I hear what they are doing with technology, and that encourages me to explore those technologies further. It’s not quite at the point of learning by osmosis simply by being in the presence of people who know stuff, but by developing relationships with people, and hearing them speak about the things they’re doing, I definitely learn a lot.

    Of course, I don’t get to know people for the sake of learning. I get to know people because I like getting to know people. But of course, one of the things I have in common with these people is SQL, and conversations often come around to that. And I know that I learn a lot from those conversations. I don’t have the luxury of living near many (any?) of my friends in the data community, and spending time with them in person definitely helps me.TSQL2sDay150x150

    And it’s not just SQL stuff that I learn. This month’s T-SQL Tuesday (for which this is a post) is hosted by Chris Yates (@YatesSQL), who I got to run alongside on one of the mornings. Even that was a learning experience for me, as we chatted about all kinds of things, and I listened to my feet hitting the ground – another technique I learned from a community – and made sure I stuck to my running form to minimise the pain I’d be feeling later in the day. Talking to Chris while I ran helped immensely, and I was far less sore than I thought I might be.

    On the SQL side, I got to learn about how excited people are about scale-out, with technologies like Stretched Tables coming very soon. As someone involved in the Parallel Data Warehouse space (and seriously – how thrilled was I to be able to chat with Dr Rimma Nehme, who was involved in the PDW Query Optimizer), scale-out is very much in my thoughts, and seeing what Microsoft is doing in this space is great – but learning what other people in the community are thinking about it is even more significant for me.


    PS: This is the 60th T-SQL Tuesday. Huge thanks to Adam Machanic (@adammachanic) for starting this, and giving me something to write about each month these last five years.

  • PASS Summit WIT Lunch

    With the pleasant sound of cutlery on crockery, those lucky enough to secure tickets to the WIT Lunch at the PASS Summit get to listen to an interview with Kimberly Bryant, who is the founder of a non-profit organisation called Black Girls Code – helping teenaged girls from low-privilege communities to get into technology.

    She calls herself an Accidental Entrepreneur, driven by her passion to see the less-privileged have opportunities to explore an industry that was dominated by a very different part of the community. Her daughter was interested in tech, and went on a tech-focused summer camp, where she was the only non-white kid, and one of only three girls. With a crowd of about 40, that was less than ten percent of the camp.

    What Kimberly saw at the camp, and in other environments that are dominated by a particular demographic, was that the people who were providing for the group would cater for the masses, and not the minorities. From an economic perspective, I’m sure this makes sense. If you’re going to find something that caters for a particular cluster of people, a particular type of person, then targetting the larger clusters is likely to give the ‘best results’. But (my opinion) this is ignoring the fact that the larger clusters of people tend to be catered for by just about anything. In my experience, if someone is part of a larger cluster, they have a large amount of support from their peers already, and need less from the organisers. But if the organisers can ensure that the edges of the group are looked after, then the ones in the middle will still be just fine, and the whole group will be encouraged.

    Diversity is something that the IT industry suffers from, and I do mean ‘suffer’. Without good diversity, our industry is held back. Stupidly, our industry keeps shooting itself in the foot, and it’s the larger clusters of people – I guess that means people like me – who need to take a stand when we see things that would alienate minority groups.

    Kimberly Bryant points out that teams need diversity, and that hiring decisions need to ensure that they don’t turn away people because of diversity. For myself, as a business owner, I hope that I never turn someone away because of diversity, because I do agree that teams need diversity. What I love the most though, is that what Kimberly has done is to develop programs to make sure that people from a particular minority group present as stronger candidates to hiring managers.

    Let’s encourage people from minority groups to get into IT. We’ll all benefit from it.


  • Dr Rimma Nehme at the PASS Summit

    This Summit’s presentation from Microsoft Research Labs is from Dr Rimma Nehme, bucking the trend of having presentations from Dr David DeWitt. I’m really pleased to be able to hear from her, because she’s an absolute legend.

    Among her qualifications is work on the PDW Query Optimizer – a topic closer to me than probably any other area of SQL Server. I just wish I had known this a few minutes ago when I met her, but I’m sure she’ll chat more freely after her big presentation.

    Today she’s talking about Cloud Computing, which is great because the cloud space has changed significantly in recent years, and it’s good to hear from Microsoft Research Labs again. For example, analysing the power-effectiveness of a data centre by comparing the total power used by a data centre against the computing power of a data centre. This leads to exploring more effective systems, such as evaporative cooling (which is used by many Australian homes and businesses, of course), making energy-responsibility a key component of cloud computing. With such an effort being put into cloud computing, the globally-responsible option is to use the cloud.

    The five key drivers for cloud that Dr Nehme listed are:

    • Elasticity
    • No CapEx
    • Pay Per Use
    • Focus on Business
    • Fast Time To Market

    These are all huge, of course, and the business aspects are massive. It’s increasingly easy to persuade businesses to move to the cloud, but the exciting thing about the technologies that have been discussed this week is the elasticity point.

    Microsoft is doing huge amounts of work to let people scale out easily. New technologies such as Stretched Tables will allow people to have hybrid solutions between on-prem and cloud like never before. With a background in the PDW Query Optimizer, Dr Nehme is the perfect person to be exploring what’s going on with spreading the load across multiple cloud-based machines for these scale-out solutions.

    The cloud means that many database professionals worry about their jobs. I’m sure people felt the same way when the industrial revolution came through. People who work on production-lines have been replaced by robots, and database administrators who only do high availability don’t need to handle that in the cloud space. But they will not be redundant. Dr Nehme just said “Cloud was not designed to be a threat to DBAs”, and this is significant. The key here is that we have more data than ever, and we need to be able to use computing power effectively.

    We can’t keep going with the amount of data that is appearing, and we need to be more responsible than ever.

    Great keynote, Dr Nehme. I hope this is the first of many keynotes from you.


  • PASS Summit – Thursday Keynote

    It’s good to point out it’s still only Thursday, as my laptop tells me that it’s already Friday.

    Today is the second of only two keynotes this Summit, which means that it’s the opportunity to hear from Microsoft Research Labs about what’s going on with data from their perspective.

    It’s also when we get to hear from the PASS VPs – community members that I used to serve with on the PASS Board of Directors – about how PASS is doing from a Financial and Marketing perspective.

    One of the interesting things about PASS is that there are reserves of over a million dollars. I mention this because it’s an area that some people is quite “interesting” for a community and non-profit organisation, but I want to point out that these savings help let PASS be more free in what they (we?) do. Having a million dollars in the bank means that PASS can reach out and do things that will serve the community, even if it seems like it could be risky. There is a lot of risk in running the Summit every year, and this is the most obvious area that PASS could need money to cover costs that might not come back if, say, there’s another volcano eruption in Iceland. I saw first-hand the freedom that PASS had because of the reserves (although some risks were still very high and freedom does not mean irresponsibility), and I know this is a good thing.

    From the marketing perspective, the celebration of individuals who have gone beyond the norm is a great part of the Summit event, and the PASSion Award winner has been announced as Andrey Korshikov. This guy has done so much for the Russian Data Community, making him the most influential SQL person in the largest country of the world. You can’t go past that…


  • Keynote technologies – new or not?

    So I’m sitting in the PASS Summit keynote, and there are some neat things being shown.

    Something that just appeared on the screen was around having the location of shoppers being shown on a plan of a store. There were some ‘Oohs’ coming from around the room, as they mentioned that Kinect was being used to track locations. Hotspots were appearing on a time-driven picture.

    But the thing that I think is most exciting is that this is almost all achievable right now. Collecting information from Kinect is something that my friends John & Bronwen have been presenting about for years, and displaying things on custom maps in Power BI (complete with hotspots) is also very achievable. If you don’t know how to do this, get along to Hope Foley’s session this afternoon (Wed 5th), as she explores more of what’s possible with Power Map. She wrote a post recently about Custom Maps in Power Map, which is a great blog post, walking through how to show spatial data on the plan of a building, playing it against a time dimension.

    The stuff in the keynote is excellent – much of it is future, but if you’re at the PASS Summit, you can be having conversations with many of the world’s best experts about how to revolutionise your data story, not just in the future, but right now.


  • PASS Summit keynote

    The PASS Summit has kicked off again with a tremendous keynote from Ranga. He's been in the role at Microsoft for a little over a year now, and has really come into his own, as can be seen by the presentation this morning. The changes to the data picture haven't changed hugely over the past year, although the "Internet of Things" space is increasing quickly.


    With that, the speed of growth in data volume has kicked in harder than ever. Being able to collect, process, and analyse the kinds of volume that we're now facing means that scaling is major feature being discussed. In recent years, this meant looking at Big Data and the ways that this can hook into our existing solutions, and technologies like Hekaton have allowed us to scale up to handle huge numbers of transactions in a scale-up scenario.

    This year, though, we see scale-out having a refreshed focus. We're hearing talk of 'sharding' more, and the idea of being able to use multiple databases (including cloud-based ones) to achieve scale on demand – an elasticity that suits business more than ever.

    Most of our customers at LobsterPot see changes in the amount of business that’s going on across the year, with some having certain key days requiring orders of magnitude more traffic than on ‘normal’ days. They already scale out their websites, but data is another matter. Databases typically scale UP, not OUT.

    My work in the Analytics Platform System / Parallel Data Warehouse space makes me acutely aware of the challenges around scaling out data. When you need to perform joins between tables which have their data in different databases, on different servers, there are problems that need addressing. A lot of it happens behind the scenes through complex data movement techniques, so that it looks like a normal query. This is stuff that is hard to do through clever data

    What we’re seeing this morning are some of the ways that Microsoft is providing scale out technology in SQL Server and SQL Database. Considering they now have over a million SQL Database databases in Azure, thinking about how to leverage this technology to enhance on-prem SQL Server databases to provide a new level of hybrid is very interesting.

    One of these technologies is Stretched Tables, which we saw this morning. This is about being able to take a table in SQL Server and stretch it into SQL Databases in Azure. This means that the table will be sharded across on-prem and cloud – hot data being stored locally, and more-rarely used data being stored in the cloud. For queries that need to access data that’s in the cloud, data can can be extracted from the cloud tables, pushing predicates down to pull back part of the data, transparently (as far as the user is concerned).

    This is not like using linked servers and views, handling inserts with triggers. This is achieving hybrid behind the scenes, giving users a logical layer they can query to access their information whether it’s local or in the cloud.

    Until now, I’ve always felt that ‘hybrid’ has been about using some components locally and other components in the cloud. But what we’re seeing now are ways that ‘hybrid’ can mean that we have the core of our database – the tables themselves – are handled in a hybrid way.

    Exciting times ahead…


  • LobsterPot staff are influential, outstanding and valuable

    The title of the post says it all, but let me explain why…

    It’s not news that LobsterPot has three SQL Server MVPs on staff. Ted received his fifth award earlier in the year, and this month saw Julie get her second award and a ninth for me.

    But not only that, Julie was recognised as one of Nine Influential Women by Solutions Review magazine, and Martin received an Outstanding Volunteer Award from the PASS organisation. Ted and Julie have both received this award in the past, and former employee Roger Noble also received this award while he was working for us. It’s all further evidence that LobsterPot staff really are very special.


  • Heroes of SQL

    Every story has heroes. Some heroes distinguish themselves by their superpowers; others by extraordinary bravery or compassion; some are simply heroes because of what they do in their jobs.

    We picture the men and women who work in the emergency departments of hospitals, soldiers who go back into the line of fire to rescue their colleagues, and of course, those who have been bitten by radioactive spiders.

    We don’t tend picture people who work with databases.

    But let me explain something – at the PASS Summit next month, you will come across a large number of heroes. The people who are presenting show extraordinary bravery to stand up in front of a room full of people who want to learn and who will write some of the nastiest things about them in evaluation forms. The members of the SQL Server Product Group (who you can see at the SQL Clinic) from Microsoft have incredible information about how SQL Server works on the inside. And then you have people like Paul White, Jon Kehayias and Ted Krueger, who have obviously spent too much time around arachnids with short half-lives.

    The amazing thing about the SQL Server community is their willingness to be heroes – not only by stepping up at conferences, but in helping people with their every day problems. It’s one thing to be a hero to help those in your workplace, by making sure that backups are performed, and that your databases are checked for corruption regularly, but people in the SQL Server community help people they don’t know on forums, they write blogs posts, and they attend (and organise) SQL Saturdays and other events so that they can sit and talk to strangers.

    The PASS Summit is the biggest gathering of SQL professionals in the world each year. So come along and see why people in the SQL community are different.TSQL2sDay150x150

    They’re heroes.


    PS: Thanks to another SQL Hero, Tracy McKibben (@realsqlguy), for his effort in hosting this month’s T-SQL Tuesday.

  • Less than a month away...

    The PASS Summit for 2014 is nearly upon us, and the MVP Summit is immediately prior, in the same week and the same city. This is my first MVP Summit since early 2008. I’ve been invited every year, but I simply haven’t prioritised it. I’ve been awarded MVP status every year since 2006 (just received my ninth award), but in 2009 and 2010 I attended SQLBits in the UK, and have been to every PASS Summit since then. This year, it’s great that I get to do both Summits in the same trip, but if I get to choose just one, then it’s an easy decision.

    So let me tell you why the PASS Summit is the bigger priority for me.

    Number of people

    Actually, the PASS Summit isn’t that much larger than the MVP Summit, but the MVP Summit has thousands of non-SQL MVPs, and only a few hundred in the SQL space. Because of this, the ‘average conversation with a stranger’ is very different. While it can be fascinating to meet someone who is an MVP for File System Storage, the PASS Summit has me surrounded by people who do what I do, and it makes for more better conversations as I learn about who people are and what they do.

    Access to Microsoft

    The NDA content that MVPs learn at the MVP Summit is good, but the PASS Summit will have content about every-SQL-thing you ever want. The same Microsoft people who present at the MVP Summit are also at the PASS Summit, and dedicate time to the SQL Clinic, which means that you can spend even more time working through ideas and problems with them. You don’t get this at the MVP Summit.


    Obviously not everyone can go to the MVP Summit, as it’s a privilege that comes as part of the MVP award each year (although it’s hardly ‘free’ when you have to fly there from Australia). While it may seem like an exclusive event is going to be, well, exclusive, most MVPs are all about the wider community, and thrive on being around non-MVPs. There are less than 400 SQL MVPs around the world, and ten times that number of SQL experts at the Summit. While some of the top experts might be MVPs, a lot of them are not, and the PASS Summit is a chance to meet those people each year.

    Content from the best

    The MVP Summit has presentations from people who work on the product. At my first MVP Summit, this was a huge deal. And it’s still good to hear what these guys are thinking, under NDA, when they can actually go into detail that they know won’t leave the room. But you don’t get to hear from Paul White at the MVP Summit, or Erin Stellato, or Julie Koesmarno, or any of the other non-Microsoft presenters. The PASS Summit gives the best of both worlds.

    I’m really looking forward to the MVP Summit. I’ve missed the last six, and it’s been too long. MVP Summits were when I met some of my oldest SQL friends, such as Kalen Delaney, Adam Machanic, Simon Sabin, Paul & Kimberly, and Jamie Thomson. The opportunities are excellent. But the PASS Summit is what the community is about.

    MVPs are MVPs because of the community – and that’s what the PASS Summit is about. That’s the one I’m looking forward to the most.


  • Passwords

    Another month, and another T-SQL Tuesday. I have some blog posts I’ve been meaning to write, but the scheduling of T-SQL Tuesday and my determination to keep my record of never having missed one keeps me going. This month is hosted by Sebastian Meine (@sqlity), and is on the topic of Passwords.


    Passwords are so often in the news. We read about how passwords are stolen through security breaches on a regular basis, and have plenty of suggestions on how using complex passwords can help (although the fact that tools such as 1Password put passwords on the clipboard must be an issue…), or that we should use passwords that are complex through length but simple in form such as a sentence – and we naturally see jump in on things with poignant commentary on life in a tech world.

    This post is actually not to tell you all to avoid using passwords more than once, or to use sufficiently complex that you don’t put onto your clipboard, or anything like that.

    Instead, I want you to think about what a password means.

    A password means that you have secret information that only you have. It’s what ‘secret’ means. As soon as you tell that secret information to multiple places, it’s not secret any more. Anyone who has seen my passport knows where I was born, and there are plenty of ways to work out my mother’s maiden name, yet these are considered ‘secret’ information that can be used to check that I’m me.

    These days, I carry multiple RSA tokens around with me, so that I can log into client sites, or connect to bank’s internet banking. The codes on these devices are considered secret, but actually, they contain a secret piece of information that can be used to identify me, through the codes they generate. Combining a password and these codes is considered enough to identify me, but not in a way that can let someone else in a few seconds later when the numbers change.

    When I develop SSIS packages for clients, or just about anything that needs to connect to sensitive data, I don’t try to figure out what passwords need to be included. Where possible (frustratingly it’s not always), I don’t include passwords in database connections at all – it’s secret information that I shouldn’t have to know. Instead, I let the package run with credentials that are stored within the SQL instance. When the package is deployed, it can run with the appropriate permissions, according to the rights given to the user identified in the credential. The trust that is established by the credential is enough to let it do what it needs to, and all I need to tell the package is “Assume you have sufficient rights for this.” I don’t need to store the password anywhere in the package that way, and I’m separated from production data, as every developer should be.

    I studied cryptography at university, although that was nearly twenty years ago and I hope things have moved on since then. I know various algorithms have been ‘cracked’, but the principles of providing secret information for identification carry on. I believe public/private key pairs are still excellent methods of proving that someone is who they say they are, so that I can generate something that you know comes from me, and you can generate something that only I can decrypt (and by using both my key pair and yours will allow us to have a secure conversation – until one of our private keys is compromised).

    Today we need to be able to identify ourselves through multiple devices and our ‘secret’ information is stored on servers, protected by passwords. Our passwords are secret, and anyone who knows any password we have used before could try to see if this is our secret information for other servers.

    I don’t know what the answer is, but I’m careful with my information. That said, I was the victim of credit-card skimming just recently, which the bank detected and cancelled my cards.

    Just be careful with your passwords. They are secret, and you should treat them that way. If you can make use of RSA tokens, or multi-factor authentication, or some other method that can trust you, then do so. Hopefully those places that you entrust your secret information will do the right thing by you…

    Be safe out there!


  • SQL Spatial: Getting “nearest” calculations working properly

    If you’ve ever done spatial work with SQL Server, I hope you’ve come across the ‘nearest’ problem.

    You have five thousand stores around the world, and you want to identify the one that’s closest to a particular place. Maybe you want the store closest to the LobsterPot office in Adelaide, at -34.925806, 138.605073. Or our new US office, at 42.524929, -87.858244. Or maybe both!

    You know how to do this. You don’t want to use an aggregate MIN or MAX, because you want the whole row, telling you which store it is. You want to use TOP, and if you want to find the closest store for multiple locations, you use APPLY. Let’s do this (but I’m going to use addresses in AdventureWorks2012, as I don’t have a list of stores). Oh, and before I do, let’s make sure we have a spatial index in place. I’m going to use the default options.

    CREATE SPATIAL INDEX spin_Address ON Person.Address(SpatialLocation);

    And my actual query:

    WITH MyLocations AS
    (SELECT * FROM (VALUES ('LobsterPot Adelaide', geography::Point(-34.925806, 138.605073, 4326)),
                           ('LobsterPot USA', geography::Point(42.524929, -87.858244, 4326))
                   ) t (Name, Geo))
    SELECT l.Name, a.AddressLine1, a.City, s.Name AS [State], c.Name AS Country
    FROM MyLocations AS l
        SELECT TOP (1) *
        FROM Person.Address AS ad
        ORDER BY l.Geo.STDistance(ad.SpatialLocation)
        ) AS a
    JOIN Person.StateProvince AS s
        ON s.StateProvinceID = a.StateProvinceID
    JOIN Person.CountryRegion AS c
        ON c.CountryRegionCode = s.CountryRegionCode


    Great! This is definitely working. I know both those City locations, even if the AddressLine1s don’t quite ring a bell. I’m sure I’ll be able to find them next time I’m in the area.

    But of course what I’m concerned about from a querying perspective is what’s happened behind the scenes – the execution plan.


    This isn’t pretty. It’s not using my index. It’s sucking every row out of the Address table TWICE (which sucks), and then it’s sorting them by the distance to find the smallest one. It’s not pretty, and it takes a while. Mind you, I do like the fact that it saw an indexed view it could use for the State and Country details – that’s pretty neat. But yeah – users of my nifty website aren’t going to like how long that query takes.

    The frustrating thing is that I know that I can use the index to find locations that are within a particular distance of my locations quite easily, and Microsoft recommends this for solving the ‘nearest’ problem, as described at

    Now, in the first example on this page, it says that the query there will use the spatial index. But when I run it on my machine, it does nothing of the sort.


    I’m not particularly impressed. But what we see here is that parallelism has kicked in. In my scenario, it’s split the data up into 4 threads, but it’s still slow, and not using my index. It’s disappointing.

    But I can persuade it with hints!

    If I tell it to FORCESEEK, or use my index, or even turn off the parallelism with MAXDOP 1, then I get the index being used, and it’s a thing of beauty! Part of the plan is here:


    It’s massive, and it’s ugly, and it uses a TVF… but it’s quick.

    The way it works is to hook into the GeodeticTessellation function, which is essentially finds where the point is, and works out through the spatial index cells that surround it. This then provides a framework to be able to see into the spatial index for the items we want. You can read more about it at – including a bunch of pretty diagrams. One of those times when we have a much more complex-looking plan, but just because of the good that’s going on.

    This tessellation stuff was introduced in SQL Server 2012. But my query isn’t using it.

    When I try to use the FORCESEEK hint on the Person.Address table, I get the friendly error:

    Msg 8622, Level 16, State 1, Line 1
    Query processor could not produce a query plan because of the hints defined in this query. Resubmit the query without specifying any hints and without using SET FORCEPLAN.

    And I’m almost tempted to just give up and move back to the old method of checking increasingly large circles around my location. After all, I can even leverage multiple OUTER APPLY clauses just like I did in my recent Lookup post.

    WITH MyLocations AS
    (SELECT * FROM (VALUES ('LobsterPot Adelaide', geography::Point(-34.925806, 138.605073, 4326)),
                           ('LobsterPot USA', geography::Point(42.524929, -87.858244, 4326))
                   ) t (Name, Geo))
        s.Name AS [State],
        c.Name AS Country
    FROM MyLocations AS l
        SELECT TOP (1) *
        FROM Person.Address AS ad
        WHERE l.Geo.STDistance(ad.SpatialLocation) < 1000
        ORDER BY l.Geo.STDistance(ad.SpatialLocation)
        ) AS a1
        SELECT TOP (1) *
        FROM Person.Address AS ad
        WHERE l.Geo.STDistance(ad.SpatialLocation) < 5000
        AND a1.AddressID IS NULL
        ORDER BY l.Geo.STDistance(ad.SpatialLocation)
        ) AS a2
        SELECT TOP (1) *
        FROM Person.Address AS ad
        WHERE l.Geo.STDistance(ad.SpatialLocation) < 20000
        AND a2.AddressID IS NULL
        ORDER BY l.Geo.STDistance(ad.SpatialLocation)
        ) AS a3
    JOIN Person.StateProvince AS s
        ON s.StateProvinceID = COALESCE(a1.StateProvinceID,a2.StateProvinceID,a3.StateProvinceID)
    JOIN Person.CountryRegion AS c
        ON c.CountryRegionCode = s.CountryRegionCode

    But this isn’t friendly-looking at all, and I’d use the method recommended by Isaac Kunen, who uses a table of numbers for the expanding circles.

    It feels old-school though, when I’m dealing with SQL 2012 (and later) versions. So why isn’t my query doing what it’s supposed to? Remember the query...

    WITH MyLocations AS
    (SELECT * FROM (VALUES ('LobsterPot Adelaide', geography::Point(-34.925806, 138.605073, 4326)),
                           ('LobsterPot USA', geography::Point(42.524929, -87.858244, 4326))
                   ) t (Name, Geo))
    SELECT l.Name, a.AddressLine1, a.City, s.Name AS [State], c.Name AS Country
    FROM MyLocations AS l
        SELECT TOP (1) *
        FROM Person.Address AS ad
        ORDER BY l.Geo.STDistance(ad.SpatialLocation)
        ) AS a
    JOIN Person.StateProvince AS s
        ON s.StateProvinceID = a.StateProvinceID
    JOIN Person.CountryRegion AS c
        ON c.CountryRegionCode = s.CountryRegionCode

    Well, I just wasn’t reading properly.

    The following requirements must be met for a Nearest Neighbor query to use a spatial index:

    1. A spatial index must be present on one of the spatial columns and the STDistance() method must use that column in the WHERE and ORDER BY clauses.

    2. The TOP clause cannot contain a PERCENT statement.

    3. The WHERE clause must contain a STDistance() method.

    4. If there are multiple predicates in the WHERE clause then the predicate containing STDistance() method must be connected by an AND conjunction to the other predicates. The STDistance() method cannot be in an optional part of the WHERE clause.

    5. The first expression in the ORDER BY clause must use the STDistance() method.

    6. Sort order for the first STDistance() expression in the ORDER BY clause must be ASC.

    7. All the rows for which STDistance returns NULL must be filtered out.

    Let’s start from the top.

    1. Needs a spatial index on one of the columns that’s in the STDistance call. Yup, got the index.

    2. No ‘PERCENT’. Yeah, I don’t have that.

    3. The WHERE clause needs to use STDistance(). Ok, but I’m not filtering, so that should be fine.

    4. Yeah, I don’t have multiple predicates.

    5. The first expression in the ORDER BY is my distance, that’s fine.

    6. Sort order is ASC, because otherwise we’d be starting with the ones that are furthest away, and that’s tricky.

    7. All the rows for which STDistance returns NULL must be filtered out. But I don’t have any NULL values, so that shouldn’t affect me either.

    ...but something’s wrong. I do actually need to satisfy #3. And I do need to make sure #7 is being handled properly, because there are some situations (eg, differing SRIDs) where STDistance can return NULL. It says so at – “STDistance() always returns null if the spatial reference IDs (SRIDs) of the geography instances do not match.” So if I simply make sure that I’m filtering out the rows that return NULL…

    …then it’s blindingly fast, I get the right results, and I’ve got the complex-but-brilliant plan that I wanted.


    It just wasn’t overly intuitive, despite being documented.


  • Nepotism In The SQL Family

    There’s a bunch of sayings about nepotism. It’s unpopular, unless you’re the family member who is getting the opportunity.

    But of course, so much in life (and career) is about who you know.

    From the perspective of the person who doesn’t get promoted (when the family member is), nepotism is simply unfair; even more so when the promoted one seems less than qualified, or incompetent in some way. We definitely get a bit miffed about that.

    But let’s also look at it from the other side of the fence – the person who did the promoting. To them, their son/daughter/nephew/whoever is just another candidate, but one in whom they have more faith. They’ve spent longer getting to know that person. They know their weaknesses and their strengths, and have seen them in all kinds of situations. They expect them to stay around in the company longer. And yes, they may have plans for that person to inherit one day. Sure, they have a vested interest, because they’d like their family members to have strong careers, but it’s not just about that – it’s often best for the company as well.

    I’m not announcing that the next LobsterPot employee is one of my sons (although I wouldn’t be opposed to the idea of getting them involved), but actually, admitting that almost all the LobsterPot employees are SQLFamily members… …which makes this post good for T-SQL Tuesday, this month hosted by Jeffrey Verheul (@DevJef).TSQL2sDay150x150

    You see, SQLFamily is the concept that the people in the SQL Server community are close. We have something in common that goes beyond ordinary friendship. We might only see each other a few times a year, at events like the PASS Summit and SQLSaturdays, but the bonds that are formed are strong, going far beyond typical professional relationships.

    And these are the people that I am prepared to hire. People that I have got to know. I get to know their skill level, how well they explain things, how confident people are in their expertise, and what their values are. Of course there people that I wouldn’t hire, but I’m a lot more comfortable hiring someone that I’ve already developed a feel for. I need to trust the LobsterPot brand to people, and that means they need to have a similar value system to me. They need to have a passion for helping people and doing what they can to make a difference. Above all, they need to have integrity.

    Therefore, I believe in nepotism. All the people I’ve hired so far are people from the SQL community. I don’t know whether I’ll always be able to hire that way, but I have no qualms admitting that the things I look for in an employee are things that I can recognise best in those that are referred to as SQLFamily.

    …like Ted Krueger (@onpnt), LobsterPot’s newest employee and the guy who is representing our brand in America. I’m completely proud of this guy. He’s everything I want in an employee. He’s an experienced consultant (even wrote a book on it!), loving husband and father, genuine expert, and incredibly respected by his peers.

    It’s not favouritism, it’s just choosing someone I’ve been interviewing for years.


  • LobsterPot Solutions in the USA

    We’re expanding!

    I’m thrilled to announce that Microsoft Gold Partner LobsterPot Solutions has started another branch appointing the amazing Ted Krueger (5-time SQL MVP awardee) as the US lead. Ted is well-known in the SQL Server world, having written books on indexing, consulting and on being a DBA (not to mention contributing chapters to both MVP Deep Dives books). He is an expert on replication and high availability, and strong in the Business Intelligence space – vast experience which is both broad and deep.lp_usa_square

    Ted is based in the south east corner of Wisconsin, just north of Chicago. He has been a consultant for eons and has helped many clients with their projects and problems, taking the role as both technical lead and consulting lead. He is also tireless in supporting and developing the SQL Server community, presenting at conferences across America, and helping people through his blog, Twitter and more.

    Despite all this – it’s neither his technical excellence with SQL Server nor his consulting skill that made me want him to lead LobsterPot’s US venture. I wanted Ted because of his values. In the time I’ve known Ted, I’ve found his integrity to be excellent, and found him to be morally beyond reproach. This is the biggest priority I have when finding people to represent the LobsterPot brand. I have no qualms in recommending Ted’s character or work ethic. It’s not just my thoughts on him – all my trusted friends that know Ted agree about this.

    So last week, LobsterPot Solutions LLC was formed in the United States, and in a couple of weeks, we will be open for business!

    LobsterPot Solutions can be contacted via email at, on the web at either or, and on Twitter as @lobsterpot_au and @lobsterpot_us.

    Ted Kruger blogs at LessThanDot, and can also be found on Twitter and LinkedIn.

    This post is cross-posted from

  • SSIS Lookup transformation in T-SQL

    There is no equivalent to the SSIS Lookup transformation in T-SQL – but there is a workaround if you’re careful.

    The big issue that you face is about the number of rows that you connect to in the Lookup. SQL Books Online (BOL) says:

    • If there is no matching entry in the reference dataset, no join occurs. By default, the Lookup transformation treats rows without matching entries as errors. However, you can configure the Lookup transformation to redirect such rows to a no match output. For more information, see Lookup Transformation Editor (General Page) and Lookup Transformation Editor (Error Output Page).
    • If there are multiple matches in the reference table, the Lookup transformation returns only the first match returned by the lookup query. If multiple matches are found, the Lookup transformation generates an error or warning only when the transformation has been configured to load all the reference dataset into the cache. In this case, the Lookup transformation generates a warning when the transformation detects multiple matches as the transformation fills the cache.

    This is very important. It means that every row that enters the Lookup transformation comes out. This could be coming out of the transformation as an error, or through a ‘No Match’ output, with an ignored failure, or having found a row. But it will never return multiple copies of the row, even if it has matched two rows. This last point is inherently different to what happens in T-SQL. In T-SQL, any time you do a join, whether an INNER JOIN or an OUTER JOIN, if you match multiple rows on the right hand side, you get two copies of the row from the left. When doing Lookups in the world of ETL (as you would with SSIS), this is a VeryBadThing.

    TSQL2sDay150x150You see, there’s an assumption with ETL systems that things are under control in your data warehouse. It’s this assumption that I want to look at in this post. I do actually think it’s quite a reasonable one, but I also recognise that a lot of people don’t feel that it’s something they can rely on. Either way, I’ll show you a couple of ways that you can implement some workarounds, and it also qualifies this post for this month’s T-SQL Tuesday, hosted by Dev Nambi.

    Consider that you have a fact row, and you need to do a lookup into a dimension table to find the appropriate key value (I might know that the fact row corresponds to the Adelaide office, but having moved recently, I would want to know whether it’s the new version of the office or the old one). I know that ‘ADL’ is unique in my source system – quite probably because of a unique constraint in my OLTP environment – but I don’t have that guarantee in my warehouse. Actually, I know that I will have multiple rows for ADL. Only one is current at any point in time, but can I be sure that if I try to find the ADL record for a particular point in time, I will only find one row?

    A typical method for versioning dimension records (a Type 2 scenario) is to have a StartDate and EndDate for each version. But implementing logic to make sure there can never be an overlap is tricky. It’s easy enough to test, particularly since LAG/LEAD functions became available, but putting an actual constraint in there is harder – even more so if you’re dealing with something like Microsoft’s Parallel Data Warehouse, which doesn’t support unique constraints (this is totally fair enough, when you consider that the rows for a single table can be spread across hundreds of sub-tables).

    If we know that we have contiguous StartDate/EndDate ranges, with no gaps and no overlaps, then we can confidently write a query like:

    FROM facttable f
    LEFT JOIN dimtable d
    ON d.BusinessKey = f.DimBK
    AND d.StartDate <= f.FactDate
    AND f.FactDate < d.EndDate

    By doing a LEFT JOIN, we know that we’re never going to eliminate a fact by failing to match it (and can introduce an inferred dimension member), but if we have somehow managed to have overlapping records, then we could inadvertently get a second copy of our fact row. That’s going to wreck our aggregates, and the business will lose faith in the environment that has been put in.

    Of course, your dimension management is sound. You will never have this problem. Really. But what happens if someone has broken the rules and manually tweaked something? What if there is disagreement amongst BI developers about the logic that should be used for EndDate values (some prefer to have a gap of a day, as in “Jan 1 to Jan 31, Feb 1 to Feb 28”, whereas others prefer to have the EndDate value the same as the next StartDate. There’s definitely potential for inconsistency between developers.

    Whatever the reason, if you suddenly find yourself with the potential for two rows to be returned by a ‘lookup join’ like this, you have a problem. Clearly the SSIS Lookup transform ensures that there is never a second row considered to match, but T-SQL doesn’t offer a join like that.

    But it does give us APPLY.

    We can use APPLY to reproduce the same functionality as a join, by using code such as:

    FROM facttable f
    OUTER APPLY (SELECT * FROM dimtable d
                 WHERE d.BusinessKey = f.DimBK
                 AND d.StartDate <= f.FactDate
                 AND f.FactDate < d.EndDate) d1

    But because we now have a fully-fledged correlated table expression, we can be a little more tricky, and tweak it with TOP,

    FROM facttable f
    OUTER APPLY (SELECT TOP (1) * FROM dimtable d
                 WHERE d.BusinessKey = f.DimBK
                 AND d.StartDate <= f.FactDate
                 AND f.FactDate < d.EndDate) d1

    , which leaves us being confident that the number of rows in the set produced by our FROM clause is exactly the same number as we have in our fact table. The OUTER APPLY (rather than CROSS APPLY) makes sure we have lose rows, and the TOP (1) ensures that we never match more than one.

    But still I feel like we have a better option that having to consider which method of StartDate/EndDate logic is used.

    What we want is the most recent version of the dimension member at the time of the fact record. To me, this sounds like a TOP query with an ORDER BY and a filter,

    FROM facttable f
    OUTER APPLY (SELECT TOP (1) * FROM dimtable d
                 WHERE d.BusinessKey = f.DimBK
                 AND d.StartDate <= f.FactDate
                 ORDER BY d.StartDate DESC) d1

    , and you will notice that I’m no longer using the EndDate at all. In fact, I don’t need to bother having it in the table at all.

    Now, the worst scenario that I can imagine is that I have a fact record that has been backdated to before the dimension member appeared in the system. I’m sure you can imagine it, such as when someone books vacation time before they’ve actually started with a company. The dimension member StartDate might be populated with when they actually start with the company, but they have activity before their record becomes ‘current’.

    Well, I solve that with a second APPLY.

    FROM facttable f
    OUTER APPLY (SELECT TOP (1) * FROM dimtable d
                 WHERE d.BusinessKey = f.DimBK
                 AND d.StartDate <= f.FactDate
                 ORDER BY d.StartDate DESC) d1
    OUTER APPLY (SELECT TOP (1) * FROM dimtable d
                 WHERE d1.BusinessKey IS NULL
                 AND d.BusinessKey = f.DimBK
                 AND d.StartDate > f.FactDate
                 ORDER BY d.StartDate ASC) d1a

    Notice that I correlate the second APPLY to the first one, with the predicate “d1.BusinessKey IS NULL”. This is very important, and addresses a common misconception, as many people will look at this query and assume that the second APPLY will be executed for every row. Let’s look at the plan that would come about here.



    I don’t have any indexes on facttable – I’m happy enough to scan the whole table, but I want you to notice the two Nested Loop operators and the lower branches for them. A Nested Loop operator sucks data from it’s top branch, and for every row that comes in, requests any matching rows from the lower one.

    We already established that the APPLY with TOP is not going to change the number of rows, so the number of rows that the left-most Nested Loop is pulling from its top branch is the same as the one on its right, which also matches the rows from the Table Scan. And we know that we do want to check dimtable for every row that’s coming from facttable.

    But we don’t want to be doing a Seek in dimtable a second time for every row that the Nested Loop pulls from factable.

    Luckily, that’s another poor assumption. People misread this about execution plans all the time.

    When taught how to read an execution plan, many will head straight to the top-right, and whenever they hit a join operator, head to the right of that branch. And it’s true that the data streams do start there. It’s not the full story though, and it’s shown quite clearly here, through that Filter operator.

    That Filter operator is no ordinary one, but has a Startup Expression Predicate property.


    This means that the operator only requests rows from its right, if that predicate is satisfied. In this case, it means if it didn’t find matching row the first time it looked in dimtable. Therefore, the second Index Seek won’t get executed except in very rare situations. And we know (but the QO doesn’t) that it will be typically none at all, and that the estimated cost is not going to be 33%, but much more like 0%.

    So now you have a way of being able to do lookups that will not only guarantee that one row (at most) will be picked up, but you also have a pattern that will let you do a second lookup for those times when you don’t have the first.

    And keep your eye out for Startup Expression Predicates – they can be very useful for knowing which parts of your execution plan don’t need to get executed...


  • SQL 2014 does data the way developers want

    A post I’ve been meaning to write for a while, good that it fits with this month’s T-SQL Tuesday, hosted by Joey D’Antoni (TSQL2sDay150x150@jdanton)

    Ever since I got into databases, I’ve been a fan. I studied Pure Maths at university (as well as Computer Science), and am very comfortable with Set Theory, which undergirds relational database concepts. But I’ve also spent a long time as a developer, and appreciate that that databases don’t exactly fit within the stuff I learned in my first year of uni, particularly the “Algorithms and Data Structures” subject, in which we studied concepts like linked lists. Writing in languages like C, we used pointers to quickly move around data, without a database in sight. Of course, if we had a power failure all this data was lost, as it was only persisted in RAM. Perhaps it’s why I’m a fan of database internals, of indexes, latches, execution plans, and so on – the developer in me wants to be reassured that we’re getting to the data as efficiently as possible.

    Back when SQL Server 2005 was approaching, one of the big stories was around CLR. Many were saying that T-SQL stored procedures would be a thing of the past because we now had CLR, and that obviously going to be much faster than using the abstracted T-SQL. Around the same time, we were seeing technologies like Linq-to-SQL produce poor T-SQL equivalents, and developers had had a gutful. They wanted to move away from T-SQL, having lost trust in it. I was never one of those developers, because I’d looked under the covers and knew that despite being abstracted, T-SQL was still a good way of getting to data. It worked for me, appealing to both my Set Theory side and my Developer side.

    CLR hasn’t exactly become the default option for stored procedures, although there are plenty of situations where it can be useful for getting faster performance.

    SQL Server 2014 is different though, through Hekaton – its In-Memory OLTP environment.

    When you create a table using Hekaton (that is, a memory-optimized one), the table you create is the kind of thing you’d’ve made as a developer. It creates code in C leveraging structs and pointers and arrays, which it compiles into fast code. When you insert data into it, it creates a new instance of a struct in memory, and adds it to an array. When the insert is committed, a small write is made to the transaction to make sure it’s durable, but none of the locking and latching behaviour that typifies transactional systems is needed. Indexes are done using hashes and using bw-trees (which avoid locking through the use of pointers) and by handling each updates as a delete-and-insert.

    This is data the way that developers do it when they’re coding for performance – the way I was taught at university before I learned about databases. Being done in C, it compiles to very quick code, and although these tables don’t support every feature that regular SQL tables do, this is still an excellent direction that has been taken.


This Blog



News? Haven't you read my blog?

My Company

Can't find something?

Contact Me

Twitter: @rob_farley
Skype: rob_farley

MVP (SQL Server)


Adelaide SQL UG

Powered by Community Server (Commercial Edition), by Telligent Systems
  Privacy Statement