SQLCMD variables can be a useful way of having changeable parameters for your SQL scripts, allowing you to specify the value from a command line, but also to control things you couldn’t manage through a SQL variable.
They can also be a little confusing the first time you see them.
Here’s an example:
:SETVAR MySQLCMDVar "Wibble" SELECT * FROM dbo.Test WHERE TextValue='$(MySQLCMDVar)';
If you just run this then you might get the error:
Msg 102, Level 15, State 1, Line 1
Incorrect syntax near ‘:’.
The important thing is to understand that when you see a colon at the beginning of a statement in your T-SQL script, then this is a SQLCMD statement, and to parse these in SSMS you need to have SQLCMD mode enabled. You can do this from the “Query” menu:
Now I execute my script again, and it runs fine – though it returns no results.
Let’s look at another quick example:
:SETVAR TableName "Test" SELECT * FROM dbo.$(TableName) WHERE TextValue='Wibble';
Here I’ve used the SQLCMD variable to define the name of the table in my query. This is the power of SQLCMD variables, you couldn’t do this with a normal SQL variable – the only way to do that would be to use dynamic SQL instead.
Let’s understand a little deeper what they are and how they work.
First of all, they don’t have a datatype, they are actually always text values. You can enclose them in double quotes or not –but I usually prefer to – although if you have spaces or other special characters then quotes are required.
You define them as follows:
:SETVAR SQLCMDVariableName “Whatever value you want”
And where you want to refer to them in your script you use a dollar sign and the variable name in brackets:
Rather than being a conventional form of variables, SQLCMD variables are actually tags for text replacement. It’s handy to understand this as it leads to some strange behaviours. What happens when you run a query with SQLCMD enabled, is that first of all the script is parsed and any SQLCMD statements are processed.
In the case of SQLCMD variables, first all the :SETVAR statements in the script are processed and each variable is assigned the correct value. Then all the references to each variable in the script are replaced with the literal value, it is then this modified version of your script (which you never get to see) which gets executed.
That’s why something like this doesn’t work:
:SETVAR TextVal "Hello There" DECLARE @TextVal varchar(30); SET @TextVal = $(TextVal); SELECT @TextVal;
When I run this I get an error:
Msg 102, Level 15, State 1, Line 11
Incorrect syntax near ‘There’.
What’s going on? Both my SQL and SQLCMD variables are text aren’t they? Why doesn’t that work?
The answer lies in what I said before, the reference to a SQLCMD variable is just a tag to be replaced with the value defined elsewhere in the script. So in the above example what actually gets executed is:
DECLARE @TextVal varchar(30); SET @TextVal = Hello There; SELECT @TextVal;
Which isn’t valid SQL. What I should have done in my original SQL is to wrap the reference to the SQLCMD variable in single quotes:
:SETVAR TextVal "Hello There" DECLARE @TextVal varchar(30); SET @TextVal = '$(TextVal)'; SELECT @TextVal;
Now it works:
I mentioned you could pass SQLCMD variables from the command line – this can be handy if you’re executing scripts and you want to (for instance) specify the database name from outside. Watch out though, if you also assign a value in your script then it is the last value assigned that gets used.
I had a developer come to me complaining that SQL wasn’t picking up the SQLCMD variable he was passing through the command line, the answer was that he had another value assigned in the script. He thought that was dumb, so I asked the question “What would you expect to happen if you were writing C# code and assigned a value to a variable, and then assigned a new one to it – which would you expect it to hold – the first or the second?”
That doesn’t mean however that assignment of values to SQLCMD variables doesn’t display some counterintuitive behaviour. Look at the following query:
:SETVAR TextVal "Hello There" SELECT '$(TextVal)'; :SETVAR TextVal "GoodBye" SELECT '$(TextVal)';
So I set a value in my SQLCMD variable, output it with a select statement, then I change the value and output it again. Let’s look at the output:
What the…?! I’ve encountered issues before where I’ve tried to change the value of a variable and – having done something wrong – the value hasn’t updated. But here it looks like the first query is looking into the future!
This goes back to what I said earlier, first the :SETVAR statements are processed and the variable evaluated, only then are the references replaced in the script. This means you can’t have changing values for your SQLCMD variable throughout the execution of your script.
You can even see the same behaviour if you do this:
:SETVAR TextVal "Hello There" SELECT '$(TextVal)'; :SETVAR TextVal "GoodBye" SELECT '$(TextVal)'; :SETVAR TextVal "See you Later!"
I’ve said you can’t change the value of your SQLCMD variable through your script, technically it’s more accurate to say you can’t have different values within the same batch. So if you separate your script into separate batches using the GO statement, then you get a different result:
:SETVAR TextVal "Hello There" SELECT '$(TextVal)'; GO :SETVAR TextVal "GoodBye" SELECT '$(TextVal)';
You might therefore think that the SQLCMD variable is only valid in the context of the batch in which is defined. So if I remove the :SETVAR in the second batch my script will fail:
:SETVAR TextVal "Hello There" SELECT '$(TextVal)'; GO SELECT '$(TextVal)';
We see from this that a SQLCMD variable is not limited to the scope of a single batch – even though it gets re-evaluated on a batch by batch basis.
I’ll finish with something you might have attempted to do at some point. How about if I conditionally try to change a SQLCMD variable:
:SETVAR TextVal "Hello There" IF 1=0 BEGIN PRINT 'Whoah!' :SETVAR TextVal "Maths is Broken" END; SELECT '$(TextVal)';
If I’ve not confused you too much with the above examples you can probably figure out what the output will be. That’s right:
This has just reminded me of a quote from “The Hitchhikers Guide to the Galaxy“ about the babel fish, particularly the last line:
“Now it is such a bizarrely improbable coincidence that anything so mind-bogglingly useful could have evolved purely by chance that some thinkers have chosen to see it as the final and clinching proof of the non-existence of God.
The argument goes something like this: “I refuse to prove that I exist,'” says God, “for proof denies faith, and without faith I am nothing.”
“But,” says Man, “The Babel fish is a dead giveaway, isn’t it? It could not have evolved by chance. It proves you exist, and so therefore, by your own arguments, you don’t. QED.”
“Oh dear,” says God, “I hadn’t thought of that,” and promptly vanishes in a puff of logic.
“Oh, that was easy,” says Man, and for an encore goes on to prove that black is white and gets himself killed on the next zebra crossing.”
The main take home from all this should be to avoid trying to use a SQLCMD variable like a normal one. Assign it once, at the top of your script or in a command line – then leave it alone!