sql_partitioner 0.6.0

data/lib/sql_partitioner/partition.rb

@@ -0,0 +1,158 @@
+module SqlPartitioner
+
+  # Represents an array of `Partition` objects, with some extra helper methods.
+  class PartitionCollection < Array
+
+    # selects all partitions that hold records older than the timestamp provided
+    # @param [Fixnum] timestamp
+    # @return [Array<Partition>] partitions that hold data older than given timestamp
+    def older_than_timestamp(timestamp)
+      non_future_partitions.select do |p|
+        timestamp > p.timestamp
+      end
+    end
+
+    # selects all partitions that hold records newer than the timestamp provided
+    # @param [Fixnum] timestamp
+    # @return [Array<Partition>] partitions that hold data newer than given timestamp
+    def newer_than_timestamp(timestamp)
+      non_future_partitions.select do |p|
+        timestamp <= p.timestamp
+      end
+    end
+
+    # fetch the partition which is currently active. i.e. holds the records generated now
+    # @param [Fixnum] current_timestamp
+    # @return [Partition,NilClass]
+    def current_partition(current_timestamp)
+      non_future_partitions.select do |p|
+        p.timestamp > current_timestamp
+      end.min_by { |p| p.timestamp }
+    end
+
+    # @return [Array<Partition>] all partitions that do not have timestamp as `FUTURE_PARTITION_VALUE`
+    def non_future_partitions
+      self.reject { |p| p.future_partition? }
+    end
+
+    # fetch the latest partition that is not a future partition i.e. (value
+    #  is not `FUTURE_PARTITION_VALUE`)
+    # @return [Partition,NilClass] partition with maximum timestamp value
+    def latest_partition
+      non_future_partitions.max_by{ |p| p.timestamp }
+    end
+
+    # @return [Partition,NilClass] the partition with oldest timestamp
+    def oldest_partition
+      non_future_partitions.min_by { |p| p.timestamp }
+    end
+  end
+
+  # Represents information for a single partition in the database
+  class Partition
+    FUTURE_PARTITION_NAME  = 'future'
+    FUTURE_PARTITION_VALUE = 'MAXVALUE'
+    TO_LOG_ATTRIBUTES_SORT_ORDER = [
+      :ordinal_position, :name, :timestamp, :table_rows, :data_length, :index_length
+    ]
+
+    # Likely only called by `Partition.all`
+    def initialize(partition_data)
+      @partition_data = partition_data
+    end
+
+    # Fetches info on all partitions for the given `table_name`, using the given `adapter`.
+    # @param [BaseAdapter] adapter
+    # @param [String] table_name
+    # @return [PartitionCollection]
+    def self.all(adapter, table_name)
+      select_sql = SqlPartitioner::SQL.partition_info
+      result = adapter.select(select_sql, adapter.schema_name, table_name).reject{|r| r.partition_description.nil? }
+
+      partition_collection = PartitionCollection.new
+      result.each{ |r| partition_collection << self.new(r) }
+
+      partition_collection
+    end
+
+    # @return [Fixnum]
+    def ordinal_position
+      @partition_data.partition_ordinal_position
+    end
+
+    # @return [String]
+    def name
+      @partition_data.partition_name
+    end
+
+    # @return [Fixnum,String] only a string for "future" partition
+    def timestamp
+      if @partition_data.partition_description == FUTURE_PARTITION_VALUE
+        FUTURE_PARTITION_VALUE
+      else
+        @partition_data.partition_description.to_i
+      end
+    end
+
+    # @return [Fixnum]
+    def table_rows
+      @partition_data.table_rows
+    end
+
+    # @return [Fixnum]
+    def data_length
+      @partition_data.data_length
+    end
+
+    # @return [Fixnum]
+    def index_length
+      @partition_data.index_length
+    end
+
+    # @return [Boolean]
+    def future_partition?
+      self.timestamp == FUTURE_PARTITION_VALUE
+    end
+
+    # @return [Hash]
+    def attributes
+      {
+        :ordinal_position  => ordinal_position,
+        :name              => name,
+        :timestamp         => timestamp,
+        :table_rows        => table_rows,
+        :data_length       => data_length,
+        :index_length      => index_length
+      }
+    end
+
+    # logs the formatted partition info from information schema
+    # @param [Array] array of partition objects
+    # @return [String] formatted partitions in tabular form
+    def self.to_log(partitions)
+      return "none" if partitions.empty?
+
+      padding = TO_LOG_ATTRIBUTES_SORT_ORDER.map do |attribute|
+                  max_length = partitions.map do |partition|
+                    partition.send(attribute).to_s.length
+                  end.max
+                  [attribute.to_s.length, max_length].max + 3
+                end
+
+      header = TO_LOG_ATTRIBUTES_SORT_ORDER.each_with_index.map do |attribute, index|
+                  attribute.to_s.ljust(padding[index])
+                end.join
+
+      body = partitions.map do |partition|
+               TO_LOG_ATTRIBUTES_SORT_ORDER.each_with_index.map do |attribute, index|
+                 partition.send(attribute).to_s.ljust(padding[index])
+               end.join
+             end.join("\n")
+
+      separator = ''.ljust(padding.inject(&:+),'-')
+
+      [separator, header, separator, body, separator].join("\n")
+    end
+
+  end
+end

data/lib/sql_partitioner/partitions_manager.rb

@@ -0,0 +1,128 @@
+module SqlPartitioner
+  # Performs partitioning operations against a table.
+  class PartitionsManager < BasePartitionsManager
+    VALID_PARTITION_SIZE_UNITS = [:months, :days]
+
+    # Initialize the partitions based on intervals relative to current timestamp.
+    # Partition size specified by (partition_size, partition_size_unit), i.e. 1 month.
+    # Partitions will be created as needed to cover days_into_future.
+    #
+    # @param [Fixnum] days_into_future Number of days into the future from current_timestamp
+    # @param [Symbol] partition_size_unit one of: [:months, :days]
+    # @param [Fixnum] partition_size size of partition (in terms of partition_size_unit), i.e. 3 month
+    # @param [Boolean] dry_run Defaults to false. If true, query wont be executed.
+    # @return [Boolean] true if not dry run
+    # @return [String] sql to initialize partitions if dry run is true
+    # @raise [ArgumentError] if days is not array or if one of the
+    #                    days is not integer
+    def initialize_partitioning_in_intervals(days_into_future, partition_size_unit = :months, partition_size = 1, dry_run = false)
+      partition_data = partitions_to_append(@current_timestamp, partition_size_unit, partition_size, days_into_future)
+      initialize_partitioning(partition_data, dry_run)
+    end
+
+    # Get partition to add a partition to end with the given window size
+    #
+    # @param [Fixnum] partition_start_timestamp
+    # @param [Symbol] partition_size_unit: [:days, :months]
+    # @param [Fixnum] partition_size, size of partition (in terms of partition_size_unit)
+    # @param [Fixnum] partitions_into_future, how many partitions into the future should be covered
+    #
+    # @return [Hash] partition_data hash
+    def partitions_to_append(partition_start_timestamp, partition_size_unit, partition_size, days_into_future)
+      _validate_positive_fixnum(:days_into_future, days_into_future)
+
+      end_timestamp = @tuc.advance(current_timestamp, :days, days_into_future)
+      partitions_to_append_by_ts_range(partition_start_timestamp, end_timestamp, partition_size_unit, partition_size)
+    end
+
+    # Get partition_data hash based on the last partition's timestamp and covering end_timestamp
+    #
+    # @param [Fixnum] partition_start_timestamp, timestamp of last partition
+    # @param [Fixnum] end_timestamp, timestamp which the newest partition needs to include
+    # @param [Symbol] partition_size_unit: [:days, :months]
+    # @param [Fixnum] partition_size, intervals covered by the new partition
+    #
+    # @return [Hash] partition_data hash
+    def partitions_to_append_by_ts_range(partition_start_timestamp, end_timestamp, partition_size_unit, partition_size)
+      if partition_size_unit.nil? || !VALID_PARTITION_SIZE_UNITS.include?(partition_size_unit)
+        _raise_arg_err "partition_size_unit must be one of: #{VALID_PARTITION_SIZE_UNITS.inspect}"
+      end
+
+      _validate_positive_fixnum(:partition_size, partition_size)
+      _validate_positive_fixnum(:partition_start_timestamp, partition_start_timestamp)
+      _validate_positive_fixnum(:end_timestamp, end_timestamp)
+
+      timestamp = partition_start_timestamp
+
+      partitions_to_append = {}
+      while timestamp < end_timestamp
+        timestamp = @tuc.advance(timestamp, partition_size_unit, partition_size)
+
+        partition_name = name_from_timestamp(timestamp)
+        partitions_to_append[partition_name] = timestamp
+      end
+
+      partitions_to_append
+    end
+
+    # Wrapper around append partition to add a partition to end with the
+    # given window size
+    #
+    # @param [Symbol] partition_size_unit: [:days, :months]
+    # @param [Fixnum] partition_size, intervals covered by the new partition
+    # @param [Fixnum] days_into_future, how many days into the future need to be covered by partitions
+    # @param [Boolean] dry_run, Defaults to false. If true, query wont be executed.
+    # @return [Hash] partition_data hash of the partitions appended
+    # @raise [ArgumentError] if  window size is nil or not greater than 0
+    def append_partition_intervals(partition_size_unit, partition_size, days_into_future = 30, dry_run = false)
+      partitions = Partition.all(adapter, table_name)
+      if partitions.blank? || partitions.non_future_partitions.blank?
+        raise "partitions must be properly initialized before appending"
+      end
+      latest_partition = partitions.latest_partition
+
+      new_partition_data = partitions_to_append(latest_partition.timestamp, partition_size_unit, partition_size, days_into_future)
+
+      if new_partition_data.empty?
+        msg = "Append: No-Op - Latest Partition Time of #{latest_partition.timestamp}, " +
+              "i.e. #{Time.at(@tuc.to_seconds(latest_partition.timestamp))} covers >= #{days_into_future} days_into_future"
+      else
+        msg = "Append: Appending the following new partitions: #{new_partition_data.inspect}"
+        reorg_future_partition(new_partition_data, dry_run)
+      end
+
+      log(msg)
+
+      new_partition_data
+    end
+
+    # drop partitions that are older than days(input) from now
+    # @param [Fixnum] days_from_now
+    # @param [Boolean] dry_run, Defaults to false. If true, query wont be executed.
+    def drop_partitions_older_than_in_days(days_from_now, dry_run = false)
+      timestamp = self.current_timestamp - @tuc.from_days(days_from_now)
+      drop_partitions_older_than(timestamp, dry_run)
+    end
+
+    # drop partitions that are older than the given timestamp
+    # @param [Fixnum] timestamp partitions older than this timestamp will be
+    #                           dropped
+    # @param [Boolean] dry_run, Defaults to false. If true, query wont be executed.
+    # @return [Array] an array of partition names that were dropped
+    def drop_partitions_older_than(timestamp, dry_run = false)
+      partitions = Partition.all(adapter, table_name).older_than_timestamp(timestamp)
+      partition_names = partitions.map(&:name)
+
+      if partition_names.empty?
+        msg = "Drop: No-Op - No partitions older than #{timestamp}, i.e. #{Time.at(@tuc.to_seconds(timestamp))} to drop"
+      else
+        msg = "Drop: Dropped partitions: #{partition_names.inspect}"
+        drop_partitions(partition_names, dry_run)
+      end
+
+      log(msg)
+
+      partition_names
+    end
+  end
+end

data/lib/sql_partitioner/sql_helper.rb

@@ -0,0 +1,122 @@
+module SqlPartitioner
+  class SQL
+
+    # SQL query will return rows having the following columns:
+    #   - TABLE_CATALOG
+    #   - TABLE_SCHEMA
+    #   - TABLE_NAME
+    #   - PARTITION_NAME
+    #   - SUBPARTITION_NAME
+    #   - PARTITION_ORDINAL_POSITION
+    #   - SUBPARTITION_ORDINAL_POSITION
+    #   - PARTITION_METHOD
+    #   - SUBPARTITION_METHOD
+    #   - PARTITION_EXPRESSION
+    #   - SUBPARTITION_EXPRESSION
+    #   - PARTITION_DESCRIPTION
+    #   - TABLE_ROWS
+    #   - AVG_ROW_LENGTH
+    #   - DATA_LENGTH
+    #   - MAX_DATA_LENGTH
+    #   - INDEX_LENGTH
+    #   - DATA_FREE
+    #   - CREATE_TIME
+    #   - UPDATE_TIME
+    #   - CHECK_TIME
+    #   - CHECKSUM
+    #   - PARTITION_COMMENT
+    #   - NODEGROUP
+    #   - TABLESPACE_NAME
+    def self.partition_info
+      compress_lines(<<-SQL)
+        SELECT  *
+        FROM information_schema.PARTITIONS
+        WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+      SQL
+    end
+
+    def self.drop_partitions(table_name, partition_names)
+      return nil if partition_names.empty?
+
+      compress_lines(<<-SQL)
+        ALTER TABLE #{table_name}
+        DROP PARTITION #{partition_names.join(',')}
+      SQL
+    end
+
+    def self.create_partition(table_name, partition_name, until_timestamp)
+      compress_lines(<<-SQL)
+        ALTER TABLE #{table_name}
+        ADD PARTITION
+        (PARTITION #{partition_name}
+         VALUES LESS THAN (#{until_timestamp}))
+      SQL
+    end
+
+    def self.reorg_partitions(table_name, new_partition_data, reorg_partition_name)
+      return nil if new_partition_data.empty?
+
+      partition_suq_query = sort_partition_data(new_partition_data).map do |partition_name, until_timestamp|
+        "PARTITION #{partition_name} VALUES LESS THAN (#{until_timestamp})"
+      end.join(',')
+
+      compress_lines(<<-SQL)
+        ALTER TABLE #{table_name}
+        REORGANIZE PARTITION #{reorg_partition_name} INTO
+        (#{partition_suq_query})
+      SQL
+    end
+
+    def self.initialize_partitioning(table_name, partition_data)
+      partition_sub_query = sort_partition_data(partition_data).map do |partition_name, until_timestamp|
+        "PARTITION #{partition_name} VALUES LESS THAN (#{until_timestamp})"
+      end.join(',')
+
+      compress_lines(<<-SQL)
+        ALTER TABLE #{table_name}
+        PARTITION BY RANGE(timestamp)
+        (#{partition_sub_query})
+      SQL
+    end
+
+
+    # @param [Hash<String,Fixnum>] partition_data hash of name to timestamp
+    # @return [Array] array of partitions sorted by timestamp ascending, with the 'future' partition at the end
+    def self.sort_partition_data(partition_data)
+      partition_data.to_a.sort do |x,y|
+        if x[1] == "MAXVALUE"
+          1
+        elsif y[1] == "MAXVALUE"
+          -1
+        else
+          x[1] <=> y[1]
+        end
+      end
+    end
+
+    # Replace sequences of whitespace (including newlines) with either
+    # a single space or remove them entirely (according to param _spaced_).
+    #
+    # Copied from:
+    #   https://github.com/datamapper/dm-core/blob/master/lib/dm-core/support/ext/string.rb
+    #
+    #   compress_lines(<<QUERY)
+    #     SELECT name
+    #     FROM users
+    #   QUERY => "SELECT name FROM users"
+    #
+    # @param [String] string
+    #   The input string.
+    #
+    # @param [TrueClass, FalseClass] spaced (default=true)
+    #   Determines whether returned string has whitespace collapsed or removed.
+    #
+    # @return [String] The input string with whitespace (including newlines) replaced.
+    #
+    def self.compress_lines(string, spaced = true)
+      string.split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+    end
+
+  end
+end

data/lib/sql_partitioner/time_unit_converter.rb

@@ -0,0 +1,92 @@
+module SqlPartitioner
+  class TimeUnitConverter
+    require 'date'
+
+    MINUTE_AS_SECONDS = 60
+    HOUR_AS_SECONDS   = 60 * MINUTE_AS_SECONDS
+    DAY_AS_SECONDS    = 24 * HOUR_AS_SECONDS
+
+    SUPPORTED_TIME_UNITS = [:seconds, :micro_seconds]
+
+    # @param [Symbol] time_unit one of SUPPORTED_TIME_UNITS
+    def initialize(time_unit)
+      raise ArgumentError.new("Invalid time unit #{time_unit} passed") if !SUPPORTED_TIME_UNITS.include?(time_unit)
+
+      @time_unit = time_unit
+    end
+
+    # @param [Fixnum] num_days
+    # @return [Fixnum] number of days represented in the configure time units
+    def from_days(num_days)
+      from_seconds(num_days * DAY_AS_SECONDS)
+    end
+
+    # @param [Fixnum] time_units_timestamp timestamp in configured time units
+    # @return [DateTime] representation of the given timestamp
+    def to_date_time(time_units_timestamp)
+      DateTime.strptime("#{to_seconds(time_units_timestamp)}", '%s')
+    end
+
+    # converts from seconds to the configured time unit
+    #
+    # @param [Fixnum] timestamp_seconds timestamp in seconds
+    #
+    # @return [Fixnum] timestamp in configured time units
+    def from_seconds(timestamp_seconds)
+      timestamp_seconds * time_units_per_second
+    end
+
+    # converts from the configured time unit to seconds
+    #
+    # @param [Fixnum] time_units_timestamp timestamp in the configured time units
+    #
+    # @return [Fixnum] timestamp in seconds
+    def to_seconds(time_units_timestamp)
+      time_units_timestamp / time_units_per_second
+    end
+
+    # @return [Fixnum] how many of the configured time_unit are in 1 second
+    def time_units_per_second
+      self.class.time_units_per_second(@time_unit)
+    end
+
+    # @param [Fixnum] time_units_timestamp
+    # @param [Symbol] calendar_unit unit for the given value, one of [:day(s), :month(s)]
+    # @param [Fixnum] value in terms of calendar_unit to add to the time_units_timestamp
+    #
+    # @return [Fixnum] new timestamp in configured time units
+    def advance(time_units_timestamp, calendar_unit, value)
+      date_time = to_date_time(time_units_timestamp)
+      date_time = self.class.advance_date_time(date_time, calendar_unit, value)
+      from_seconds(date_time.to_time.to_i)
+    end
+
+    # @param [DateTime] date_time to advance
+    # @param [Symbol] calendar_unit unit for the following `value`, one of [:day(s), :month(s)]
+    # @param [Fixnum] value in terms of calendar_unit to add to the date_time
+    # @return [DateTime] result of advancing the given date_time by the given value
+    def self.advance_date_time(date_time, calendar_unit, value)
+      new_time = case calendar_unit
+        when :days, :day
+          date_time + value
+        when :months, :month
+          date_time >> value
+      end
+
+      new_time
+    end
+
+    # @param [Symbol] time_unit one of `SUPPORTED_TIME_UNITS`
+    # @return [Fixnum] how many of the given time_unit are in 1 second
+    def self.time_units_per_second(time_unit)
+      case time_unit
+      when :micro_seconds
+        1_000_000
+      when :seconds
+        1
+      else
+        raise "unknown time_unit #{time_unit.inspect}"
+      end
+    end
+  end
+end

data/lib/sql_partitioner/version.rb

@@ -0,0 +1,3 @@
+module SqlPartitioner
+  VERSION = "0.6.0"
+end

data/lib/sql_partitioner.rb

@@ -0,0 +1,14 @@
+# standard requires
+require 'sql_partitioner/loader'
+require 'sql_partitioner/lock_wait_timeout_handler'
+require 'sql_partitioner/partition'
+require 'sql_partitioner/time_unit_converter'
+require 'sql_partitioner/sql_helper'
+require 'sql_partitioner/base_partitions_manager'
+require 'sql_partitioner/partitions_manager'
+
+SqlPartitioner::Loader.require_or_skip('sql_partitioner/adapters/ar_adapter', 'ActiveRecord')
+SqlPartitioner::Loader.require_or_skip('sql_partitioner/adapters/dm_adapter', 'DataMapper')
+
+
+

data/spec/db_conf.yml

@@ -0,0 +1,7 @@
+test:
+  adapter: mysql
+  database: sql_partitioner_test
+  username: root
+  password:
+  host: localhost
+

data/spec/lib/spec_helper.rb

@@ -0,0 +1,52 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'active_record'
+require 'data_mapper'
+
+require 'sql_partitioner'
+
+require 'logger'
+
+#require 'ruby-debug' # enable debugger support
+
+SPEC_LOGGER = Logger.new(nil)
+
+RSpec.configure do |config|
+  # enable both should and expect syntax in rspec without deprecation warnings
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.before :suite do
+    require 'yaml'
+    db_conf = YAML.load_file('spec/db_conf.yml')
+
+    # establish both ActiveRecord and DataMapper connections
+    ActiveRecord::Base.establish_connection(db_conf["test"])
+
+    adapter,database,user,pass,host = db_conf["test"].values_at *%W(adapter database username password host)
+    connection_string = "#{adapter}://#{user}:#{pass}@#{host}/#{database}"
+    DataMapper.setup(:default, connection_string)
+  end
+
+  config.before :each do
+    sql = <<-SQL
+      DROP TABLE IF EXISTS `test_events`
+    SQL
+    DataMapper.repository.adapter.execute(sql)
+
+    sql = <<-SQL
+      CREATE TABLE IF NOT EXISTS `test_events` (
+        `id` bigint(20) NOT NULL AUTO_INCREMENT,
+        `timestamp` bigint(20) unsigned NOT NULL DEFAULT '0',
+        PRIMARY KEY (`id`,`timestamp`)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8
+    SQL
+    DataMapper.repository.adapter.execute(sql)
+
+  end
+end

data/spec/lib/sql_partitioner/adapters/adapters_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+shared_examples_for "an adapter" do
+  describe "#execute" do
+    it "should execute the SQL statement passed" do
+      adapter.execute("SET @sql_partitioner_test = 1")
+
+      adapter.select("SELECT @sql_partitioner_test").first.to_i.should == 1
+
+      adapter.execute("SET @sql_partitioner_test = NULL")
+    end
+  end
+
+  describe "#schema_name" do
+    it "should return the schema_name" do
+      adapter.schema_name.should == "sql_partitioner_test"
+    end
+  end
+
+  describe ".select" do
+    context "with multiple columns selected" do
+      context "and no data returned" do
+        it "should return an empty hash" do
+          adapter.select("SELECT * FROM test_events").should == []
+        end
+      end
+      context "and data returned" do
+        before(:each) do
+          adapter.execute("INSERT INTO test_events(timestamp) VALUES(1)")
+          adapter.execute("INSERT INTO test_events(timestamp) VALUES(2)")
+        end
+        it "should return a Struct with accessors for each column" do
+          result = adapter.select("SELECT * FROM test_events")
+
+          result.should be_a_kind_of(Array)
+
+          result.first.should be_a_kind_of(Struct)
+          result.first.timestamp.to_i.should == 1
+
+          result.last.should be_a_kind_of(Struct)
+          result.last.timestamp.to_i.should  == 2
+        end
+      end
+    end
+    context "with a single column selected" do
+      before(:each) do
+        adapter.execute("INSERT INTO test_events(timestamp) VALUES(1)")
+        adapter.execute("INSERT INTO test_events(timestamp) VALUES(2)")
+      end
+      it "should return the values without Struct" do
+        result = adapter.select("SELECT timestamp FROM test_events")
+
+        result.should be_a_kind_of(Array)
+
+        result.first.to_i.should == 1
+        result.last.to_i.should  == 2
+      end
+      it "should return an array even when only one row is selected" do
+        result = adapter.select("SELECT timestamp FROM test_events LIMIT 1")
+
+        result.should be_a_kind_of(Array)
+      end
+    end
+  end
+end
+
+describe SqlPartitioner::ARAdapter do
+  it_should_behave_like "an adapter" do
+    let(:adapter) do 
+      SqlPartitioner::ARAdapter.new(ActiveRecord::Base.connection)
+    end
+  end
+end
+
+describe SqlPartitioner::DMAdapter do
+  it_should_behave_like "an adapter" do
+    let(:adapter) do
+      SqlPartitioner::DMAdapter.new(DataMapper.repository.adapter)
+    end
+  end
+end
+

data/spec/lib/sql_partitioner/adapters/base_adapter_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path("../../spec_helper", File.dirname(__FILE__))
+
+describe "BaseAdapter" do
+  before(:each) do
+    @base_adapter = SqlPartitioner::BaseAdapter.new
+  end
+  describe "#select" do
+    it "should raise an RuntimeError" do
+      lambda{
+        @base_adapter.select("SELECT database()")
+      }.should raise_error(RuntimeError, /MUST BE IMPLEMENTED/)
+    end
+  end
+  describe "#execute" do
+    it "should raise an RuntimeError" do
+      lambda{
+        @base_adapter.execute("SELECT database()")
+      }.should raise_error(RuntimeError, /MUST BE IMPLEMENTED/)
+    end
+  end
+  describe "#schema_name" do
+    it "should raise an RuntimeError" do
+      lambda{
+        @base_adapter.schema_name
+      }.should raise_error(RuntimeError, /MUST BE IMPLEMENTED/)
+    end
+  end
+end