associate_jsonb 0.0.1 → 0.0.7

data/lib/associate_jsonb/arel_extensions/visitors/visitor.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelExtensions
+    module Visitors
+      module Visitor
+        def dispatch_cache
+          @dispatch_cache ||= Hash.new do |hash, klass|
+            hash[klass] =
+              "visit_#{(klass.name || '').
+                sub("AssociateJsonb::ArelNodes::SqlCasted", "Arel::Nodes::").
+                gsub('::', '_')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/jsonb/attribute.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    module Jsonb
+      class Attribute
+        attr_reader :relation, :name, :delegated
+
+        def initialize(relation, name, delegated)
+          @relation = relation,
+          @name = name
+          @delegated = delegated
+        end
+
+        def lower
+          relation.lower self
+        end
+
+        def type_cast_for_database(value)
+          relation.type_cast_for_database(name, value)
+        end
+
+        def able_to_type_cast?
+          relation.able_to_type_cast?
+        end
+
+        def respond_to_missing?(mthd, include_private = false)
+          delegated.respond_to?(mthd, include_private)
+        end
+
+        def method_missing(mthd, *args, **opts, &block)
+          delegated.public_send(mthd, *args, **opts, &block)
+        end
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/sql_casted_binary.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module ArelNodes
+    class SqlCastedBinary < ::Arel::Nodes::Binary
+      attr_reader :original_left
+      def initialize(left, cast_as, right)
+        @original_left = left
+        super(
+          ::Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [ left.as(cast_as) ]
+          ),
+          right
+        )
+      end
+    end
+  end
+end

data/lib/associate_jsonb/arel_nodes/sql_casted_equality.rb

@@ -1,20 +1,34 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+# module AssociateJsonb
+#   module ArelNodes
+#     class SqlCastedEquality < ::Arel::Nodes::Equality
+#       attr_reader :original_left
+#       def initialize(left, cast_as, right)
+#         @original_left = left
+#         super(
+#           ::Arel::Nodes::NamedFunction.new(
+#             "CAST",
+#             [ left.as(cast_as) ]
+#           ),
+#           right
+#         )
+#       end
+#     end
+#   end
+# end
+
+
+# encoding: utf-8
+# frozen_string_literal: true
+
 module AssociateJsonb
   module ArelNodes
-    class SqlCastedEquality < ::Arel::Nodes::Equality
-      attr_reader :original_left
-      def initialize(left, cast_as, right)
-        @original_left = left
-        super(
-          ::Arel::Nodes::NamedFunction.new(
-            "CAST",
-            [ left.as(cast_as) ]
-          ),
-          right
-        )
-      end
+    class SqlCastedEquality < AssociateJsonb::ArelNodes::SqlCastedBinary
+      def operator; :== end
+      alias :operand1 :left
+      alias :operand2 :right
     end
   end
 end

data/lib/associate_jsonb/associations/alias_tracker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+
+module AssociateJsonb
+  module Associations
+    module AliasTracker # :nodoc:
+      def aliased_table_for(table_name, aliased_name, type_caster, store_tracker = nil)
+        super(table_name, aliased_name, type_caster).with_store_tracker(store_tracker)
+      end
+    end
+  end
+end

data/lib/associate_jsonb/associations/association_scope.rb

@@ -4,6 +4,22 @@
 module AssociateJsonb
   module Associations
     module AssociationScope #:nodoc:
+
+      def get_chain(reflection, association, tracker)
+        name = reflection.name
+        chain = [ActiveRecord::Reflection::RuntimeReflection.new(reflection, association)]
+        reflection.chain.drop(1).each do |refl|
+          aliased_table = tracker.aliased_table_for(
+            refl.table_name,
+            refl.alias_candidate(name),
+            refl.klass.type_caster,
+            refl.klass.store_column_attribute_tracker
+          )
+          chain << ActiveRecord::Associations::AssociationScope::ReflectionProxy.new(refl, aliased_table)
+        end
+        chain
+      end
+
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def last_chain_scope(scope, owner_reflection, owner)
         reflection = owner_reflection.instance_variable_get(:@reflection)
@@ -28,40 +44,21 @@ module AssociateJsonb
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def apply_jsonb_equality(scope, table, jsonb_column, store_key, foreign_key, value, foreign_klass)
-        sql_type = type = node_klass = nil
+        sql_type = type = nil
         begin
           type = foreign_klass.attribute_types[foreign_key.to_s]
           raise "type not found" unless type.present?
           sql_type = foreign_klass.columns_hash[foreign_key.to_s]
           raise "not a column" unless sql_type.present?
           sql_type = sql_type.sql_type
-          node_klass = Arel::Nodes::Jsonb::DashArrow
         rescue
           type = ActiveModel::Type::String.new
           sql_type = "text"
-          node_klass = Arel::Nodes::Jsonb::DashDoubleArrow
         end
 
-        # scope.where!(
-        #   Arel::Nodes::HashableNamedFunction.new(
-        #     "CAST",
-        #     [
-        #       node_klass.
-        #         new(table, table[jsonb_column], store_key).
-        #         as(sql_type)
-        #     ]
-        #   ).eq(
-        #     Arel::Nodes::BindParam.new(
-        #       ActiveRecord::Relation::QueryAttribute.new(
-        #         store_key, value, type
-        #       )
-        #     )
-        #   )
-        # )
-
         scope.where!(
           Arel::Nodes::SqlCastedEquality.new(
-            node_klass.new(table, table[jsonb_column], store_key),
+            Arel::Nodes::Jsonb::DashDoubleArrow.new(table, table[jsonb_column], store_key),
             sql_type,
             Arel::Nodes::BindParam.new(
               ActiveRecord::Relation::QueryAttribute.new(
@@ -70,30 +67,6 @@ module AssociateJsonb
             )
           )
         )
-
-        # scope.where!(
-        #   Arel::Nodes::Jsonb::DashDoubleArrow.
-        #     new(table, table[jsonb_column], store_key).
-        #     eq(
-        #       Arel::Nodes::BindParam.new(
-        #         ActiveRecord::Relation::QueryAttribute.new(
-        #           store_key, value, ActiveModel::Type::String.new
-        #         )
-        #       )
-        #     )
-        # )
-
-        # scope.where!(
-        #   node_klass.new(
-        #     table, table[jsonb_column], store_key
-        #   ).eq(
-        #     Arel::Nodes::BindParam.new(
-        #       ActiveRecord::Relation::QueryAttribute.new(
-        #         store_key, value, type
-        #       )
-        #     )
-        #   )
-        # )
       end
     end
   end

data/lib/associate_jsonb/associations/belongs_to_association.rb

@@ -4,14 +4,14 @@
 module AssociateJsonb
   module Associations
     module BelongsToAssociation #:nodoc:
-      def replace_keys(record)
-        return super unless reflection.options.key?(:store)
-
-        owner[reflection.foreign_key] =
-          record._read_attribute(
-            reflection.association_primary_key(record.class)
-          )
-      end
+      # def replace_keys(record)
+      #   return super unless reflection.options.key?(:store)
+      #
+      #   owner[reflection.foreign_key] =
+      #     record._read_attribute(
+      #       reflection.association_primary_key(record.class)
+      #     )
+      # end
     end
   end
 end

data/lib/associate_jsonb/associations/builder/belongs_to.rb

@@ -22,7 +22,7 @@ module AssociateJsonb
           key = (reflection.jsonb_store_key || foreign_key).to_s
           store = reflection.jsonb_store_attr
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
             if attribute_names.include?(foreign_key)
               raise AssociateJsonb::Associations::
                       ConflictingAssociation,
@@ -33,6 +33,7 @@ module AssociateJsonb
 
           opts = {}
           foreign_type = :integer
+          sql_type = "numeric"
           begin
             primary_key = reflection.active_record_primary_key.to_s
             primary_column = reflection.klass.columns.find {|col| col.name == primary_key }
@@ -40,6 +41,7 @@ module AssociateJsonb
             if primary_column
               foreign_type = primary_column.type
               sql_data = primary_column.sql_type_metadata.as_json
+              sql_type = sql_data["sql_type"]
               %i[ limit precision scale ].each do |k|
                 opts[k] = sql_data[k.to_s] if sql_data[k.to_s]
               end
@@ -49,8 +51,8 @@ module AssociateJsonb
             foreign_type = :integer
           end
 
-          mixin.instance_eval <<-CODE, __FILE__, __LINE__ + 1
-            store_column_attribute(:#{store}, :#{foreign_key}, :#{foreign_type}, key: "#{key}", **opts)
+          mixin.instance_eval <<~CODE, __FILE__, __LINE__ + 1
+            store_column_attribute(:#{store}, :#{foreign_key}, foreign_type, sql_type: sql_type, key: "#{key}", **opts)
           CODE
         end
       end

data/lib/associate_jsonb/associations/join_dependency.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
+
+module AssociateJsonb
+  module Associations
+    module JoinDependency # :nodoc:
+      private
+        def table_aliases_for(parent, node)
+          node.reflection.chain.map { |reflection|
+            alias_tracker.aliased_table_for(
+              reflection.table_name,
+              table_alias_for(reflection, parent, reflection != node.reflection),
+              reflection.klass.type_caster,
+              reflection.klass.store_column_attribute_tracker
+            )
+          }
+        end
+    end
+  end
+end

data/lib/associate_jsonb/attribute_methods.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module AssociateJsonb
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include Read
+    end
+
+    private
+      def attributes_with_info(attribute_names)
+        attribute_names.each_with_object({}) do |name, attrs|
+          attrs[name] = _fetch_attribute(name)
+        end
+      end
+  end
+end

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,162 @@
+# 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;
+
+              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