associate_jsonb 0.0.1 → 0.0.7

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,88 @@
+# 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
+        end
+
+        return unless index
+
+        columns.each do |col_name, type, opts|
+          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

data/lib/associate_jsonb/connection_adapters/schema_statements.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ConnectionAdapters
+    module SchemaStatements
+      def add_jsonb_nested_set_function
+        execute schema_creation.accept(AddJsonbNestedSetFunction.new)
+      end
+
+      def add_jsonb_foreign_key_function
+        execute schema_creation.accept(AddJsonbForeignKeyFunction.new)
+      end
+
+      def create_table(table_name, **options)
+        td = create_table_definition(table_name, **options)
+
+        if options[:id] != false && !options[:as]
+          pk = options.fetch(:primary_key) do
+            ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+          end
+
+          if pk.is_a?(Array)
+            td.primary_keys pk
+          else
+            td.primary_key pk, options.fetch(:id, :primary_key), **options.except(:comment)
+          end
+        end
+
+        yield td if block_given?
+
+        if options[:force]
+          drop_table(table_name, **options, if_exists: true)
+        end
+
+        result = execute schema_creation.accept td
+
+        td.indexes.each do |column_name, index_options|
+          add_index(table_name, column_name, index_options)
+        end
+
+        td.constraints.each do |ct|
+          add_constraint(table_name, **ct)
+        end
+
+        if table_comment = options[:comment].presence
+          change_table_comment(table_name, table_comment)
+        end
+
+        td.columns.each do |column|
+          change_column_comment(table_name, column.name, column.comment) if column.comment.present?
+        end
+
+        result
+      end
+
+      def add_constraint(table_name, **options)
+        at = create_alter_table table_name
+        at.add_constraint(**options)
+        execute schema_creation.accept at
+      end
+
+      def constraints(table_name) # :nodoc:
+        scope = quoted_scope(table_name)
+
+        result = query(<<~SQL, "SCHEMA")
+          SELECT
+            con.oid,
+            con.conname,
+            con.connamespace,
+            con.contype,
+            con.condeferrable,
+            con.condeferred,
+            con.convalidated,
+            pg_get_constraintdef(con.oid) as consrc
+          FROM pg_catalog.pg_constraint con
+          INNER JOIN pg_catalog.pg_class rel
+                     ON rel.oid = con.conrelid
+          INNER JOIN pg_catalog.pg_namespace nsp
+                     ON nsp.oid = connamespace
+          WHERE nsp.nspname = #{scope[:schema]}
+          AND rel.relname = #{scope[:name]}
+          ORDER BY rel.relname
+        SQL
+
+        result.map do |row|
+          {
+            oid: row[0],
+            name: row[1],
+            deferrable: row[4],
+            deferred: row[5],
+            validated: row[6],
+            definition: row[7],
+            type:
+              case row[3].to_s.downcase
+              when "c"
+                "CHECK"
+              when "f"
+                "FOREIGN KEY"
+              when "p"
+                "PRIMARY KEY"
+              when "u"
+                "UNIQUE"
+              when "t"
+                "TRIGGER"
+              when "x"
+                "EXCLUDE"
+              else
+                "UNKNOWN"
+              end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/persistence.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module Persistence
+    private
+      def _update_row(attribute_names, attempted_action = "update")
+        self.class._update_record(
+          attributes_with_info(attribute_names),
+          @primary_key => id_in_database
+        )
+      end
+  end
+end

data/lib/associate_jsonb/predicate_builder.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module PredicateBuilder # :nodoc:
+    def build_bind_attribute(column_name, value)
+      if value.respond_to?(:value_before_type_cast)
+        attr = ActiveRecord::Relation::QueryAttribute.new(column_name.to_s, value.value_before_type_cast, table.type(column_name), value)
+      else
+        attr = ActiveRecord::Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+      end
+      Arel::Nodes::BindParam.new(attr)
+    end
+  end
+end

data/lib/associate_jsonb/reflection.rb

@@ -60,7 +60,7 @@ module AssociateJsonb
           Arel::Nodes::NamedFunction.new(
             "CAST",
             [
-              Arel::Nodes::Jsonb::DashArrow.
+              Arel::Nodes::Jsonb::DashDoubleArrow.
                 new(table, table[foreign_store_attr], foreign_store_key || key).
                 as(foreign_klass.columns_hash[foreign_key.to_s].sql_type)
             ]
@@ -83,7 +83,7 @@ module AssociateJsonb
           Arel::Nodes::NamedFunction.new(
             "CAST",
             [
-              Arel::Nodes::Jsonb::DashArrow.
+              Arel::Nodes::Jsonb::DashDoubleArrow.
                 new(foreign_table, foreign_table[jsonb_store_attr], jsonb_store_key || foreign_key).
                 as(klass.columns_hash[key.to_s].sql_type)
             ]

data/lib/associate_jsonb/relation/where_clause.rb

@@ -1,3 +1,6 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
 module AssociateJsonb
   module Relation
     module WhereClause
@@ -15,6 +18,22 @@ module AssociateJsonb
           [name, value]
         }.to_h
       end
+
+      private
+        def equalities(predicates)
+          equalities = []
+
+          predicates.each do |node|
+            case node
+            when Arel::Nodes::Equality, Arel::Nodes::SqlCastedEquality
+              equalities << node
+            when Arel::Nodes::And
+              equalities.concat equalities(node.children)
+            end
+          end
+
+          equalities
+        end
     end
   end
 end