serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/rcte_tree.rb

@@ -0,0 +1,343 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # = Overview
+    #
+    # The rcte_tree plugin deals with tree structured data stored
+    # in the database using the adjacency list model (where child rows
+    # have a foreign key pointing to the parent rows), using recursive
+    # common table expressions to load all ancestors in a single query,
+    # all descendants in a single query, and all descendants to a given
+    # level (where level 1 is children, level 2 is children and grandchildren
+    # etc.) in a single query.
+    #
+    # = Usage
+    #
+    # The rcte_tree plugin adds four associations to the model: parent, children, ancestors, and
+    # descendants.  Both the parent and children are fairly standard many_to_one
+    # and one_to_many associations, respectively.  However, the ancestors and
+    # descendants associations are special.  Both the ancestors and descendants
+    # associations will automatically set the parent and children associations,
+    # respectively, for current object and all of the ancestor or descendant
+    # objects, whenever they are loaded (either eagerly or lazily).  Additionally,
+    # the descendants association can take a level argument when called eagerly,
+    # which limits the returned objects to only that many levels in the tree (see
+    # the Overview).
+    #
+    #   Model.plugin :rcte_tree
+    #   
+    #   # Lazy loading
+    #   model = Model.first
+    #   model.parent
+    #   model.children
+    #   model.ancestors # Populates :parent association for all ancestors
+    #   model.descendants # Populates :children association for all descendants
+    #   
+    #   # Eager loading - also populates the :parent and children associations
+    #   # for all ancestors and descendants
+    #   Model.where(id: [1, 2]).eager(:ancestors, :descendants).all
+    #   
+    #   # Eager loading children and grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 2).all
+    #   # Eager loading children, grandchildren, and great grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 3).all
+    #
+    # = Options
+    #
+    # You can override the options for any specific association by making
+    # sure the plugin options contain one of the following keys:
+    #
+    # :parent :: hash of options for the parent association
+    # :children :: hash of options for the children association
+    # :ancestors :: hash of options for the ancestors association
+    # :descendants :: hash of options for the descendants association
+    #
+    # Note that you can change the name of the above associations by specifying
+    # a :name key in the appropriate hash of options above.  For example:
+    #
+    #   Model.plugin :rcte_tree, parent: {name: :mother},
+    #    children: {name: :daughters}, descendants: {name: :offspring}
+    #
+    # Any other keys in the main options hash are treated as options shared by
+    # all of the associations.  Here's a few options that affect the plugin:
+    #
+    # :key :: The foreign key in the table that points to the primary key
+    #         of the parent (default: :parent_id)
+    # :primary_key :: The primary key to use (default: the model's primary key)
+    # :key_alias :: The symbol identifier to use for aliasing when eager
+    #               loading (default: :x_root_x)
+    # :cte_name :: The symbol identifier to use for the common table expression
+    #              (default: :t)
+    # :level_alias :: The symbol identifier to use when eagerly loading descendants
+    #                 up to a given level (default: :x_level_x)
+    # :union_all :: Whether to use UNION ALL or UNION with the recursive
+    #               common table expression (default: true)
+    module RcteTree
+      # Create the appropriate parent, children, ancestors, and descendants
+      # associations for the model.
+      def self.apply(model, opts=OPTS)
+        model.plugin :tree, opts
+
+        opts = opts.dup
+        opts[:class] = model
+        opts[:methods_module] = Sequel.set_temp_name(Module.new){"#{model.name}::_rcte_tree[:methods_module]"}
+        opts[:union_all] = opts[:union_all].nil? ? true : opts[:union_all]
+        model.send(:include, opts[:methods_module])
+        
+        key = opts[:key] ||= :parent_id
+        prkey = opts[:primary_key] ||= model.primary_key
+        ka = opts[:key_alias] ||= :x_root_x
+        t = opts[:cte_name] ||= :t
+        c_all = if model.dataset.recursive_cte_requires_column_aliases?
+          # Work around Oracle/ruby-oci8 bug that returns integers as BigDecimals in recursive queries.
+          conv_bd = model.db.database_type == :oracle
+          col_aliases = model.dataset.columns
+          model_table = model.table_name
+          col_aliases.map{|c| SQL::QualifiedIdentifier.new(model_table, c)}
+        else
+          [SQL::ColumnAll.new(model.table_name)]
+        end
+        
+        bd_conv = lambda{|v| conv_bd && v.is_a?(BigDecimal) ? v.to_i : v}
+
+        key_array = Array(key)
+        prkey_array = Array(prkey)
+        if key.is_a?(Array)
+          key_conv = lambda{|m| key_array.map{|k| m[k]}}
+          key_present = lambda{|m| key_conv[m].all?}
+          prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
+          key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
+          ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
+          descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
+          recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
+          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.remove_key!(ka_)]}}
+        else
+          key_present = key_conv = lambda{|m| m[key]}
+          prkey_conv = lambda{|m| m[prkey]}
+          key_aliases = [ka]
+          ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
+          descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
+          recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
+          extract_key_alias = lambda{|m| bd_conv[m.remove_key!(ka)]}
+        end
+        
+        parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, OPTS)).fetch(:name, :children)
+        
+        opts[:reciprocal] = nil
+        a = opts.merge(opts.fetch(:ancestors, OPTS))
+        ancestors = a.fetch(:name, :ancestors)
+        a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
+        a[:eager_loader_key] = key
+        a[:dataset] ||= proc do
+          base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
+          recursive_ds = model.join(t, key_array.zip(prkey_array))
+          if c = a[:conditions]
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
+            end
+          end
+          table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
+          model.from(SQL::AliasedExpression.new(t, table_alias)).
+           with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
+            recursive_ds.select(*c_all),
+            :args=>col_aliases, union_all: opts[:union_all])
+        end
+        aal = Array(a[:after_load])
+        aal << proc do |m, ancs|
+          unless m.associations.has_key?(parent)
+            parent_map = {prkey_conv[m]=>m}
+            child_map = {}
+            child_map[key_conv[m]] = m if key_present[m]
+            m.associations[parent] = nil
+            ancs.each do |obj|
+              obj.associations[parent] = nil
+              parent_map[prkey_conv[obj]] = obj
+              if ok = key_conv[obj]
+                child_map[ok] = obj
+              end
+            end
+            parent_map.each do |parent_id, obj|
+              if child = child_map[parent_id]
+                child.associations[parent] = obj
+              end
+            end
+          end
+        end
+        a[:after_load] ||= aal
+        a[:eager_loader] ||= proc do |eo|
+          id_map = eo[:id_map]
+          parent_map = {}
+          children_map = {}
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              (children_map[key_conv[obj]] ||= []) << obj
+              obj.associations[ancestors] = []
+              obj.associations[parent] = nil
+            end
+          end
+          r = model.association_reflection(ancestors)
+          base_case = model.where(prkey=>id_map.keys).
+           select(*ancestor_base_case_columns)
+          recursive_case = model.join(t, key_array.zip(prkey_array)).
+           select(*recursive_case_columns)
+          if c = r[:conditions]
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
+            end
+          end
+          table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
+          ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
+            with_recursive(t, base_case, recursive_case,
+             :args=>((key_aliases + col_aliases) if col_aliases), union_all: opts[:union_all])
+          ds = r.apply_eager_dataset_changes(ds)
+          ds = ds.select_append(ka) unless ds.opts[:select] == nil
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
+            opk = prkey_conv[obj]
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
+              obj = idm_obj
+            else
+              obj.associations[parent] = nil
+              parent_map[opk] = obj
+              (children_map[key_conv[obj]] ||= []) << obj
+            end
+            
+            id_map[extract_key_alias[obj]].each do |root|
+              root.associations[ancestors] << obj
+            end
+          end
+          Sequel.synchronize_with(eo[:mutex]) do
+            parent_map.each do |parent_id, obj|
+              if children = children_map[parent_id]
+                children.each do |child|
+                  child.associations[parent] = obj
+                end
+              end
+            end
+          end
+        end
+        model.one_to_many ancestors, a
+        
+        d = opts.merge(opts.fetch(:descendants, OPTS))
+        descendants = d.fetch(:name, :descendants)
+        d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
+        la = d[:level_alias] ||= :x_level_x
+        d[:dataset] ||= proc do
+          base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
+          recursive_ds = model.join(t, prkey_array.zip(key_array))
+          if c = d[:conditions]
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
+            end
+          end
+          table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
+          model.from(SQL::AliasedExpression.new(t, table_alias)).
+           with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
+            recursive_ds.select(*c_all),
+            :args=>col_aliases, union_all: opts[:union_all])
+          end
+        dal = Array(d[:after_load])
+        dal << proc do |m, descs|
+          unless m.associations.has_key?(childrena)
+            parent_map = {prkey_conv[m]=>m}
+            children_map = {}
+            m.associations[childrena] = []
+            descs.each do |obj|
+              obj.associations[childrena] = []
+              if opk = prkey_conv[obj]
+                parent_map[opk] = obj
+              end
+              if ok = key_conv[obj]
+                (children_map[ok] ||= []) << obj
+              end
+            end
+            children_map.each do |parent_id, objs|
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
+            end
+          end
+        end
+        d[:after_load] = dal
+        d[:eager_loader] ||= proc do |eo|
+          id_map = eo[:id_map]
+          associations = eo[:associations]
+          parent_map = {}
+          children_map = {}
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              obj.associations[descendants] = []
+              obj.associations[childrena] = []
+            end
+          end
+          r = model.association_reflection(descendants)
+          base_case = model.where(key=>id_map.keys).
+           select(*descendant_base_case_columns)
+          recursive_case = model.join(t, prkey_array.zip(key_array)).
+           select(*recursive_case_columns)
+          if c = r[:conditions]
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
+            end
+          end
+          if associations.is_a?(Integer)
+            level = associations
+            no_cache_level = level - 1
+            associations = {}
+            base_case = base_case.select_append(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
+            recursive_case = recursive_case.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).where(SQL::QualifiedIdentifier.new(t, la) < level - 1)
+          end
+          table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
+          ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
+            with_recursive(t, base_case, recursive_case,
+              :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases), union_all: opts[:union_all])
+          ds = r.apply_eager_dataset_changes(ds)
+          ds = ds.select_append(ka) unless ds.opts[:select] == nil
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
+            if level
+              no_cache = no_cache_level == obj.remove_key!(la)
+            end
+            
+            opk = prkey_conv[obj]
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
+              obj = idm_obj
+            else
+              obj.associations[childrena] = [] unless no_cache
+              parent_map[opk] = obj
+            end
+            
+            if root = id_map[extract_key_alias[obj]].first
+              root.associations[descendants] << obj
+            end
+            
+            (children_map[key_conv[obj]] ||= []) << obj
+          end
+          Sequel.synchronize_with(eo[:mutex]) do
+            children_map.each do |parent_id, objs|
+              objs = objs.uniq
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
+            end
+          end
+        end
+        model.one_to_many descendants, d
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/require_valid_schema.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The require_valid_schema plugin makes Sequel raise or warn if attempting
+    # to set the dataset of a model class to a simple table, where the database
+    # supports schema parsing, but schema parsing does not work for the model's
+    # table.
+    #
+    # The plugin's default behavior requires that all models that select from a
+    # single identifier have a valid table schema, if the database supports
+    # schema parsing. If the schema cannot be determined for such
+    # a model, an error is raised:
+    #   
+    #   Sequel::Model.plugin :require_valid_schema
+    #
+    # If you load the plugin with an argument of :warn, Sequel will warn instead
+    # of raising for such tables:
+    #
+    #   Sequel::Model.plugin :require_valid_schema, :warn
+    #
+    # This can catch bugs where you expect models to have valid schema, but
+    # they do not. This setting only affects future attempts to set datasets
+    # in the current class and subclasses created in the future.
+    #
+    # If you load the plugin with an argument of false, it will not require valid schema.
+    # This can be used in subclasses where you do not want to require valid schema,
+    # but the plugin must be loaded before a dataset with invalid schema is set:
+    #
+    #   Sequel::Model.plugin :require_valid_schema
+    #   InvalidSchemaAllowed = Class.new(Sequel::Model)
+    #   InvalidSchemaAllowed.plugin :require_valid_schema, false
+    #   class MyModel < InvalidSchemaAllowed
+    #   end
+    module RequireValidSchema
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model, setting=true)
+        model.instance_variable_set(:@require_valid_schema, setting)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@require_valid_schema=>nil)
+
+        private
+
+        # If the schema cannot be determined, the model uses a simple table,
+        # require_valid_schema is set, and the database supports schema parsing, raise or
+        # warn based on the require_valid_schema setting.
+        def get_db_schema_array(reload)
+          schema_array = super
+
+          if !schema_array && simple_table && @require_valid_schema
+            message = "Not able to parse schema for model: #{inspect}, table: #{simple_table}"
+            if @require_valid_schema == :warn
+              warn message
+            else
+              raise Error, message
+            end
+          end
+
+          schema_array
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/serialization.rb

@@ -0,0 +1,242 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The serialization plugin allows you to keep serialized
+    # ruby objects in the database, while giving you deserialized objects
+    # when you call an accessor.
+    #
+    # This plugin works by keeping the serialized value in the values, and
+    # adding a deserialized_values hash.  The reader method for serialized columns
+    # will check the deserialized_values for the value, return it if present,
+    # or deserialize the entry in values and return it.  The writer method will
+    # set the deserialized_values entry.  This plugin adds a before_validation hook
+    # that serializes all deserialized_values to values.
+    #
+    # You can specify the serialization format as a pair of serializer/deserializer
+    # callable objects.  You can also specify the serialization format as a single
+    # symbol, if such a symbol has a registered serializer/deserializer pair in the
+    # plugin.  By default, the plugin registers the :marshal, :yaml, and :json
+    # serialization formats.  To register your own serialization formats, use
+    # Sequel::Plugins::Serialization.register_format.
+    # If you use yaml or json format, you need to require the libraries, Sequel
+    # does not do the requiring for you.
+    #
+    # You can specify the columns to serialize when loading the plugin, or later
+    # using the serialize_attributes class method.
+    #
+    # Because of how this plugin works, it must be used inside each model class
+    # that needs serialization, after any set_dataset method calls in that class.
+    # Otherwise, it is possible that the default column accessors will take
+    # precedence.
+    #
+    # == Example
+    #
+    #   # Require json if you plan to use it, as the plugin doesn't require it for you.
+    #   require 'json'
+    #
+    #   # Register custom serializer/deserializer pair, if desired
+    #   require 'sequel/plugins/serialization'
+    #   require 'base64'
+    #   Sequel::Plugins::Serialization.register_format(:base64, Base64.method(:encode64), Base64.method(:decode64))
+    #
+    #   class User < Sequel::Model
+    #     # Built-in format support when loading the plugin
+    #     plugin :serialization, :json, :permissions
+    #
+    #     # Built-in format support after loading the plugin using serialize_attributes
+    #     plugin :serialization
+    #     serialize_attributes :marshal, :permissions
+    #
+    #     # Use custom registered serialization format just like built-in format
+    #     serialize_attributes :base64, :password
+    #
+    #     # Use a custom serializer/deserializer pair without registering
+    #     serialize_attributes [ Base64.method(:encode64), Base64.method(:decode64)], :password
+    #   end
+    #   user = User.create
+    #   user.permissions = {global: 'read-only'}
+    #   user.save
+    #
+    # Note that if you mutate serialized column values without reassigning them,
+    # those changes won't be picked up by <tt>Model#save_changes</tt> or
+    # <tt>Model#update</tt>.  Example:
+    #
+    #   user = User[1]
+    #   user.permissions[:global] = 'foo'
+    #   user.save_changes # Will not pick up changes to permissions
+    #
+    # You can use the +serialization_modification_detection+ plugin to pick
+    # up such changes.
+    module Serialization
+      # The default serializers supported by the serialization module.
+      # Use register_format to add serializers to this hash.
+      REGISTERED_FORMATS = {}
+
+      # Set up the column readers to do deserialization and the column writers
+      # to save the value in deserialized_values.
+      def self.apply(model, *args)
+        model.instance_exec do
+          @deserialization_map = {}
+          @serialization_map = {}
+        end
+      end
+      
+      # Automatically call serialize_attributes with the format and columns unless
+      # no columns were provided.
+      def self.configure(model, format=nil, *columns)
+        model.serialize_attributes(format, *columns) unless columns.empty?
+      end
+
+      # Register a serializer/deserializer pair with a format symbol, to allow
+      # models to pick this format by name.  Both serializer and deserializer
+      # should be callable objects.
+      def self.register_format(format, serializer, deserializer)
+        Sequel.synchronize{REGISTERED_FORMATS[format] = [serializer, deserializer].freeze}
+      end
+      register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
+        lambda do |v|
+          # Handle unpacked marshalled data for backwards compat
+          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          Marshal.load(v)
+        end)
+      register_format(:yaml, :to_yaml.to_proc, lambda{|s| YAML.load(s)})
+      register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
+
+      module ClassMethods
+        # A hash with column name symbols and callable values, with the value
+        # called to deserialize the column.
+        attr_reader :deserialization_map
+
+        # A hash with column name symbols and callable values, with the value
+        # called to serialize the column.
+        attr_reader :serialization_map
+
+        Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
+
+        # Freeze serialization metadata when freezing model class.
+        def freeze
+          @deserialization_map.freeze
+          @serialization_map.freeze
+          @serialization_module.freeze if @serialization_module
+
+          super
+        end
+        
+        # Create instance level reader that deserializes column values on request,
+        # and instance level writer that stores new deserialized values. If +format+
+        # is a symbol, it should correspond to a previously-registered format using +register_format+.
+        # Otherwise, +format+ is expected to be a 2-element array of callables,
+        # with the first element being the serializer, used to convert the value used by the application
+        # to the value that will be stored in the database, and the second element being the deserializer,
+        # used to convert the value stored the database to the value used by the application.
+        def serialize_attributes(format, *columns)
+          if format.is_a?(Symbol)
+            unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.inspect})")
+            end
+          end
+          serializer, deserializer = format
+          raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
+          define_serialized_attribute_accessor(serializer, deserializer, *columns)
+        end
+        
+        private
+
+        # Add serializated attribute acessor methods to the serialization_module
+        def define_serialized_attribute_accessor(serializer, deserializer, *columns)
+          m = self
+          include(@serialization_module ||= Sequel.set_temp_name(Module.new){"#{name}::@serialization_module"}) unless @serialization_module
+          @serialization_module.class_eval do
+            columns.each do |column|
+              m.serialization_map[column] = serializer
+              m.deserialization_map[column] = deserializer
+              define_method(column) do 
+                if deserialized_values.has_key?(column)
+                  deserialized_values[column]
+                elsif frozen?
+                  deserialize_value(column, super())
+                else
+                  deserialized_values[column] = deserialize_value(column, super())
+                end
+              end
+              alias_method(column, column)
+
+              setter = :"#{column}="
+              define_method(setter) do |v| 
+                cc = changed_columns
+                if !cc.include?(column) && (new? || get_column_value(column) != v)
+                  cc << column
+
+                  will_change_column(column) if respond_to?(:will_change_column)
+                end
+
+                deserialized_values[column] = v
+              end
+              alias_method(setter, setter)
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Hash of deserialized values, used as a cache.
+        def deserialized_values
+          @deserialized_values ||= {}
+        end
+
+        # Freeze the deserialized values
+        def freeze
+          deserialized_values
+          super
+          deserialized_values.freeze
+          self
+        end
+
+        # Serialize deserialized values before saving
+        def before_validation
+          serialize_deserialized_values
+          super
+        end
+        
+        private
+
+        # Clear any cached deserialized values when doing a manual refresh.
+        def _refresh_set_values(hash)
+          @deserialized_values.clear if @deserialized_values
+          super
+        end
+
+        # Deserialize the column value.  Called when the model column accessor is called to
+        # return a deserialized value.
+        def deserialize_value(column, v)
+          unless v.nil?
+            raise Sequel::Error, "no entry in deserialization_map for #{column.inspect}" unless callable = model.deserialization_map[column]
+            callable.call(v)
+          end
+        end
+
+        # Dup the deserialized values when duping model instance.
+        def initialize_copy(other)
+          super
+          @deserialized_values = Hash[other.deserialized_values]
+          self
+        end
+
+        # Serialize all deserialized values
+        def serialize_deserialized_values
+          deserialized_values.each{|k,v| @values[k] = serialize_value(k, v)}
+        end
+
+        # Serialize the column value.  Called before saving to ensure the serialized value
+        # is saved in the database.
+        def serialize_value(column, v)
+          unless v.nil?
+            raise Sequel::Error, "no entry in serialization_map for #{column.inspect}" unless callable = model.serialization_map[column]
+            callable.call(v)
+          end
+        end
+      end
+    end
+  end
+end