{"id":599,"date":"2007-10-03T09:01:52","date_gmt":"2007-10-03T09:01:52","guid":{"rendered":"\/blogs\/kimberly\/post\/The-perils-of-case-insensitive-data-(and-our-life-in-tangent-land).aspx"},"modified":"2013-01-02T06:57:17","modified_gmt":"2013-01-02T14:57:17","slug":"the-perils-of-case-insensitive-data-and-our-life-in-tangent-land","status":"publish","type":"post","link":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/the-perils-of-case-insensitive-data-and-our-life-in-tangent-land\/","title":{"rendered":"The perils of case-insensitive data (and our life in tangent-land)"},"content":{"rendered":"

OK, have you ever been working on one thing…that led you to another (and another and another<\/EM>) and then you seem to have lost hours? OK, I know. That’s our life [in the computer industry and I’m sure others!] – putting out fires and chasing strange behaviors that we eventually call “gremlins” when we really can’t figure them out (especially when they don’t repro<\/EM>). And, I know that we all want to be incredibly prepared but, sometimes bugs happen. And, sometimes bugs lead to serious problems possibly even data corruption\/loss (which I’ve seen) and NO, I’m not directly relating this to anything about SQL Server. I’m just wanting to stress the necessity of a backup strategy (ah, a *tested*<\/STRONG> backup strategy<\/EM>) but, the bugs I’ve run into today are really not all that serious (they do NOT corrupt data<\/STRONG>). But, they do lead me to believe that far fewer changes are made to collations than I had thought? Or, that many of you change collations at the most granular level (probably at the column level?) and that database collation changes are done but without additional column level changes later.  <\/P>
\n

And, that’s really the point of this blog post… for now, I’m going to recommend that you make changes at the column-level OR you don’t make additional changes AFTER you’ve changed a particular database’s collation. In other words, if you have a case insensitive server and a case sensitive database then things will probably work well. You can even leverage things like default_collation<\/a> for temp tables. However, if you try to make addition changes to collations in other objects – such as views – it doesn’t seem to work. Basically, I’ve run into problems creating views with different collations only when the database’s collation is different than the server’s collation. So far, that’s the only thing that I’ve found that’s wrong with what I’ve been doing. And, I didn’t even figure this one out on my own – I did a live search on the error and found this: http:\/\/cc.msnscache.com\/cache.aspx?q=72171562874629&mkt=en-US&lang=en-US&w=286a60c3&FORM=CVRE<\/a> which seems like the same problem I’m having (and sorry for the cached page, I couldn’t seem to get to the live page).<\/P>
\n

Regardless of this issue (is it a bug?), the real reason for this blog post is that a great discussion came up on the Regional Director<\/a> tech alias (it’s an internal thing we use to leverage each other’s skills). The original question led to a few discussions and in the end, I think there are really two questions that I thought I’d discuss here:<\/P>
\n

#1) do you want a ONE-TIME way of checking a bunch of data to find rows that are lower-case (and shouldn’t be)
#2) do you want to REPEATEDLY find rows based based on a case-sensitive search (where the data is stored case-insensitive).<\/P>
\n

In my first response, I answered #2. And, I’m going to start with that one here too. If you want to query a case-insensitive column with a case-sensitive search then changing the collation on the fly (with a where clause) works (although there are some performance issues related to this). So, I took an old example of mine (which was against pubs) and I decided that it needed a refresh (meaning, I wanted to update this to work against AdventureWorks). And, that’s where half of my fun today started since this is where I’ve run into what I think is a bug. Anyway, let’s start with what works:<\/P>
\n

— First, I’ll create a test database. Without a collation specified,
— it will use the server’s default collation.<\/P><\/FONT>
\n

CREATE<\/FONT> <\/FONT>DATABASE<\/FONT> TestAdventureWorks
<\/FONT>go<\/P><\/FONT>
\n

— Verify the database collation
<\/FONT>SELECT<\/FONT> <\/FONT>DATABASEPROPERTYEX<\/FONT>(<\/FONT>‘TestAdventureWorks’<\/FONT>,<\/FONT> <\/FONT>‘Collation’<\/FONT>)
<\/FONT>go<\/P><\/FONT>
\n

— database is set to SQL_Latin1_General_CP1_CI_AS as expected
— this is a case-insensitive database<\/P><\/FONT>
\n

USE<\/FONT> TestAdventureWorks
<\/FONT>go<\/P><\/FONT>
\n

SELECT<\/FONT> LastName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> LastName
<\/FONT><\/FONT>,<\/FONT> FirstName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> FirstName
<\/FONT>,<\/FONT> MiddleName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> MiddleName
<\/FONT>INTO<\/FONT> MyTestContacts
<\/FONT><\/FONT>FROM<\/FONT> Adventureworks<\/FONT>.<\/FONT>Person<\/FONT>.<\/FONT>Contact
<\/FONT>go<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> Lastname <\/FONT>=<\/FONT> N<\/FONT>‘Adams’
<\/FONT>go <\/FONT>— (86 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> Lastname <\/FONT>=<\/FONT> N<\/FONT>‘adams’
<\/FONT>go <\/FONT>— (86 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> Lastname <\/FONT>COLLATE<\/FONT> Latin1_General_CS_AS_KS_WS <\/FONT>=<\/FONT> N<\/FONT>‘Adams’
<\/FONT>go <\/FONT>— (86 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> Lastname <\/FONT>COLLATE<\/FONT> Latin1_General_CS_AS_KS_WS <\/FONT>=<\/FONT> N<\/FONT>‘adams’
<\/FONT>go <\/FONT>— (0 row(s) affected)<\/P>
\n

— Next, create a view:
<\/FONT>CREATE<\/FONT> <\/FONT>VIEW<\/FONT> ContactLastNameCaseSensitive
<\/FONT><\/FONT>AS
SELECT<\/FONT> LastName <\/FONT>COLLATE<\/FONT> Latin1_General_CS_AS_KS_WS <\/FONT>AS<\/FONT> CSName
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT>go<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> ContactLastNameCaseSensitive
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> N<\/FONT>‘Adams’
<\/FONT>go <\/FONT>— (86 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> ContactLastNameCaseSensitive
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> N<\/FONT>‘adams’
<\/FONT>go <\/FONT>— (0 row(s) affected)<\/P><\/FONT>
\n

And, everything works… in TestAdventureworks. In the *real* AdventureWorks, I get an error when I try to create the view:
Msg 2791, Level 16, State 5, Procedure ContactLastNameCaseSensitive, Line 3
Could not resolve expression for schemabound object or constraint.<\/P><\/FONT>
\n

So, this is the first issue. It seems as though you can’t create the view if your database has a different collation than the server collation. Well, (again), I haven’t spent all that much time on this one but I did repro what the chain on the forum seemed to have found.<\/P>
\n

Now, as for the second issue… the query can be EXTREMELY painful and slow if you run this against a large set of data. See, changing the collation on the fly will need to perform a row-by-row comparison of the data. So, to minimize that HUGE hit on performance – you have two options.<\/P>
\n


\n

1) actually consider changing the column’s collation so that it matches your queries AND then create an index (note: the actual use of the index will be determined by the selectivity of the data).<\/P>
\n


\n

SELECT<\/FONT> LastName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> LastName
<\/FONT><\/FONT>,<\/FONT> FirstName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> FirstName
<\/FONT>,<\/FONT> MiddleName <\/FONT>collate<\/FONT> database_default <\/FONT>AS<\/FONT> MiddleName
<\/FONT>INTO<\/FONT> MyTestContacts2
<\/FONT><\/FONT>FROM<\/FONT> Adventureworks<\/FONT>.<\/FONT>Person<\/FONT>.<\/FONT>Contact
<\/FONT>go<\/P><\/FONT>
\n

ALTER<\/FONT> <\/FONT>TABLE<\/FONT> MyTestContacts2
<\/FONT><\/FONT>ALTER<\/FONT> <\/FONT>COLUMN<\/FONT> LastName <\/FONT>nvarchar<\/FONT>(<\/FONT>100<\/FONT>)<\/FONT> <\/FONT>COLLATE<\/FONT> Latin1_General_CS_AS_KS_WS
<\/FONT>go<\/P><\/FONT>
\n

CREATE<\/FONT> <\/FONT>INDEX<\/FONT> CSNameInd <\/FONT>on<\/FONT> MyTestContacts2 <\/FONT>(<\/FONT>LastName<\/FONT>)
<\/FONT>go<\/P><\/FONT>
\n

— let’s use a query that’s highly selective (selective enough to use the index):<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT><\/FONT>WHERE<\/FONT> LastName <\/FONT>=<\/FONT> N<\/FONT>‘Barlow’
<\/FONT>go <\/FONT>— (1 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT><\/FONT>WHERE<\/FONT> LastName <\/FONT>=<\/FONT> N<\/FONT>‘barlow’
<\/FONT>go <\/FONT>— (0 row(s) affected)<\/P><\/BLOCKQUOTE><\/FONT>
\n

2) create an index with a different collation… but this is harder than it sounds as the CREATE INDEX statement doesn’t directly allow changing collation (however, it should!). But, you can do this by either creating another column (real or computed) with the case-sensitive collation and then indexing it OR you could do this through an indexed view (but that adds a few complexities as well). I think the computed column that’s indexed is GREAT if the searches are generally highly selective. If they are not, then it is probably better to create a real column – as a computed copy of the inserted value – that is case sensitive. However, at that point, I’m not entirely sure why you’re keeping the case-insensitive version around…unless it’s to keep the actual inserted value (maybe for printing and\/or display?). Regardless, here’s how you can create an indexed computed column.<\/P>
\n

ALTER<\/FONT> <\/FONT>TABLE<\/FONT> MyTestContacts
<\/FONT><\/FONT>ADD<\/FONT>
<\/FONT>CSName <\/FONT>AS<\/FONT> LastName <\/FONT>COLLATE<\/FONT> Latin1_General_CS_AS_KS_WS
go<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> N<\/FONT>‘Adams’
<\/FONT>go <\/FONT>— (86 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> N<\/FONT>‘adams’
<\/FONT>go <\/FONT>— (0 row(s) affected)<\/P><\/FONT>
\n

CREATE<\/FONT> <\/FONT>INDEX<\/FONT> CSNameInd <\/FONT>ON<\/FONT> MyTestContacts <\/FONT>(<\/FONT>CSName<\/FONT>)
<\/FONT>go<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> <\/FONT>‘Barlow’
<\/FONT>go <\/FONT>— (1 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT>
<\/FONT><\/FONT>FROM<\/FONT> MyTestContacts
<\/FONT><\/FONT>WHERE<\/FONT> CSName <\/FONT>=<\/FONT> <\/FONT>‘barlow’
<\/FONT>go <\/FONT>— (0 row(s) affected)<\/FONT><\/P>
\n

And, the index will be used if the query is highly selective.<\/FONT><\/P><\/BLOCKQUOTE>
\n

OK, so that ends the answer to part 2 of the question (see how tangents can take us a bit off track :)…. <\/STRONG><\/FONT><\/P>
\n

Now, let’s get back to question #1.<\/STRONG><\/FONT><\/P>
\n

What if you want to do a one-time search through your data to find all of the lower case data? Well, there are a few thoughts here…. First, let’s modify the ONE Barlow row to be lowercase barlow so that we have something to find:<\/FONT><\/P>
\n

UPDATE<\/FONT> MyTestContacts2
<\/FONT>SET<\/FONT> LastName <\/FONT>=<\/FONT> N<\/FONT>‘barlow’
<\/FONT>WHERE<\/FONT> LastName <\/FONT>=<\/FONT> N<\/FONT>‘Barlow’<\/FONT>
go — (1 row(s) affected)<\/FONT><\/FONT><\/P>
\n

NOTE: This is an ABSOLUTELY horrible quiery as I didn’t use any key to point to the exact row I wanted to modify. Had there been a lot of Barlow’s I would have modified them all. This worked here because I knew there was only one row. But, all of your tables should have a primary key, etc. (not even going to begin this tangent :).<\/P>
\n

<\/FONT>Now, having said that… let’s see if we can find this row easily? You should <\/EM><\/STRONG>be able to do this using Transact-SQL and using some type of wildcard pattern matching such as:<\/FONT><\/P>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>like<\/FONT> N<\/FONT>‘b%’
go<\/FONT> — (1 row(s) affected)<\/FONT><\/FONT><\/P>
\n

And, that works without any problems. <\/FONT><\/FONT><\/P>
\n

So, what about NOT an upper case B.<\/FONT><\/FONT><\/P>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>NOT<\/FONT> <\/FONT>LIKE<\/FONT> N<\/FONT>‘B%’
<\/FONT>go <\/FONT>— (18768 row(s) affected)<\/P><\/FONT>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>NOT<\/FONT> <\/FONT>LIKE<\/FONT> N<\/FONT>‘%B%’
<\/FONT>go <\/FONT>— (18765 row(s) affected)<\/FONT><\/P>
\n

tangent number 87 <g>: if you’re wondering what the 3 rows are (as was I <\/EM>:)… they are 1 row of O’Brien and 2 rows of Smith-Bates. Here’s that query: <\/P>
\n


\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> <\/FONT>(<\/FONT>SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>NOT<\/FONT> <\/FONT>LIKE<\/FONT> N<\/FONT>‘B%’<\/FONT>)<\/FONT> <\/FONT>AS<\/FONT> Bs
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>like<\/FONT> <\/FONT>‘%B%’
<\/FONT>go<\/FONT><\/P><\/BLOCKQUOTE>
\n

OK, so, I thought we were there… I thought we could go to what I thought was the next logical step…..<\/FONT><\/P>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>NOT<\/FONT> <\/FONT>LIKE<\/FONT> N<\/FONT>‘%[A-B]%’
go<\/FONT><\/FONT><\/P>
\n

And… well, we lose barlow from the result set. For some reason…when you do ranges of characters it seems to lose the case??? I remember that [A-Z] and [a-z] were different in some release? Is this a regression? Someone help me out with this one as I’m without a clue. In the end, the ONLY way I could get this to work is to do this:<\/P>
\n

SELECT<\/FONT> <\/FONT>*<\/FONT> <\/FONT>FROM<\/FONT> MyTestContacts2
<\/FONT>WHERE<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%A%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%B%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%C%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%D%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%E%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%F%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%G%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%H%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%I%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%J%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%K%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%L%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%M%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%N%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%O%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%P%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%Q%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%R%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%S%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%T%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%U%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%V%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%W%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%X%’<\/FONT>
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%Y%’
<\/FONT>AND<\/FONT> Lastname <\/FONT>not<\/FONT> <\/FONT>like<\/FONT> N<\/FONT>‘%Z%’
go<\/FONT><\/FONT><\/FONT><\/P>
\n

And, well, that works. But, it is NOT pretty! The query’s going to require a table scan anyway AND it is a one-time query. I’m OK with this as a solution to this problem BUT, am I missing something here? Please tell me there’s something more clever here? Is this a bug?<\/FONT><\/FONT><\/FONT><\/P>
\n

I’m definitely interested in feedback on this one!
kt<\/FONT><\/FONT><\/FONT><\/FONT><\/FONT><\/FONT><\/FONT><\/FONT><\/FONT><\/P><\/p>\n","protected":false},"excerpt":{"rendered":"

OK, have you ever been working on one thing…that led you to another (and another and another) and then you seem to have lost hours? OK, I know. That’s our life [in the computer industry and I’m sure others!] – putting out fires and chasing strange behaviors that we eventually call “gremlins” when we really […]<\/p>\n","protected":false},"author":7,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[65],"tags":[],"class_list":["post-599","post","type-post","status-publish","format-standard","hentry","category-sql-server-2005"],"_links":{"self":[{"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/posts\/599","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/comments?post=599"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/posts\/599\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/media?parent=599"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/categories?post=599"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/kimberly\/wp-json\/wp\/v2\/tags?post=599"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}