dumbo 0.0.1

data/lib/dumbo/composite_type.rb

@@ -0,0 +1,31 @@
+module Dumbo
+  class CompositeType < Type
+    attr_accessor  :attributes
+
+    def load_attributes
+      super
+      res = execute <<-SQL
+      SELECT
+        attname,
+        format_type(t.oid,NULL) AS typname
+      FROM pg_attribute att
+      JOIN pg_type t ON t.oid=atttypid
+
+      WHERE att.attrelid=#{typrelid}
+      ORDER by attnum
+      SQL
+
+      attribute = Struct.new(:name, :type)
+      @attributes = res.map{|r| attribute.new(r['attname'],r['typname'])}
+    end
+
+    def to_sql
+      attr_str = attributes.map{|a| "#{a.name} #{a.type}"}.join(",\n  ")
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE #{name} AS (
+        #{attr_str}
+      );
+      SQL
+    end
+  end
+end

data/lib/dumbo/db_task.rb

@@ -0,0 +1,57 @@
+require "rake"
+require 'rake/tasklib'
+require 'active_record'
+
+module Dumbo
+  class DbTask < ::Rake::TaskLib
+    attr_accessor :name
+    def initialize(name = 'db')
+      @name = name
+
+      namespace name do
+        task environment: ['db:configure_connection' ]
+
+        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
+    end
+
+    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
+  end
+end

data/lib/dumbo/dependency_resolver.rb

@@ -0,0 +1,105 @@
+require 'pathname'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Dumbo
+
+  class DependencyNotFound < StandardError
+    attr_accessor :dep, :file
+
+    def initialize(dep, file)
+      super "Can't find dependency #{dep} for file: #{file}"
+    end
+  end
+
+  class DependencyResolver
+    def self.depends_pattern
+      /\s*--\s*require +([^\s'";]+)/
+    end
+
+    # Constructor
+    # accepts an array of files
+    def initialize(file_list)
+      @file_list = file_list
+    end
+
+    def resolve
+      list = dependency_list.sort{|a,b| a.last.size <=> b.last.size}
+      resolve_list(list)
+    end
+
+    private
+
+    def resolve_list(list)
+      @resolve_list = []
+      @temp_list = list
+      loops = 0
+      until @temp_list.empty? || loops > 10 do
+        @temp_list.each do |(file, deps)|
+          _resolve(file, deps)
+        end
+        loops +=1
+      end
+
+      raise "Can't resolve dependencies" if loops > 10
+
+      @resolve_list
+    end
+
+    def _resolve(file, deps)
+      if deps.empty?
+        @resolve_list.push(@temp_list.shift.first)
+        return
+      end
+
+      left = deps - @resolve_list
+      if left.empty?
+        @resolve_list.push(@temp_list.shift.first)
+        return
+      else
+        @temp_list.push @temp_list.shift
+      end
+    end
+
+
+    def dependency_list
+      @file_list.map do |file|
+        deps = []
+        IO.foreach(file) do |line|
+          catch(:done) do
+            dep = parse(line)
+            deps << relative_path(dep,file) if dep
+          end
+        end
+        [file, deps]
+      end
+    end
+
+    def encoded_line(line)
+      if String.method_defined?(:encode)
+        line.encode!('UTF-8', 'UTF-8', :invalid => :replace)
+      else
+        line
+      end
+    end
+
+    def parse(line)
+      return $1 if encoded_line(line) =~ DependencyResolver.depends_pattern
+
+      # end of first commenting block we're done.
+      throw :done unless line =~ /--/
+    end
+
+    def relative_path(dep,file)
+      p = Pathname.new(file).dirname.join(dep)
+      if p.exist? && p.extname.present?
+        return p.to_s
+      elsif p.extname.empty?
+        %w(.sql .erb).each do |ext|
+          new_p = p.sub_ext(ext)
+          return new_p.to_s if new_p.exist?
+        end
+      end
+      raise DependencyNotFound.new(dep, file)
+    end
+  end
+end

data/lib/dumbo/enum_type.rb

@@ -0,0 +1,28 @@
+module Dumbo
+  class EnumType < Type
+    attr_accessor :labels
+
+
+    def load_attributes
+      super
+
+      res = execute <<-SQL
+          SELECT enumlabel
+          FROM pg_enum
+          WHERE enumtypid = #{oid}
+          ORDER by enumsortorder
+        SQL
+        @labels = res.to_a.map{|r| r['enumlabel']}
+    end
+
+    def to_sql
+      lbl_str = labels.map{|l| "'"+l+"'"}.join(",\n  ")
+
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE TYPE #{name} AS ENUM (
+        #{lbl_str}
+      );
+      SQL
+  end
+  end
+end

data/lib/dumbo/extension.rb

@@ -0,0 +1,73 @@
+module Dumbo
+  class Extension
+    attr_reader :name, :version
+    def initialize(name = nil, version = nil)
+      @name = name || File.read('Makefile')[/EXTENSION *= *([^\s]*)/,1]
+      @version = version || File.read("#{self.name}.control")[/default_version *= *'([^']*)'/,1]
+    end
+
+    # main releases without migrations
+    def releases
+      Dir.glob("#{name}--*.sql").reject{|f| f=~/\d--\d/}
+    end
+
+    def available_versions
+      versions = releases.map{|f| ExtensionVersion.new f[/#{name}--([\d\.]*?)\.sql/,1] }
+      versions.sort
+    end
+
+    def install
+      execute "DROP EXTENSION IF EXISTS #{name}"
+      execute "CREATE EXTENSION #{name} VERSION '#{version}'"
+      self
+    end
+
+    def obj_id
+      @obj_id ||= begin
+        result = execute <<-sql
+          SELECT e.extname, e.oid
+          FROM pg_catalog.pg_extension e
+          WHERE e.extname ~ '^(#{name})$'
+          ORDER BY 1;
+        sql
+        result.first['oid']
+      end
+    end
+
+    def objects
+      @objects ||= begin
+        result = execute <<-SQL
+          SELECT classid::pg_catalog.regclass, objid
+          FROM pg_catalog.pg_depend
+          WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = '#{obj_id}' AND deptype = 'e'
+          ORDER BY 1;
+        SQL
+
+        result.map{|r| PgObject.new(r['objid']).get(r['classid'])}
+      end
+    end
+
+    def types
+      objects.select{|o| o.kind_of?(Type)}
+    end
+
+    def functions
+      objects.select{|o| o.kind_of?(Function)}
+    end
+
+    def casts
+      objects.select{|o| o.kind_of?(Cast)}
+    end
+
+    def operators
+      objects.select{|o| o.kind_of?(Operator)}
+    end
+
+    private
+
+    def execute(sql)
+      ActiveRecord::Base.connection.execute sql
+    end
+
+  end
+end

data/lib/dumbo/extension_migrator.rb

@@ -0,0 +1,66 @@
+module Dumbo
+  class ExtensionMigrator
+    attr_reader :old_version, :new_version, :name
+    TYPES = [:types, :functions, :casts, :operators]
+
+    def initialize(name, old_version, new_version)
+      @name = name
+      @old_version = Extension.new(name, old_version).install
+      @old_version.objects
+      @new_version = Extension.new(name, new_version).install
+      @new_version.objects
+    end
+
+    def create
+      File.open("#{name}--#{old_version.version}--#{new_version.version}.sql",'w') do |f|
+        f.puts upgrade
+      end
+      File.open("#{name}--#{new_version.version}--#{old_version.version}.sql",'w') do |f|
+        f.puts downgrade
+      end
+    end
+
+    def upgrade
+      TYPES.map do |type|
+        diff = object_diff(type,:upgrade)
+        "----#{type}----\n" + diff if diff.present?
+      end.compact.join("\n")
+    end
+
+    def downgrade
+      TYPES.map do |type|
+        diff = object_diff(type,:downgrade)
+        "----#{type}----\n" + diff if diff.present?
+      end.compact.join("\n")
+    end
+
+    def function_diff
+      object_diff(@old_version.functions, @new_version.functions)
+    end
+
+    def cast_diff
+      object_diff(@old_version.casts, @new_version.casts)
+    end
+
+    def object_diff(type, dir)
+      ids = @old_version.public_send(type).map(&:identify) | @new_version.public_send(type).map(&:identify)
+
+      sqls = ids.map do |id|
+        n = @new_version.public_send(type).find{|n| n.identify == id }
+        o = @old_version.public_send(type).find{|n| n.identify == id }
+        if n
+          n.public_send(dir,o)
+        elsif o
+          o.public_send(dir,o)
+        end
+      end
+
+      sqls.join("\n----\n")
+    end
+
+    private
+    def execute(sql)
+      ActiveRecord::Base.connection.execute sql
+    end
+  end
+end

data/lib/dumbo/extension_version.rb

@@ -0,0 +1,25 @@
+module Dumbo
+  class ExtensionVersion
+    include Comparable
+
+    attr_reader :major, :minor, :patch
+
+    def initialize(version="")
+      @major, @minor, @patch = version.split(".").map(&:to_i)
+    end
+
+    def <=>(other)
+      return major <=> other.major if ((major <=> other.major) != 0)
+      return minor <=> other.minor if ((minor <=> other.minor) != 0)
+      return patch <=> other.patch if ((patch <=> other.patch) != 0)
+    end
+
+    def self.sort
+      self.sort!{|a,b| a <=> b}
+    end
+
+    def to_s
+      [major,minor,patch].join('.')
+    end
+  end
+end

data/lib/dumbo/function.rb

@@ -0,0 +1,101 @@
+module Dumbo
+  class Function < PgObject
+    attr_accessor :name, :result_type, :definition, :type, :arg_types
+    identfied_by :name, :arg_types
+
+    def initialize(oid)
+      super
+      get
+    end
+
+    def get
+      if type == 'agg'
+        Aggregate.new(oid)
+      else
+        self
+      end
+    end
+
+    def drop
+      "DROP FUNCTION #{name} #{arg_types}"
+    end
+
+    def upgrade(other)
+      return self.to_sql if other.nil?
+
+      if other.identify != self.identify
+        raise "Not the Same Objects!"
+      end
+
+      return nil if other.to_sql == self.to_sql
+
+      if other.result_type != self.result_type
+         <<-SQL.gsub(/^ {8}/, '')
+        #{self.drop}
+        #{self.to_sql}
+        SQL
+      else
+        self.to_sql
+      end
+    end
+
+    def downgrade(other)
+      return self.to_sql if other.nil?
+
+      if other.identify != self.identify
+        raise "Not the Same Objects!"
+      end
+
+      return nil if other.to_sql == self.to_sql
+
+      if other.result_type != self.result_type
+         <<-SQL.gsub(/^ {8}/, '')
+        #{self.drop}
+        #{other.to_sql}
+        SQL
+      else
+        other.to_sql
+      end
+    end
+
+    def load_attributes
+      result = execute <<-SQL
+        SELECT
+          p.proname as name,
+          pg_catalog.pg_get_function_result(p.oid) as result_type,
+          pg_catalog.pg_get_function_arguments(p.oid) as arg_types,
+          CASE
+            WHEN p.proisagg THEN 'agg'
+            WHEN p.proiswindow THEN 'window'
+            WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN 'trigger'
+            ELSE 'normal'
+          END as "type",
+          CASE
+            WHEN p.provolatile = 'i' THEN 'immutable'
+            WHEN p.provolatile = 's' THEN 'stable'
+            WHEN p.provolatile = 'v' THEN 'volatile'
+          END as volatility,
+          proisstrict as is_strict,
+          l.lanname as language,
+          p.prosrc as "source",
+          pg_catalog.obj_description(p.oid, 'pg_proc') as description,
+          CASE WHEN p.proisagg THEN 'agg_dummy' ELSE pg_get_functiondef(p.oid) END as definition
+
+        FROM pg_catalog.pg_proc p
+        LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang
+        WHERE pg_catalog.pg_function_is_visible(p.oid)
+          AND p.oid = #{oid};
+      SQL
+
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+
+      result.first
+    end
+
+    def to_sql
+      definition.gsub("public.#{name}",name)
+    end
+  end
+end