MSSQL, jTDS, NVARCHAR and Slow Indexes

Home/Database, Java/MSSQL, jTDS, NVARCHAR and Slow Indexes
Mr. Slow

Mr. Slow by Vox

An application I’ve built is going into production soon. It’s the first application I’ve been involved with which will be using MSSQL server in production, I have some learning about MSSQL to do. After some research, I ended up using the jDTS JDBC driver instead of the Microsoft JDBC driver (which is feature incomplete and has some serious open issues).

We recently began performance testing and saw some odd behavior. Initially the application was performing well. However after few runs of the stress test the performance went from good to awful. The main web service call went from 600 ms to 23,000 ms. The database server’s CPU was pinned, and the app servers were barely loading, spending all their time waiting for the database server to return queries. Stranger still, my local instance (running against PostgreSQL) performed well with the same code and same stress tests. Luckily a smart MSSQL DBA was able to figure out why the database was burning so much CPU and responding so slowly.

One of the primary queries is against a table which has been growing. The select query is simple and had an indexed column in the WHERE clause. Even as the table grew to over a million rows, it should have been a very quick query. Unfortunately it was taking several seconds to complete. My local instance had over 30 million rows in the same table in PostgreSQL and the query was lightening fast. The DBA discovered that the query execution was converting the indexed varchar column into nvarchar values for comparison with the query parameter used in the WHERE clause which was inexplicably coming over as an nvarchar. This datatype mismatch between the column definition and the query parameter meant that MSSQL was doing a scan of the million+ record index instead of the almost instant seek it should have been doing.

It turns out that jTDS sends String parameters over as Unicode (nvarchar) by default. It’s easily fixed by adding this property to your connection-url:

sendStringParametersAsUnicode=false

That immediately fixed the performance issues.

So, if you’re using jTDS and are using indexed varchar columns in your queries, you should add the property above to avoid your indexes being wasted and your queries running slowly.

By | 2017-05-18T15:16:21+00:00 May 23rd, 2009|Database, Java|4 Comments

About the Author:

4 Comments

  1. John Shin November 20, 2009 at 6:00 am - Reply

    Can you elaborate on the SQLServer configuration (Version of DB, version of OS and 32/64bit)?

    • Devon November 20, 2009 at 7:29 am - Reply

      John,

      I think it was MSSQL 2005 on Windows Server 2003, 32 bit I think. However I believe the issue is not version specific, it’s simply a matter of how jTDS handles string params.

      Devon

  2. Andy March 4, 2010 at 12:46 pm - Reply

    Very cool article; we actually experienced the same issue with a production application using MSSQL server and _the Microsoft JDBC_ driver.

    So, it seems like the issue is not specific to the jTDS driver.

    • Devon March 4, 2010 at 12:47 pm - Reply

      Andy,

      good to know! Glad you solved it, as it can a bear to figure out:)

      Devon

Leave A Comment