Add in initial version

Author: urkle

.gitignore

@@ -5,5 +5,3 @@
 
 *.lock
 *.log
-*.sqlite3
-!gemfiles/**/*.sqlite3

.travis.yml

@@ -5,12 +5,10 @@
 ---
 sudo: false
 rvm:
-- 2.1.5
+- 2.3.1
 gemfile:
-- gemfiles/activerecord-4.2/Gemfile.mysql2
-- gemfiles/activerecord-4.2/Gemfile.postgresql
-- gemfiles/activerecord-4.2/Gemfile.sqlite3
-env: POSTGRESQL_DB_USER=postgres MYSQL_DB_USER=travis
+- gemfiles/activerecord-5.2/Gemfile.postgresql
+env: POSTGRESQL_DB_USER=postgres
 addons:
   postgresql: '9.4'
 before_script: bundle exec rake create_databases

Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "http://rubygems.org"
 
 gemspec

README.md

@@ -5,7 +5,7 @@
 
 # SchemaPlus::Functions
 
-TODO: Write a gem description
+SchemaPlus::Functions adds support for SQL functions in ActiveRecord.
 
 SchemaPlus::Functions is part of the [SchemaPlus](https://github.com/SchemaPlus/) family of Ruby on Rails ActiveRecord extension gems.
 
@@ -22,20 +22,73 @@ gem.add_dependency "schema_plus_functions" # in a .gemspec
 
 <!-- SCHEMA_DEV: TEMPLATE INSTALLATION - end -->
 
+## Usage
+
+### Migrations
+
+To declare a function use `create_function`:
+
+    create_function :test, "start date, stop date DEFAULT NULL::date", <<-END
+    RETURNS integer
+      LANGUAGE plpgsql
+      AS $$
+    DECLARE
+      processed INTEGER = 0;
+    BEGIN
+      processed = processed + 1;  
+      RETURN processed;
+    END;
+    $$
+    END
+
+To create an aggregate function specify the `function_type`:
+
+    create_function :array_cat_agg, "anyarray", <<-END, function_type: :aggregate
+    (SFUNC=array_cat,STYPE=anyarray)
+    END
+
+To update a function in a new migration specify the `allow_replace` property
+
+    create_function :test, "start date, stop date DEFAULT NULL::date", <<-END, allow_replace: true
+    RETURNS integer
+      LANGUAGE plpgsql
+      AS $$
+    DECLARE
+      processed INTEGER = 0;
+    BEGIN
+      processed = processed + 5;  
+      RETURN processed;
+    END;
+    $$
+    END
+
+To remove a function use `drop_function` with the name and argument types:
+
+    drop_function :test, "start date, stop date"
+
+To remove an aggregate use `drop_function` with the name and argument types with the `function_type`:
+
+    drop_function :array_cat_agg, "anyarray", function_type: :aggrgate
+
+### Introspection
+
+You can query the list of user functions at the connection level (uncached):
+
+    connection.functions
+
+This will return a array of arrays. The inner array containing the function_name, argument types
+and possible function type.
+
 ## Compatibility
 
 SchemaPlus::Functions is tested on:
 
 <!-- SCHEMA_DEV: MATRIX - begin -->
 <!-- These lines are auto-generated by schema_dev based on schema_dev.yml -->
-* ruby **2.1.5** with activerecord **4.2**, using **mysql2**, **sqlite3** or **postgresql**
+* ruby **2.3.1** with activerecord **5.2**, using **postgresql**
 
 <!-- SCHEMA_DEV: MATRIX - end -->
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## History
 
 * 0.1.0 - Initial release

Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler'
 Bundler::GemHelper.install_tasks
 

gemfiles/activerecord-4.2/Gemfile.mysql2

@@ -1,3 +1,3 @@
 eval File.read File.expand_path('../../Gemfile.base', __FILE__)
 
-gem "activerecord", "~> 4.2.6"
+gem "activerecord", ">= 5.2.0.beta0", "< 5.3"

gemfiles/activerecord-4.2/Gemfile.sqlite3

@@ -2,7 +2,7 @@ require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
 platform :ruby do
-  gem "pg", "< 1"
+  gem "pg"
 end
 
 platform :jruby do

gemfiles/activerecord-4.2/Gemfile.base gemfiles/activerecord-5.2/Gemfile.base

@@ -1,13 +1,18 @@
+# frozen_string_literal: true
+
 require 'schema_plus/core'
 
 require_relative 'functions/version'
+require_relative 'functions/active_record/connection_adapters/abstract_adapter'
+require_relative 'functions/active_record/migration/command_recorder'
+require_relative 'functions/middleware'
 
-# Load any mixins to ActiveRecord modules, such as:
-#
-#require_relative 'functions/active_record/base'
-
-# Load any middleware, such as:
-#
-# require_relative 'functions/middleware/model'
+module SchemaPlus::Functions
+  module ActiveRecord
+    module ConnectionAdapters
+      autoload :PostgresqlAdapter, 'schema_plus/functions/active_record/connection_adapters/postgresql_adapter'
+    end
+  end
+end
 
-SchemaMonkey.register SchemaPlus::Functions
+SchemaMonkey.register SchemaPlus::Functions

gemfiles/activerecord-4.2/Gemfile.postgresql gemfiles/activerecord-5.2/Gemfile.postgresql

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SchemaPlus::Functions
+  module ActiveRecord
+    module ConnectionAdapters
+      module AbstractAdapter
+        # Create a function.  Valid options are :force,
+        # :allow_replace, and :function_type
+        def create_function(function_name, params, definition, options = {})
+          SchemaMonkey::Middleware::Migration::CreateFunction.start(connection: self, function_name: function_name, params: params, definition: definition, options: options) do |env|
+            function_name = env.function_name
+            function_type = (options[:function_type] || :function).to_s.upcase
+            params        = env.params
+            definition    = env.definition
+            options       = env.options
+
+            definition    = definition.to_sql if definition.respond_to? :to_sql
+            if options[:force]
+              drop_function(function_name, params, function_type: options[:function_type], if_exists: true)
+            end
+
+            command = if options[:allow_replace]
+                        "CREATE OR REPLACE"
+                      else
+                        "CREATE"
+                      end
+            execute "#{command} #{function_type} #{function_name}(#{params}) #{definition}"
+          end
+        end
+
+        # Remove a function.  Valid options are :function_type,
+        # :if_exists, and :cascade
+        #
+        # If your function type is an aggregate, you must specify the type
+        #
+        #    drop_function 'my_func', 'int', if_exists: true, cascade: true
+        #    drop_function 'my_agg', 'int', function_type: :aggregate
+        def drop_function(function_name, params, options = {})
+          SchemaMonkey::Middleware::Migration::CreateFunction.start(connection: self, function_name: function_name, params: params, options: options) do |env|
+            function_name = env.function_name
+            params        = env.params
+            options       = env.options
+            function_type = (options[:function_type] || :function).to_s.upcase
+
+            sql = "DROP #{function_type}"
+            sql += " IF EXISTS" if options[:if_exists]
+            sql += " #{function_name}(#{params})"
+            sql += " CASCADE" if options[:cascade]
+
+            execute sql
+          end
+        end
+
+        #####################################################################
+        #
+        # The functions below here are abstract; each subclass should
+        # define them all. Defining them here only for reference.
+        #
+
+        # (abstract) Return the Function objects for functions
+        def functions(name = nil)
+          raise "Internal Error: Connection adapter did not override abstract function"
+        end
+
+        # (abstract) Return the Function definition for the named function and parameter set
+        def function_definition(function_name, params, name = nil)
+          raise "Internal Error: Connection adapter did not override abstract function"
+        end
+      end
+    end
+  end
+end

lib/schema_plus/functions.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SchemaPlus::Functions
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+        def drop_function(function_name, params, options = {})
+          clean_params = params.gsub(/ DEFAULT[^,]+/i, '')
+          super(function_name, clean_params, options)
+        end
+
+        def functions(name = nil) #:nodoc:
+          SchemaMonkey::Middleware::Schema::Functions.start(connection: self, query_name: name, functions: []) do |env|
+            sql = <<-SQL
+            SELECT P.proname as function_name, pg_get_function_identity_arguments(P.oid), proisagg as is_agg
+              FROM pg_proc P
+            WHERE
+                  pronamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false))) 
+              AND NOT EXISTS (SELECT 1 FROM pg_depend WHERE classid = 'pg_proc'::regclass 
+                    AND objid = p.oid AND deptype = 'i')
+              AND NOT EXISTS (SELECT 1 FROM pg_depend WHERE classid = 'pg_proc'::regclass
+                    AND objid = p.oid AND refclassid = 'pg_extension'::regclass AND deptype = 'e')
+            ORDER BY 1,2
+            SQL
+
+            env.functions += env.connection.query(sql, env.query_name).map do |row|
+              options                 = {}
+              options[:function_type] = :aggregate if row[2]
+              [row[0], row[1], options]
+            end
+          end.functions
+        end
+
+        def function_definition(function_name, params, name = nil) #:nodoc:
+          data = SchemaMonkey::Middleware::Schema::FunctionDefinition.start(connection: self, function_name: function_name, params: params, query_name: name) do |env|
+            result = env.connection.query(<<-SQL, env.query_name)
+            SELECT prosrc,
+                pg_get_function_arguments(p.oid),
+                pg_catalog.pg_get_function_result(p.oid) AS funcresult,
+                (SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname,
+                a.aggtransfn as transfn,
+                format_type(a.aggtranstype, null) as transtype
+              FROM pg_proc p
+              LEFT JOIN pg_aggregate a ON a.aggfnoid = p.oid
+            WHERE 
+                pronamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)))
+                AND proname = '#{quote_string(function_name)}'
+                AND pg_get_function_identity_arguments(P.oid) = '#{quote_string(params)}'
+            SQL
+
+            row = result.first
+
+            function_type = nil
+
+            unless row.nil?
+              sql               = if row[4].present? || row[0] == 'aggregate_dummy'
+                                    # it's an aggregate function
+                                    function_type = :aggregate
+                                    "(SFUNC=#{row[4]},STYPE=#{row[5]})"
+                                  else
+                                    "RETURNS #{row[2]} LANGUAGE #{row[3]} AS $$#{row[0]}$$"
+                                  end
+              env.params        = row[1]
+              env.definition    = sql
+              env.function_type = function_type
+            end
+          end
+
+          return data.params, data.definition, data.function_type
+        end
+      end
+    end
+  end
+end
+

lib/schema_plus/functions/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SchemaPlus::Functions
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+        def create_function(*args, &block)
+          record(:create_function, args, &block)
+        end
+
+        def drop_function(*args, &block)
+          record(:drop_function, args, &block)
+        end
+
+        def invert_create_function(args)
+          options                 = {}
+          options[:function_type] = args[3][:function_type] if args[3].has_key?(:function_type)
+          [:drop_function, [args.first, args.second, options]]
+        end
+      end
+    end
+  end
+end