dumbo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c38d6d2545804ea840a234c51c3d912fc2988a3
+  data.tar.gz: a1ace87c6b8469126e95a1eb94f9a503bcd93483
+SHA512:
+  metadata.gz: 6043bb12bfee32add950dd79093d41c3ea70732028749ccf8db79413d2e2219e8b3d5b197695255c4cba3d24ce4e38b3e3a2bdfc83522095ba9b85466fbf4623
+  data.tar.gz: ac5757b0c2dee69ecd5c0d962d3e0f4557b1937b5c08f63c0d3d3210134ef11975803a675e01f2770df35e250865e1331404577a42b246d8043406492394c778

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dumbo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Manuel Kniep
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Dumbo
+
+postgres extension with fun
+
+![](http://img1.wikia.nocookie.net/__cb20091210033559/disney/images/7/76/Dumbo-HQ.JPG)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dumbo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dumbo
+
+## Getting Started
+
+At the command prompt, create a new extension:
+
+  dumbo new myextention
+
+where "myextention" is the extension name.
+
+Change directory to myextention to start hacking:
+
+    cd myapp
+
+As a stating point take a look at the sample function in
+
+    sql/sample.sql
+
+and the corresponding test file
+
+    spec/sample_spec.rb
+
+build the extension and run the specs
+
+    rake
+
+if you start working on a new version run
+
+    rake dumbo:new_version [level]
+
+where level is new version level (major, minor patch)
+
+when you are done you can create the migration files with
+
+    rake dumbo:migrations
+
+## Contributing
+
+1. Fork it ( http://github.com/adeven/dumbo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'dumbo/db_task'
+
+RSpec::Core::RakeTask.new(:spec)
+Dumbo::DbTask.new(:db)
+
+task :default => ['db:test:prepare', :spec]

data/bin/dumbo

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'thor/group'
+require 'erubis'
+require 'fileutils'
+
+module Cli
+  class Dumbo < Thor
+
+    desc "new name", "creates a new extension skeleton"
+
+    def new(name, initial_version='0.0.1')
+      FileUtils.mkdir_p("#{name}/sql")
+      FileUtils.mkdir_p("#{name}/src")
+      FileUtils.mkdir_p("#{name}/spec/support")
+      FileUtils.mkdir_p("#{name}/config")
+      FileUtils.mkdir_p("#{name}/lib/tasks")
+
+      spec_helper = Dir.glob(File.expand_path('../../spec/spec_helper.rb', __FILE__))
+      spec_helper += Dir.glob(File.expand_path('../../spec/support', __FILE__))
+
+      FileUtils.cp_r spec_helper, "#{name}/spec/"
+
+      FileUtils.cp File.expand_path('../../config/boot.rb', __FILE__), "#{name}/config/"
+
+      template_path = File.expand_path('../../template', __FILE__)
+
+      Dir.glob(File.expand_path('../../template/**/*', __FILE__)).each do |template|
+        pathname = Pathname.new(template)
+        dest_name = pathname.relative_path_from Pathname.new(template_path)
+
+        if pathname.directory?
+          FileUtils.mkdir_p("#{name}/#{dest_name}")
+          next
+        end
+
+        if dest_name.extname =='.erb'
+          eruby = Erubis::Eruby.new(File.read(template))
+          File.open("#{name}/#{dest_name.sub_ext('')}",'w') do |f|
+            f.puts eruby.result({ext_name: name})
+          end
+        else
+          FileUtils.cp template, "#{name}/#{dest_name}"
+        end
+      end
+
+      File.open("#{name}/#{name}.control",'w') do |f|
+        f.puts "# #{name} extension"
+        f.puts "comment = 'my awesome extension'"
+        f.puts "default_version = '#{initial_version}'"
+        f.puts "relocatable = true"
+        f.puts "requires = ''"
+      end
+    end
+  end
+end
+
+Cli::Dumbo.start(ARGV)

data/config/boot.rb

@@ -0,0 +1,15 @@
+$:.unshift File.expand_path('../..', __FILE__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+ENV['DUMBO_ENV']  ||= 'development'
+
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+Bundler.require(:default, ENV['DUMBO_ENV'].to_sym)
+
+def db_config
+  @config ||= YAML.load_file('config/database.yml')
+end
+
+
+ActiveRecord::Base.establish_connection db_config[ENV['DUMBO_ENV']]

data/config/database.yml

@@ -0,0 +1,31 @@
+# general postgres settings
+# Connect on a TCP socket. Omitted by default since the client uses a
+# domain socket that doesn't need configuration. Windows does not have
+# domain sockets, so uncomment these lines.
+# host: localhost
+# port: 5432
+
+# Schema search path. The server defaults to $user,public
+# schema_search_path: myapp,sharedapp,public
+
+# Minimum log levels, in increasing order:
+#   debug5, debug4, debug3, debug2, debug1,
+#   log, notice, warning, error, fatal, and panic
+# The server defaults to notice.
+# min_messages: warning
+
+postgres: &postgres
+  adapter: postgresql
+  encoding: utf8
+  pool: 5
+  username: postgres
+  password:
+  host: localhost
+
+development:
+  <<: *postgres
+  database: dumbo_development
+
+test:
+  <<: *postgres
+  database: dumbo_test

data/dumbo.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dumbo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dumbo"
+  spec.version       = Dumbo::VERSION
+  spec.authors       = ["Manuel Kniep"]
+  spec.email         = ["m.kniep@web.de"]
+  spec.summary       = %q{postgres extension with fun}
+  spec.homepage      = "https://github.com/adjust/dumbo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "rake"
+  spec.add_dependency 'erubis'
+  spec.add_dependency 'rspec', '~> 2.14.0'
+  spec.add_dependency'factory_girl', '~> 4.0'
+  spec.add_dependency 'activerecord'
+  spec.add_dependency 'pg', '> 0.17'
+
+  spec.add_dependency 'thor'
+  spec.add_dependency 'activesupport'
+
+  spec.add_dependency "bundler", "~> 1.5"
+end

data/lib/dumbo.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require "dumbo/version"
+require "dumbo/pg_object"
+require "dumbo/type"
+require "dumbo/function"
+require "dumbo/cast"
+require "dumbo/base_type"
+require "dumbo/aggregate"
+require "dumbo/composite_type"
+require "dumbo/dependency_resolver"
+require "dumbo/enum_type"
+require "dumbo/extension"
+require "dumbo/extension_migrator"
+require "dumbo/extension_version"
+require "dumbo/operator"
+require "dumbo/range_type"
+require "dumbo/version"
+
+module Dumbo
+  # Your code goes here...
+end

data/lib/dumbo/aggregate.rb

@@ -0,0 +1,57 @@
+module Dumbo
+  class Aggregate < PgObject
+    attr_accessor :name, :sfunc, :transname, :ffunc, :input_data_type, :state_data_type,
+                  :initial_condition, :sort_operator
+
+    def load_attributes
+      result = execute <<-SQL
+        SELECT
+        proname AS name,
+        pg_get_function_arguments(pr.oid) AS input_data_type,
+        aggtransfn AS sfunc,
+        aggfinalfn AS ffunc,
+        agginitval AS initial_condition,
+        op.oprname AS sort_operator,
+        proargtypes,
+        aggtranstype AS state_data_type , proacl,
+        CASE WHEN (tt.typlen = -1 AND tt.typelem != 0) THEN (SELECT at.typname FROM pg_type at WHERE at.oid = tt.typelem) || '[]' ELSE tt.typname END as state_data_type,
+        prorettype AS aggfinaltype,
+        --CASE WHEN (tf.typlen = -1 AND tf.typelem != 0) THEN (SELECT at.typname FROM pg_type at WHERE at.oid = tf.typelem) || '[]' ELSE tf.typname END as ffunc,
+        description,
+        (SELECT array_agg(label) FROM pg_seclabels sl1 WHERE sl1.objoid=aggfnoid) AS labels,
+        (SELECT array_agg(provider) FROM pg_seclabels sl2 WHERE sl2.objoid=aggfnoid) AS providers, oprname, opn.nspname as oprnsp
+         FROM pg_aggregate ag
+         LEFT OUTER JOIN pg_operator op ON op.oid=aggsortop
+         LEFT OUTER JOIN pg_namespace opn ON opn.oid=op.oprnamespace
+         JOIN pg_proc pr ON pr.oid = ag.aggfnoid
+         JOIN pg_type tt on tt.oid=aggtranstype
+         JOIN pg_type tf on tf.oid=prorettype
+         LEFT OUTER JOIN pg_description des ON (des.objoid=aggfnoid::oid AND des.classoid='pg_aggregate'::regclass)
+        WHERE aggfnoid = #{oid}
+      SQL
+
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+
+      result.first
+    end
+
+
+    def to_sql
+      attributes = []
+      attributes << "SFUNC = #{sfunc}"
+      attributes << "STYPE = #{state_data_type}"
+      attributes << "FINALFUNC = #{ffunc}" if ffunc && ffunc != '-'
+      attributes << "INITCOND = '#{initial_condition}'" if initial_condition
+      attributes << "SORTOP = #{sort_operator}" if sort_operator
+
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE AGGREGATE #{name}(#{input_data_type}) (
+        #{attributes.join(",\n  ")}
+      );
+      SQL
+    end
+
+  end
+end

data/lib/dumbo/base_type.rb

@@ -0,0 +1,71 @@
+module Dumbo
+  class BaseType < Type
+    attr_accessor  :input_function,
+                    :output_function,
+                    :receive_function,
+                    :send_function,
+                    :analyze_function,
+                    :category,
+                    :default,
+                    :alignment,
+                    :storage,
+                    :type,
+                    :internallength,
+                    :attribute_name,
+                    :typrelid
+
+    def load_attributes
+      sql = <<-SQL
+        SELECT
+        t.typname AS name,
+        t.typinput AS input_function,
+        t.typoutput AS output_function,
+        t.typreceive AS receive_function,
+        t.typsend AS send_function,
+        t.typanalyze AS analyze_function,
+        t.typcategory AS category,
+        t.typdefault AS default,
+        t.typrelid,
+        CASE WHEN t.typalign = 'i' THEN 'int' WHEN t.typalign = 'c' THEN 'char' WHEN t.typalign = 's' THEN 'short'  WHEN t.typalign = 'd' THEN 'double' ELSE NULL END AS alignment,
+        CASE WHEN t.typstorage = 'p' THEN 'PLAIN' WHEN t.typstorage = 'e' THEN 'EXTENDED' WHEN t.typstorage = 'm' THEN 'MAIN'  WHEN t.typstorage = 'x' THEN 'EXTENDED' ELSE NULL END AS storage,
+        t.typtype AS type,
+        t.typlen AS internallength,
+        format_type(t.oid, null) AS alias, e.typname as element,
+        description, ct.oid AS taboid,
+        (SELECT array_agg(label) FROM pg_seclabels sl1 WHERE sl1.objoid=t.oid) AS labels,
+        (SELECT array_agg(provider) FROM pg_seclabels sl2 WHERE sl2.objoid=t.oid) AS providers
+         FROM pg_type t
+         LEFT OUTER JOIN pg_type e ON e.oid=t.typelem
+         LEFT OUTER JOIN pg_class ct ON ct.oid = t.typrelid AND ct.relkind <> 'c'
+         LEFT OUTER JOIN pg_description des ON (des.objoid=t.oid AND des.classoid='pg_type'::regclass)
+        WHERE t.typtype != 'd' AND t.typnamespace = 2200::oid
+          AND ct.oid IS NULL
+          AND t.oid = #{oid}
+      SQL
+
+      result = execute sql
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+
+      result.first
+    end
+
+    def to_sql
+        <<-SQL.gsub(/^ {8}/, '')
+        CREATE TYPE #{name}(
+          INPUT=#{input_function},
+          OUTPUT=#{output_function},
+          RECEIVE=#{receive_function},
+          SEND=#{send_function},
+          ANALYZE=#{analyze_function},
+          CATEGORY='#{category}',
+          DEFAULT='#{default}',
+          INTERNALLENGTH=#{internallength},
+          ALIGNMENT=#{alignment},
+          STORAGE=#{storage}
+        );
+        SQL
+    end
+  end
+end

data/lib/dumbo/cast.rb

@@ -0,0 +1,49 @@
+module Dumbo
+  class Cast < PgObject
+    attr_accessor :source_type, :target_type, :function_name, :argument_type, :context
+    identfied_by :source_type, :target_type
+
+    def load_attributes
+      result = execute <<-SQL
+      SELECT
+        format_type(st.oid,NULL) AS source_type,
+        format_type(st.oid,NULL) AS argument_type,
+        format_type(tt.oid,tt.typtypmod) AS target_type,
+        proname AS function_name,
+      CASE WHEN ca.castcontext = 'e' THEN NULL
+            WHEN ca.castcontext = 'a' THEN 'ASSIGNMENT'
+            ELSE 'IMPLICIT'
+       END AS context
+
+       FROM pg_cast ca
+       JOIN pg_type st ON st.oid=castsource
+       JOIN pg_type tt ON tt.oid=casttarget
+       LEFT JOIN pg_proc pr ON pr.oid=castfunc
+       LEFT OUTER JOIN pg_description des ON (des.objoid=ca.oid AND des.objsubid=0 AND des.classoid='pg_cast'::regclass)
+      WHERE ca.oid = #{oid}
+      SQL
+
+      result.first.each do |k,v|
+        send("#{k}=",v) rescue nil
+      end
+
+      result.first
+    end
+
+    def drop
+      "DROP CAST (#{source_type} AS #{target_type})"
+    end
+
+    def to_sql
+      attributes = []
+      attributes << "WITH FUNCTION #{function_name}(#{source_type})" if function_name
+      attributes << "WITHOUT FUNCTION" unless function_name
+      attributes << context if context
+
+      <<-SQL.gsub(/^ {6}/, '')
+      CREATE CAST (#{source_type} AS #{target_type})
+      #{attributes.join("\nAS ")};
+      SQL
+    end
+  end
+end