associate_jsonb 0.0.2 → 0.0.8

data/lib/associate_jsonb/attribute_methods/read.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      def _fetch_attribute(attr_name, &block) # :nodoc
+        sync_with_transaction_state if @transaction_state&.finalized?
+        @attributes.fetch(attr_name.to_s, &block)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_creation.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module SchemaCreation
+      private
+        def visit_AlterTable(o)
+          sql = super
+          sql << o.constraint_adds.map {|ct| visit_AddConstraint ct }.join(" ")
+          sql << o.constraint_drops.map {|ct| visit_DropConstraint ct }.join(" ")
+          sql
+        end
+
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
+
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+          end
+
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            # statements.concat(o.constraints.map { |ct| visit_ConstraintDefinition(ct) })
+          end
+
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, table_options(o))
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
+        end
+
+        def visit_ConstraintDeferral(o)
+          return "" unless o.deferrable_default?
+          return "NOT DEFERRABLE" unless o.deferrable?
+          initial =
+            case o.deferrable
+            when :immediate
+              "IMMEDIATE"
+            else
+              "DEFERRED"
+            end
+          "DEFERRABLE INITIALLY #{initial}"
+        end
+
+        def visit_ConstraintDefinition(o)
+          +<<-SQL.squish
+            CONSTRAINT #{quote_column_name(o.name)}
+            CHECK (#{o.value})
+              #{visit_ConstraintDeferral(o)}
+              #{o.not_valid? ? "NOT VALID" : ''}
+          SQL
+        end
+
+        def visit_AddConstraint(o)
+          sql = +""
+          if o.force?
+            sql << visit_DropConstraint(o)
+            sql << " "
+          end
+          sql << "ADD #{accept(o)}"
+        end
+
+        def visit_DropConstraint(o, if_exists: false)
+          +<<-SQL.squish
+            DROP CONSTRAINT #{quote_column_name(o.name)}
+              #{o.force? ? "IF EXISTS" : ""}
+          SQL
+        end
+
+        def visit_AddJsonbForeignKeyFunction(*)
+          <<~SQL
+            CREATE OR REPLACE FUNCTION jsonb_foreign_key
+              (
+                table_name text,
+                foreign_key text,
+                store jsonb,
+                key text,
+                type text default 'numeric',
+                nullable boolean default TRUE
+              )
+            RETURNS BOOLEAN AS
+            $BODY$
+            DECLARE
+              does_exist BOOLEAN;
+            BEGIN
+              IF store->>key IS NULL
+              THEN
+                return nullable;
+              END IF;
+
+              IF store->>key = ''
+              THEN
+                return FALSE;
+              END IF;
+
+              EXECUTE FORMAT('SELECT EXISTS (SELECT 1 FROM %1$I WHERE %1$I.%2$I = CAST($1 AS ' || type || '))', table_name, foreign_key)
+              INTO does_exist
+              USING store->>key;
+
+              RETURN does_exist;
+            END;
+            $BODY$
+            LANGUAGE plpgsql;
+
+          SQL
+        end
+
+        def visit_AddJsonbNestedSetFunction(*)
+          <<~SQL
+            CREATE OR REPLACE FUNCTION jsonb_nested_set
+              (
+                target jsonb,
+                path text[],
+                new_value jsonb
+              )
+            RETURNS jsonb AS
+            $BODY$
+            DECLARE
+              new_json jsonb := '{}'::jsonb;
+              does_exist BOOLEAN;
+              current_path text[];
+              key text;
+            BEGIN
+              IF target #> path IS NOT NULL
+              THEN
+                return jsonb_set(target, path, new_value);
+              ELSE
+                new_json := target;
+
+                IF array_length(path, 1) > 1
+                THEN
+                  FOREACH key IN ARRAY path[:(array_length(path, 1) - 1)]
+                  LOOP
+                    current_path := array_append(current_path, key);
+                    IF new_json #> current_path IS NULL
+                    THEN
+                      new_json := jsonb_set(new_json, current_path, '{}'::jsonb, TRUE);
+                    END IF;
+                  END LOOP;
+                END IF;
+
+                return jsonb_set(new_json, path, new_value, TRUE);
+              END IF;
+            END;
+            $BODY$
+            LANGUAGE plpgsql;
+          SQL
+        end
+
+        def add_column_options!(sql, opts)
+          super
+
+          if opts[:constraint]
+            sql << " #{accept(ConstraintDefinition.new(**opts[:constraint]))}"
+          end
+
+          sql
+        end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/add_jsonb_foreign_key_function.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    class AddJsonbForeignKeyFunction
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/add_jsonb_nested_set_function.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    class AddJsonbNestedSetFunction
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/alter_table.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module AlterTable # :nodoc:
+      attr_reader :constraint_adds, :constraint_drops
+      def initialize(td)
+        super
+        @constraint_adds = []
+        @constraint_drops = []
+      end
+
+      def add_constraint(name = nil, **opts)
+        unless opts[:value].present?
+          raise ArgumentError.new("Invalid Add Constraint Options")
+        end
+
+        @constraint_adds << ConstraintDefinition.new(
+          **opts.reverse_merge(name: name)
+        )
+      end
+
+      def alter_constraint(name = nil, **opts)
+        opts[:force] = true
+        add_constraint(name, **opts)
+      end
+
+      def drop_constraint(name = nil, **opts)
+        opts = opts.reverse_merge(force: true, name: name, value: nil)
+
+        unless opts[:name].present? || opts[:value].present?
+          raise ArgumentError.new("Invalid Drop Constraint Options")
+        end
+
+        @constraint_drops << ConstraintDefinition.new(**opts)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/constraint_definition.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    class ConstraintDefinition
+      # rubocop:disable Metrics/ParameterLists
+      attr_reader :name, :value, :not_valid, :deferrable, :force
+      def initialize(value:, name: nil, not_valid: false, force: false, deferrable: true, **)
+        @name = name.presence
+        @value = value
+        @not_valid = not_valid
+        @deferrable = deferrable
+        @force = force
+
+        @name ||=
+          "rails_constraint_" \
+          "#{@value.hash}" \
+          "_#{not_valid ? "nv" : "v"}" \
+          "_#{deferrable ? "d" : "nd"}"
+      end
+
+      def deferrable_default?
+        deferrable.nil?
+      end
+
+
+      def name?
+        !!name
+      end
+
+      def value?
+        !!value
+      end
+
+      def not_valid?
+        !!not_valid
+      end
+
+      def deferrable?
+        !!deferrable
+      end
+
+      def force?
+        !!force
+      end
+
+      def to_h
+        {
+          name: name,
+          value: value,
+          not_valid: not_valid,
+          deferrable: deferrable,
+          force: force
+        }
+      end
+      alias :to_hash :to_h
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/reference_definition.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module ReferenceDefinition
+      ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        name,
+        store: false,
+        store_key: false,
+        **options
+      )
+        @store = store && store.to_sym
+        @store_key = store_key && store_key.to_s unless options[:polymorphic]
+        @nullable = options[:null] != false
+
+        super(name, **options)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def column_name
+        store_key || super
+      end
+
+      def add_to(table)
+        return super unless store
+
+        should_add_col = false
+        if table.respond_to? :column_exists?
+          should_add_col = !table.column_exists?(store)
+        elsif table.respond_to? :columns
+          should_add_col = table.columns.none? {|col| col.name.to_sym == store}
+        end
+
+        if should_add_col
+          opts = { null: false, default: {} }
+          table.column(store, :jsonb, **opts)
+        end
+
+        if foreign_key && column_names.length == 1
+          fk = ForeignKeyDefinition.new(table.name, foreign_table_name, foreign_key_options)
+          columns.each do |col_name, type, options|
+            options ||= {}
+            value = <<-SQL.squish
+              jsonb_foreign_key(
+                '#{fk.to_table}'::text,
+                '#{fk.primary_key}'::text,
+                #{store}::jsonb,
+                '#{col_name}'::text,
+                '#{type}'::text,
+                #{nullable}
+              )
+            SQL
+            table.constraint(
+              name: "#{table.name}_#{col_name}_foreign_key",
+              value: value,
+              not_valid: true,
+              deferrable: true
+            )
+          end
+        elsif !nullable
+          columns.each do |col_name, *|
+            value = <<-SQL.squish
+              #{store}->>'#{col_name}' IS NOT NULL
+              AND
+              #{store}->>'#{col_name}' <> ''
+            SQL
+            table.constraint(
+              name: "#{table.name}_#{col_name}_not_null",
+              value: value,
+              not_valid: false,
+              deferrable: true
+            )
+          end
+        end
+
+        return unless index
+
+        columns.each do |col_name, type, *|
+          type = :text if type == :string
+          table.index(
+            "CAST (\"#{store}\"->>'#{col_name}' AS #{type || :bigint})",
+            using: :btree,
+            name: "index_#{table.name}_on_#{store}_#{col_name}"
+          )
+
+          table.index(
+            "(\"#{store}\"->>'#{col_name}')",
+            using: :btree,
+            name: "index_#{table.name}_on_#{store}_#{col_name}_text"
+          )
+        end
+      end
+
+      protected
+
+      attr_reader :store, :store_key, :nullable
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/table.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module Table
+      def constraint(**opts)
+        @base.add_constraint(name, **opts)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/connection_adapters/schema_definitions/table_definition.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module TableDefinition
+      attr_reader :constraints
+
+      def initialize(*,**)
+        super
+        @constraints = []
+      end
+
+      def constraint(name = nil, **opts)
+        unless opts[:value].present?
+          raise ArgumentError.new("Invalid Drop Constraint Options")
+        end
+
+        @constraints << ConstraintDefinition.new(
+          **opts.reverse_merge(name: name)
+        )
+      end
+    end
+  end
+end