disposable_db 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/*
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in disposable_db.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bench/bench.rb

@@ -0,0 +1,96 @@
+require File.expand_path("../bench_helper", __FILE__)
+
+def create_columns(n = 100)
+  columns = []
+  n.times do |i|
+    columns << TableTemplate::Column.new("field_#{i}", String)
+  end
+  columns
+end
+
+def create_database(table_template)
+  database = Databases::SQLite.new(:connection_string => 'sqlite://tmp/benchmark.db')
+  #database = Databases::SQLite.new
+  database.create_table! table_template
+  database
+end
+
+def create_model
+  columns = create_columns
+
+  tt = TableTemplate.new('benchmark', columns)
+
+  database = create_database tt
+
+  DisposableModel.factory(:database => database, :table_name => tt.name)
+end
+
+n = 10000
+batch = []
+Benchmark.bm(30) do |x|
+  m = create_model
+  x.report("generating random data:")   { n.times { generate_random_data(m.columns) } }
+
+  m = create_model
+  cols = m.columns
+  batch = []
+  v = generate_random_data(cols)
+  result = RubyProf.profile do
+  #x.report("imports with transaction:") do
+    n.times do |i|
+      batch << v.values
+      if batch.length >= 1000
+        m.import(cols, batch)
+        batch = []
+      end
+    end
+    m.import(cols, batch) unless batch.length < 1
+  #end
+  end
+
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print(STDOUT, {})
+
+  exit
+
+
+# Print a graph profile to text
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print(STDOUT, {})
+
+  m = create_model
+  x.report("single inserts with transaction:") { m.transaction { n.times { m.insert(generate_random_data(m.columns)) } } }
+
+  m = create_model
+  v = generate_random_data(m.columns)
+  x.report("single inserts:") { n.times { m.insert(v) } }
+
+  m = create_model
+  h = {}
+  m.columns.each { |c| h[c] = :"$new_#{c.to_s}" }
+  p = m.dataset.prepare(:insert, :insert_all_columns, h)
+  v = generate_random_data(m.columns, "new_")
+  x.report("prepared single inserts:") do
+    n.times do
+      p.call(v)
+    end
+  end
+
+  m = create_model
+  x.report("single inserts with transaction:") { m.transaction { n.times { m.insert(generate_random_data(m.columns)) } } }
+
+  m = create_model
+  v = generate_random_data(m.columns)
+  x.report("multi inserts with transaction:") do
+    m.transaction do
+      n.times do
+        batch build_batch(batch, m.columns, v)
+        if batch.length >= 100
+          m.import(m.columns, batch)
+          batch = []
+        end
+      end
+      m.multi_insert(batch) unless batch.empty?
+    end
+  end
+end

data/bench/bench_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'ffaker'
+require 'benchmark'
+require 'ruby-prof'
+require 'disposable_db'
+require 'fileutils'
+
+include DisposableDB
+
+class TableTemplate::Column
+
+  def mock
+    if self.type.kind_of?(Numeric)
+      rand(999999999999999)
+    else
+      Faker::Name.name
+    end
+  end
+end
+
+def generate_random_data(column_names, prefix = nil)
+  data = {}
+  column_names.each do |cn|
+    data[:"#{prefix}#{cn.to_s}"] = Faker::Name.name
+  end
+  data
+end

data/disposable_db.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "disposable_db/version"
+
+Gem::Specification.new do |s|
+  s.name        = "disposable_db"
+  s.version     = DisposableDB::VERSION
+  s.authors     = ["Keith Larrimore"]
+  s.email       = ["keithlarrimore@icehook.com"]
+  s.authors     = ['Keith Larrimore']
+  s.homepage    = 'https://github.com/klarrimore/disposable_db'
+  s.date        = Date.today.to_s
+  s.summary = 'A utility that makes it easy to create "on-the-fly databases"'
+  s.description = 'A utility that makes it easy to create "on-the-fly databases"'
+
+  #s.rubyforge_project = "disposable_db"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,bench,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency 'rspec', ['>= 2.9.0']
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'ffaker', ['>= 1.13.0']
+  s.add_development_dependency 'ruby-prof'
+  s.add_runtime_dependency 'sequel', ['= 3.33.0']
+end

data/lib/disposable_db.rb

@@ -0,0 +1,39 @@
+require 'logger'
+require 'tempfile'
+require 'sequel'
+require 'disposable_db/version'
+require 'disposable_db/table_template'
+require 'disposable_db/database'
+require 'disposable_db/databases/sqlite'
+require 'disposable_db/disposable_model'
+
+module DisposableDB
+  class << self
+
+    def options
+      @options ||= {
+        :log => true
+      }
+    end
+  
+    def log(message)
+      logger.info("[disposable_db] #{message}") if logging?
+    end
+
+    def logger
+      @logger ||= options[:logger] || Logger.new(STDOUT)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logging?
+      options[:log]
+    end
+
+    class DisposableDBError < StandardError #:nodoc:
+    end
+
+  end
+end

data/lib/disposable_db/database.rb

@@ -0,0 +1,30 @@
+module DisposableDB
+  class Database
+    attr_accessor :connection
+
+    def initialize(args = {})
+      @connection = args[:connection] || Sequel.sqlite
+    end
+
+    def create_table!(table_template)
+      @connection.create_table! table_template.name.to_sym do
+        table_template.columns.each do |column|
+          column column.name.to_sym, column.type
+        end
+      end
+    end
+
+    def create_table(table_template)
+      @connection.create_table? table_template.name.to_sym do
+        table_template.columns.each do |column|
+          column column.name.to_sym, column.type
+        end
+      end
+    end
+
+    def table_exists?(name)
+      @connection.table_exists? name
+    end
+
+  end
+end

data/lib/disposable_db/databases/sqlite.rb

@@ -0,0 +1,17 @@
+module DisposableDB
+  module Databases
+    class SQLite < Database
+
+      def intialize(args = {})
+        unless args.has_key? :connection
+          if args[:connection_string]
+            args[:connection] = Sequel.sqlite(args[:connection_string])
+          end
+        end
+
+        super(args)
+      end
+
+    end
+  end
+end

data/lib/disposable_db/disposable_model.rb

@@ -0,0 +1,36 @@
+module DisposableDB
+  class DisposableModel
+
+    class << self
+      def build(database, table_name)
+
+        m = Class.new(Sequel::Model(database.connection)) do
+              set_dataset table_name.to_sym
+
+              def self.database
+                @database
+              end
+
+              def self.database=(d)
+                @database = d
+              end
+
+              def self.transaction(opts = {}, &block)
+                self.database.connection.transaction opts, &block
+              end
+            end
+
+        m.database = database
+
+        m
+      end
+
+    end
+
+    def DisposableModel.factory(args = {})
+      database = args[:database] || Database.new
+      table_name = args[:table_name] || 'disposable_table'
+      build(database, table_name)
+    end
+  end
+end

data/lib/disposable_db/table_template.rb

@@ -0,0 +1,34 @@
+module DisposableDB
+  class TableTemplate
+    attr_accessor :name, :columns
+
+    def initialize(name, columns = [])
+      @name = name
+      @columns = columns
+    end
+
+    def add_column(column)
+      @columns << column
+    end
+
+    class Column
+      attr_accessor :name, :type, :indexed
+
+      def self.types
+        # [String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal, Date, DateTime, Time, File, TrueClass, FalseClass]
+        #types = Sequel::Schema::Generator::GENERIC_TYPES
+
+        #name ? types.select { |t| t.name == name }.first : types
+        Sequel::Schema::Generator::GENERIC_TYPES
+      end
+
+      def initialize(name, type, options = {})
+        @name = name
+        @type = type
+        @indexed = options[:indexed] || false
+      end
+
+    end
+
+  end
+end

data/lib/disposable_db/version.rb

@@ -0,0 +1,3 @@
+module DisposableDB
+  VERSION = "0.0.1" unless defined? DisposableDB::VERSION
+end

data/spec/database_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+include DisposableDB::Databases
+
+describe Database do
+
+  it "can be instantiated" do
+    Database.new.should be_an_instance_of(Database)
+  end
+
+  it "can create table" do
+    columns = []
+    columns << TableTemplate::Column.new('t1', Integer)
+    columns << TableTemplate::Column.new('t2', String)
+
+    tt = TableTemplate.new('foo', columns)
+
+    d = Database.new
+    d.table_exists?(tt.name).should be_false
+    d.create_table tt
+    d.table_exists?(tt.name).should be_true
+  end
+
+end

data/spec/databases/sqlite_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe SQLite do
+
+end

data/spec/disposable_db_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe DisposableDB do
+  it "can log" do
+    tf = Tempfile.new('output.txt')
+    DisposableDB.logger = Logger.new(tf)
+    DisposableDB.log 'foobar'
+    tf.close
+    File.read(tf.path).should =~ /foobar/
+  end
+end

data/spec/disposable_model_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe DisposableModel do
+
+  it "can be instantiated" do
+    m = DisposableModel.factory(:database => Database.new)
+    m.new.should be_a_kind_of(Sequel::Model)
+  end
+
+  it "has a database" do
+    m = DisposableModel.factory(:database => Database.new)
+    m.database.should be_a_kind_of(Database)
+  end
+
+  it "has a database with connection" do
+    m = DisposableModel.factory(:database => Database.new(:connection => Sequel.sqlite))
+    m.database.connection.should be_a_kind_of(Sequel::SQLite::Database)
+  end
+
+  it "has a database with adjustable connection" do
+    m1 = DisposableModel.factory(:database => Database.new(:connection => Sequel.sqlite))
+    m2 = DisposableModel.factory(:database => Database.new(:connection => Sequel.sqlite('/tmp/test.db')))
+    m1.database.connection.uri.should == 'sqlite:/'
+    m2.database.connection.uri.should == 'sqlite://tmp/test.db'
+  end
+
+  it "has an underlying table with columns" do
+    columns = []
+    columns << TableTemplate::Column.new('t1', Integer)
+    columns << TableTemplate::Column.new('t2', String)
+
+    tt = TableTemplate.new('foo', columns)
+
+    database = Databases::SQLite.new
+    database.create_table! tt
+
+    m = DisposableModel.factory(:database => database, :table_name => tt.name)
+    m.columns.length.should == columns.length
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'disposable_db'
+
+include DisposableDB
+
+RSpec.configure do |config|
+  
+end

data/spec/table_template_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe TableTemplate do
+
+  it "can be instantiated" do
+    tt = TableTemplate.new('foo')
+    tt.should be_an_instance_of(TableTemplate)
+  end
+
+  it "can add columns" do
+    tt = TableTemplate.new('foo')
+    columns = []
+    columns << TableTemplate::Column.new('t1', Integer)
+    columns << TableTemplate::Column.new('t2', String)
+
+    columns.each do |column|
+      tt.add_column column
+    end
+
+    tt.columns.length.should == columns.length
+  end
+
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: disposable_db
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Keith Larrimore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &11827800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *11827800
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &11826540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11826540
+- !ruby/object:Gem::Dependency
+  name: ffaker
+  requirement: &11824160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :development
+  prerelease: false
+  version_requirements: *11824160
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: &11823320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11823320
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &11822320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 3.33.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *11822320
+description: A utility that makes it easy to create "on-the-fly databases"
+email:
+- keithlarrimore@icehook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- bench/bench.rb
+- bench/bench_helper.rb
+- disposable_db.gemspec
+- lib/disposable_db.rb
+- lib/disposable_db/database.rb
+- lib/disposable_db/databases/sqlite.rb
+- lib/disposable_db/disposable_model.rb
+- lib/disposable_db/table_template.rb
+- lib/disposable_db/version.rb
+- spec/database_spec.rb
+- spec/databases/sqlite_spec.rb
+- spec/disposable_db_spec.rb
+- spec/disposable_model_spec.rb
+- spec/spec_helper.rb
+- spec/table_template_spec.rb
+homepage: https://github.com/klarrimore/disposable_db
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A utility that makes it easy to create "on-the-fly databases"
+test_files: []