dumbo 0.0.1

data/lib/dumbo/operator.rb

@@ -0,0 +1,74 @@
+module Dumbo
+  class Operator < PgObject
+    attr_accessor :name,
+                  :kind,
+                  :hashes,
+                  :merges,
+                  :leftarg,
+                  :rightarg,
+                  :result_type,
+                  :commutator,
+                  :negator,
+                  :function_name,
+                  :join,
+                  :restrict
+
+    identfied_by :name, :leftarg, :rightarg
+
+    def load_attributes
+
+      result = execute <<-SQL
+        SELECT
+         op.oprname AS name,
+         op.oprkind AS kind,
+         op.oprcanhash AS hashes,
+         op.oprcanmerge AS merges,
+         lt.typname AS leftarg,
+         rt.typname AS rightarg,
+         et.typname AS result_type,
+         co.oprname AS commutator,
+         ne.oprname AS negator,
+         op.oprcode AS function_name,
+         op.oprjoin AS join,
+         op.oprrest AS restrict,
+         description
+        FROM pg_operator op
+        LEFT OUTER JOIN pg_type lt ON lt.oid=op.oprleft
+        LEFT OUTER JOIN pg_type rt ON rt.oid=op.oprright
+        JOIN pg_type et on et.oid=op.oprresult
+        LEFT OUTER JOIN pg_operator co ON co.oid=op.oprcom
+        LEFT OUTER JOIN pg_operator ne ON ne.oid=op.oprnegate
+        LEFT OUTER JOIN pg_description des ON des.objoid=op.oid
+        WHERE op.oid = #{oid}
+      SQL
+
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+
+      result.first
+
+    end
+
+    def to_sql
+      attrs = [:leftarg, :rightarg, :commutator, :negator, :restrict, :join].inject([]) do |mem, attr|
+        mem << "#{attr.to_s.upcase} = #{public_send(attr)}" if public_send(attr)
+        mem
+      end
+      atttr_str = attrs.join(",\n  ")
+      attrs << ",\n  HASHES" if hashes
+      attrs << ",\n  MERGES" if merges
+
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE OPERATOR #{name} (
+        PROCEDURE = #{function_name},
+        #{atttr_str}
+      );
+      SQL
+    end
+
+    def drop
+      "DROP OPERATOR #{name};"
+    end
+  end
+end

data/lib/dumbo/pg_object.rb

@@ -0,0 +1,80 @@
+require 'active_support/core_ext/class/attribute'
+
+module Dumbo
+  class PgObject
+    attr_reader :oid
+    class_attribute :identifier
+
+    class << self
+      def identfied_by(*args)
+        self.identifier = args
+      end
+    end
+
+    def initialize(oid)
+      @oid = oid
+      load_attributes
+    end
+
+    def identify
+       identifier.map{|a| public_send a}
+    end
+
+    def get(type=nil)
+      case type
+      when 'function', 'pg_proc'
+        Function.new(oid).get
+      when 'cast', 'pg_cast'
+        Cast.new(oid).get
+      when 'operator', 'pg_operator'
+        Operator.new(oid).get
+      when 'type', 'pg_type'
+        Type.new(oid).get
+      else
+        self.load_attributes
+        self
+      end
+    end
+
+    def load_attributes
+
+    end
+
+    def upgrade(other)
+      return self.to_sql if other.nil?
+
+      if other.identify != self.identify
+        raise "Not the Same Objects!"
+      end
+
+      if other.to_sql != self.to_sql
+         <<-SQL.gsub(/^ {8}/, '')
+        #{self.drop}
+        #{self.to_sql}
+        SQL
+      end
+
+
+    end
+
+    def downgrade(other)
+      return self.drop if other.nil?
+
+      if other.identify != self.identify
+        raise "Not the Same Objects!"
+      end
+
+      if other.to_sql != self.to_sql
+         <<-SQL.gsub(/^ {8}/, '')
+        #{self.drop}
+        #{other.to_sql}
+        SQL
+      end
+    end
+
+    def execute(sql)
+      ActiveRecord::Base.connection.execute(sql)
+    end
+
+  end
+end

data/lib/dumbo/rake_task.rb

@@ -0,0 +1,121 @@
+require "rake"
+require 'rake/tasklib'
+require "erubis"
+require "pathname"
+require 'yaml'
+require 'logger'
+require 'active_record'
+require "dumbo/extension"
+require "dumbo/dependency_resolver"
+
+module Dumbo
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name
+
+    def initialize(name = 'dumbo')
+
+      @name = name
+
+      namespace name do
+        desc 'creates and installs extension'
+        task :all => ["#{extension}--#{version}.sql", :install]
+
+        desc 'installs the extension'
+        task :install do
+          system('make clean && make && make install')
+        end
+
+        desc 'concatenates files'
+        file "#{extension}--#{version}.sql" => file_list do |t|
+          sql = t.prerequisites.map do |file|
+            ["--source file #{file}"] + get_sql(file) + [" "]
+          end.flatten
+          concatenate sql, t.name
+        end
+
+        desc 'creates migration files for the last two versions'
+        task :migrations do
+          old_version, new_version = Dumbo::Extension.new.available_versions.last(2).map(&:to_s)
+          if new_version
+            Dumbo::ExtensionMigrator.new(Dumbo::Extension.new.name, old_version, new_version).create
+          end
+        end
+
+        desc 'release a new version'
+        task :new_version, :level do |t, args|
+          args.with_defaults(:level => 'patch')
+          v = version_bump args[:level]
+          set_version v
+
+          Rake::Task["#{name}:all"].invoke
+        end
+      end
+    end
+
+    def set_version(new_version)
+      content = File.read("#{extension}.control")
+      new_content = content.gsub(version, new_version)
+      File.open("#{extension}.control", "w") {|file| file.puts new_content}
+    end
+
+    def version_bump(level='patch')
+      levels = {'patch' => 2, 'minor' => 1, 'major' => 0}
+      parts = version.split('.').map(&:to_i)
+      l = levels[level]
+      parts[l] += 1
+      (l+1..2).each {|l| parts[l]=0}
+
+      parts.join('.')
+    end
+
+    def version
+      Dumbo::Extension.new.version
+    end
+
+    def extension
+      Dumbo::Extension.new.name
+    end
+
+    def available_versions
+      Dumbo::Extension.new.name.available_versions
+    end
+
+        # source sql file list
+    def file_list
+      Dumbo::DependencyResolver.new(Dir.glob("sql/**/*.{sql,erb}")).resolve
+    end
+
+    def concatenate(lines, target)
+      File.open(target,'w') do |f|
+        lines.each do |line|
+          f.puts line unless line =~ Dumbo::DependencyResolver.depends_pattern
+        end
+      end
+    end
+
+    def get_sql(file)
+      ext = Pathname.new(file).extname
+      if  ext == '.erb'
+        convert_template(file)
+      else
+        File.readlines(file)
+      end
+    end
+
+    def convert_template(file)
+      eruby = Erubis::Eruby.new(File.read(file))
+      bindigs = get_bindings(file)
+      eruby.result(bindigs).split("\n")
+    end
+
+    def get_bindings(file)
+      base = Pathname.new(file).sub_ext('.yml').basename
+      yaml = Pathname.new('config').join(base)
+      if yaml.exist?
+        YAML.load_file(yaml)
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/dumbo/range_type.rb

@@ -0,0 +1,43 @@
+module Dumbo
+  class RangeType < Type
+    attr_accessor :subtype, :subtype_opclass, :collation,
+                  :canonical,:subtype_diff
+
+    def load_attributes
+      super
+      result = execute <<-SQL
+        SELECT
+          st.typname AS subtype,
+          opc.opcname AS subtype_opclass,
+          col.collname AS collation,
+          rngcanonical AS canonical,
+          rngsubdiff AS  subtype_diff
+        FROM pg_range
+        LEFT JOIN pg_type st ON st.oid=rngsubtype
+        LEFT JOIN pg_collation col ON col.oid=rngcollation
+        LEFT JOIN pg_opclass opc ON opc.oid=rngsubopc
+        WHERE rngtypid=#{oid}
+        SQL
+
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+      result.first
+    end
+
+
+
+
+    def to_sql
+      attr_str = [:subtype, :subtype_opclass, :collation, :canonical,:subtype_diff].map do |a|
+        [a, public_send(a)]
+      end.select{|k,v| v && v != '-' }.map{|k,v| "#{k.upcase}=#{v}"}.join(",\n  ")
+
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE #{name} AS RANGE (
+        #{attr_str}
+      );
+      SQL
+    end
+  end
+end

data/lib/dumbo/type.rb

@@ -0,0 +1,31 @@
+module Dumbo
+  class Type < PgObject
+    attr_accessor  :name, :type, :typrelid
+    identfied_by :name
+
+    def load_attributes
+      result = execute("SELECT typname, typtype, typrelid FROM pg_type WHERE oid = #{oid}").first
+      @name = result['typname']
+      @type = result['typtype']
+      @typrelid = result['typrelid']
+    end
+
+    def get
+      case type
+      when 'c'
+        CompositeType.new(oid)
+      when 'b'
+        BaseType.new(oid)
+      when 'r'
+        RangeType.new(oid)
+      when 'e'
+        EnumType.new(oid)
+      end
+    end
+
+    def drop
+      "DROP TYPE #{name}"
+    end
+
+  end
+end

data/lib/dumbo/version.rb

@@ -0,0 +1,3 @@
+module Dumbo
+  VERSION = "0.0.1"
+end

data/lib/tasks/db.rake

@@ -0,0 +1,52 @@
+require 'yaml'
+require 'logger'
+require 'active_record'
+
+task environment: ['db:configure_connection' ]
+
+task :test_env do
+  ENV['DUMBO_ENV'] = 'test'
+end
+
+namespace :db do
+  def create_database(config)
+    ActiveRecord::Base.establish_connection config.merge('database' => nil)
+    ActiveRecord::Base.connection.create_database config['database'], config
+    ActiveRecord::Base.establish_connection config
+  end
+
+  task :configuration do
+    @config = YAML.load_file('config/database.yml')[ENV['DUMBO_ENV']]
+  end
+
+  task configure_connection: :configuration do
+    ActiveRecord::Base.establish_connection @config
+    ActiveRecord::Base.logger = Logger.new STDOUT if @config['logger']
+  end
+
+  desc 'Create the database from config/database.yml for the current ENV'
+  task create: :environment do
+    create_database @config
+  end
+
+  desc 'Drops the database for the current ENV'
+  task drop: :environment do
+    ActiveRecord::Base.establish_connection @config.merge('database' => nil)
+    ActiveRecord::Base.connection.drop_database @config['database']
+  end
+
+  namespace :test do
+    task :environment do
+      ENV['DUMBO_ENV'] ||= 'test'
+      ActiveRecord::Schema.verbose = false
+    end
+
+    task load_structure: :environment do
+      filename = ENV['DB_STRUCTURE'] || File.join("db", "structure.sql")
+      ActiveRecord::Tasks::DatabaseTasks.structure_load(@config, filename)
+    end
+
+    desc "Re-create and prepare test database"
+    task prepare: [:environment, :drop, :create]
+  end
+end

data/lib/tasks/dumbo.rake

@@ -0,0 +1,23 @@
+require 'erubis'
+require 'pathname'
+
+task :default => ['dumbo:all', :spec]
+
+namespace :dumbo do
+  include Dumbo::RakeHelper
+
+  task :all => ["#{extension}--#{version}.sql", :install]
+
+  desc 'installs the extension'
+  task :install do
+    system('make clean && make && make install')
+  end
+
+  desc 'concatenates files'
+  file "#{extension}--#{version}.sql" => file_list do |t|
+    sql = t.prerequisites.map do |file|
+      ["--source file #{file}"] + get_sql(file) + [" "]
+    end.flatten
+    concatenate sql, t.name
+  end
+end

data/spec/Makefile

@@ -0,0 +1,6 @@
+#http://blog.pgxn.org/post/4783001135/extension-makefiles pg makefiles
+EXTENSION = dumbo_sample
+PG_CONFIG ?= pg_config
+DATA = $(wildcard *--*.sql)
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

data/spec/aggregate_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+describe Dumbo::Aggregate do
+  let(:avg) do
+    oid = sql("SELECT p.oid
+              FROM pg_proc p
+              JOIN pg_aggregate ag ON p.oid = ag.aggfnoid
+              WHERE proname='avg' AND pg_get_function_arguments(p.oid) = 'integer'",'oid').first
+    Dumbo::Aggregate.new(oid)
+  end
+
+  let(:min) do
+    oid = sql("SELECT p.oid
+              FROM pg_proc p
+              JOIN pg_aggregate ag ON p.oid = ag.aggfnoid
+              WHERE proname='min' AND pg_get_function_arguments(p.oid) = 'integer'",'oid').first
+    Dumbo::Aggregate.new(oid)
+  end
+
+
+  it "avg should have a sql representation" do
+      avg.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE AGGREGATE avg(integer) (
+        SFUNC = int4_avg_accum,
+        STYPE = int8[],
+        FINALFUNC = int8_avg,
+        INITCOND = '{0,0}'
+      );
+      SQL
+  end
+
+  it "min should have a sql representation" do
+      min.to_sql.should eq <<-SQL.gsub(/^ {6}/, '')
+      CREATE AGGREGATE min(integer) (
+        SFUNC = int4smaller,
+        STYPE = int4,
+        SORTOP = <
+      );
+      SQL
+  end
+
+end