SharpThoughts

NHibernate HI-LO Generator for non-primary keyed columns

admin — Sun, 16 May 2010 21:33:02 +0000

GUID’s are nice, they allow us to create objects on the client and persist at will, they guarantee a globally unique number and allow us to never have to worry about identity columns again. But what happens when we need to communicate with legacy systems requiring long integer values and not Guids?

Currently, on the production code that I am working on, we have just that problem. For all intents and purposes, we use GUIDs as our object identifiers and primary keys in our databases. However, our system needs to send data to a 3rd party, and many of those 3rd parties cannot accept GUIDs as identifiers in their aging systems.

What about Identity columns? In our situation, our entire transaction needed to be atomic, from object creation, to persistence in our system, to persistence in the 3rd party system. Identity values are only returned when the transaction is committed. This simply would not work for us…we needed a more robust and scalable solution.

We knew the solution would be a Hi-Lo algorithm of some sort. NHibernate has a nice HI-LO algorithm built in, however this is only allowed to be used on ID columns, so we decided to roll our own.

The way it works:

Grabs the current high value from the DB
Check and see if the current low > max low, and if it is, create a new High value in the DB, and set current low to 1
Increment current low by 1, and add it to Current Hi * Max Hi and return the resulting value as the unique key.

What this does is allow for an infinite number of instances of your application to be running at once. Each application instance stores the high and low values in a singleton is guaranteed to have a unique high value due to SQL table locking.

Database Schema: Table – UniqueKey

CS Class File

public class HiLoUniqueKeyGenerator : IUniqueKeyGenerator {
 
       private static Dictionary<string, long> currentHi = new Dictionary<string, long>();
       private static Dictionary<string, long> currentLo = new Dictionary<string, long>();
       private static object loLock = new object();
       // WARNING: Never change this number to be lower than the current value. It will significantly impact the generation of IDs!!!
       // PLEASE THINK CAREFULLY BEFORE CHANGING THIS NUMBER.
       private const int maxLo = 1000;
       private readonly ISessionFactory sessionFactory;
       private IDbConnection dbConnection;
       private IStatelessSession session;
 
       public HiLoUniqueKeyGenerator(ISessionFactory sessionFactory) {
           this.sessionFactory = sessionFactory;
           session = sessionFactory.OpenStatelessSession();
           dbConnection = session.Connection;
       }
 
       public long NextKey(string keyName) {
           lock (loLock) {
               if (NeedsNextHi(keyName))
                   GetNextHi(keyName);
               return (CurrentHi(keyName) * maxLo) + NextLo(keyName);
           }
       }
 
       private long CurrentHi(string keyName) {
           return currentHi[keyName];
       }
 
       private long NextLo(string keyName) {
           var lo = currentLo[keyName];
           currentLo[keyName] = lo + 1;
           return lo;
       }
 
       private bool NeedsNextHi(string keyName) {
           if (!currentHi.ContainsKey(keyName))
               return true;
           if (!currentLo.ContainsKey(keyName))
               return true;
           return currentLo[keyName] > maxLo;
       }
 
       private void GetNextHi(string keyName) {
           // Hardcoded SQL to ensure that a 
           if (dbConnection.State != ConnectionState.Open)
               dbConnection.Open();
           using (var transaction = dbConnection.BeginTransaction(IsolationLevel.RepeatableRead)) {
               object value = null;
               using (var selectCurrentValue = dbConnection.CreateCommand()) {
                   selectCurrentValue.Transaction = transaction;
                   selectCurrentValue.CommandText = "SELECT next_hi FROM UniqueKey WITH (ROWLOCK, XLOCK) WHERE key_name = '" + keyName.ToString() + "'";
                   value = selectCurrentValue.ExecuteScalar();
               }
               using (var insertNextValue = dbConnection.CreateCommand()) {
                   insertNextValue.Transaction = transaction;
                   if (value == null || value == DBNull.Value) {
                       currentHi[keyName] = 0;
                       insertNextValue.CommandText = "INSERT UniqueKey (key_name, next_hi) VALUES ('" + keyName.ToString() + "', " + (currentHi[keyName] + 1).ToString() + ")";
                   } else {
                       currentHi[keyName] = (long)value;
                       insertNextValue.CommandText = "UPDATE UniqueKey SET next_hi = " + (currentHi[keyName] + 1).ToString() + " WHERE key_name = '" + keyName.ToString() + "'";
                   }
                   insertNextValue.ExecuteNonQuery();
               }
               transaction.Commit();
           }
           currentLo[keyName] = 1;
       }
   }

This code is very efficient on the database as it only has to hit the DB at application startup and after every 1000 id’s that have been generated.

Singleton Container

We now need a container to hold the instance of the HiLoUniqueKeyGenerator and that class must be initialized once when the NHibernateSessionFactory has been initialized. Here is my class for the singleton.

public class UniqueKeyGenerator {
 
    private static IUniqueKeyGenerator defaultInstance;
    public static IUniqueKeyGenerator Default {
        get {
            if (defaultInstance == null)
                throw new InvalidOperationException("Default instance of UniqueKeyGenerator has not been initialized.");
            return defaultInstance;
        }
    }
 
    public static void Initialize(IUniqueKeyGenerator defaultInstance) {
        if (UniqueKeyGenerator.defaultInstance != null)
            throw new InvalidOperationException("Default instance has already been initialized.");
        UniqueKeyGenerator.defaultInstance = defaultInstance;
    }
}
 
public interface IUniqueKeyGenerator {
    long NextKey(string keyName);
}

Now all we have to do is initialize it with NHibernate and it is ready to use:

UniqueKeyGenerator.Initialize(
        new HiLoUniqueKeyGenerator(NHibernateSessionFactory));

Using the UniqueKeyGenerator

myObject.MyProperty = UniqueKeyGenerator
        .Default.NextKey("myObject.myProperty");

Cucumber Debugging in Visual Studio with Ruby in Steel

admin — Sun, 16 May 2010 20:29:06 +0000

In this article, we will delve into the process of getting a Debugger working for cucumber inside visual Studio using Ruby in Steel.

If you have never seen Ruby in Steel. I highly recommend it, so go check it out at http://www.sapphiresteel.com/.

If you have never used cucumber from within visual studio, check out Brendan Erwin’s article on “Quick and Easy Cucumber Integration in Visual Studio.
http://brendanjerwin.github.com/2009/04/07/quick-and-easy-cucumber-integration-in-visual-studio.html

Done with all that? Good let’s get started!

Step 1.
Go to the link above and download/install Ruby in Steel (RiS), they offer a 60-day trial license so you have plenty of time to play around with it.

Step 2.
Once installed, open up visual studio, to any project you would like to add cucumber integration to. Right-Click on the solution, and add a new ruby project.

Step 3
Create your cucumber files & folder structure.

Step 4
Now comes the interesting part. In order to get cucumber to run within RiS, you’ll need to define an entry point for cucumber so that the RiS debugger can load the debugging symbols.

There are many ways to do this, when I first attempted to tackle this problem, I took the cucumber ruby file and added it to my solution…but I couldn’t figure out how to make it only run the scenarios I wanted.

Along came the C# helper program!

static void Main(string[] args)
{
    var stream = GetEmbeddedFile("CucumberDebugger", "cucumber.rb");
  
    FileStream fs = new FileStream(@"C:\ruby\bin\CucumberDebugger.rb",FileMode.Create,FileAccess.Write);
  
    ReadWriteStream(stream, fs);
  
    string workingDirectory = args[0];
    string itemPath = args[1];
  
    string lineNumber = "";
 
    if (args.Length == 3)
       lineNumber = args[2];
  
     System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\ruby\bin\debuginfo.dbg");
     file.WriteLine(workingDirectory.Replace('\\', '/').Remove(workingDirectory.Length-1));
     file.WriteLine(itemPath.Replace('\\', '/'));
  
     if (args.Length == 3)
         file.WriteLine(lineNumber);
 
     file.Close();
 }

Basically, what this program does is take 3 command line arguments: Project Directory, Item Path, and optionally Current Line and saves them to a file called “debuginfo.dbg”. It also takes an embedded resource, cucumber.rb and and writes it to the ruby directory for use as well. This ruby fill will be the entry point for our debugger. It takes all the parameters from the “debuginfo.dbg” file and kicks off cucumber with those params.

require 'rubygems'
  
lineNumber = nil
file = File.new("debuginfo.dbg", "r")
  
workingDir = file.gets.chomp();
featureFile = file.gets.chomp();
  
begin
lineNumber = file.gets.chomp();
rescue
end
  
version = ">= 0"
  
if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
    version = $1
    ARGV.shift
end
  
ARGV[0] = '--guess';
ARGV[1] = '-r';
ARGV[2] = "#{workingDir}/features/"
  
if (lineNumber == nil)
    ARGV[3] = "#{featureFile}"
else
    ARGV[3] = "#{featureFile}:#{lineNumber}"
end
  
gem 'cucumber', version
load 'cucumber'

You can download the full C# solution here: CucumberDebugger.zip

Step 5

Now we need to create an external tool that will call our CucumberDebugger.exe with the parameters we need.

Create a new tool called Cucumber Debug (Scenario) with the settings below:

Arguments (for ease of copy/paste): $(ProjectDir) $(ItemPath) $(CurLine)

Step 6

Now go to your *.feature file, choose the scenario to run (place your cursor there), and run your external tool.

This will create 2 files at C:\ruby\bin. “cucumberDebugger.rb” and “debuginfo.dbg’”

Last step

All we need to do now, is tell the debugger to look for our entry point file, and kick it off.

Right-Click on your ruby project and go to “Properties”, then the build tab.

Set your ruby start file to: C:\ruby\bin\CucumberDebugger.rb, save and close.

Go back to your feature file and click Run!

You can now step through your ruby code just like any other .net file!

Enjoy!

Please let me know if you have any questions.

Source Code