tachyon 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e508417f45cc19402918a4a554f8928cd43919d
-  data.tar.gz: 0f97c7354af65aebbd184ee4f85eb735eb841a01
+  metadata.gz: 020224e8c886048d69c0c929aa937d2bb6939dff
+  data.tar.gz: bc97180405d1c796355ab0d4fcec8bcefdd43d6b
 SHA512:
-  metadata.gz: 4e1a77ae53773d6c6e7d0aaa81765bf8ede459dfca2cd06120402c8314cade4e7f73e33c4e85149913c5e7304a41bc7a630f6f2ce51a69d74a28287686f0f8dc
-  data.tar.gz: 177c88d41f2809cfd356d4ada6acd192101c28943425d5431d1d337dce1d688c6338a9862ac9ab318a53af9d66bb02d7d7d8dbc63f43fc45c4284ef501386465
+  metadata.gz: 1ab76163499e5b2407e07a6f71d4cc2630bb46fcdaa9b4cae843f4480068cdfbcd526ccb4b79946726d1150a08f42674270b9f02753d0a16fc511dc516fca4ac
+  data.tar.gz: d34249d947078919f4c76b74ac0cda7bf7ab0d5005fb3b1bd47be35643d8b7c99a1e142c6976808ad70ecf1dde5378e95e08ec285bef00cfa3251181e0677dba

data/README.md

@@ -2,6 +2,8 @@
 
 Tachyon is a simple library designed to insert rows into any DB managed by ActiveRecord as fast as possible. Tachyon does not do validations, and only does minimal typescasting. Tachyon simply gets records into the DB as fast as possible. This is very useful in the case when you need to bulk-insert data for some reason, but it really shouldn't be used to replace your normal ActiveRecord DB operations.
 
+An ideal use-case for Tachyon (and the reason it was developed) is to dump/insert data from the DB as part of the setup step for large test cases.
+
 ## How fast is it?
 
 Tachyon is as fast (or faster) than executing raw SQL via `ActiveRecord::Base.connection`:
@@ -9,22 +11,22 @@ Tachyon is as fast (or faster) than executing raw SQL via `ActiveRecord::Base.co
 ```
 Benchmark Results (Inserting 10,000 rows):
 ------------------------------------------------
-User.create(Hash)                 : 7.72 seconds
-Raw SQL (w/ string interpolation) : 1.01 seconds
-Tachyon.insert(User, Hash)        : 1.00 seconds
+User.create(Hash)                 : 8.14 seconds
+Raw SQL (w/ string interpolation) : 1.17 seconds
+Tachyon.insert(User, Hash)        : 1.03 seconds
 ```
 
 ## Features
 
 * As fast (or faster!) than generating SQL via string interpolation, but with a much nicer syntax!
 * Suppresses duplicate key errors, which makes life easier when doing bulk data imports
-* Allows you to dump records from the database in a useful format via `Tachyon.dump_record`
+* Allows you to dump records from the database in a useful format via `Tachyon.dump`
 * Compatible with MySQL, PostgreSQL and SQLite3
 
 ## Caveats
 
 * Tachyon does not perform validations
-* Tachyon only does minimal typecasting
+* Tachyon only does minimal typecasting (ie: inserting a `Time` object does not work, use `Time.to_s(:db)` instead)
 
 ## Typecasting
 
@@ -32,12 +34,22 @@ Tachyon does extremely minimal typecasting. Integers and Floats are passed throu
 
 ## Usage
 
-Simply supply the model class along with a hash of attributes:
+To insert simply supply the model class along with a hash of attributes. It's important to note that the keys of the hash must be symbols, not strings:
 
 ```ruby
 Tachyon.insert(Article, id: 13, title: "Brand new article")
 ```
 
+And to dump a record simply call `Tachyon.dump`:
+
+```ruby
+article = Article.find(13)
+Tachyon.dump(article)
+=> { id: 13, title: "Brand new article", created_at: "2016-06-30 03:32:49", updated_at: "2016-06-30 03:32:49" }
+```
+
+Note that Tachyon is dumping the data in a way that is directly compatible with the DB, the data won't require much in the way of typecasting to insert it back into the DB.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/tachyon.rb

@@ -1,67 +1,70 @@
 require "tachyon/version"
 
 class Tachyon
+  class << self
 
-  @@sql_cache = {}
-  @@connection_cache = {}
+    @@sql_cache = {}
+    @@connection_cache = {}
 
-  def self.insert(klass, data)
-    self.connection_for(klass).execute(self.sql_for(klass, data))
-  rescue ActiveRecord::RecordNotUnique
-    # NO OP
-  end
+    def insert(klass, data)
+      connection_for(klass).execute(sql_for(klass, data))
+    rescue ActiveRecord::RecordNotUnique
+      # NO OP
+    end
 
-  def self.connection_for(klass)
-    return @@connection_cache[klass] if @@connection_cache.has_key?(klass)
-    @@connection_cache[klass] = klass.connection
-  end
+    def connection_for(klass)
+      return @@connection_cache[klass] if @@connection_cache.has_key?(klass)
+      @@connection_cache[klass] = klass.connection
+    end
 
-  def self.sql_for(klass, data)
-    self.sql_template_for(klass) % self.quote_data(data)
-  rescue KeyError => e
-    raise "Data was not supplied for all columns - " + e.to_s
-  end
+    def sql_for(klass, data)
+      sql_template_for(klass) % quote_data(data)
+    rescue KeyError => e
+      raise "Data was not supplied for all columns - " + e.to_s
+    end
 
-  def self.sql_template_for(klass)
-    return @@sql_cache[klass] if @@sql_cache.has_key?(klass)
+    def sql_template_for(klass)
+      return @@sql_cache[klass] if @@sql_cache.has_key?(klass)
 
-    columns = klass.columns.map(&:name)
-    table_name = klass.table_name
-    columns_string = columns.map {|x| "`#{x}`" }.join(", ")
-    values_string = columns.map {|x| "%{#{x}}" }.join(", ")
+      columns = klass.columns.map(&:name)
+      table_name = klass.table_name
+      columns_string = columns.map {|x| "`#{x}`" }.join(", ")
+      values_string = columns.map {|x| "%{#{x}}" }.join(", ")
 
-    sql = "INSERT INTO `#{table_name}` (#{columns_string}) VALUES (#{values_string})"
+      sql = "INSERT INTO `#{table_name}` (#{columns_string}) VALUES (#{values_string})"
 
-    @@sql_cache[klass] = sql
-  end
+      @@sql_cache[klass] = sql
+    end
 
-  def self.quote_data(data)
-    data.map do |key, value|
-      [key, self.quote_value(value)]
-    end.to_h
-  end
+    def quote_data(data)
+      data.map do |key, value|
+        [key, quote_value(value)]
+      end.to_h
+    end
 
-  def self.quote_value(value)
-    case value
-    when String then "'#{value.gsub("'", "''")}'"
-    when NilClass then "NULL"
-    else value
+    def quote_value(value)
+      case value
+      when String then "'#{value.gsub("'", "''")}'"
+      when NilClass then "NULL"
+      else value
+      end
     end
-  end
 
-  def self.dump_record(record)
-    record.attributes_before_type_cast.map do |key, value|
-      [key.to_sym, self.dump_attribute(value)]
-    end.to_h
-  end
+    def dump(record)
+      record.attributes_before_type_cast.map do |key, value|
+        [key.to_sym, dump_attribute(value)]
+      end.to_h
+    end
 
-  def self.dump_attribute(attribute)
-    case attribute
-    when Time then attribute.to_s(:db)
-    when Date then attribute.to_s(:db)
-    when TrueClass then 1
-    when FalseClass then 0
-    else attribute
+    def dump_attribute(attribute)
+      case attribute
+      when Time then attribute.to_s(:db)
+      when Date then attribute.to_s(:db)
+      when TrueClass then 1
+      when FalseClass then 0
+      else attribute
+      end
     end
+    
   end
 end

data/lib/tachyon/version.rb

@@ -1,3 +1,3 @@
 class Tachyon
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tachyon
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Aaron Gough