perpetuity-postgres 0.0.1

data/lib/perpetuity/postgres.rb

@@ -0,0 +1,170 @@
+require 'perpetuity'
+require 'json'
+require 'perpetuity/postgres/connection_pool'
+require 'perpetuity/postgres/serializer'
+require 'perpetuity/postgres/query'
+require 'perpetuity/postgres/negated_query'
+require 'perpetuity/postgres/table'
+require 'perpetuity/postgres/table/attribute'
+require 'perpetuity/postgres/sql_select'
+require 'perpetuity/postgres/sql_update'
+
+module Perpetuity
+  class Postgres
+    attr_reader :host, :port, :db, :pool_size, :username, :password,
+                :connection
+
+    def initialize options
+      @host      = options.fetch(:host) { 'localhost' }
+      @port      = options.fetch(:port) { 5432 }
+      @db        = options.fetch(:db)
+      @pool_size = options.fetch(:pool_size) { 5 }
+      @username  = options.fetch(:username) { ENV['USER'] }
+      @password  = options.fetch(:password) {}
+
+      @connection ||= ConnectionPool.new(
+        db:       db,
+        host:     host,
+        port:     port,
+        username: username,
+        password: password,
+        pool_size: pool_size
+      )
+    end
+
+    def insert klass, serialized_objects, attributes
+      table = TableName.new(klass)
+      data = serialized_objects.reduce(:+)
+      sql = "INSERT INTO #{table} #{data} RETURNING id"
+
+      results = connection.execute(sql).to_a
+      ids = results.map { |result| result['id'] }
+
+      ids
+    rescue PG::UndefinedTable => e # Table doesn't exist, so we create it.
+      retries ||= 0
+      retries += 1
+      create_table_with_attributes klass, attributes
+      retry unless retries > 1
+      raise e
+    end
+
+    def delete id, klass
+      table = TableName.new(klass)
+      id_string = TextValue.new(id)
+      sql = "DELETE FROM #{table} WHERE id = #{id_string}"
+      connection.execute(sql).to_a
+    end
+
+    def count klass, query='TRUE', options={}, &block
+      where = if block_given?
+                query(&block)
+              else
+                query
+              end
+      options = translate_options(options).merge(from: klass, where: where)
+      table = table_name(klass)
+      sql = select 'COUNT(*)', options
+      connection.execute(sql).to_a.first['count'].to_i
+    rescue PG::UndefinedTable
+      # Table does not exist, so there are 0 records
+      0
+    end
+
+    def find klass, id
+      retrieve(klass, query { |o| o.id == id }.to_db).first
+    end
+
+    def table_name klass
+      TableName.new(klass)
+    end
+
+    def delete_all klass
+      table = table_name(klass)
+      sql = "DELETE FROM #{table}"
+      connection.execute(sql)
+    rescue PG::UndefinedTable
+      # Do nothing. There is already nothing here.
+    end
+
+    def query &block
+      Query.new(&block)
+    end
+
+    def negate_query &block
+      NegatedQuery.new(&block)
+    end
+
+    def retrieve klass, criteria, options={}
+      options = translate_options(options).merge from: klass, where: criteria
+
+      sql = select options
+      connection.execute(sql).to_a
+    rescue PG::UndefinedTable
+      []
+    end
+
+    def update klass, id, attributes
+      sql = SQLUpdate.new(klass, id, attributes).to_s
+      connection.execute(sql).to_a
+    end
+
+    def translate_options options
+      options = options.dup
+      if options[:attribute]
+        options[:order] = options.delete(:attribute)
+        if direction = options.delete(:direction)
+          direction = direction.to_s[/\w{1,2}sc/i]
+          options[:order] = { options[:order] => direction }
+        end
+      end
+      if options[:skip]
+        options[:offset] = options.delete(:skip)
+      end
+
+      options
+    end
+
+    def select *args
+      SQLSelect.new(*args).to_s
+    end
+
+    def drop_table name
+      connection.execute "DROP TABLE IF EXISTS #{table_name(name)}"
+    end
+
+    def create_table name, attributes
+      connection.execute Table.new(name, attributes).create_table_sql
+    end
+
+    def has_table? name
+      connection.tables.include? name
+    end
+
+    def postgresify value
+      Serializer.new(nil).serialize_attribute value
+    end
+
+    def serialize object, mapper
+      Serializer.new(mapper).serialize object
+    end
+
+    def serialize_changed_attributes object, original, mapper
+      Serializer.new(mapper).serialize_changes object, original
+    end
+
+    def unserialize data, mapper
+      Serializer.new(mapper).unserialize data
+    end
+
+    def create_table_with_attributes klass, attributes
+      table_attributes = attributes.map do |attr|
+        name = attr.name
+        type = attr.type
+        options = attr.options
+        Table::Attribute.new name, type, options
+      end
+      create_table klass.to_s, table_attributes
+    end
+  end
+end

data/perpetuity-postgres.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'perpetuity/postgres/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "perpetuity-postgres"
+  spec.version       = Perpetuity::Postgres::VERSION
+  spec.authors       = ["Jamie Gaskins"]
+  spec.email         = ["jgaskins@gmail.com"]
+  spec.description   = %q{PostgreSQL adapter for Perpetuity}
+  spec.summary       = %q{PostgreSQL adapter for Perpetuity}
+  spec.homepage      = "https://github.com/jgaskins/perpetuity-postgres"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "perpetuity", "~> 1.0.0.beta"
+  spec.add_runtime_dependency "pg"
+end

data/spec/perpetuity/postgres/boolean_value_spec.rb

@@ -0,0 +1,15 @@
+require 'perpetuity/postgres/boolean_value'
+
+module Perpetuity
+  class Postgres
+    describe BooleanValue do
+      it 'serializes true into a Postgres true value' do
+        BooleanValue.new(true).to_s.should == 'TRUE'
+      end
+
+      it 'serializes false into a Postgres false value' do
+        BooleanValue.new(false).to_s.should == 'FALSE'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/connection_pool_spec.rb

@@ -0,0 +1,55 @@
+require 'perpetuity/postgres/connection_pool'
+
+module Perpetuity
+  class Postgres
+    describe ConnectionPool do
+      let(:pool) { ConnectionPool.new }
+
+      it 'defaults to 5 connections' do
+        pool.should have(5).connections
+      end
+
+      describe 'lending a connection' do
+        it 'executes the given block' do
+          expect { |probe| pool.lend_connection(&probe) }.to yield_control
+        end
+
+        it 'does not yield when there is no block given' do
+          pool.lend_connection
+        end
+
+        it 'lends a connection for the duration of a block' do
+          pool.lend_connection do |connection|
+            pool.should have(4).connections
+          end
+          pool.should have(5).connections
+        end
+
+        it 'returns the value of the block' do
+          pool.lend_connection { 1 }.should == 1
+        end
+      end
+
+      it 'executes a given SQL statement' do
+        sql = "SELECT TRUE"
+        Connection.any_instance.should_receive(:execute)
+                               .with(sql)
+        pool.execute sql
+      end
+
+      it 'passes the tables message to a connection' do
+        Connection.any_instance.should_receive(:tables)
+        pool.tables
+      end
+
+      it 'cycles through each connection round-robin style' do
+        connections = []
+        pool.size.times do
+          pool.lend_connection { |c| connections << c }
+        end
+
+        connections.uniq.should have(pool.size).items
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/connection_spec.rb

@@ -0,0 +1,30 @@
+require 'perpetuity/postgres/connection'
+
+module Perpetuity
+  class Postgres
+    describe Connection do
+      let(:connection) { Connection.new(db: 'perpetuity_gem_test') }
+
+      it 'sanitizes the options for the pg gem' do
+        options = { db: 'db', username: 'user' }
+        connection.sanitize_options(options).should == {
+          dbname: 'db',
+          user: 'user'
+        }
+      end
+
+      it 'is only activated when it is used' do
+        connection.should_not be_active
+        connection.connect
+        connection.should be_active
+      end
+
+      it 'executes SQL' do
+        connection.execute 'CREATE TABLE IF NOT EXISTS abcdefg (name text)'
+        connection.tables.should include 'abcdefg'
+        connection.execute 'DROP TABLE IF EXISTS abcdefg'
+        connection.tables.should_not include 'abcdefg'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/expression_spec.rb

@@ -0,0 +1,13 @@
+require 'perpetuity/postgres/expression'
+
+module Perpetuity
+  class Postgres
+    describe Expression do
+      let(:expression) { Expression.new('uuid_generate_v4()') }
+
+      it 'passes the expression straight into SQL' do
+        expression.to_sql.should == 'uuid_generate_v4()'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/json_array_spec.rb

@@ -0,0 +1,31 @@
+require 'perpetuity/postgres/json_array'
+
+module Perpetuity
+  class Postgres
+    describe JSONArray do
+      it 'serializes empty arrays' do
+        JSONArray.new([]).to_s.should == "'[]'"
+      end
+
+      it 'serializes arrays of numeric values' do
+        JSONArray.new([1,2,3]).to_s.should == "'[1,2,3]'"
+      end
+
+      it 'serializes arrays of strings' do
+        JSONArray.new(%w(foo bar baz)).to_s.should == %q{'["foo","bar","baz"]'}
+      end
+
+      it 'serializes arrays of hashes' do
+        JSONArray.new([{a: 1}, {b: 2}]).to_s.should == %q{'[{"a":1},{"b":2}]'}
+      end
+
+      it 'serializes arrays of JSONHashes' do
+        JSONArray.new([JSONHash.new(a: 1)]).to_s.should == %q{'[{"a":1}]'}
+      end
+
+      it 'serializes elements of arrays' do
+        JSONArray.new([1,'a']).to_s.should == %q{'[1,"a"]'}
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/json_hash_spec.rb

@@ -0,0 +1,39 @@
+require 'perpetuity/postgres/json_hash'
+
+module Perpetuity
+  class Postgres
+    describe JSONHash do
+      it 'serializes empty hashes' do
+        JSONHash.new({}).to_s.should == "'{}'"
+      end
+
+      it 'serializes hashes with string elements' do
+        JSONHash.new({a: 'b'}).to_s.should == %q{'{"a":"b"}'}
+      end
+
+      it 'serializes hashes with numeric elements' do
+        JSONHash.new({a: 1}).to_s.should == %q{'{"a":1}'}
+      end
+
+      it 'serializes hashes with boolean elements' do
+        JSONHash.new({a: true, b: false}).to_s.should == %q('{"a":true,"b":false}')
+      end
+
+      it 'does not surround the an inner serialized value with quotes' do
+        JSONHash.new({a: 1}, :inner).to_s.should == %q[{"a":1}]
+      end
+
+      it 'serializes hashes with multiple entries' do
+        JSONHash.new({a: 1, b: 'c'}).to_s.should == %q{'{"a":1,"b":"c"}'}
+      end
+
+      it 'converts back to a hash' do
+        JSONHash.new({a: 1}).to_hash.should == { a: 1 }
+      end
+
+      it 'is equal to an identical hash' do
+        JSONHash.new(a: 1).should == JSONHash.new(a: 1)
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/json_string_value_spec.rb

@@ -0,0 +1,11 @@
+require 'perpetuity/postgres/json_string_value'
+
+module Perpetuity
+  class Postgres
+    describe JSONStringValue do
+      it 'serializes into a JSON string value' do
+        JSONStringValue.new('Jamie').to_s.should == '"Jamie"'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/negated_query_spec.rb

@@ -0,0 +1,39 @@
+require 'perpetuity/postgres/negated_query'
+
+module Perpetuity
+  class Postgres
+    describe NegatedQuery do
+      it 'negates equality' do
+        NegatedQuery.new { |o| o.name == 'foo' }.to_db.should == "NOT (name = 'foo')"
+      end
+
+      it 'negates regex matching' do
+        NegatedQuery.new { |o| o.name =~ /foo/ }.to_db.should == "NOT (name ~ 'foo')"
+      end
+
+      it 'negates case-insensitive regex matching' do
+        NegatedQuery.new { |o| o.name =~ /foo/i }.to_db.should == "NOT (name ~* 'foo')"
+      end
+
+      it 'negates inequality' do
+        NegatedQuery.new { |o| o.name != /foo/i }.to_db.should == "NOT (name != 'foo')"
+      end
+
+      it 'negates greater-than' do
+        NegatedQuery.new { |o| o.age > 1 }.to_db.should == "NOT (age > 1)"
+      end
+
+      it 'negates greater-than-or-equal' do
+        NegatedQuery.new { |o| o.age >= 1 }.to_db.should == "NOT (age >= 1)"
+      end
+
+      it 'negates less-than' do
+        NegatedQuery.new { |o| o.age < 1 }.to_db.should == "NOT (age < 1)"
+      end
+
+      it 'negates less-than-or-equal' do
+        NegatedQuery.new { |o| o.age <= 1 }.to_db.should == "NOT (age <= 1)"
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/null_value_spec.rb

@@ -0,0 +1,11 @@
+require 'perpetuity/postgres/null_value'
+
+module Perpetuity
+  class Postgres
+    describe NullValue do
+      it 'serializes into a Postgres NULL value' do
+        NullValue.new.to_s.should == 'NULL'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/numeric_value_spec.rb

@@ -0,0 +1,12 @@
+require 'perpetuity/postgres/numeric_value'
+
+module Perpetuity
+  class Postgres
+    describe NumericValue do
+      it 'serializes into a Postgres-compatible number value' do
+        NumericValue.new(1).to_s.should == '1'
+      end
+    end
+  end
+end
+

data/spec/perpetuity/postgres/query_attribute_spec.rb

@@ -0,0 +1,48 @@
+require 'perpetuity/postgres/query_attribute'
+
+module Perpetuity
+  class Postgres
+    describe QueryAttribute do
+      let(:attribute) { QueryAttribute.new :attribute_name }
+      subject { attribute }
+
+      its(:name) { should == :attribute_name }
+
+      it 'checks for equality' do
+        (attribute == 1).should be_a QueryExpression
+      end
+
+      it 'checks for less than' do
+        (attribute < 1).should be_a QueryExpression
+      end
+
+      it 'checks for <=' do
+        (attribute <= 1).should be_a QueryExpression
+      end
+
+      it 'checks for greater than' do
+        (attribute > 1).should be_a QueryExpression
+      end
+
+      it 'checks for >=' do
+        (attribute >= 1).should be_a QueryExpression
+      end
+
+      it 'checks for inequality' do
+        (attribute != 1).should be_a QueryExpression
+      end
+
+      it 'checks for regexp matches' do
+        (attribute =~ /value/).should be_a QueryExpression
+      end
+
+      it 'checks for inclusion' do
+        (attribute.in [1, 2, 3]).should be_a QueryExpression
+      end
+
+      it 'checks for nil' do
+        attribute.nil?.should be_a QueryExpression
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/query_expression_spec.rb

@@ -0,0 +1,110 @@
+require 'perpetuity/postgres/query_expression'
+
+module Perpetuity
+  class Postgres
+    describe QueryExpression do
+      let(:expression) { QueryExpression.new :attribute, :==, :value }
+      subject { expression }
+
+      describe 'translation to SQL expressions' do
+        it 'translates equality to symbol by comparing with a string' do
+          expression.to_db.should == "attribute = 'value'"
+        end
+
+        it 'translates equality to strings' do
+          expression.value = expression.value.to_s
+          expression.to_db.should == "attribute = 'value'"
+        end
+
+        it 'removes SQL injection from strings' do
+          expression.value = "' OR 1; --"
+          expression.to_db.should == "attribute = ''' OR 1; --'"
+        end
+
+        it 'translates equality to numbers' do
+          expression.value = 1
+          expression.to_db.should == 'attribute = 1'
+        end
+
+        it 'less-than expression' do
+          expression.comparator = :<
+          expression.to_db.should == "attribute < 'value'"
+        end
+
+        it 'less-than-or-equal-to expression' do
+          expression.comparator = :<=
+          expression.to_db.should == "attribute <= 'value'"
+        end
+
+        it 'greater-than expression' do
+          expression.comparator = :>
+          expression.to_db.should == "attribute > 'value'"
+        end
+
+        it 'greater-than-or-equal-to expression' do
+          expression.comparator = :>=
+          expression.to_db.should == "attribute >= 'value'"
+        end
+
+        it 'not-equal' do
+          expression.comparator = :!=
+          expression.to_db.should == "attribute != 'value'"
+        end
+
+        it 'checks for inclusion' do
+          expression.comparator = :in
+          expression.value = [1, 2, 3]
+          expression.to_db.should == "attribute IN (1,2,3)"
+        end
+
+        it 'checks for inclusion of strings' do
+          expression.comparator = :in
+          expression.value = ['abc', '123']
+          expression.to_db.should == "attribute IN ('abc','123')"
+        end
+
+        it 'checks for regexp matching' do
+          expression.comparator = :=~
+          expression.value = /value/
+          expression.to_db.should == "attribute ~ 'value'"
+
+          expression.value = /value/i
+          expression.to_db.should == "attribute ~* 'value'"
+        end
+
+        it 'checks for nil' do
+          expression.value = nil
+          expression.to_db.should == "attribute IS NULL"
+
+          expression.comparator = :!=
+          expression.to_db.should == "attribute IS NOT NULL"
+        end
+      end
+
+      describe 'unions' do
+        let(:lhs) { QueryExpression.new :first, :==, :one }
+        let(:rhs) { QueryExpression.new :second, :==, :two }
+
+        it 'converts | to an $or query' do
+          (lhs | rhs).to_db.should == "(first = 'one' OR second = 'two')"
+        end
+      end
+
+      describe 'intersections' do
+        let(:lhs) { QueryExpression.new :first, :==, :one }
+        let(:rhs) { QueryExpression.new :second, :==, :two }
+
+        it 'converts & to an $and query' do
+          (lhs & rhs).to_db.should == "(first = 'one' AND second = 'two')"
+        end
+      end
+
+      describe 'values' do
+        it 'compares against times' do
+          expression.value = Time.new(2013, 1, 2, 3, 4, 5.1234567, '-05:00')
+          expression.to_db.should == "attribute = '2013-01-02 03:04:05.123456-0500'::timestamptz"
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/query_intersection_spec.rb

@@ -0,0 +1,23 @@
+require 'perpetuity/postgres/query_intersection'
+
+module Perpetuity
+  class Postgres
+    describe QueryIntersection do
+      let(:lhs) { double('LHS', to_db: 'left = 1') }
+      let(:rhs) { double('RHS', to_db: 'right = 2') }
+      let(:intersection) { QueryIntersection.new(lhs, rhs) }
+
+      it 'converts to a SQL "AND" expression' do
+        intersection.to_db.should == '(left = 1 AND right = 2)'
+      end
+
+      it 'allows intersections to have other intersections' do
+        (intersection&intersection).to_db.should == '((left = 1 AND right = 2) AND (left = 1 AND right = 2))'
+      end
+
+      it 'allows intersections to have unions' do
+        (intersection|intersection).to_db.should == '((left = 1 AND right = 2) OR (left = 1 AND right = 2))'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/query_spec.rb

@@ -0,0 +1,23 @@
+require 'perpetuity/postgres/query'
+
+module Perpetuity
+  class Postgres
+    describe Query do
+      let(:query) { Query.new { |o| o.name == 'foo' } }
+
+      it 'generates an equality statement' do
+        query.to_db.should == "name = 'foo'"
+      end
+
+      it 'automatically converts to a string' do
+        q = ''
+        q << query
+        q.should == "name = 'foo'"
+      end
+
+      it 'returns TRUE with no block passed' do
+        Query.new.to_db.should == 'TRUE'
+      end
+    end
+  end
+end