perpetuity-postgres 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae601e3900e9e24c2bb98c63eb6d8817b6f06b1b
-  data.tar.gz: abf781e103cb6292df35a779388bf8a662ecbce5
+  metadata.gz: 45cd2bfa1345abc08e97eda5e929c3ef1c4b7c23
+  data.tar.gz: 2cab12a23a5f25a0f114b76494f283793f7213be
 SHA512:
-  metadata.gz: 8ff4c1bbd74e6baec79e9db3000644eecc08b5270ba5df5b822eec79792e35dedce562e00d7cdcc2e3f30ccd97e7c5e5745dec67dc95bb869ae500df2dfb5811
-  data.tar.gz: 429991a3ec80b543567a581e600aa30918fae13b7d7d75a3bc7ee3ebab2bef9ea64ea5d25a8f4db6c845b4bb4ec6bbc6649039f96fd8a3aa792f52e946d3f25c
+  metadata.gz: 79578054a8adc0164fd5e5197f6b52f0ed337c8af13b6910dfef79060dedea6c6e08f8310c9ad26b01fc70e756896996820ea695bf2ee9a70a1a16037fba2ba8
+  data.tar.gz: a0d72ba46bff515cc6d7c222fd68e63ea780aee5fcf2f534a4c9f8963f1afa54f15739c5335aa8e15591d43fe8f52e8a2e1d76d351c421e1e85ba119901b4c44

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+## Version 0.0.2
+
+- Make DB creation call out to remote DB to create it instead of calling on localhost.
+- Add index support
+- Only load UUID extension on UUID failure. This keeps the DB log from getting flooded every time the app connects to it.
+- Add support for any?/none? on query attributes for queries like `mapper.select { |user| user.friends.any? }`
+- Serialize nil values in JSONHash
+- Add support for in-place increment/decrement. This allows you to use a mapper's `#increment`/`#decrement` methods to modify the object without pulling it down from the DB first.
+- Keep first value when inserting multiple records. This fixes a bug where a `SerializedData` value (the data structure holding what's being inserted) would modify itself in place on `each` calls.
+- Cast numeric ids to numeric types on insertion. Previously, if you had an `Integer` id column, it was being returned as a string.
+- Don't allow double quotes in table names. Postgres doesn't allow it, so this catches it before we have to make the DB call.
+- Add support for more numeric types
+- Escape double quotes in JSON strings
+- Add table columns automatically if they don't exist. This way, you can simply add more attributes in your mapper and Perpetuity::Postgres will take care of it on its own.
+
+## Version 0.0.1
+
+- Initial release.
+- Most Perpetuity CRUD features enabled.

data/lib/perpetuity/postgres/connection.rb

@@ -19,12 +19,12 @@ module Perpetuity
 
       def connect
         @pg_connection = PG.connect(options)
-        use_uuid_extension
-
-        @pg_connection
       rescue PG::ConnectionBad => e
         tries ||= 0
-        conn = PG.connect
+        connect_options = options.dup
+        connect_options.delete :dbname
+
+        conn = PG.connect connect_options
         conn.exec "CREATE DATABASE #{db}"
         conn.close
 
@@ -41,6 +41,13 @@ module Perpetuity
 
       def execute sql
         pg_connection.exec sql
+      rescue PG::UndefinedFunction => e
+        if e.message =~ /uuid_generate/
+          use_uuid_extension
+          retry
+        else
+          raise
+        end
       end
 
       def tables
@@ -69,7 +76,7 @@ module Perpetuity
 
       private
       def use_uuid_extension
-        @pg_connection.exec 'CREATE EXTENSION "uuid-ossp"'
+        execute 'CREATE EXTENSION "uuid-ossp"'
       rescue PG::DuplicateObject
         # Ignore. It just means the extension's already been loaded.
       end

data/lib/perpetuity/postgres/index.rb

@@ -0,0 +1,67 @@
+require 'perpetuity/attribute'
+
+module Perpetuity
+  class Postgres
+    class Index
+      attr_reader :attributes, :name
+
+      def initialize options={}
+        @attributes = options.fetch(:attributes)
+        @name       = options.fetch(:name)
+        @unique     = options.fetch(:unique) { false }
+        @active     = options.fetch(:active) { false }
+      end
+
+      def self.from_sql sql_result
+        attributes = sql_result['attributes'].gsub(/[{}]/, '').split(',').map do |attr|
+          Attribute.new(attr)
+        end
+        unique = sql_result['unique'] == 't'
+        active = sql_result['active'] == 't'
+        new(name: sql_result['name'],
+            attributes: attributes,
+            unique: unique,
+            active: active)
+      end
+
+      def attribute
+        attributes.first
+      end
+
+      def attribute_names
+        attributes.map { |attr| attr.name.to_s }
+      end
+
+      def unique?
+        !!@unique
+      end
+
+      def active?
+        !!@active
+      end
+
+      def inactive?
+        !active?
+      end
+
+      def activate!
+        @active = true
+      end
+
+      def table
+        name.gsub("_#{attributes.map(&:to_s).join('_')}_idx", '')
+      end
+
+      def == other
+        other.is_a?(self.class) &&
+        attributes.map(&:to_s) == other.attributes.map(&:to_s) &&
+        name.to_s == other.name.to_s &&
+        unique? == other.unique?
+      end
+
+      def eql? other
+        self == other
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/index_collection.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+module Perpetuity
+  class Postgres
+    class IndexCollection
+      include Enumerable
+
+      attr_reader :table
+
+      def initialize table, *indexes
+        @table = table.to_s
+        @indexes = indexes.flatten.to_set
+      end
+
+      def << index
+        @indexes << index
+      end
+
+      def each
+        @indexes.each { |index| yield index }
+      end
+
+      def reject! &block
+        @indexes.reject!(&block)
+      end
+
+      def to_a
+        @indexes.to_a
+      end
+
+      def to_ary
+        to_a
+      end
+
+      def - other
+        difference = self.class.new(table)
+        each do |index|
+          unless other.include? index
+            difference << index
+          end
+        end
+
+        difference
+      end
+
+      def == other
+        table == other.table &&
+        count == other.count &&
+        (self - other).empty?
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/json_hash.rb

@@ -36,6 +36,8 @@ module Perpetuity
             JSONStringValue.new(value.to_s)
           elsif [true, false].include? value
             value.to_s
+          elsif value.nil?
+            'null'
           else
             value
           end

data/lib/perpetuity/postgres/json_string_value.rb

@@ -2,7 +2,7 @@ module Perpetuity
   class Postgres
     class JSONStringValue
       def initialize value
-        @value = value
+        @value = value.to_s.gsub('"') { '\\"' }
       end
 
       def to_s

data/lib/perpetuity/postgres/query_attribute.rb

@@ -1,4 +1,5 @@
 require 'perpetuity/postgres/query_expression'
+require 'perpetuity/postgres/sql_function'
 
 module Perpetuity
   class Postgres
@@ -25,6 +26,18 @@ METHOD
         QueryExpression.new self, :==, nil
       end
 
+      def count
+        SQLFunction.new('json_array_length', self)
+      end
+
+      def any?
+        QueryExpression.new count, :>, 0
+      end
+
+      def none?
+        QueryExpression.new count, :==, 0
+      end
+
       def to_s
         name.to_s
       end

data/lib/perpetuity/postgres/serialized_data.rb

@@ -27,7 +27,7 @@ module Perpetuity
       end
 
       def + other
-        combined = dup
+        combined = self.class.new(column_names.dup, *(values.dup))
         combined.values << other.values
 
         combined

data/lib/perpetuity/postgres/serializer.rb

@@ -59,7 +59,7 @@ module Perpetuity
             value = unserialize_foreign_object value
           end
           if attribute
-            if attribute.type == Integer
+            if [Fixnum, Bignum, Integer].include? attribute.type
               value = value.to_i
             elsif attribute.type == Time
               value = TimestampValue.from_sql(value).to_time

data/lib/perpetuity/postgres/sql_function.rb

@@ -0,0 +1,15 @@
+module Perpetuity
+  class Postgres
+    class SQLFunction
+      attr_reader :name, :args
+      def initialize name, *args
+        @name = name
+        @args = args
+      end
+
+      def to_s
+        "#{name}(#{args.join(',')})"
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/table/attribute.rb

@@ -22,8 +22,12 @@ module Perpetuity
             else
               'TEXT'
             end
-          elsif type == Integer
-            'INTEGER'
+          elsif type == Integer or type == Fixnum
+            'BIGINT'
+          elsif type == Bignum or type == BigDecimal
+            'NUMERIC'
+          elsif type == Float
+            'FLOAT'
           elsif type == UUID
             'UUID'
           elsif type == Time

data/lib/perpetuity/postgres/table_name.rb

@@ -1,8 +1,10 @@
 module Perpetuity
   class Postgres
+    InvalidTableName = Class.new(StandardError)
     class TableName
       def initialize name
         @name = name.to_s
+        raise InvalidTableName, "PostgreSQL table name cannot contain double quotes" if @name.include? '"'
       end
 
       def to_s

data/lib/perpetuity/postgres/version.rb

@@ -1,5 +1,5 @@
 module Perpetuity
   class Postgres
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/perpetuity/postgres.rb

@@ -8,6 +8,8 @@ require 'perpetuity/postgres/table'
 require 'perpetuity/postgres/table/attribute'
 require 'perpetuity/postgres/sql_select'
 require 'perpetuity/postgres/sql_update'
+require 'perpetuity/postgres/index_collection'
+require 'perpetuity/postgres/index'
 
 module Perpetuity
   class Postgres
@@ -38,7 +40,7 @@ module Perpetuity
       sql = "INSERT INTO #{table} #{data} RETURNING id"
 
       results = connection.execute(sql).to_a
-      ids = results.map { |result| result['id'] }
+      ids = results.map { |result| cast_id(result['id'], attributes[:id]) }
 
       ids
     rescue PG::UndefinedTable => e # Table doesn't exist, so we create it.
@@ -47,6 +49,25 @@ module Perpetuity
       create_table_with_attributes klass, attributes
       retry unless retries > 1
       raise e
+    rescue PG::UndefinedColumn => e
+      retries ||= 0
+      retries += 1
+      error ||= nil
+
+      if retries > 1 && e.message == error
+        # We've retried more than once and we're getting the same error
+        raise
+      end
+
+      error = e.message
+      if error =~ /column "(.+)" of relation "(.+)" does not exist/
+        column_name = $1
+        table_name = $2
+        add_column table_name, column_name, attributes
+        retry
+      end
+
+      raise
     end
 
     def delete id, klass
@@ -109,12 +130,64 @@ module Perpetuity
       connection.execute(sql).to_a
     end
 
+    def index klass, attributes, options={}
+      name = "#{klass}_#{Array(attributes).map(&:name).join('_')}_idx"
+      index = Index.new(name: name,
+                        attributes: Array(attributes),
+                        unique: !!options[:unique],
+                        active: false)
+      indexes(klass) << index
+      index
+    end
+
+    def indexes klass
+      @indexes ||= {}
+      @indexes[klass] ||= IndexCollection.new(klass)
+    end
+
+    def activate_index! index
+      sql = "CREATE "
+      sql << "UNIQUE " if index.unique?
+      sql << "INDEX ON #{TableName.new(index.table)} (#{index.attribute_names.join(',')})"
+      connection.execute(sql)
+      index.activate!
+    rescue PG::UndefinedTable => e
+      create_table_with_attributes index.table, index.attributes
+      retry
+    end
+
+    def active_indexes table
+      sql = <<-SQL
+      SELECT pg_class.relname AS name,
+             ARRAY(
+               SELECT pg_get_indexdef(pg_index.indexrelid, k + 1, true)
+               FROM generate_subscripts(pg_index.indkey, 1) AS k
+               ORDER BY k
+             ) AS attributes,
+             pg_index.indisunique AS unique,
+             pg_index.indisready AS active
+      FROM pg_class
+      INNER JOIN pg_index ON pg_class.oid = pg_index.indexrelid
+      WHERE pg_class.relname ~ '^#{table}.*idx$'
+      SQL
+
+      indexes = connection.execute(sql).map do |index|
+        Index.from_sql(index)
+      end
+      IndexCollection.new(table, indexes)
+    end
+
+    def remove_index index
+      sql = %Q{DROP INDEX IF EXISTS #{TableName.new(index.name)}}
+      connection.execute(sql)
+    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]
+          direction = direction.to_s[/(asc|desc)/i]
           options[:order] = { options[:order] => direction }
         end
       end
@@ -132,6 +205,7 @@ module Perpetuity
     def drop_table name
       connection.execute "DROP TABLE IF EXISTS #{table_name(name)}"
     end
+    alias :drop_collection :drop_table
 
     def create_table name, attributes
       connection.execute Table.new(name, attributes).create_table_sql
@@ -153,10 +227,26 @@ module Perpetuity
       Serializer.new(mapper).serialize_changes object, original
     end
 
+    def cast_id id, id_attribute
+      return id if id_attribute.nil?
+
+      if [Bignum, Fixnum, Integer].include? id_attribute.type
+        id.to_i
+      else
+        id
+      end
+    end
+
     def unserialize data, mapper
       Serializer.new(mapper).unserialize data
     end
 
+    def increment klass, id, attribute, count=1
+      table = TableName.new(klass)
+      sql = %Q{UPDATE #{table} SET #{attribute} = #{attribute} + #{count} WHERE id = #{SQLValue.new(id)} RETURNING #{attribute}}
+      connection.execute(sql).to_a
+    end
+
     def create_table_with_attributes klass, attributes
       table_attributes = attributes.map do |attr|
         name = attr.name
@@ -166,5 +256,13 @@ module Perpetuity
       end
       create_table klass.to_s, table_attributes
     end
+
+    def add_column table_name, column_name, attributes
+      attr = attributes.detect { |a| a.name.to_s == column_name.to_s }
+      column = Table::Attribute.new(attr.name, attr.type, attr.options)
+
+      sql = %Q(ALTER TABLE "#{table_name}" ADD #{column.sql_declaration})
+      connection.execute sql
+    end
   end
 end

data/perpetuity-postgres.gemspec

@@ -21,6 +21,6 @@ Gem::Specification.new do |spec|
   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 "perpetuity", "~> 1.0.0.beta2"
   spec.add_runtime_dependency "pg"
 end

data/spec/perpetuity/postgres/connection_spec.rb

@@ -15,6 +15,7 @@ module Perpetuity
 
       it 'is only activated when it is used' do
         connection.should_not be_active
+        PG.stub(connect: true)
         connection.connect
         connection.should be_active
       end

data/spec/perpetuity/postgres/index_collection_spec.rb

@@ -0,0 +1,29 @@
+require 'perpetuity/postgres/index_collection'
+require 'perpetuity/attribute'
+
+module Perpetuity
+  class Postgres
+    describe IndexCollection do
+      let(:indexes) { IndexCollection.new(Object) }
+
+      it 'knows which table it is indexing' do
+        indexes.table.should == 'Object'
+      end
+
+      it 'iterates over its indexes' do
+        indexes << 1
+        indexes.map { |index| index.to_s }.should include '1'
+      end
+
+      it 'converts to an array' do
+        indexes.to_ary.should == []
+      end
+
+      it 'removes indexes based on a block' do
+        indexes << double('Index', name: 'lol')
+        indexes.reject! { |index| index.name == 'lol' }
+        indexes.map(&:name).should_not include 'lol'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/index_spec.rb

@@ -0,0 +1,83 @@
+require 'perpetuity/postgres/index'
+
+module Perpetuity
+  class Postgres
+    describe Index do
+      it 'can be generated from SQL results' do
+        index_hash = {
+          "name"=>"Object_id_name_idx",
+          "attributes"=>"{id,name}",
+          "unique"=>"t",
+          "active"=>"t"
+        }
+
+        index = Index.from_sql(index_hash)
+        index.attribute_names.should == ['id', 'name']
+        index.name.should == 'Object_id_name_idx'
+        index.table.should == 'Object'
+        index.should be_unique
+        index.should be_active
+      end
+
+      it 'sets itself as active' do
+        index = Index.new(attributes: double('Attributes'),
+                          name: 'Table',
+                          unique: false)
+
+        index.should_not be_active
+        index.activate!
+        index.should be_active
+      end
+
+      describe 'equality' do
+        let(:attributes) { [:id, :name] }
+        let(:name) { 'Object' }
+        let(:unique) { true }
+        let(:index) do
+          Index.new(attributes: [:id, :name],
+                    name: name,
+                    unique: true)
+        end
+
+        it 'is equal to an index with identical state' do
+          new_index = index.dup
+          new_index.should == index
+        end
+
+        it 'is not equal to an index with different attributes' do
+          new_index = Index.new(attributes: [:lol],
+                                name: name,
+                                unique: false)
+
+          new_index.should_not == index
+        end
+
+        it 'is equal to an index with stringified attributes' do
+          new_index = Index.new(attributes: attributes.map(&:to_s),
+                                name: name,
+                                unique: unique)
+          new_index.should == index
+        end
+
+        it 'is not equal to an index with another name' do
+          new_index = Index.new(attributes: attributes,
+                                name: 'NotObject',
+                                unique: unique)
+
+          new_index.should_not == index
+        end
+
+        it 'is not equal to an index with opposite uniqueness' do
+          new_index = Index.new(attributes: attributes,
+                                name: name,
+                                unique: !unique)
+          new_index.should_not == index
+        end
+
+        it 'is not equal to things that are not indexes' do
+          index.should_not == 'lol'
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/json_hash_spec.rb

@@ -19,6 +19,10 @@ module Perpetuity
         JSONHash.new({a: true, b: false}).to_s.should == %q('{"a":true,"b":false}')
       end
 
+      it 'serializes nil values' do
+        JSONHash.new({a: nil}).to_s.should == %q('{"a":null}')
+      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

data/spec/perpetuity/postgres/json_string_value_spec.rb

@@ -6,6 +6,15 @@ module Perpetuity
       it 'serializes into a JSON string value' do
         JSONStringValue.new('Jamie').to_s.should == '"Jamie"'
       end
+
+      it 'converts symbols into strings' do
+        JSONStringValue.new(:foo).to_s.should == '"foo"'
+      end
+
+      it 'escapes quotes' do
+        JSONStringValue.new('Anakin "Darth Vader" Skywalker').to_s.should ==
+          '"Anakin \\"Darth Vader\\" Skywalker"'
+      end
     end
   end
 end

data/spec/perpetuity/postgres/query_attribute_spec.rb

@@ -40,6 +40,14 @@ module Perpetuity
         (attribute.in [1, 2, 3]).should be_a QueryExpression
       end
 
+      it 'checks for existence' do
+        (attribute.any?).to_db.should == 'json_array_length(attribute_name) > 0'
+      end
+
+      it 'checks for no existence' do
+        (attribute.none?).to_db.should == 'json_array_length(attribute_name) = 0'
+      end
+
       it 'checks for nil' do
         attribute.nil?.should be_a QueryExpression
       end

data/spec/perpetuity/postgres/serialized_data_spec.rb

@@ -29,13 +29,18 @@ module Perpetuity
           [ SerializedData.new(columns, ["'Jamie'", 31]),
             SerializedData.new(columns, ["'Jessica'", 23]),
             SerializedData.new(columns, ["'Kevin'", 22]),
-          ].reduce(:+)
+          ]
         end
-        let(:serialized_multiple) { serialized + SerializedData.new(columns, ["'Jessica'", 23]) +
-                                                 SerializedData.new(columns, ["'Kevin'",22])}
 
         it 'matches a SQL string' do
-          serialized_multiple.to_s.should == "(name,age) VALUES ('Jamie',31),('Jessica',23),('Kevin',22)"
+          serialized_multiple.reduce(:+).to_s.should ==
+            "(name,age) VALUES ('Jamie',31),('Jessica',23),('Kevin',22)"
+        end
+
+        it 'does not modify the first value' do
+          jamie_values = serialized_multiple.first.values.dup
+          serialized_multiple.reduce(:+)
+          serialized_multiple.first.values.should == jamie_values
         end
       end
 

data/spec/perpetuity/postgres/sql_function_spec.rb

@@ -0,0 +1,17 @@
+require 'perpetuity/postgres/sql_function'
+
+module Perpetuity
+  class Postgres
+    describe SQLFunction do
+      it 'converts to a SQL function call' do
+        function = SQLFunction.new('json_array_length', :comments)
+        function.to_s.should == 'json_array_length(comments)'
+      end
+
+      it 'takes multiple arguments' do
+        function = SQLFunction.new('compare', :a, :b)
+        function.to_s.should == 'compare(a,b)'
+      end
+    end
+  end
+end

data/spec/perpetuity/postgres/table/attribute_spec.rb

@@ -55,9 +55,21 @@ module Perpetuity
 
         describe 'integers' do
           let(:page_views) { Attribute.new('page_views', Integer, default: 0) }
+          let(:public_key) { Attribute.new('public_key', Bignum) }
 
           it 'generates the proper SQL' do
-            page_views.sql_declaration.should == 'page_views INTEGER DEFAULT 0'
+            page_views.sql_declaration.should == 'page_views BIGINT DEFAULT 0'
+            public_key.sql_declaration.should == 'public_key NUMERIC'
+          end
+        end
+
+        describe 'floating-point numbers' do
+          let(:pi) { Attribute.new('pi', Float) }
+          let(:precise_pi) { Attribute.new('precise_pi', BigDecimal) }
+
+          it 'generates the proper SQL' do
+            pi.sql_declaration.should == 'pi FLOAT'
+            precise_pi.sql_declaration.should == 'precise_pi NUMERIC'
           end
         end
 

data/spec/perpetuity/postgres/table_name_spec.rb

@@ -7,6 +7,10 @@ module Perpetuity
         TableName.new('Person').to_s.should == '"Person"'
       end
 
+      it 'cannot contain double quotes' do
+        expect { TableName.new('Foo "Bar"') }.to raise_error InvalidTableName
+      end
+
       it 'compares equally to its string representation' do
         TableName.new('Person').should == 'Person'
       end

data/spec/perpetuity/postgres/table_spec.rb

@@ -26,7 +26,7 @@ module Perpetuity
 
       it 'generates proper SQL to create itself' do
         table.create_table_sql.should ==
-          'CREATE TABLE IF NOT EXISTS "Article" (id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), title VARCHAR(40), body TEXT, author JSON, published_at TIMESTAMPTZ, views INTEGER)'
+          'CREATE TABLE IF NOT EXISTS "Article" (id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), title VARCHAR(40), body TEXT, author JSON, published_at TIMESTAMPTZ, views BIGINT)'
       end
 
       describe 'id column' do

data/spec/perpetuity/postgres_spec.rb

@@ -59,6 +59,27 @@ module Perpetuity
       postgres.should_not have_table 'Article'
     end
 
+    it 'adds columns automatically if they are not there' do
+      attributes = AttributeSet.new
+      attributes << Attribute.new('title', String, max_length: 40)
+      attributes << Attribute.new('body', String)
+      attributes << Attribute.new('author', Object)
+
+      postgres.drop_table 'Article'
+      postgres.create_table 'Article', attributes.map { |attr|
+        Postgres::Table::Attribute.new(attr.name, attr.type, attr.options)
+      }
+
+      attributes << Attribute.new('timestamp', Time)
+      data = [Postgres::SerializedData.new([:title, :timestamp],
+                                           ["'Jamie'", "'2013-1-1'"])]
+      id = postgres.insert('Article', data, attributes).first
+
+      postgres.find('Article', id)['timestamp'].should =~ /2013/
+
+      postgres.drop_table 'Article' # Cleanup
+    end
+
     it 'converts values into something that works with the DB' do
       postgres.postgresify("string").should == "'string'"
       postgres.postgresify(1).should == '1'
@@ -66,9 +87,13 @@ module Perpetuity
     end
 
     describe 'working with data' do
-      let(:attributes) { [Attribute.new(:name, String)] }
+      let(:attributes) { AttributeSet.new }
       let(:data) { [Postgres::SerializedData.new([:name], ["'Jamie'"])] }
 
+      before do
+        attributes << Attribute.new(:name, String)
+      end
+
       it 'inserts data and finds by id' do
         id = postgres.insert('User', data, attributes).first
         result = postgres.find('User', id)
@@ -77,12 +102,23 @@ module Perpetuity
         result['name'].should == 'Jamie'
       end
 
-      it 'returns the ids of all items saved' do
-        self.data << Postgres::SerializedData.new([:name], ["'Jessica'"]) <<
-                     Postgres::SerializedData.new([:name], ["'Kevin'"])
-        ids = postgres.insert('User', data, attributes)
-        ids.should be_a Array
-        ids.should have(3).items
+      describe 'returning ids' do
+        it 'returns the ids of all items saved' do
+          data << Postgres::SerializedData.new([:name], ["'Jessica'"]) <<
+          Postgres::SerializedData.new([:name], ["'Kevin'"])
+          ids = postgres.insert('User', data, attributes)
+          ids.should be_a Array
+          ids.should have(3).items
+        end
+
+        it 'returns numeric ids when numeric ids are specified' do
+          postgres.drop_table 'User'
+          attributes << Attribute.new(:id, Integer)
+          data.first[:id] = 1234
+          ids = postgres.insert 'User', data, attributes
+          ids.first.should == 1234
+          postgres.drop_table 'User'
+        end
       end
 
       it 'counts objects' do
@@ -123,6 +159,21 @@ module Perpetuity
         id = postgres.insert('User', data, attributes).first
         expect { postgres.delete id, 'User' }.to change { postgres.count 'User' }.by -1
       end
+
+      describe 'incrementing/decrementing' do
+        let(:attributes) { AttributeSet.new }
+        let(:data) { [Postgres::SerializedData.new([:n], [1])] }
+
+        before do
+          attributes << Attribute.new(:n, Fixnum)
+        end
+
+        it 'increments a value for a record' do
+          id = postgres.insert('Increment', data, attributes).first
+          postgres.increment 'Increment', id, :n, 10
+          postgres.find('Increment', id)['n'].should == '11'
+        end
+      end
     end
 
     describe 'query generation' do
@@ -159,5 +210,58 @@ module Perpetuity
         end
       end
     end
+
+    describe 'indexes' do
+      let(:title) { Postgres::Table::Attribute.new('title', String) }
+
+      before do
+        postgres.drop_table Object
+        postgres.create_table Object, [title]
+      end
+
+      after do
+        postgres.drop_table Object
+      end
+
+      it 'retrieves the active indexes from the database' do
+        index = postgres.index(Object, Attribute.new(:title, String), unique: true)
+        postgres.activate_index! index
+
+        active_indexes = postgres.active_indexes(Object)
+        index = active_indexes.find { |i| i.attribute_names == ['title'] }
+        index.attribute_names.should == ['title']
+        index.table.should == 'Object'
+        index.should be_unique
+        index.should be_active
+      end
+
+      describe 'adding indexes to the database' do
+        it 'adds an inactive index to the database' do
+          title_attribute = Attribute.new(:title, String)
+          postgres.index Object, title_attribute
+          index = postgres.indexes(Object).find { |i| i.attributes.map(&:name) == [:title] }
+          index.attribute_names.should == ['title']
+          index.table.should == 'Object'
+          index.should_not be_unique
+          index.should_not be_active
+        end
+
+        it 'activates the specified index' do
+          title_attribute = Attribute.new(:title, String)
+          index = postgres.index Object, title_attribute
+          postgres.activate_index! index
+          postgres.active_indexes(Object).map(&:attribute_names).should include ['title']
+        end
+      end
+
+      describe 'removing indexes' do
+        it 'removes the specified index' do
+          index = postgres.index(Object, Attribute.new(:title, String))
+          postgres.activate_index! index
+          postgres.remove_index index
+          postgres.active_indexes(Object).map(&:attribute_names).should_not include ['title']
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perpetuity-postgres
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jamie Gaskins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-15 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta
+        version: 1.0.0.beta2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta
+        version: 1.0.0.beta2
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -97,6 +98,8 @@ files:
 - lib/perpetuity/postgres/connection.rb
 - lib/perpetuity/postgres/connection_pool.rb
 - lib/perpetuity/postgres/expression.rb
+- lib/perpetuity/postgres/index.rb
+- lib/perpetuity/postgres/index_collection.rb
 - lib/perpetuity/postgres/json_array.rb
 - lib/perpetuity/postgres/json_hash.rb
 - lib/perpetuity/postgres/json_string_value.rb
@@ -111,6 +114,7 @@ files:
 - lib/perpetuity/postgres/query_union.rb
 - lib/perpetuity/postgres/serialized_data.rb
 - lib/perpetuity/postgres/serializer.rb
+- lib/perpetuity/postgres/sql_function.rb
 - lib/perpetuity/postgres/sql_select.rb
 - lib/perpetuity/postgres/sql_update.rb
 - lib/perpetuity/postgres/sql_value.rb
@@ -126,6 +130,8 @@ files:
 - spec/perpetuity/postgres/connection_pool_spec.rb
 - spec/perpetuity/postgres/connection_spec.rb
 - spec/perpetuity/postgres/expression_spec.rb
+- spec/perpetuity/postgres/index_collection_spec.rb
+- spec/perpetuity/postgres/index_spec.rb
 - spec/perpetuity/postgres/json_array_spec.rb
 - spec/perpetuity/postgres/json_hash_spec.rb
 - spec/perpetuity/postgres/json_string_value_spec.rb
@@ -139,6 +145,7 @@ files:
 - spec/perpetuity/postgres/query_union_spec.rb
 - spec/perpetuity/postgres/serialized_data_spec.rb
 - spec/perpetuity/postgres/serializer_spec.rb
+- spec/perpetuity/postgres/sql_function_spec.rb
 - spec/perpetuity/postgres/sql_select_spec.rb
 - spec/perpetuity/postgres/sql_update_spec.rb
 - spec/perpetuity/postgres/sql_value_spec.rb
@@ -171,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: PostgreSQL adapter for Perpetuity
@@ -180,6 +187,8 @@ test_files:
 - spec/perpetuity/postgres/connection_pool_spec.rb
 - spec/perpetuity/postgres/connection_spec.rb
 - spec/perpetuity/postgres/expression_spec.rb
+- spec/perpetuity/postgres/index_collection_spec.rb
+- spec/perpetuity/postgres/index_spec.rb
 - spec/perpetuity/postgres/json_array_spec.rb
 - spec/perpetuity/postgres/json_hash_spec.rb
 - spec/perpetuity/postgres/json_string_value_spec.rb
@@ -193,6 +202,7 @@ test_files:
 - spec/perpetuity/postgres/query_union_spec.rb
 - spec/perpetuity/postgres/serialized_data_spec.rb
 - spec/perpetuity/postgres/serializer_spec.rb
+- spec/perpetuity/postgres/sql_function_spec.rb
 - spec/perpetuity/postgres/sql_select_spec.rb
 - spec/perpetuity/postgres/sql_update_spec.rb
 - spec/perpetuity/postgres/sql_value_spec.rb