hgimenez-peegee 0.1.0

data/README.textile

@@ -0,0 +1,54 @@
+h1. What?
+
+Peegee (pronounced "Pee - Gee", as in the letters PG, for Postgres) is a utility that provides an abstraction for performing PostgreSQL related tasks from Ruby, or your Rails application.
+
+h1. Why?
+
+This project started with the need to improve the performance of PostgreSQL's CLUSTER command. While clustering your database tables improves query performance significantly, the actual process of clustering takes unacceptable amounts of time. For instance, it may take roughly 20 hours on a moderately big set of tables (around 60GB). Your milage may vary, of course.
+Refactoring the clustering functionality surfaced a clean set of utilities that resulted in the creation of this gem. Some are useful, and some are just pointless.
+
+The initial code for this gem was created during the Boston.rb hackfest at Thoughtbot, on April 7th, 2009.
+
+h1. Example usage
+
+Assuming we're in a Rails app, you can simply do:
+
+<pre><code>people_table = Peegee::Table.new(:table_name => 'people')
+people_table.ddl # a string containing this table's DDL
+people_table.indexes
+people_table.foreign_keys
+people_table.dependent_foreign_keys</code></pre>
+The three commands above return arrays of Peegee::Index and Peegee::ForeignKey objects, which all respond to drop and create.
+For example, you could drop and recreate the first dependent foreign key (some other table referencing people) with:
+<pre><code>people_table.dependent_foreign_keys.first.drop
+people_table.dependent_foreign_keys.first.create</code></pre>
+After the call to drop, the @dependent_foreign_keys instance variable on the people_table object remains cached, and calling create will simply execute the cached SQL required to recreate the database object.
+
+The strategy used for clustering a table is to store all dependencies in order to restore them later (as viewed above), and move all of the table's data on the order given by a certain index. This is all executed in a database transaction in case it blows up. The result should be just like the pgsql native CLUSTER command:
+<pre><code>people_table.cluster('people_pk') #must specify an index by which to cluster</code></pre>
+
+h2. Todo
+
+The first order of business will be to create specs where applicable.
+
+Then, the idea is to keep adding functionality that may be useful for DBAs or application developers and other PostgreSQL users. Some that come to mind are:
+
+* Ability to clean out all of table's index and foreign key names, following a given pattern. On occasions, table names are altered leaving behind pesky legacy names for related objects.
+* Ability to identify database stinks. For instance: 
+** tables without primary keys, or indexes (which are not pure join tables)
+** foreign keys without indexes (useful for manually identifying and fixing if applicable), 
+** report on columns that look like foreign keys, but aren't (based on rails conventions).
+** columns that are nullable, and are flagged as unique
+** tables with incrementing columns names, indiciating a possible denormalization
+** columns with a default value of 'NULL' (the varchar), where NULL may have been intended.
+(much of these are stolen from the excellent "SchemaSpy":http://schemaspy.sourceforge.net/)
+
+There's also a bunch of #TODO tags in the code, where there's clearly room for improvement.
+
+I would also like to make this code ORM agnostic. Right now, it depends on ActiveRecord to retrieve a connection and execute commands.
+
+Please fork away and help improve it.
+
+h1. License
+
+Copyright (c) 2009 Harold A. Gimenez, released under the MIT license.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "peegee"
+    gem.summary = %Q{A set of utilities for doing PostgreSQL database related stuffs from ruby.}
+    gem.email = "harold.gimenez@gmail.com"
+    gem.homepage = "http://github.com/hgimenez/peegee"
+    gem.authors = ["Harold A. Gimenez"]
+    gem.add_dependency 'activerecord'
+    gem.requirements << 'A functioning PostgreSQL database, configured via ActiveRecord (for example, database.yml on a Rails project, or inline within your scripts).'
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "peegee #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/peegee/clustering.rb

@@ -0,0 +1,118 @@
+module Peegee
+  module Clustering
+
+    # Clusters this table. See http://www.postgresql.org/docs/8.3/interactive/sql-cluster.html
+    # Optionally specify the index to cluster by (by name or Peegee::Index object).
+    # If the index is not specify, it will try to induce which index to 
+    # use by looking at postgresql's internals. If it can't find out,
+    # an exception will be raised.
+    def cluster(cluster_index = nil)
+      cluster_index = find_cluster_index(cluster_index)
+      puts "Cluster index is: #{cluster_index.inspect}"
+      puts "Cluster index type is: #{cluster_index.class.name}"
+      dependencies = remember_dependencies
+      ActiveRecord::Base.transaction do
+        puts "Clustering #{@table_name} by #{cluster_index.index_name} (with order => #{cluster_index.order})"
+        dependencies.map { |dep| dep.drop }
+        create_tmp_table
+        move_data(cluster_index)
+        drop_original_and_rename_tmp_table
+        dependencies.reverse.map { |dep| dep.create }
+      end
+    end
+
+    private
+
+      # Retrieves the Peegee::Index object that will be used
+      # for clustering this table. The cluster_index parameter can
+      # be either a string representing the index name, or a Peegee::Index object.
+      # Raises an exception if either a proper index was not found
+      # or more than one index was found given a cluster_index name.
+      def find_cluster_index(cluster_index)
+        return cluster_index if cluster_index.kind_of?(Peegee::Index)
+        the_index = nil
+        if cluster_index #cluster_index is specified
+          the_index = indexes.select { |i| i.index_name == cluster_index}
+        else #find cluster index from postgresql's information schema
+          the_index = indexes.select { |i| i.is_clustered? }
+        end
+        raise "Ambiguous cluster_index definition. #{the_index.inspect}" if the_index.size != 1
+        the_index[0] #this is surely an array of size one.
+      end
+
+      # Creates the tmp table to be used to temporarily hold
+      # the data of the table being clustered. Additionally,
+      # it assigns the sequence of the table to the tmp table.
+      def create_tmp_table
+        ActiveRecord::Base.connection.execute(tmp_ddl)
+        reasign_sequence_to_tmp_table
+      end
+
+      # Moves the data contained in this table
+      # to a tmp table in the order specified by
+      # its cluster_index.
+      def move_data(cluster_index)
+        ActiveRecord::Base.connection.execute("insert into #{@table_name}_tmp select * from #{@table_name} order by #{cluster_index.order}")
+      end
+
+
+      # Returns the DDL for the tmp table where data is moved
+      # to temporarily during clustering.
+      def tmp_ddl
+        ddl.gsub(/\b#{@table_name}\b/, "#{@table_name}_tmp")
+      end
+
+      # Alters the sequence of the table being clustered,
+      # by assigning it to its temp table. This is necessary in order to
+      # drop the table being clustered (to clean out the dependency on
+      # the sequence).
+      # This method is called after having created the tmp table, otherwise it will fail.
+      #
+      # The method for finding a table's sequence is hackish. 
+      # TODO: Find a better method for finding a table's sequence.
+      def reasign_sequence_to_tmp_table
+        sql = 'SELECT a.attname, ' +
+            'pg_catalog.format_type(a.atttypid, a.atttypmod), ' +
+            '(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128) ' +
+            ' FROM pg_catalog.pg_attrdef d ' +
+            ' WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef), ' +
+            'a.attnotnull, a.attnum ' +
+          'FROM pg_catalog.pg_attribute a ' +
+          "WHERE a.attrelid = '#{oid}' AND a.attnum > 0 AND NOT a.attisdropped " +
+          " and " +
+            '(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128) ' +
+            ' FROM pg_catalog.pg_attrdef d ' +
+            " WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef) like '%nextval%' " +
+          'ORDER BY a.attnum ' 
+        seq = ActiveRecord::Base.connection.execute(sql).entries.flatten
+        if !seq[0].nil? and !seq[2].empty?
+          seq[2].match /nextval\('[\"']{0,2}(\w*)[\"']{0,2}.*'::regclass\)/
+          sequence_name = $1 #the match above...
+          ActiveRecord::Base.connection.execute("ALTER SEQUENCE \"#{sequence_name}\" OWNED BY #{@table_name}_tmp.#{seq[0]}")
+        else
+          puts "\n\n\t*****#{@table_name} apparently doesn't have a sequence"
+        end
+      end
+
+
+      # Drops the table being clustered,
+      # and renames the tmp table to its original name.
+      def drop_original_and_rename_tmp_table
+        sql = []
+        sql << "drop table #{@table_name};"
+        sql << "alter table #{@table_name}_tmp rename to #{@table_name};"
+        sql.each do |s|
+          ActiveRecord::Base.connection.execute(s + ';')
+        end
+      end
+
+      # Retreives an array of this table's foreign keys,
+      # dependent foreign keys, and indexes. 
+      def remember_dependencies
+        dependencies = []
+        dependencies << foreign_keys << dependent_foreign_keys << indexes
+        dependencies.flatten
+      end
+
+  end
+end

data/lib/peegee/constraint.rb

@@ -0,0 +1,28 @@
+module Peegee
+  class Constraint
+
+    def initialize(opts = {})
+      @table_name = opts[:table_name]
+      @constraint_name = opts[:constraint_name]
+      @constraint_def = opts[:constraint_def]
+    end
+
+    # Returns human readable constraint.
+    def to_s
+      "Constraint: #{@constraint_name} on #{table_name}"
+    end
+
+    # Creates this constraint definition.
+    def create
+      sql = "alter table #{@table_name} add constraint #{@constraint_name} #{@constraint_def}"
+      ActiveRecord::Base.connection.execute(sql)
+    end
+
+    # Drops this constraint.
+    def drop
+      sql = "alter table #{@table_name} drop constraint #{@constraint_name}"
+      ActiveRecord::Base.connection.execute(sql)
+    end
+
+  end
+end

data/lib/peegee/foreign_key.rb

@@ -0,0 +1,19 @@
+module Peegee
+  class ForeignKey < Peegee::Constraint
+
+    def initialize(opts)
+      super(opts)
+    end
+
+    # Returns the name of this foreign key.
+    def foreign_key_name
+      @constraint_name
+    end
+
+    # Returns human readable foreign key definition
+    def to_s
+      "Foreign Key: #{foreign_key_name} on #{table_name}"
+    end
+
+  end
+end

data/lib/peegee/index.rb

@@ -0,0 +1,72 @@
+module Peegee
+  class Index
+
+    attr_accessor :index_name
+
+    def initialize(opts = {})
+      @table_name = opts[:table_name]
+      @index_name = opts[:index_name]
+      @clustered = opts[:clustered]
+      @def = opts[:def]
+    end
+
+    # prints human readable index definition
+    def to_s
+      "Index: #{@index_name} on #{@table_name} => (#{columns})"
+    end
+
+    # Returns the columns affected by this index
+    # TODO: Find out if there's a better way to 
+    # retreive the column list, via postgres internals.
+    #
+    # TODO: Find out if this is the cleanest way to get 
+    # the match of the regex
+    def columns
+      raise "Can't find index order for #{@index_name}" unless @def.match /\((.*)\)/
+      $1 #return the regex match (column list)
+    end
+
+    alias_method :order, :columns
+
+    # Drops this index
+    def drop
+      ActiveRecord::Base.connection.execute(drop_statement)
+    end
+
+    # Constructs the SQL statement to drop this index
+    # Optionally, pass in the boolean cascade value to
+    # also drop any dependent DB objects.
+    #
+    # PostgreSQL will error out if the index does not exists
+    # We purposely do not work around that.
+    def drop_statement(cascade = false)
+      drop_statement = "DROP INDEX \"#{@index_name}\""
+      drop_statement += " CASCADE" if cascade
+      drop_statement
+    end
+
+    # Creates this index
+    def create
+      ActiveRecord::Base.connection.execute(@def)
+    end
+
+    # returns true if this was the last clustered index
+    # on the associated table
+    def is_clustered?
+      @clustered
+    end
+
+    # Builds and returns Index object, given the index name
+    # The optional table_name is required when 
+    # the index_name is not unique, ie: More than one
+    # index with that name was found on PostgreSQL's 
+    # information catalog.
+    # If more than one index by that name is found, 
+    # and table_name is not specified, an exception is raised.
+    # TODO: write implementation of this method...
+    def self.build(index_name, table_name = nil)
+
+    end
+
+  end
+end

data/lib/peegee/primary_key.rb

@@ -0,0 +1,19 @@
+module Peegee
+  class PrimaryKey < Peegee::Constraint
+
+    def initialize(opts)
+      super(opts)
+    end
+
+    # Returns the name of this primary key.
+    def primary_key_name
+      @constraint_name
+    end
+
+    # Returns human readable primary key definition
+    def to_s
+      "Primary Key: #{primary_key_name} on #{@table_name}"
+    end
+
+  end
+end

data/lib/peegee/table.rb

@@ -0,0 +1,168 @@
+require File.dirname(__FILE__) + '/clustering'
+module Peegee
+
+  class Table
+    include Peegee::Clustering
+    
+    def initialize(opts = {})
+      @table_name = opts[:table_name]
+    end
+
+    def oid
+      @oid ||= fetch_oid
+    end
+
+    def foreign_keys
+      @foreign_keys ||= fetch_foreign_keys
+    end
+
+    def dependent_foreign_keys
+      @dependent_foreign_keys ||= fetch_dependent_foreign_keys
+    end
+
+    def primary_keys
+      @primary_keys ||= fetch_primary_keys
+    end
+
+    def unique_constraints
+      @unique_constraints ||= fetch_unique_constraints
+    end
+
+    def indexes
+      @indexes ||= fetch_indexes
+    end
+
+    # Returns the DDL for this table as a string.
+    def ddl
+      sql = 'SELECT a.attname, ' +
+          'pg_catalog.format_type(a.atttypid, a.atttypmod), ' +
+          '(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128) ' +
+          ' FROM pg_catalog.pg_attrdef d ' +
+          ' WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef), ' +
+          'a.attnotnull, a.attnum ' +
+        'FROM pg_catalog.pg_attribute a ' +
+        "WHERE a.attrelid = '#{oid}' AND a.attnum > 0 AND NOT a.attisdropped " +
+        'ORDER BY a.attnum ' 
+
+      column_defs = ActiveRecord::Base.connection.execute(sql).entries
+
+      ddl = "create table #{@table_name} ( "
+      columns = []
+      column_defs.each do |column_def|
+        #name and type
+        column = column_def[0] + ' ' + column_def[1] + ' '
+        #not null?
+        column += 'NOT NULL ' if column_def[3] == 't'
+        #add modifiers:
+        column += 'DEFAULT ' + column_def[2] unless (column_def[2].nil? || column_def[2].empty?)
+        columns << column
+      end
+
+      ddl += columns.join(', ') + ' )'
+      ddl.gsub('\\','')
+    end
+
+
+    private
+      def fetch_oid
+        sql = 'SELECT c.oid ' +
+        ' FROM pg_catalog.pg_class c ' +
+             ' LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace ' +
+        " WHERE c.relname ~ '^(#{@table_name})$' " +
+          ' AND pg_catalog.pg_table_is_visible(c.oid) '
+        return ActiveRecord::Base.connection.execute(sql).entries[0]
+      end
+
+
+
+      def fetch_primary_keys
+        sql = 'select  conname ' +
+            ' , pg_get_constraintdef(pk.oid, true) as foreign_key ' +
+            ' from pg_catalog.pg_constraint pk ' +
+            ' inner join pg_class c ' +
+            ' on c.oid = pk.conrelid ' +
+            " where contype = 'p' " +
+            " and c.oid = '#{@table_name}'::regclass "
+        raw_pks = ActiveRecord::Base.connection.execute(sql).entries
+        return raw_pks.collect do  |pk|
+          Peegee::ForeignKey.new(#TODO: Consider passing table object (self)
+                                 :table_name => @table_name,
+                                 :constraint_name => pk[0],
+                                 :constraint_def => pk[1])
+        end
+      end
+
+
+      def fetch_unique_constraints
+        sql = 'select  conname ' +
+            ' , pg_get_constraintdef(uc.oid, true) as foreign_key ' +
+            ' from pg_catalog.pg_constraint uc ' +
+            ' inner join pg_class c ' +
+            ' on c.oid = uc.conrelid ' +
+            " where contype = 'u' " +
+            " and c.oid = '#{@table_name}'::regclass "
+        raw_ucs = ActiveRecord::Base.connection.execute(sql).entries
+        return raw_ucs.collect do  |uc|
+          Peegee::UniqueConstraint.new(#TODO: Consider passing table object (self)
+                                 :table_name => @table_name,
+                                 :constraint_name => uc[0],
+                                 :constraint_def => uc[1])
+        end
+      end
+
+      def fetch_foreign_keys
+        sql = 'select  conname ' +
+            ' , pg_get_constraintdef(fk.oid, true) as foreign_key ' +
+            ' from pg_catalog.pg_constraint fk ' +
+            ' inner join pg_class c ' +
+            ' on c.oid = fk.conrelid ' +
+            " where contype = 'f' " +
+            " and c.oid = '#{@table_name}'::regclass "
+        raw_fks = ActiveRecord::Base.connection.execute(sql).entries
+        return raw_fks.collect do  |fk|
+          Peegee::ForeignKey.new(#TODO: Consider passing table object (self)
+                                 :table_name => @table_name,
+                                 :constraint_name => fk[0],
+                                 :constraint_def => fk[1])
+        end
+
+      end
+
+      def fetch_dependent_foreign_keys
+        sql = 'select pg_constraint.conname,' +
+            'dep_table.relname, ' +
+            'pg_get_constraintdef(pg_constraint.oid, true)  ' +
+            'from pg_constraint  ' +
+              'inner join pg_class dep_table on pg_constraint.conrelid = dep_table.oid ' +
+              "where pg_constraint.confrelid = '#{@table_name}'::regclass; "
+        raw_dpfks = ActiveRecord::Base.connection.execute(sql).entries
+        return raw_dpfks.collect do |dpfk|
+          Peegee::ForeignKey.new(#TODO: Consider passing table object (self)
+                                 :table_name => dpfk[1],
+                                 :constraint_name => dpfk[0],
+                                 :constraint_def => dpfk[2])
+        end
+      end
+
+      def fetch_indexes
+        sql = "SELECT pg_get_indexdef(i.indexrelid, 0, true) as index_definition " +
+            ", c2.relname as index_name " +
+            ", i.indisclustered " +
+            "FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i " +
+            "WHERE c.oid = '#{@table_name}'::regclass AND c.oid = i.indrelid AND i.indexrelid = c2.oid " #+
+            #"AND i.indisprimary = false" #don't get primary key constraints...
+        #indexes = ActiveRecord::Base.connection.execute(sql).entries.collect{ |i| i[0] + ';'}
+        indexes = ActiveRecord::Base.connection.execute(sql).entries
+        return indexes.collect do |i| 
+          Peegee::Index.new(:table_name => @table_name,
+                            :index_name => i[1],
+                            :clustered => (i[2] == 't' ? true : false),
+                            :def => i[0])
+          end
+      end
+
+
+
+  end
+
+end

data/lib/peegee/unique_constraint.rb

@@ -0,0 +1,19 @@
+module Peegee
+  class UniqueConstraint
+
+    def initialize(opts)
+      super(opts)
+    end
+
+    # Returns the name of this unique constraint
+    def unique_constraint_name
+      @constraint_name
+    end
+
+    #returns human readable unique constraint definition
+    def to_s
+      "Unique Constraint: #{unique_constraint_name} on #{table_name}"
+    end
+
+  end
+end

data/lib/peegee.rb

@@ -0,0 +1,6 @@
+require 'peegee/table'
+require 'peegee/constraint'
+require 'peegee/unique_constraint'
+require 'peegee/primary_key'
+require 'peegee/foreign_key'
+require 'peegee/index'

data/peegee.gemspec

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s| 
+  s.name = %q{peegee}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Harold A. Gimenez"]
+  s.date = %q{2009-04-10}
+  s.email = %q{harold.gimenez@gmail.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    "README.textile",
+    "Rakefile",
+    "VERSION.yml",
+    "lib/peegee.rb",
+    "lib/peegee/clustering.rb",
+    "lib/peegee/constraint.rb",
+    "lib/peegee/foreign_key.rb",
+    "lib/peegee/index.rb",
+    "lib/peegee/primary_key.rb",
+    "lib/peegee/table.rb",
+    "lib/peegee/unique_constraint.rb",
+    "peegee.gemspec",
+    "spec/peegee_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/hgimenez/peegee}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.requirements = ["A functioning PostgreSQL database, configured via ActiveRecord (for example, database.yml on a Rails project, or inline within your scripts)."]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A set of utilities for doing PostgreSQL database related stuffs from ruby.}
+  s.test_files = [
+    "spec/peegee_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+  end
+end

data/spec/peegee_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "Peegee" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'peegee'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: hgimenez-peegee
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Harold A. Gimenez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: harold.gimenez@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/peegee.rb
+- lib/peegee/clustering.rb
+- lib/peegee/constraint.rb
+- lib/peegee/foreign_key.rb
+- lib/peegee/index.rb
+- lib/peegee/primary_key.rb
+- lib/peegee/table.rb
+- lib/peegee/unique_constraint.rb
+- peegee.gemspec
+- spec/peegee_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/hgimenez/peegee
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- A functioning PostgreSQL database, configured via ActiveRecord (for example, database.yml on a Rails project, or inline within your scripts).
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A set of utilities for doing PostgreSQL database related stuffs from ruby.
+test_files: 
+- spec/peegee_spec.rb
+- spec/spec_helper.rb