hyperion-sql 0.0.1.alpha2

data/lib/hyperion/sql/datastore.rb

@@ -0,0 +1,84 @@
+require 'hyperion/api'
+require 'hyperion/key'
+require 'hyperion/sql/query_builder'
+require 'hyperion/sql/query_executor'
+
+module Hyperion
+  module Sql
+
+    class Datastore
+
+      def initialize(db_strategy, query_executor_strategy, query_builder_strategy)
+        @db_strategy = db_strategy
+        @query_executor = QueryExecutor.new(query_executor_strategy)
+        @query_builder = QueryBuilder.new(query_builder_strategy)
+      end
+
+      def save(records)
+        records.map do |record|
+          if API.new?(record)
+            execute_save_query(query_builder.build_insert(record), record)
+          elsif non_empty_record?(record)
+            execute_save_query(query_builder.build_update(record), record)
+          else
+            record
+          end
+        end
+      end
+
+      def find_by_key(key)
+        find(query_from_key(key)).first
+      end
+
+      def find(query)
+        sql_query = query_builder.build_select(query)
+        results = query_executor.execute_query(sql_query)
+        results.map { |record| record_from_db(record, query.kind) }
+      end
+
+      def delete_by_key(key)
+        delete(query_from_key(key))
+      end
+
+      def delete(query)
+        sql_query = query_builder.build_delete(query)
+        query_executor.execute_mutation(sql_query)
+        nil
+      end
+
+      def count(query)
+        sql_query = query_builder.build_count(query)
+        results = query_executor.execute_query(sql_query)
+        db_strategy.process_count_result(results[0])
+      end
+
+      private
+
+      attr_reader :query_builder, :query_executor, :db_strategy
+
+      def non_empty_record?(record)
+        record = record.dup
+        record.delete(:kind)
+        record.delete(:key)
+        !record.empty?
+      end
+
+      def execute_save_query(sql_query, record)
+        result = query_executor.execute_write(sql_query)
+        returned_record = db_strategy.process_result(record, result)
+        record_from_db(returned_record, record[:kind])
+      end
+
+      def record_from_db(record, table)
+        record[:key] = Key.compose_key(table, record.delete('id')) if API.new?(record)
+        record[:kind] = table
+        record
+      end
+
+      def query_from_key(key)
+        table, id = Key.decompose_key(key)
+        Query.new(table, [Filter.new(:id, '=', id)], nil, nil, nil)
+      end
+    end
+  end
+end

data/lib/hyperion/sql/query_builder.rb

@@ -0,0 +1,125 @@
+require 'hyperion/key'
+require 'hyperion/sql/sql_query'
+
+module Hyperion
+  module Sql
+
+    class QueryBuilder
+
+      def initialize(qb_strategy)
+        @qb_strategy = qb_strategy
+      end
+
+      def build_insert(record)
+        record = record.dup
+        table = format_table(record.delete(:kind))
+        unless record.empty?
+          columns = format_array(record.keys.map {|c| format_column(c) })
+          values = format_array(record.values.map {|v| '?'})
+          query = "INSERT INTO #{table} #{columns} VALUES #{values}"
+        else
+          query = qb_strategy.empty_insert_query(table)
+        end
+        SqlQuery.new(qb_strategy.normalize_insert(query), record.values)
+      end
+
+      def build_update(record)
+        record = record.dup
+        table, id = Key.decompose_key(record.delete(:key))
+        table = format_table(record.delete(:kind))
+        column_values = record.keys.map {|field| "#{format_column(field)} = ?"}
+        query = qb_strategy.normalize_update("UPDATE #{table} SET #{column_values.join(', ')} WHERE #{quote('id')} = #{id}")
+        SqlQuery.new(query, record.values)
+      end
+
+      def build_select(query)
+        sql_query = SqlQuery.new("SELECT * FROM \"#{query.kind}\"")
+        apply_filters(sql_query, query.filters)
+        apply_sorts(sql_query, query.sorts)
+        qb_strategy.apply_limit_and_offset(sql_query, query.limit, query.offset)
+        sql_query
+      end
+
+      def build_delete(query)
+        sql_query = SqlQuery.new("DELETE FROM \"#{query.kind}\"")
+        apply_filters(sql_query, query.filters)
+        sql_query
+      end
+
+      def build_count(query)
+        sql_query = SqlQuery.new("SELECT COUNT(*) FROM \"#{query.kind}\"")
+        apply_filters(sql_query, query.filters)
+        sql_query
+      end
+
+      private
+
+      attr_reader :qb_strategy
+
+      def quote(str)
+        tick = qb_strategy.quote_tick
+        tick + str.to_s.gsub(tick, tick + tick) + tick
+      end
+
+      def format_column(column)
+        quote(column)
+      end
+
+      def format_table(table)
+        quote(table)
+      end
+
+      def format_array(arr)
+        "(#{arr.join(', ')})"
+      end
+
+      def apply_filters(sql_query, filters)
+        if filters.empty?
+          sql_query
+        else
+          filter_sql = []
+          filter_values = []
+          filters.each do |filter|
+            filter_sql << "#{format_column(filter.field)} #{format_operator(filter.operator)} ?"
+            filter_values << filter.value
+          end
+          sql_query.append("WHERE #{filter_sql.join(' AND ')}", filter_values)
+        end
+      end
+
+      def format_operator(operator)
+        case operator
+        when 'contains?'
+          "IN"
+        when '!='
+          "<>"
+        else
+          operator
+        end
+      end
+
+      def apply_sorts(sql_query, sorts)
+        if sorts.empty?
+          sql_query
+        else
+          sort_sql = []
+          sort_values = []
+          sort_sql = sorts.map do |sort|
+            "#{format_column(sort.field)} #{format_order(sort.order)}"
+          end
+          sql_query.append("ORDER BY #{sort_sql.join(', ')}")
+        end
+      end
+
+      def format_order(order)
+        case order
+        when :asc
+          "ASC"
+        when :desc
+          "DESC"
+        end
+      end
+    end
+
+  end
+end

data/lib/hyperion/sql/query_executor.rb

@@ -0,0 +1,35 @@
+require 'hyperion/sql'
+
+module Hyperion
+  module Sql
+
+    class QueryExecutor
+
+      attr_reader :strategy
+
+      def initialize(strategy)
+        @strategy = strategy
+      end
+
+      def execute_mutation(sql_query)
+        command = connection.create_command(sql_query.query_str)
+        command.execute_non_query(*sql_query.bind_values)
+      end
+
+      def execute_query(sql_query)
+        command = connection.create_command(sql_query.query_str)
+        command.execute_reader(*sql_query.bind_values).to_a
+      end
+
+      def execute_write(sql_query)
+        strategy.execute_write(sql_query)
+      end
+
+      def connection
+        Sql.connection
+      end
+
+    end
+
+  end
+end

data/lib/hyperion/sql/sql_query.rb

@@ -0,0 +1,19 @@
+
+module Hyperion
+  module Sql
+
+    class SqlQuery
+      attr_reader :query_str, :bind_values
+
+      def initialize(query_str, bind_values=[])
+        @query_str = query_str
+        @bind_values = bind_values || []
+      end
+
+      def append(str, values=[])
+        @query_str << " #{str}"
+        @bind_values += values if values
+      end
+    end
+  end
+end

data/lib/hyperion/sql/transaction.rb

@@ -0,0 +1,56 @@
+require 'socket'
+require 'digest'
+require 'digest/sha2'
+
+module Hyperion
+  module Sql
+    class Transaction
+
+      HOST = "#{Socket::gethostbyname(Socket::gethostname)[0]}" rescue "localhost"
+
+      attr_reader :connection
+
+      @@counter = 0
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def begin
+        run "BEGIN"
+      end
+
+      def commit
+        run "COMMIT"
+      end
+
+      def rollback
+        run "ROLLBACK"
+      end
+
+      def begin_savepoint
+        id = new_savepoint_id
+        run %{SAVEPOINT "#{id}"}
+        id
+      end
+
+      def release_savepoint(id)
+        run %{RELEASE SAVEPOINT "#{id}"}
+      end
+
+      def rollback_to_savepoint(id)
+        run %{ROLLBACK TO SAVEPOINT "#{id}"}
+      end
+
+      private
+
+      def run(cmd)
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def new_savepoint_id
+        Digest::SHA256.hexdigest("#{HOST}:#{$$}:#{Time.now.to_f}:#{@@counter += 1}")[0..-2]
+      end
+    end
+  end
+end

data/lib/hyperion/sql/transaction_spec.rb

@@ -0,0 +1,156 @@
+shared_examples_for 'Sql Transactions' do
+  def write(query)
+    command = Hyperion::Sql.connection.create_command(query)
+    command.execute_non_query
+  end
+
+  def create_table(table_name)
+    write("CREATE TABLE #{table_name} (name VARCHAR(20), age INTEGER)")
+  end
+
+  def drop_table(table_name)
+    write("DROP TABLE IF EXISTS #{table_name}")
+  end
+
+  around :each do |example|
+    begin
+      create_table('test')
+      example.run
+    ensure
+      drop_table('test')
+    end
+  end
+
+  def test_count
+    Hyperion::API.count_by_kind('test')
+  end
+
+  context 'rollback' do
+
+    it 'rolls back all changes' do
+      Hyperion::Sql.rollback do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        test_count.should == 1
+      end
+      test_count.should == 0
+    end
+
+    it 'rolls back multiple' do
+      Hyperion::Sql.rollback do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        Hyperion::Sql.rollback do
+          write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+          test_count.should == 2
+        end
+          test_count.should == 1
+      end
+      test_count.should == 0
+    end
+
+    it 'returns the result of the body' do
+      Hyperion::Sql.rollback do
+        :result
+      end.should == :result
+    end
+
+  end
+
+  context 'transaction' do
+
+    it 'commits' do
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        test_count.should == 1
+      end
+      test_count.should == 1
+    end
+
+    it 'commits multiple' do
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+      end
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+      end
+      test_count.should == 2
+    end
+
+    it 'commits one and then rolls back the next' do
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+      end
+      expect {
+        Hyperion::Sql.transaction do
+          write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+          raise
+        end
+      }.to raise_error
+      test_count.should == 1
+    end
+
+    it 'rolls back when an exception is thrown' do
+      expect {
+        Hyperion::Sql.transaction do
+          write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+          test_count.should == 1
+          raise
+        end
+      }.to raise_error
+      test_count.should == 0
+    end
+
+    it 'commits nested transactions' do
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        Hyperion::Sql.transaction do
+          write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        end
+      end
+      test_count.should == 2
+    end
+
+    it 'rolls back nested transactions' do
+      expect {
+        Hyperion::Sql.transaction do
+          write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+          Hyperion::Sql.transaction do
+            write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+          end
+          test_count.should == 2
+          raise
+        end
+      }.to raise_error
+      test_count.should == 0
+    end
+
+    it 'returns the result of the transaction' do
+      Hyperion::Sql.transaction do
+        :result
+      end.should == :result
+    end
+
+  end
+
+  it 'can handle outer rollback and inner transaction' do
+    Hyperion::Sql.rollback do
+      Hyperion::Sql.transaction do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+      end
+      test_count.should == 1
+    end
+    test_count.should == 0
+  end
+
+  it 'can handle outer transaction and inner rollback' do
+    Hyperion::Sql.transaction do
+      write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+      test_count.should == 1
+      Hyperion::Sql.rollback do
+        write("INSERT INTO test (name, age) VALUES ('Myles', 23)")
+        test_count.should == 2
+      end
+      test_count.should == 1
+    end
+    test_count.should == 1
+  end
+end

data/lib/hyperion/sql.rb

@@ -0,0 +1,66 @@
+require 'hyperion/sql/transaction'
+
+module Hyperion
+  module Sql
+
+    def self.with_connection(url)
+      connection = DataObjects::Connection.new(url)
+      Thread.current[:connection] = connection
+      yield(connection)
+      connection.close
+      Thread.current[:connection] = nil
+    end
+
+    def self.connection
+      Thread.current[:connection] || raise('No Connection Established')
+    end
+
+    def self.rollback
+      with_txn do |txn|
+        begin
+          savepoint_id = txn.begin_savepoint
+          yield
+        ensure
+          txn.rollback_to_savepoint(savepoint_id)
+        end
+      end
+    end
+
+    def self.transaction
+      with_txn do |txn|
+        begin
+          savepoint_id = txn.begin_savepoint
+          result = yield
+          txn.release_savepoint(savepoint_id)
+          result
+        rescue Exception => e
+          txn.rollback_to_savepoint(savepoint_id)
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def self.in_transaction?
+      !Thread.current[:transaction].nil?
+    end
+
+    def self.with_txn
+      if Thread.current[:transaction]
+        yield(Thread.current[:transaction])
+      else
+        txn = (Thread.current[:transaction] = Transaction.new(connection))
+        txn.begin
+        result = yield(txn)
+        txn.commit
+        result
+      end
+    rescue Exception => e
+      txn.rollback
+      raise e
+    ensure
+      Thread.current[:transaction] = nil
+    end
+  end
+end

data/spec/hyperion/sql_spec.rb

@@ -0,0 +1,4 @@
+require 'hyperion/sql'
+
+describe Hyperion::Sql do
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: hyperion-sql
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha2
+  prerelease: 6
+platform: ruby
+authors:
+- 8th Light, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: hyperion-api
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.alpha2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.alpha2
+description: Shared behavior for Sql databases
+email:
+- myles@8thlight.com
+- skim@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hyperion/sql.rb
+- lib/hyperion/sql/query_executor.rb
+- lib/hyperion/sql/sql_query.rb
+- lib/hyperion/sql/transaction.rb
+- lib/hyperion/sql/transaction_spec.rb
+- lib/hyperion/sql/query_builder.rb
+- lib/hyperion/sql/datastore.rb
+- spec/hyperion/sql_spec.rb
+homepage: https://github.com/mylesmegyesi/hyperion-ruby
+licenses:
+- Eclipse Public License
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Shared behavior for Sql databases
+test_files:
+- spec/hyperion/sql_spec.rb