I used a slightly tweaked version of the code from our MSDN site https://msdn.microsoft.com/en-us/library/aa342335(SQL.90).aspx and it worked fine the first time through.

Since the 2.0 JDBC driver shipped prior to Windows, it means that my Development counterparts either did their homework ahead of time and tested with the near-RTM code or the Windows 7 Backwards Compatibility folks did their homework and tested the JDBC driver.  Yay!!!

P.S.  I hope at least one of the two possibilities is true – otherwise we just got really lucky!!

Now, anyone who has been supporting SSRS for any period of time is familiar with the three-and-out behavior that is seen when authentication is failing.  However, this generally results in a nice 401 error being returned by IIS.

And that is the rub!  Prior to SSRS 2008, Reporting Services sat on top of IIS.  However, SSRS 2008 natively hosts HTTP.SYS.  The good news is that removing the dependency on IIS means that ISAPI filters and inherited web.config values can no longer break Reporting Services.  The bad news is that you don’t get all of the IIS functionality for free!

In the case of a 401, you were totally rejected by SSRS.  In its current implementation, SSRS does not return a 401 on an authentication failure.  It just returns blank HTML.  Now, I would argue that SSRS should return something more informative to the browser, but at this point it does not.

So, the recommendation I would give is to start thinking authentication issues if you ever see an empty HTML page returned by SSRS.

P.S.  There is a two line reference to this behavior in https://msdn.microsoft.com/en-us/library/cc281253.aspx, but you’ll forgive me if I overlooked it until the other day. 

In my role, I am often trying to get SPNs configured properly for SQL Server and Reporting Services (and Analysis Services and IIS application pools on bad days).  Generally, I take the approach of knowing the five SPNs that are necessary (SQL NetBIOS, SQL NetBIOS:port, SQL FQDN, SQL FQDN:port, SSRS URL).  Then, if it still doesn’t work, I am reduced to doing setspn –l against the various service accounts looking for duplicates.

Generally, this is not too hard, but sometimes the list of SPNs is long and the customer uses a naming convention that appears to consist of 29 characters of which 27 are identical and the two ones that are different are scattered in the middle of the name.  Needless to say, this makes finding duplicates really difficult.

However, Windows 2008 shipped with a new and improved version of setspn.  Not only does it exist on every Vista/Windows 2008 or higher machine, but it has some handy new features.  If you run setspn from the command-line with no parameters, this is what you get:

Usage: setspn [modifiers switch] [accountname]
  Where "accountname" can be the name or domain\name
  of the target computer or user account

  Edit Mode Switches:
   -R = reset HOST ServicePrincipalName
    Usage:   setspn -R accountname
   -A = add arbitrary SPN 
    Usage:   setspn -A SPN accountname
   -S = add arbitrary SPN after verifying no duplicates exist
    Usage:   setspn -S SPN accountname
   -D = delete arbitrary SPN
    Usage:   setspn -D SPN accountname
   -L = list SPNs registered to target account
    Usage:   setspn [-L] accountname  

  Edit Mode Modifiers:
   -C = specify that accountname is a computer account
   -U = specify that accountname is a user account
    Note: -C and -U are exclusive.  If neither is specified, the tool
     will interpret accountname as a computer name if such a computer
     exists, and a user name if it does not.

  Query Mode Switches:
   -Q = query for existence of SPN
    Usage:   setspn -Q SPN
   -X = search for duplicate SPNs
    Usage:   setspn -X

    Note: searching for duplicates, especially forestwide, can take
     a long period of time and a large amount of memory.  -Q will execute
     on each target domain/forest.  -X will return duplicates that exist
     across all targets. SPNs are not required to be unique across forests,
     but duplicates can cause authentication issues when authenticating
     cross-forest.

  Query Mode Modifiers:
   -P = suppresses progress to the console and can be used when redirecting
    output to a file or when used in an unattended script.  There will be no
    output until the command is complete.
   -F = perform queries at the forest, rather than domain level
   -T = perform query on the specified domain or forest (when -F is also used)
    Usage:   setspn -T domain (switches and other parameters)
     "" or * can be used to indicate the current domain or forest.

    Note: these modifiers can be used with the -S switch in order to specify
     where the check for duplicates should be performed before adding the SPN.
    Note: -T can be specified multiple times.

Examples:
setspn -R daserver1
   It will register SPN "HOST/daserver1" and "HOST/{DNS of daserver1}"
setspn -A http/daserver daserver1
   It will register SPN "http/daserver" for computer "daserver1"
setspn -D http/daserver daserver1
   It will delete SPN "http/daserver" for computer "daserver1"
setspn -F -S http/daserver daserver1
   It will register SPN "http/daserver" for computer "daserver1 if no such SPN exists in the forest
setspn -U -A http/daserver dauser
   It will register SPN "http/daserver" for user account "dauser"
setspn -T * -T foo -X
   It will report all duplicate registration of SPNs in this domain and foo
setspn -T foo -F -Q */daserver
   It will find all SPNs of the form */daserver registered in the forest to which foo belongs

A little bit longer than the old list, huh?  :)

To be honest, I am still trying to figure out how to use the various new switches (and I cannot find any good documentation online).  However, the –x parameter caught my eye and indeed saved me a bunch of time the other day.

I had a customer who had started with using one service account and then changed their mind midway (or at least that is what we figured out after the fact :)).  No big deal, but they didn’t keep track of which SPNs they had already created.  Needless to say, we ended up with a bunch of duplicates.

Now comes the cool part.  All we had to do was run “setspn –x” from the command-line.  The output took about three minutes to generate, but the resulting list showed up exactly what duplicates we had.  As soon as my customer saw that list, they remembered they had started out with another account.  Life was easy after that…

So, I immediately checked my CLASSPATH, figuring I had a typo somewhere in there.  However, I was surprised to find that it was correct.  So why the heck was I getting a CLASSPATH error?  Then, I looked closer at the error and realized it was not ClassNotFoundException, but instead was UnsupportedClassVersionError.  What the heck?  I have been supporting JDBC for more than four year now and I didn’t recall every seeing that before!  So, I started looking at what had changed on my machine. 

After poking around a little, I remembered I had just rebuilt my machine a few weeks back.  However, I didn’t remember installing a JVM.  Yet, somehow I was able to run Java and Javac, so that meant some application had installed the JDK.  But what version was installed?

A quick jump out to a command prompt and a “javac –version” showed that I was running the 1.4 version of the JDK.  1.4?!  That version of the JVM is not supported by the 2.0 JDBC driver!

Just to confirm my suspicions, I wired up a quick batch file and ran some of my stock Java connectivity test code:

Here’s the batch file:

@echo off 

echo Confirm we have the ClassPath set to the 2.0 driver
Set CLASSPATH=.;C:\JDBC\sqljdbc_2.0\enu\sqljdbc.jar
set classpath 

echo.
echo.
echo Confirm we have the 1.5 JDK
C:\j2sdk1.5\bin\java -version 

echo.
echo.
echo Compile and run the sample code with 1.5
C:\j2sdk1.5\bin\javac MSversion.java
C:\j2sdk1.5\bin\java MSversion 

echo.
echo.
echo Confirm we have the 1.4 JDK
C:\j2sdk1.4.2_19\bin\java -version 

echo.
echo.
echo Now, compile and run the sample code with 1.4
C:\j2sdk1.4.2_19\bin\javac MSversion.java
C:\j2sdk1.4.2_19\bin\java MSversion

and here’s the Java code:

import java.*;
import java.sql.*;
import java.util.*;
import java.text.*;

class MSversion
{
    public static void main(String[] args) throws Exception
    {
        // Load the JDBC driver
        Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        // Connect to SQL Server
        Connection conn = null;
        String url = "jdbc:sqlserver://myserver;DatabaseName=master;";

        // Process the command line input
        if (args.length == 0)
        {
            //  Connect with default id/password
            conn = DriverManager.getConnection(url, "username", "password");
            //conn = DriverManager.getConnection(url);
        }
        else if (args.length == 2)
        {
            // Connect with user-provided username and password
            String userName = args[0];
            String password = args[1];
            conn = DriverManager.getConnection(url, userName, password);
        }
        else if (args.length == 3)
        {
            // Connect with user-provided username and password and url
            String userName = args[0];
            String password = args[1];
            url= args[2];
            conn = DriverManager.getConnection(url, userName, password);
        }
        else
        {
            // Invalid command -> throw an exception
            throw new Exception("\nUsage: java version [userName password]\n");
        }

        // Driver information
        DatabaseMetaData dm = conn.getMetaData();
        System.out.println("Connected to " + dm.getURL());
        System.out.println("Driver Information");
        System.out.println("\tDriver Name:    " + dm.getDriverName());
        System.out.println("\tDriver Version: " + dm.getDriverVersion());
        System.out.println("\tDatabase Major Version: " + dm.getDatabaseMajorVersion());
        System.out.println("\tDatabase Minor Version: " + dm.getDatabaseMinorVersion());
        System.out.println();

        // Cleanup
        dm=null;
        conn.close();
        conn=null;
    }
}

Lastly, here’s the output:

Confirm we have the ClassPath set to the 2.0 driver
CLASSPATH=.;C:\JDBC\sqljdbc_2.0\enu\sqljdbc.jar 

Confirm we have the 1.5 JDK
java version "1.5.0_19"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_19-b02)
Java HotSpot(TM) 64-Bit Server VM (build 1.5.0_19-b02, mixed mode) 

Compile and run the sample code with 1.5
Connected to jdbc:sqlserver://myserver:1433;xopenStates=false;trustServerCertificate=false;
sendStringParametersAsUnicode=true;selectMethod=direct;responseBuffering=adaptive;
packetSize=8000;loginTimeout=15;lockTimeout=-1;lastUpdateCount=true;encrypt=false;
disableStatementPooling=true;databaseName=master;applicationName=Microsoft SQL Server JDBC Driver;
Driver Information
    Driver Name:    Microsoft SQL Server JDBC Driver 2.0
    Driver Version: 2.0.1803.100
    Database Major Version: 9
    Database Minor Version: 0 

Confirm we have the 1.4 JDK
java version "1.4.2_19"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_19-b04)
Java HotSpot(TM) Client VM (build 1.4.2_19-b04, mixed mode) 

Now, compile and run the sample code with 1.4
java.lang.UnsupportedClassVersionError: com/microsoft/sqlserver/jdbc/SQLServerDriver 
(Unsupported major.minor version 49.0)
    at java.lang.ClassLoader.defineClass0(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:539)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:123)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:251)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:55)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:194)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:187)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:289)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:274)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:235)
    at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:302)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:141)
    at MSversion.main(MSversion.java:11)
Exception in thread "main" 

At this point, I knew all I had to do was point my PATH to either the 1.5 or 1.6 JDK and I should be fine. 

GZIP (see the Other Uses section of https://en.wikipedia.org/wiki/Gzip) is a standard mechanism for compressing streams between IIS and a client.  Turning it on at the IIS level is as simple as using adsutil.vbs (see the IIS documentation).  Most modern browsers add the Accept-Encoding: gzip, deflate header since they can properly decompress the stream from IIS.

This is where the problem comes in for Reporting Services (SSRS).  SSRS does all of its interaction with its web service component through the ReportViewer control (even from within Report Manager).  There are both WinForms and WebForms version of the control, but they are basically the same.  Unfortunately, neither of the controls knows how to decompress the HTML stream that comes back from a GZIP-compressed IIS instance.  That means you will get an error similar to:

Response is not well-formed XML. ''. hexadecimal value 0x1FR, is an invalid character. Line 1, position 1.

Bummer, huh?

At this point, there is no solution for this problem.  However, change requests have been put in to enable this feature in future releases of Reporting Services.  This would like mean that, not only would the ReportViewer controls be able to decompress the stream, but the ReportServer web service would be able to compress the stream (remember – post-SSRS 2005, SSRS has no dependency on IIS, so cannot rely on IIS’ built-in capabilities).

0:033> !dumpheap -stat
...
0x65400574   11,959    1,339,408 System.Data.SqlClient.SqlConnectionString
0x654049c0   11,959    1,482,916 System.Data.SqlClient.TdsParser
0x65405fdc   11,958    1,530,624 System.Data.SqlClient._SqlMetaData
0x65404744   11,959    1,674,260 System.Data.SqlClient.SqlInternalConnectionTds
0x79101fe4   36,452    2,041,312 System.Collections.Hashtable
0x65404dec   11,959    2,248,292 System.Data.SqlClient.TdsParserStateObject
0x7910be50  206,356    2,476,272 System.Boolean
0x65400808  233,910    4,678,200 System.Data.Common.NameValuePermission
0x65400b64  221,950    5,326,800 System.Data.Common.NameValuePair
0x7912d8f8  257,690    5,741,720 System.Object[]
0x000df590      175   10,314,064      Free
0x7912d9bc   36,461   13,194,048 System.Collections.Hashtable+bucket[]
0x790fd8c4  493,301   34,033,216 System.String
0x7912dae8   48,478  192,431,300 System.Byte[]
Total 1,994,862 objects, Total size: 290,427,832

Notice any pattern?  11959 seems to be pretty repetitive.  I  especially don't understand why we have almost 12000 internal connections unless....

Yep - customer is not pooling!!

First, dump out the method table for the System.Data.SqlClient.SqlConnectionString

0:033> !dumpheap -mt 0x65400574

This produces a ridiculously large (11,959 members!) list of SqlConnectionStrings.  So, let's dump out one at random:

0:033>  !do 0x2e016064
Name: System.Data.SqlClient.SqlConnectionString
MethodTable: 65400574
EEClass: 6544c6c0
Size: 112(0x70) bytes
GC Generation: 2
(C:\WINDOWS\assembly\GAC_32\System.Data\2.0.0.0__b77a5c561934e089\System.Data.dll)
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
790fd8c4  4000bce        4        System.String  0 instance 2e015e50 _usersConnectionString

And then keep drilling into him...

0:033> !do 2e015e50
Name: System.String

String: Data Source=cpsrv;Initial Catalog=Changepoint;Integrated Security=False;User ID=xxxxx;Password=yyyyy;Enlist=False;Pooling=False;Asynchronous Processing=True;Application Name=SqlQueryNotificationService-ac370dde-d9c4-4cbe-9d82-7d7a8df159c6

Let's do another one, too

0:033> !do 0x2c5b9aa8
Name: System.Data.SqlClient.SqlConnectionString
MethodTable: 65400574
EEClass: 6544c6c0
Size: 112(0x70) bytes
GC Generation: 2
(C:\WINDOWS\assembly\GAC_32\System.Data\2.0.0.0__b77a5c561934e089\System.Data.dll)
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
790fd8c4  4000bce        4        System.String  0 instance 2c5b9894 _usersConnectionString

0:033> !do 2c5b9894
Name: System.String
MethodTable: 790fd8c4
EEClass: 790fd824
Size: 530(0x212) bytes
GC Generation: 2
(C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
String: Data Source=cpsrv;Initial Catalog=Changepoint;Integrated Security=False;User ID=xxxx;Password=yyyy;Enlist=False;Pooling=False;Asynchronous Processing=True;Application Name=SqlQueryNotificationService-78b81d9b-ecd9-400d-8435-6e745d449c96

Note that in both cases, the connection string has Pooling=False and an application name that has a GUID.  Either one of these will prevent good use of connection pooling. 

The customer needs to turn pooling on, plus eliminate the GUID from the Application Name.

“What is Component Checker?” and “Why should I care it was updated?” are probably right on the tip of your tongue.  Wait for it, wait for it…

OK, no more teasing – Component Checker is a tool that can be used to check the state of your Microsoft Data Access Components (affectionately known as “MDAC” by those who deal with it) installation.  These components are used by all native applications to talk to various types of databases and are basically required parts of any client/server application that involves a database as the server component.  If you want to see exactly what turning of one of the core parts of MDAC does to your system, follow the workaround of unregistering OLEDB32 from MS08-078.  Good luck trying to do anything functional with data of any type!

The cool thing about the newest release of Component Checker is that is can be used to check every OS installation in existence that might have a bad MDAC installation.  This includes all the variants of XP, 2003, and 2000 (2008 and Vista are left off this list intentionally since it is almost impossible to corrupt their data access stack).  All you have to do is run Component Checker, select “Perform analysis against a selected version” and the select your version of Windows.

You should get something that looks like this:

If you installation is clean, you will see nothing but matches above. 

So, you might ask, why do I have mismatches above?  Well, for that, I go back to the reference to MS08-078 above.  Component Checker is not smart enough to know that files that are LATER than the ones it is checking for are OK.   Unfortunately, due to the bad guys out there these days, it is pretty common to find later versions of the various binaries pushed out via Windows Update.

However, it is still pretty easy to check your installation.  Just look to make sure that the Mismatch Fields column has a version number less than the Version field:

(click on the image above for a larger view)

As you can see above, Component Checker is looking for 2.81.1117 and I have 2.81.1135 (MSADCE) and 2.81.1124 (MSADCO).  Good to go!

Since when has BOGO (Buy One, Get One) become BOGOHO (Buy One, Get One Half Off)?  Now, in all honesty, my local grocery store still does BOGO.  In fact, this past weekend, they did Buy One, Get Two Free.  Needless to say, I now have a lot of ice cream in my freezer! 

However, I see more and more retail stores advertising BOGO, but doing BOGOHO.  Talk about false advertising!!  I know, I know – they do have some sort of text or disclaimer that explains that BOGO is really BOGOHO, but that is generally in small text.  The really BIG text says BOGO.

Sigh…

The other key question that I see constantly is “What is the difference between SDS and Azure Storage?  They both store blobs…”.

The truthful answer to that is there is not much functional difference between them right now.  The key is to look down the road.  SDS’ stated goal is to add more and more database-type functionality.  This means that you will start seeing SQL Server-type functionality added over time.  In theory, you will eventually be able to just use SDS for your database instead of an instance of SQL Server.  Obviously, that is waaaaaaay down the road, but you have to start somewhere!

Personally, I specialize in JDBC and SSRS.

Oh yeah – due to an oddity of the organizational structure of our Development teams, we also support XML.  :)