bigrecord-driver 0.0.6 → 0.0.7

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/bin/bigrecord-driver

@@ -62,7 +62,7 @@ unset RUBYLIB
 if [ "$DRIVERNAME" == "" ]; then
   echo "Driver type was not specified"
   exit 1
-elif [ "$DRIVERNAME" != "hbase" -a "$DRIVERNAME" != "cassandra" ]; then
+elif [ "$DRIVERNAME" != "hbase" ]; then
   echo "Driver type \"$DRIVERNAME\" is invalid"
   exit 1
 fi
@@ -126,30 +126,30 @@ start() {
     refresh_pids
 
     if [ -f "$PIDS_DIR/$PORT.pid" -a "$PID" != "" ] ; then
-        echo -e "\nAlready running (pid="$PID")."
-        exit 1
+      echo -e "\nAlready running (pid="$PID")."
+      exit 1
     else
 	    rm -f $LOGS_DIR/$PORT.log
 	    nohup jruby $DRIVER $PORT >> $LOGS_DIR/$PORT.log 2>&1 < /dev/null &
 	    PID=$!
 	    if [ "$PID" != "" ] ; then
-	        # monitor the log file for the message saying that the server is started
-	        for ((i=0; i<$STARTUP_TIMEOUT; i+=1)); do
-	          sleep 1
-	          echo -n "."
-	          if [ "$(cat $LOGS_DIR/$PORT.log | grep 'Started drb server')" != "" ] ; then
-	            break
-	          fi
-	        done
-
-	        if [ "$i" == $STARTUP_TIMEOUT ] ; then
-	          echo -e "\nStartup timeout: couldn't start the DRb server."
-	        else
-	          echo $PID > $PIDS_DIR/$PORT.pid
-	        fi
-	        echo ""
+        # monitor the log file for the message saying that the server is started
+        for ((i=0; i<$STARTUP_TIMEOUT; i+=1)); do
+          sleep 1
+          echo -n "."
+          if [ "$(cat $LOGS_DIR/$PORT.log | grep 'Started drb server')" != "" ] ; then
+            break
+          fi
+        done
+
+        if [ "$i" == $STARTUP_TIMEOUT ] ; then
+          echo -e "\nStartup timeout: couldn't start the DRb server."
+        else
+          echo $PID > $PIDS_DIR/$PORT.pid
+        fi
+        echo ""
 	    else
-            echo -e "\nAn error occured while starting the DRb server."
+        echo -e "\nAn error occured while starting the DRb server."
 	    fi
     fi
 }
@@ -161,8 +161,8 @@ stop() {
 
 	if [ -f "$PIDS_DIR/$PORT.pid" -a "$PID" != "" ] ; then
 		echo "Stopping driver (pid = $PID)." >> $LOGS_DIR/$PORT.log
-	    kill $PID
-	    rm $PIDS_DIR/$PORT.pid
+    kill $PID
+    rm $PIDS_DIR/$PORT.pid
 	else
 		echo "No $DRIVERNAME driver to kill."
 	fi
@@ -183,24 +183,25 @@ start_debug() {
 }
 
 case "$ACTION" in
-    start)
-   		start
-        ;;
-    stop)
-   		stop
-        ;;
-    restart)
-   		stop
-   		start
-        ;;
-    status)
-        status
-        ;;
-    start_debug)
-    	start_debug
-    	;;
-    *)
-        print_usage
-        exit 1
+  start)
+	  start
+    ;;
+  stop)
+	  stop
+    ;;
+  restart)
+	  stop
+	  start
+    ;;
+  status)
+    status
+    ;;
+  start_debug)
+	  start_debug
+	  ;;
+  *)
+    print_usage
+    exit 1
 esac
+
 exit 0

data/bin/hbase-driver

@@ -11,22 +11,22 @@ if ARGV.include?("-l")
 
   # Make sure that the folder exists
   if File.exists?(hbase_path)
-	# We're only going to include the jar files we need.
-	required_jars = Dir[hbase_path+"/*.jar",
-						hbase_path+"/lib/commons-logging*.jar",
-						hbase_path+"/lib/zookeeper*.jar",
-						hbase_path+"/lib/log4j*.jar",
-						hbase_path+"/lib/hadoop*.jar"]
-	classpath = required_jars.join(":")
+	  # We're only going to include the jar files we need.
+	  required_jars = Dir[hbase_path+"/*.jar",
+						  hbase_path+"/lib/commons-logging*.jar",
+						  hbase_path+"/lib/zookeeper*.jar",
+						  hbase_path+"/lib/log4j*.jar",
+						  hbase_path+"/lib/hadoop*.jar"]
+	  classpath = required_jars.join(":")
 
-	args.delete_at(switch_index)
-	args.delete_at(switch_index)
-	args = args + ["-c", '"'+classpath+'"']
+	  args.delete_at(switch_index)
+	  args.delete_at(switch_index)
+	  args = args + ["-c", '"'+classpath+'"']
 
   # Otherwise we'll warn the user and quit
   else
-	puts "Folder #{hbase_path} does not exist"
-	exit
+	  puts "Folder #{hbase_path} does not exist"
+	  exit
   end
 end
 

data/lib/big_record_driver.rb

@@ -1,7 +1,14 @@
-LIB_ROOT = File.dirname(__FILE__)
+module BigRecord
+  module Driver
+  end
+end
 
-require LIB_ROOT + '/big_record_driver/client'
-require LIB_ROOT + '/big_record_driver/exceptions'
-require LIB_ROOT + '/big_record_driver/column_descriptor'
-require LIB_ROOT + '/big_record_driver/driver_manager'
-require LIB_ROOT + '/big_record_driver/version'
+BRD_ROOT = File.dirname(__FILE__)
+
+require BRD_ROOT + '/big_record_driver/client'
+require BRD_ROOT + '/big_record_driver/exceptions'
+require BRD_ROOT + '/big_record_driver/column_descriptor'
+require BRD_ROOT + '/big_record_driver/version'
+
+# Aliasing the old namespace
+BigRecordDriver = BigRecord::Driver

data/lib/big_record_driver/client.rb

@@ -1,36 +1,39 @@
-require 'rubygems'
-require 'activesupport' 
+require 'active_support' 
 require 'set'
 require 'drb'
 
-module BigRecordDriver
-  class Client
-    
-    def initialize(config={}) # :nodoc:
-      config = config.symbolize_keys
-      config[:drb_host]     ||= '127.0.0.1'
-      config[:drb_port]     ||= 40000
-      
-      @config = config
-
-      DRb.start_service('druby://127.0.0.1:0')
-      begin
-        @server = DRbObject.new(nil, "druby://#{@config[:drb_host]}:#{@config[:drb_port]}")
-      rescue DRb::DRbConnError
-        raise ConnectionError, "Failed to connect to the DRb server (jruby) " +
-                                      "at #{@config[:drb_host]}:#{@config[:drb_port]}."
+module BigRecord
+  module Driver
+
+    class Client
+      attr_accessor :config, :server
+
+      def initialize(config={}) # :nodoc:
+        config = config.symbolize_keys
+        config[:drb_host] ||= '127.0.0.1'
+        config[:drb_port] ||= 40000
+
+        @config = config
+
+        DRb.start_service nil
+        begin
+          @server = DRbObject.new(nil, "druby://#{@config[:drb_host]}:#{@config[:drb_port]}")
+        rescue DRb::DRbConnError
+          raise ConnectionError, "Failed to connect to the DRb server (jruby) " +
+                                        "at #{@config[:drb_host]}:#{@config[:drb_port]}."
+        end
+        @server.configure(@config)
+      end
+
+      # Delegate the methods to the server
+      def method_missing(method, *args)
+        @server.send(method, *args)
+      end
+
+      def respond_to?(method)
+        super
       end
-      @server.configure(@config)
-    end
-    
-    # Delegate the methods to the server
-    def method_missing(method, *args)
-      @server.send(method, *args)
-    end
-    
-    def respond_to?(method)
-      super
     end
-    
+
   end
 end

data/lib/big_record_driver/column_descriptor.rb

@@ -1,23 +1,20 @@
-module BigRecordDriver
+module BigRecord
+  module Driver
 
-  class ColumnDescriptor
+    class ColumnDescriptor
+      attr_accessor :name, :versions, :in_memory, :bloom_filter, :compression
 
-    attr_accessor :name
-    attr_accessor :versions
-    attr_accessor :in_memory
-    attr_accessor :bloom_filter
-    attr_accessor :compression
+      def initialize(name, options={})
+        raise ArgumentError, "name is mandatory" unless name
 
-    def initialize(name, options={})
-      raise ArgumentError, "name is mandatory" unless name
-
-      @name = name.to_s
-      @versions         = options[:versions]
-      @in_memory        = options[:in_memory]
-      @bloom_filter     = options[:bloom_filter]
-      @compression      = options[:compression]
+        @name = name.to_s
+        @versions     = options[:versions]
+        @in_memory    = options[:in_memory]
+        @bloom_filter = options[:bloom_filter]
+        @compression  = options[:compression]
+      end
     end
 
   end
-
 end
+

data/lib/big_record_driver/exceptions.rb

@@ -1,12 +1,14 @@
-module BigRecordDriver
-  class BigDBError < StandardError
-  end
-  class TableNotFound < BigDBError
-  end
-  class TableAlreadyExists < BigDBError
-  end
-  class JavaError < BigDBError
-  end
-  class ConnectionError < BigDBError
+module BigRecord
+  module Driver
+    class DriverError < StandardError
+    end
+    class TableNotFound < DriverError
+    end
+    class TableAlreadyExists < DriverError
+    end
+    class JavaError < DriverError
+    end
+    class ConnectionError < DriverError
+    end
   end
 end

data/lib/big_record_driver/hbase_driver/server.rb

@@ -1,396 +1,427 @@
 require File.dirname(__FILE__) + '/../column_descriptor'
 require File.dirname(__FILE__) + '/../exceptions'
-require File.dirname(__FILE__) + '/../bigrecord_server'
+require File.dirname(__FILE__) + '/../server'
 
-module BigRecordDriver
+module BigRecord
+  module Driver
 
-class HbaseServer < BigRecordServer
-  include_class "java.util.TreeMap"
+    class HbaseServer < Server
+      java_import "java.util.TreeMap"
+      include_package "org.apache.hadoop.hbase.client"
+      java_import "org.apache.hadoop.hbase.KeyValue"
+      java_import "org.apache.hadoop.hbase.io.hfile.Compression"
+      java_import "org.apache.hadoop.hbase.HBaseConfiguration"
+      java_import "org.apache.hadoop.hbase.HTableDescriptor"
+      java_import "org.apache.hadoop.hbase.HColumnDescriptor"
 
-  include_class "org.apache.hadoop.hbase.client.HTable"
-  include_class "org.apache.hadoop.hbase.client.HBaseAdmin"
-  include_class "org.apache.hadoop.hbase.io.BatchUpdate"
-  include_class "org.apache.hadoop.hbase.io.hfile.Compression"
-  include_class "org.apache.hadoop.hbase.HBaseConfiguration"
-  include_class "org.apache.hadoop.hbase.HConstants"
-  include_class "org.apache.hadoop.hbase.HStoreKey"
-  include_class "org.apache.hadoop.hbase.HTableDescriptor"
-  include_class "org.apache.hadoop.hbase.HColumnDescriptor"
+      # Establish the connection with HBase with the given configuration parameters.
+      def configure(config = {})
+        config[:zookeeper_quorum]       ||= 'localhost'
+        config[:zookeeper_client_port]  ||= '2181'
 
-  include_class "org.apache.hadoop.io.Writable"
+        @config = config
 
-  # Establish the connection with HBase with the given configuration parameters.
-  def configure(config = {})
-    config[:zookeeper_quorum]        ||= 'localhost'
-    config[:zookeeper_client_port]  ||= '2181'
+        init_connection
+      end
 
-    @config = config
+      # Atomic row insertion/update. Example:
+      #   update('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', {'attribute:name' => "--- Oahu\n",
+      #                                                               'attribute:travel_rank' => "--- 0.90124565\n"})
+      #   => 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8'
+      def update(table_name, row, values, timestamp=nil)
+        safe_exec do
+          return nil unless row
 
-    init_connection
-  end
+          table = connect_table(table_name)
+          row_lock = table.lockRow(row.to_bytes)
 
-  # Atomic row insertion/update. Example:
-  #   update('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', {'attribute:name' => "--- Oahu\n",
-  #                                                               'attribute:travel_rank' => "--- 0.90124565\n"})
-  #   => 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8'
-  def update(table_name, row, values, timestamp=nil)
-    safe_exec do
-      return nil unless row
-      table = connect_table(table_name)
+          put = generate_put(row, values, timestamp, row_lock)
+          table.put(put)
 
-      batch = timestamp ? BatchUpdate.new(row, timestamp) : BatchUpdate.new(row)
+          table.unlockRow(row_lock)
 
-      values.each do |column, value|
-        batch.put(column, value.to_bytes)
+          row
+        end
       end
 
-      table.commit(batch)
-      row
-    end
-  end
+      # Returns a column of a row. Example:
+      #   get('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', 'attribute:travel_rank')
+      #   => "--- 0.90124565\n"
+      #
+      # valid options:
+      #   :timestamp  => integer corresponding to the time when the record was saved in hbase
+      #   :versions   => number of versions to retreive, starting at the specified timestamp (or the latest)
+      def get(table_name, row, column, options={})
+        safe_exec do
+          return nil unless row
+
+          table = connect_table(table_name)
+
+          # Grab the version number if the client's using the old API,
+          # or retrieve only the lastest version by default
+          options[:versions] ||= options[:num_versions]
+          options[:versions] ||= 1
+
+          # validate the arguments
+          raise ArgumentError, "versions must be >= 1" unless options[:versions] >= 1
+
+          get = generate_get(row, column, options)
+          result = table.get(get)
+
+          if (result.nil? || result.isEmpty)
+            return (options[:versions] == 1 ? nil : [])
+          else
+            output = result.list.collect do |keyvalue|
+              to_ruby_string(keyvalue.getValue)
+            end
 
-  # Returns a column of a row. Example:
-  #   get('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', 'attribute:travel_rank')
-  #   => "--- 0.90124565\n"
-  #
-  # valid options:
-  #   :timestamp      => integer corresponding to the time when the record was saved in hbase
-  #   :versions   => number of versions to retreive, starting at the specified timestamp (or the latest)
-  def get(table_name, row, column, options={})
-    safe_exec do
-      return nil unless row
-      table = connect_table(table_name)
-
-      # Retreive only the last version by default
-      options[:versions] ||= options[:num_versions]
-      options[:versions] ||= 1
-
-      # validate the arguments
-      raise ArgumentError, "versions must be >= 1" unless options[:versions] >= 1
-
-      # get the raw data from hbase
-      unless options[:timestamp]
-        if options[:versions] == 1
-          raw_data = table.get(row, column)
-        else
-          raw_data = table.get(row,
-                                column,
-                                options[:versions])
+            return (options[:versions] == 1 ? output[0] : output)
+          end
         end
-      else
-        raw_data = table.get(row,
-                              column,
-                              options[:timestamp],
-                              options[:versions])
       end
 
-      # Return either a single value or an array, depending on the number of version that have been requested
-      if options[:versions] == 1
-        return nil unless raw_data
-        raw_data = raw_data[0] if options[:timestamp]
-        to_ruby_string(raw_data)
-      else
-        return [] unless raw_data
-        raw_data.collect do |raw_data_version|
-          to_ruby_string(raw_data_version)
+      # Returns the last version of the given columns of the given row. The columns works with
+      # regular expressions (e.g. 'attribute:' matches all attributes columns). Example:
+      #   get_columns('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', ['attribute:'])
+      #   => {"attribute:name" => "--- Oahu\n", "attribute:travel_rank" => "--- 0.90124565\n", etc...}
+      def get_columns(table_name, row, columns, options={})
+        safe_exec do
+          return nil unless row
+
+          table_name = table_name.to_s
+          table = connect_table(table_name)
+
+          get = generate_get(row, columns, options)
+          result = table.get(get)
+
+          begin
+            parse_result(result)
+          rescue
+            nil
+          end
         end
       end
-    end
-  end
 
-  # Returns the last version of the given columns of the given row. The columns works with
-  # regular expressions (e.g. 'attribute:' matches all attributes columns). Example:
-  #   get_columns('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', ['attribute:'])
-  #   => {"attribute:name" => "--- Oahu\n", "attribute:travel_rank" => "--- 0.90124565\n", etc...}
-  def get_columns(table_name, row, columns, options={})
-    safe_exec do
-      return nil unless row
-      table_name = table_name.to_s
-      table = connect_table(table_name)
-
-      java_cols = Java::String[columns.size].new
-      columns.each_with_index do |col, i|
-        java_cols[i] = Java::String.new(col)
-      end
+      # Get consecutive rows. Example to get 100 records starting with the one specified and get all the
+      # columns in the column family 'attribute:' :
+      #   get_consecutive_rows('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', 100, ['attribute:'])
+      def get_consecutive_rows(table_name, start_row, limit, columns, stop_row = nil)
+        safe_exec do
+          table_name = table_name.to_s
+          table = connect_table(table_name)
 
-      result =
-      if options[:timestamp]
-        table.getRow(row, java_cols, options[:timestamp])
-      else
-        table.getRow(row, java_cols)
-      end
+          scan = Scan.new
+          scan.setStartRow(start_row.to_bytes) if start_row
+          scan.setStopRow(stop_row.to_bytes) if stop_row
+
+          columns.each do |column|
+            (column[-1,1] == ":") ?
+              scan.addFamily(column.gsub(":", "").to_bytes) :
+              scan.addColumn(column.to_bytes)
+          end
+
+          scanner = table.getScanner(scan)
 
-      unless !result or result.isEmpty
-        values = {}
-        result.entrySet.each do |entry|
-          column_name = Java::String.new(entry.getKey).to_s
-          values[column_name] = to_ruby_string(entry.getValue)
+          if limit
+            results = scanner.next(limit)
+          else
+            results = []
+            while (row_result = scanner.next) != nil
+              results << row_result
+            end
+          end
+
+          output = []
+          results.each do |result|
+            output << parse_result(result)
+          end
+          scanner.close
+
+          return output
         end
-        values["id"] = row
-        values
-      else
-        nil
       end
-    end
-  end
 
-  # Get consecutive rows. Example to get 100 records starting with the one specified and get all the
-  # columns in the column family 'attribute:' :
-  #   get_consecutive_rows('entities', 'b9cef848-a4e0-11dc-a7ba-0018f3137ea8', 100, ['attribute:'])
-  def get_consecutive_rows(table_name, start_row, limit, columns, stop_row = nil)
-    safe_exec do
-      table_name = table_name.to_s
-      table = connect_table(table_name)
-
-      java_cols = Java::String[columns.size].new
-      columns.each_with_index do |col, i|
-        java_cols[i] = Java::String.new(col)
+      # Delete a whole row.
+      def delete(table_name, row, timestamp = nil)
+        safe_exec do
+          table = connect_table(table_name)
+
+          if timestamp
+            row_lock = table.lockRow(row.to_bytes)
+            table.delete(Delete.new(row.to_bytes, timestamp, row_lock))
+            table.unlockRow(row_lock)
+          else
+            table.delete(Delete.new(row.to_bytes))
+          end
+        end
       end
 
-      start_row ||= ""
-      start_row = start_row.to_s
+      # Create a table
+      def create_table(table_name, column_descriptors)
+        safe_exec do
+          table_name = table_name.to_s
+          unless table_exists?(table_name)
+            tdesc = HTableDescriptor.new(table_name)
 
-      # We cannot set stop_row like start_row because a
-      # default stop row would have to be the biggest value possible
-      if stop_row
-        scanner = table.getScanner(java_cols, start_row, stop_row, HConstants::LATEST_TIMESTAMP)
-      else
-        scanner = table.getScanner(java_cols, start_row)
-      end
+            column_descriptors.each do |cd|
+              cdesc = generate_column_descriptor(cd)
 
-      row_count = 0 if limit
-      result = []
-      while (row_result = scanner.next) != nil
-        if limit
-          break if row_count == limit
-          row_count += 1
-        end
-        values = {}
-        row_result.entrySet.each do |entry|
-          column_name = Java::String.new(entry.getKey).to_s
-          data = to_ruby_string(entry.getValue)
-          values[column_name] = data
+              tdesc.addFamily(cdesc)
+            end
+            @admin.createTable(tdesc)
+          else
+            raise TableAlreadyExists, table_name
+          end
         end
-        unless values.empty?
-          # TODO: is this really supposed to be hard coded?
-          values['id'] = Java::String.new(row_result.getRow).to_s
-          result << values
+      end
+
+      # Delete a table
+      def drop_table(table_name)
+        safe_exec do
+          table_name = table_name.to_s
+
+          if @admin.tableExists(table_name)
+            @admin.disableTable(table_name)
+            @admin.deleteTable(table_name)
+
+            # Remove the table connection from the cache
+            @tables.delete(table_name) if @tables.has_key?(table_name)
+          else
+            raise TableNotFound, table_name
+          end
         end
       end
-      scanner.close
-      result
-    end
-  end
 
-  # Delete a whole row.
-  def delete(table_name, row, timestamp = nil)
-    safe_exec do
-      table = connect_table(table_name)
-      timestamp ? table.deleteAll(row.to_bytes, timestamp) : table.deleteAll(row.to_bytes)
-    end
-  end
+      def add_column(table_name, column_descriptor)
+        safe_exec do
+          table_name = table_name.to_s
 
-  # Create a table
-  def create_table(table_name, column_descriptors)
-    safe_exec do
-      table_name = table_name.to_s
-      unless table_exists?(table_name)
-        tdesc = HTableDescriptor.new(table_name)
+          if @admin.tableExists(table_name)
+            @admin.disableTable(table_name)
 
-        column_descriptors.each do |cd|
-          cdesc = generate_column_descriptor(cd)
+            cdesc = generate_column_descriptor(column_descriptor)
+            @admin.addColumn(table_name, cdesc)
 
-          tdesc.addFamily(cdesc)
+            @admin.enableTable(table_name)
+          else
+            raise TableNotFound, table_name
+          end
         end
-        @admin.createTable(tdesc)
-      else
-        raise BigRecordDriver::TableAlreadyExists, table_name
       end
-    end
-  end
 
-  # Delete a table
-  def drop_table(table_name)
-    safe_exec do
-      table_name = table_name.to_s
+      def remove_column(table_name, column_name)
+        safe_exec do
+          table_name = table_name.to_s
+          column_name = column_name.to_s
+
+          if @admin.tableExists(table_name)
+            @admin.disableTable(table_name)
 
-      if @admin.tableExists(table_name)
-        @admin.disableTable(table_name)
-        @admin.deleteTable(table_name)
+            column_name << ":" unless column_name =~ /:$/
+            @admin.deleteColumn(table_name, column_name)
 
-        # Remove the table connection from the cache
-        @tables.delete(table_name) if @tables.has_key?(table_name)
-      else
-        raise BigRecordDriver::TableNotFound, table_name
+            @admin.enableTable(table_name)
+          else
+            raise TableNotFound, table_name
+          end
+        end
       end
-    end
-  end
 
-  def add_column(table_name, column_descriptor)
-    safe_exec do
-      table_name = table_name.to_s
+      def modify_column(table_name, column_descriptor)
+        safe_exec do
+          table_name = table_name.to_s
 
-      if @admin.tableExists(table_name)
-        @admin.disableTable(table_name)
+          if @admin.tableExists(table_name)
+            @admin.disableTable(table_name)
 
-        cdesc = generate_column_descriptor(column_descriptor)
-        @admin.addColumn(table_name, cdesc)
+            cdesc = generate_column_descriptor(column_descriptor)
+            @admin.modifyColumn(table_name, column_descriptor.name, cdesc)
 
-        @admin.enableTable(table_name)
-      else
-        raise BigRecordDriver::TableNotFound, table_name
+            @admin.enableTable(table_name)
+          else
+            raise TableNotFound, table_name
+          end
+        end
       end
-    end
-  end
 
-  def remove_column(table_name, column_name)
-    safe_exec do
-      table_name = table_name.to_s
-      column_name = column_name.to_s
+      def truncate_table(table_name)
+        safe_exec do
+          table_name = table_name.to_s
+          table = connect_table(table_name)
+          tableDescriptor = table.getTableDescriptor
+          drop_table(table_name)
+          @admin.createTable(tableDescriptor)
+        end
+      end
 
-      if @admin.tableExists(table_name)
-        @admin.disableTable(table_name)
+      def ping
+        safe_exec do
+          @admin.isMasterRunning
+        end
+      end
 
-        column_name << ":" unless column_name =~ /:$/
-        @admin.deleteColumn(table_name, column_name)
+      def table_exists?(table_name)
+        safe_exec do
+          @admin.tableExists(table_name.to_s)
+        end
+      end
 
-        @admin.enableTable(table_name)
-      else
-        raise BigRecordDriver::TableNotFound, table_name
+      def table_names
+        safe_exec do
+          @admin.listTables.collect{|td| Java::String.new(td.getName).to_s}
+        end
       end
-    end
-  end
 
-  def modify_column(table_name, column_descriptor)
-    safe_exec do
-      table_name = table_name.to_s
-      column_name = column_name.to_s
+    private
 
-      if @admin.tableExists(table_name)
-        @admin.disableTable(table_name)
+      def init_connection
+        safe_exec do
+          @conf = HBaseConfiguration.new
+          @conf.set('hbase.zookeeper.quorum', "#{@config[:zookeeper_quorum]}")
+          @conf.set('hbase.zookeeper.property.clientPort', "#{@config[:zookeeper_client_port]}")
+          @admin = HBaseAdmin.new(@conf)
+          @tables = {}
+        end
+      end
 
-        cdesc = generate_column_descriptor(column_descriptor)
-        @admin.modifyColumn(table_name, column_descriptor.name, cdesc)
+      # Create a connection to an HBase table and keep it in memory.
+      def connect_table(table_name)
+        safe_exec do
+          table_name = table_name.to_s
+          return @tables[table_name] if @tables.has_key?(table_name)
 
-        @admin.enableTable(table_name)
-      else
-        raise BigRecordDriver::TableNotFound, table_name
+          if table_exists?(table_name)
+            @tables[table_name] = HTable.new(@conf, table_name)
+          else
+            if table_name and !table_name.empty?
+              raise TableNotFound, table_name
+            else
+              raise ArgumentError, "Table name not specified"
+            end
+          end
+          @tables[table_name]
+        end
       end
-    end
-  end
 
-  def truncate_table(table_name)
-    safe_exec do
-      table_name = table_name.to_s
-      table = connect_table(table_name)
-      tableDescriptor = table.getTableDescriptor
-      drop_table(table_name)
-      @admin.createTable(tableDescriptor)
-    end
-  end
+      # Create a Get object given parameters.
+      #
+      # @param [String] row
+      # @param [Array, String] A single (or collection) of strings
+      #     fully qualified column name or column family (ends with ':').
+      # @param [Hash] options
+      #
+      # @return [Get] org.apache.hadoop.hbase.client.Get object
+      #     corresponding to the arguments passed.
+      def generate_get(row, columns, options = {})
+        columns = [columns].flatten
+
+        get = Get.new(row.to_bytes)
+
+        columns.each do |column|
+          # If the column name ends with ':' then it's a column family.
+          (column[-1,1] == ":") ?
+            get.addFamily(column.gsub(":", "").to_bytes) :
+            get.addColumn(column.to_bytes)
+        end
 
-  def ping
-    safe_exec do
-      @admin.isMasterRunning
-    end
-  end
+        get.setMaxVersions(options[:versions]) if options[:versions]
 
-  def table_exists?(table_name)
-    safe_exec do
-      @admin.tableExists(table_name.to_s)
-    end
-  end
+        # Need to add 1 to the timestamp due to the the API sillyness, i.e. min timestamp
+        # is inclusive while max timestamp is exclusive.
+        get.setTimeRange(java.lang.Long::MIN_VALUE, options[:timestamp]+1) if options[:timestamp]
 
-  def table_names
-    safe_exec do
-      @admin.listTables.collect{|td| Java::String.new(td.getName).to_s}
-    end
-  end
+        return get
+      end
 
-#  def const_missing(const)
-#    super
-#  rescue NameError => ex
-#    raise NameError, "uninitialized constant #{const}"
-#  end
-
-private
-  # Create a connection to a Hbase table and keep it in memory.
-  def connect_table(table_name)
-    safe_exec do
-      table_name = table_name.to_s
-      return @tables[table_name] if @tables.has_key?(table_name)
-
-      if table_exists?(table_name)
-        @tables[table_name] = HTable.new(@conf, table_name)
-      else
-        if table_name and !table_name.empty?
-          raise BigRecordDriver::TableNotFound, table_name
-        else
-          raise ArgumentError, "Table name not specified"
+      # Create a Put object given parameters.
+      #
+      # @param [String] row
+      # @param [Hash] Keys as the fully qualified column names and
+      #     their associated values.
+      # @param [Integer] timestamp
+      # @param [org.apache.hadoop.hbase.client.RowLock] row_lock
+      #
+      # @return [Put] org.apache.hadoop.hbase.client.Put object
+      #     corresponding to the arguments passed.
+      def generate_put(row, columns = {}, timestamp = nil, row_lock = nil)
+        put = row_lock ? Put.new(row.to_bytes, row_lock) : Put.new(row.to_bytes)
+
+        columns.each do |name, value|
+          family, qualifier = name.split(":")
+          timestamp ?
+            put.add(family.to_bytes, qualifier.to_bytes, timestamp, value.to_bytes) :
+            put.add(family.to_bytes, qualifier.to_bytes, value.to_bytes)
         end
+
+        return put
       end
-      @tables[table_name]
-    end
-  end
 
-  def init_connection
-    safe_exec do
-      @conf = HBaseConfiguration.new
-      @conf.set('hbase.zookeeper.quorum', "#{@config[:zookeeper_quorum]}")
-      @conf.set('hbase.zookeeper.property.clientPort', "#{@config[:zookeeper_client_port]}")
-      @admin = HBaseAdmin.new(@conf)
-      @tables = {}
-    end
-  end
+      # Parse a Result object into a Hash.
+      #
+      # @param [Result] result
+      #
+      # @return [Hash] Fully qualified column names as keys
+      #     and their corresponding values.
+      def parse_result(result)
+        output = {}
+
+        result.list.each do |keyvalue|
+          output[to_ruby_string(keyvalue.getColumn)] = to_ruby_string(keyvalue.getValue)
+        end
 
-  def generate_column_descriptor(column_descriptor)
-    raise ArgumentError, "a column descriptor is missing a name" unless column_descriptor.name
-    raise "bloom_filter option not supported yet" if column_descriptor.bloom_filter
+        output["id"] = to_ruby_string(result.getRow)
 
-    if column_descriptor.compression
-      compression =
-        case column_descriptor.compression.to_s
-          when 'none';   Compression::Algorithm::NONE.getName()
-          when 'gz';     Compression::Algorithm::GZ.getName()
-          when 'lzo';    Compression::Algorithm::LZO.getName()
-          else
-            raise ArgumentError, "Invalid compression type: #{column_descriptor.compression} for the column_family #{column_descriptor.name}"
+        return output
+      end
+
+      def generate_column_descriptor(column_descriptor)
+        raise ArgumentError, "a column descriptor is missing a name" unless column_descriptor.name
+        raise "bloom_filter option not supported yet" if column_descriptor.bloom_filter
+
+        if column_descriptor.compression
+          compression =
+            case column_descriptor.compression.to_s
+              when 'none';   Compression::Algorithm::NONE.getName()
+              when 'gz';     Compression::Algorithm::GZ.getName()
+              when 'lzo';    Compression::Algorithm::LZO.getName()
+              else
+                raise ArgumentError, "Invalid compression type: #{column_descriptor.compression} for the column_family #{column_descriptor.name}"
+            end
         end
-    end
 
-    n_versions    = column_descriptor.versions
-    in_memory     = column_descriptor.in_memory
-
-    # set the default values of the missing parameters
-    n_versions        ||= HColumnDescriptor::DEFAULT_VERSIONS
-    compression       ||= HColumnDescriptor::DEFAULT_COMPRESSION
-    in_memory         ||= HColumnDescriptor::DEFAULT_IN_MEMORY
-    block_cache       ||= HColumnDescriptor::DEFAULT_BLOCKCACHE
-    block_size        ||= HColumnDescriptor::DEFAULT_BLOCKSIZE
-    bloomfilter       ||= HColumnDescriptor::DEFAULT_BLOOMFILTER
-    ttl               ||= HColumnDescriptor::DEFAULT_TTL
-
-    # add the ':' at the end if the user didn't specify it
-    column_descriptor.name << ":" unless column_descriptor.name =~ /:$/
-
-    cdesc = HColumnDescriptor.new(column_descriptor.name.to_bytes,
-                                  n_versions,
-                                  compression,
-                                  in_memory,
-                                  block_cache,
-                                  block_size,
-                                  ttl,
-                                  bloomfilter)
-
-    return cdesc
-  end
+        n_versions    = column_descriptor.versions
+        in_memory     = column_descriptor.in_memory
+
+        # set the default values of the missing parameters
+        n_versions        ||= HColumnDescriptor::DEFAULT_VERSIONS
+        compression       ||= HColumnDescriptor::DEFAULT_COMPRESSION
+        in_memory         ||= HColumnDescriptor::DEFAULT_IN_MEMORY
+        block_cache       ||= HColumnDescriptor::DEFAULT_BLOCKCACHE
+        block_size        ||= HColumnDescriptor::DEFAULT_BLOCKSIZE
+        bloomfilter       ||= HColumnDescriptor::DEFAULT_BLOOMFILTER
+        ttl               ||= HColumnDescriptor::DEFAULT_TTL
+
+        # add the ':' at the end if the user didn't specify it
+        column_descriptor.name << ":" unless column_descriptor.name =~ /:$/
+
+        cdesc = HColumnDescriptor.new(column_descriptor.name.to_bytes,
+                                      n_versions,
+                                      compression,
+                                      in_memory,
+                                      block_cache,
+                                      block_size,
+                                      ttl,
+                                      bloomfilter)
+
+        return cdesc
+      end
 
-end
+    end
 
+  end
 end
 
-port = ARGV[0]
-port ||= 40000
-DRb.start_service("druby://:#{port}", BigRecordDriver::HbaseServer.new)
+port = ARGV[0] || 40000
+DRb.start_service("druby://:#{port}", BigRecord::Driver::HbaseServer.new)
 puts "Started drb server on port #{port}."
 DRb.thread.join