active_record_sql_exporter 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3010d854876fc641281a9a5a18e061fbadf581f4
+  data.tar.gz: 9ce358b90dcc53660bbf44d619f1805be0672bde
+SHA512:
+  metadata.gz: 9047c67b2d656acc37b0df892f513bb4b81e0fc4b0608ea180314474ea0dbcf8a97466ddce19284aeb68c0d494caeaa14b74e90370c3618f117fd0cc708bc9ba
+  data.tar.gz: d1c85cf635ebedb84ad2a1de7d59a0994888cbc7cfc5ca90dd70fe6393c7d13f9cc334932569c83242f480ea1c28dc500cc5f44ee5fb2dcb854f466a788062b5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,42 @@
+ActiveRecordSqlExporter
+=======================
+
+This plugin takes a record in your database and converts it into SQL statements
+that can be used to insert it.
+
+This was written after I had to restore some specific data for a user (a number
+of rows, across a number of tables.)
+
+It might be useful as a simple backup utility - for example, store the restoration
+sql after something gets removed.
+
+This moves down through relations along has_many, has_one relations, but will
+not move up along belongs_to relations.
+
+However, this doesn't make you any less likely to screw up and shoot yourself 
+in the proverbial memory usage foot with a massive swath of data, so often
+you'll want to use the second argument to to_sql, which is an array of classes
+to ignore.
+
+
+
+Example
+=======
+
+Obj.find( obj_id ).to_sql
+
+For a blog_post, that belongs to a user, that might have many posts:
+Post.find( id ).to_sql( {}, [User] )
+
+Export an object to a file:
+Post.find( id ).to_sql( {:file => a_file_object} )
+
+Copyright (c) 2010 Adam Palmblad (adam.palmblad@teampages.com), released under the MIT license
+
+
+To Do
+=====
+* Watch dependent => nullify and write restoration query
+* The generation the SQL that checks for the presence of a value is broken!
+* Add ability to toggle sql options, such as the ON DUPLICATE KEY stuff
+* Support for non MySQL databases

data/lib/active_record/sql_exporter.rb

@@ -0,0 +1,238 @@
+# encoding: UTF-8
+module ActiveRecord::SqlExporter
+  class NestedException < ArgumentError
+    attr_accessor :old_exception, :klass
+    def initialize( old_exception, klass, key )
+      @old_exception = old_exception
+      @klass = klass
+      @key = key
+    end
+
+    # --------------------------------------------------------------------- to_s
+    def to_s
+      "Unexpected error on #{@klass}.#{@key} / #{@old_exception.to_s}"
+    end
+  end
+  # ------------------------------------------------------------------ included?
+  def included?( klass )
+    klass.include( InstanceMethods )
+    klass.extend( ClassMethods )
+  end
+  ##############################################################################
+  # FileWriter
+  ##############################################################################
+  class FileWriter
+    # --------------------------------------------------------------- initialize
+    def initialize( file )
+      @file = file
+    end
+    # ------------------------------------------------------------------------ +
+    def +( s )
+      @file.write( s )
+      return self
+    end
+  end
+
+  module ClassMethods
+    # ---------------------------------------------------------- build_check_sql
+    def build_check_sql( id )
+      "IF( NOT EXISTS( SELECT * FROM #{quoted_table_name} WHERE #{connection.quote_column_name(primary_key)} = #{quote_value(id)} ) THEN ROLLBACK; END IF;\n"
+    end
+  end
+
+  module InstanceMethods
+    CREATION_NODE = 1
+    EXISTENCE_CHECK_NODE = 2
+    UPDATE_NODE = 3
+    # --------------------- pretend_to_sql( args = {}, classes_to_ignore = [] ) 
+    def print_relation_tree( args = {}, classes_to_ignore = [] ) 
+      tree = {}
+      _print_relation( tree, classes_to_ignore )
+      return if classes_to_ignore.include?( self.class )
+    end
+    # ------------------------------------------------------------------- to_sql
+    def to_backup_sql( args = {}, classes_to_ignore = [] )
+      tree = {}
+      build_export_tree( tree, classes_to_ignore )
+      sql = args[:file] ? ActiveRecord::SqlExporter::FileWriter.new( args[:file] ) : ''
+      unless args[:no_transaction]
+        sql += "BEGIN;"
+      end
+      tree.keys.each do |klass|
+        tree[klass].keys.each do |id|
+          node = tree[klass][id]
+          begin
+            if node[:type] == EXISTENCE_CHECK_NODE
+              sql += klass.constantize.build_check_sql( id )
+            elsif node[:type] == CREATION_NODE
+              object = klass.constantize.find( id )
+              sql += object.sql_restore_string
+            elsif node[:type] == UPDATE_NODE
+              object = klass.constantize.find( id )
+              sql += object.update_sql_string( node[:key] )
+            end
+          rescue Encoding::UndefinedConversionError
+            raise "Error with encoding of #{object.inspect}"
+          end
+        end
+      end
+      sql += "COMMIT;" unless args[:no_transaction]
+      return sql
+    end
+################################################################################
+    protected
+################################################################################
+    # -------------------------------------------------------- update_sql_string
+    def update_sql_string( key_name )
+      data = []
+      self.class.columns.map do |x|
+        next if x.primary
+        data << "#{connection.quote_column_name( x.name )}=#{connection.quote( read_attribute(x.name))}"
+      end
+      "UPDATE #{self.class.quoted_table_name} SET #{data.join(',')} WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)};\n"
+    end
+    # ------------------------------------------------------- sql_restore_string
+    def sql_restore_string( args = {} )
+      columns = self.class.columns.map do |x|
+        connection.quote_column_name( x.name )
+      end
+      values = self.class.columns.map do |x|
+        connection.quote( read_attribute( x.name ) )
+      end
+
+      sql = "\nINSERT INTO #{self.class.quoted_table_name} (#{columns.join(',')}) VALUES (#{values.join(',')})"
+      unless args[:no_update]
+        pairs = []
+        columns.each_with_index do |c,i|
+          pairs << "#{c}=#{values[i]}"
+        end
+        sql += " ON DUPLICATE KEY UPDATE #{pairs.join(',')}"
+      end
+      sql += ";\n"
+      return sql
+    end
+    # -------------------------------------------------------- build_export_tree
+    def build_export_tree( tree = {}, classes_to_ignore = [] )
+      return if classes_to_ignore.include?( self.class )
+      if tree[self.class.name].nil? || ( tree[self.class.name] && ( tree[self.class.name][id].nil? || tree[self.class.name][id][:type] == EXISTENCE_CHECK_NODE ) )
+        self.add_to_tree( tree, CREATION_NODE )
+        expand_tree_with_relations( tree, self.class.reflections, classes_to_ignore )
+      end
+      return tree
+    end
+    # ------------------------------------------------------------- add_to_tree 
+    def add_to_tree( tree, type, options = {} )
+      tree[self.class.name] ||= {}
+      node = tree[self.class.name][self.id] 
+      if node.nil? || node[:type] == EXISTENCE_CHECK_NODE
+        options[:type] = type
+        tree[self.class.name][self.id] = options
+      end
+      return tree
+    end
+    # ---------------------------------------------------------- build_check_sql
+    def build_check_sql
+      "IF( NOT EXISTS( SELECT * FROM #{self.class.quoted_table_name} WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)} ) THEN ROLLBACK; END IF;\n"
+    end
+    # ---------------------------------------- convert_has_many_relations_to_sql
+    def expand_tree_with_relations( tree, reflections, classes_to_ignore )
+      reflections.each_pair do |key, value|
+        next if value.options[:dependent] && ![:destroy, :nullify].include?( value.options[:dependent] )
+        if value.options[:polymorphic]
+          next if classes_to_ignore.include?( send( key ).class )
+        else
+          begin
+            next if classes_to_ignore.include?( value.klass )
+          rescue
+            raise "Problem in a #{self.class.name} with #{key} = #{value}"
+          end
+        end
+        case value.macro
+        when :has_one
+          begin
+            singleton_method( key ) do |e|
+              e.build_export_tree( tree, classes_to_ignore )
+            end
+          rescue NestedException => ex
+            raise NestedException.new( ex.old_exception, "#{self.class.name}.#{ex.klass}", key )
+          rescue Exception => ex
+            raise NestedException.new( ex, self.class.name, key )
+          end
+        when :has_many, :has_and_belongs_to_many
+          begin
+            records = send( key )
+            if value.options[:dependent] == :nullify
+              records.each do |record|
+                record.add_to_tree( tree, UPDATE_NODE, key: value.association_primary_key )
+              end
+            else
+              records.each{ |x| x.build_export_tree( tree, classes_to_ignore ) }
+            end
+          rescue NestedException => ex
+            raise NestedException.new( ex.old_exception, "#{self.class.name}.#{ex.klass}", key )
+          rescue Exception => ex
+            raise ex
+            raise NestedException.new( ex, self.class.name, key )
+          end
+        when :belongs_to
+          singleton_method( key ) do |e|
+            e.add_to_tree( tree, EXISTENCE_CHECK_NODE )
+          end
+        else
+          raise "Unhandled reflection: #{value.macro}"
+        end
+      end
+      return tree
+    end
+    # ----------------------------------------------------------- print_relation
+    def _print_relation( tree, classes_to_ignore, indent_depth = 0 )
+      if tree[self.class.name].nil? || ( tree[self.class.name] && ( tree[self.class.name][id].nil? || tree[self.class.name][id][:type] == EXISTENCE_CHECK_NODE ) )
+        puts "%s%s - %d" % ["\t" * indent_depth, self.class.name, self.id]
+        self.add_to_tree( tree, CREATION_NODE )
+        _print_reflection_relations( tree, self.class.reflections, classes_to_ignore, indent_depth + 1 )
+      end
+    end
+    # ---------------------------------------- convert_has_many_relations_to_sql
+    def _print_reflection_relations( tree, reflections, classes_to_ignore, indent_level = 1 )
+      reflections.each_pair do |key, value|
+        next if value.options[:dependent] && ![:destroy, :nullify].include?( value.options[:dependent] )
+        if value.options[:polymorphic]
+          next if classes_to_ignore.include?( send( key ).class )
+        else
+          begin
+            next if classes_to_ignore.include?( value.klass )
+          rescue
+            raise "Problem in a #{self.class.name} with #{key} = #{value}"
+          end
+        end
+        case value.macro
+        when :has_one
+          singleton_method( key ) do |e|
+            e._print_relation( tree, classes_to_ignore, indent_level )
+          end
+        when :has_many, :has_and_belongs_to_many
+          records = send( key )
+          if value.options[:dependent] == :nullify
+            records.each do |record|
+              record.add_to_tree( tree, UPDATE_NODE, key: value.primary_key_name )
+              puts "%s%s [UPDATE] - %d" % ["\t" * indent_level, record.class.name, record.id]
+            end
+          else
+            records.each do |x|
+              x._print_relation( tree, classes_to_ignore, indent_level )
+            end
+          end
+        when :belongs_to
+        else
+          raise "Unhandled reflection: #{value.macro}"
+        end
+      end
+    end
+    # --------------------------------------------------------- singleton_method
+    def singleton_method( key )
+      if v = self.send( key )
+        yield v
+      end
+    end
+  end
+end

data/lib/active_record_sql_exporter.rb

@@ -0,0 +1,4 @@
+# ActiveRecordSqlExporter
+require 'active_record/sql_exporter'
+ActiveRecord::Base.send( :include, ActiveRecord::SqlExporter::InstanceMethods )
+ActiveRecord::Base.send( :extend, ActiveRecord::SqlExporter::ClassMethods )

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: active_record_sql_exporter
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Adam Palmblad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Quickly export an active record object to raw sql, useful for restoring
+  partial data from a backup
+email:
+- Adam Palmblad
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README
+- lib/active_record/sql_exporter.rb
+- lib/active_record_sql_exporter.rb
+homepage: http://github.com/apalmblad/active_record_sql_exporter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Export active record objects to raw sql.
+test_files: []