swift 0.4.3 → 0.5.0

data/API.rdoc

@@ -0,0 +1,90 @@
+= Swift
+
+== Public API
+
+Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
+
+  Swift
+    .setup  #=> Adapter
+    .db     #=> Adapter
+    .schema #=> [Scheme, ...]
+    .trace
+
+    # Abstract.
+    Adapter
+      .new         #=> Adapter
+      #all         #=> Result
+      #begin       #=> Adapter
+      #commit
+      #create      #=> Scheme
+      #destroy     #=> Result
+      #execute     #=> Result
+      #first       #=> Scheme
+      #get         #=> Scheme
+      #prepare     #=> Statement
+      #rollback
+      #transaction #=> Adapter
+      #update      #=> Result
+
+      # TODO: DBI < Adapter
+        # returning? #=> true or false
+
+    # Concrete.
+    DB
+      Mysql    < Adapter # TODO: Adapter::DBI?
+      Postgres < Adapter # TODO: Adapter::DBI?
+
+    # Enumerable collection of Scheme or Hash tuples.
+    Result
+      .new       #=> Result
+      #insert_id #=> Numeric
+
+    Statement < Result
+      .new     #=> Statement
+      #execute #=> Statement
+
+    Scheme
+      .all       #=> Result
+      .attribute #=> Type
+      .create    #=> Scheme
+      .first     #=> Scheme
+      .get       #=> Scheme
+      .header    #=> Header
+      .load      #=> Scheme
+      .new       #=> Scheme
+      .scheme    #=> Alias for self.class
+      .store     #=> Symbol
+      #destroy   #=> Result
+      #tuple     #=> Hash
+      #update    #=> Result
+
+    # Enumerable collection of Types for Scheme
+    Header
+      .new        #=> Header
+      #all        #=> [Type, ...]
+      #insertable #=> [Type, ...]
+      #keys       #=> [Symbol, ...]
+      #new_tuple  #=> Hash
+      #push       #=> Type
+      #serial     #=> Symbol or nil.
+      #updatable  #=> [Type, ...]
+
+    # Abstract.
+    Attribute
+      .new                   #=> Attribute
+      #name                  #=> Symbol
+      #field                 #=> Symbol
+      #key                   #=> true or false
+      #serial                #=> Symbol or nil
+      #default               #=> Object
+      #define_scheme_methods
+
+    # Concrete
+    Type
+      BigDecimal < Attribute
+      Boolean    < Attribute
+      Float      < Attribute
+      Integer    < Attribute
+      IO         < Attribute
+      String     < Attribute
+      Time       < Attribute # Soon to be DateTime?

data/README.rdoc

@@ -21,6 +21,7 @@ dbic++ can be found here http://github.com/deepfryed/dbicpp
 * Bind values.
 * Transactions and named save points.
 * EventMachine asynchronous interface.
+* IdentityMap.
 * Migrations.
 
 == Synopsis
@@ -39,7 +40,7 @@ dbic++ can be found here http://github.com/deepfryed/dbicpp
 
     # Save points are supported.
     db.transaction :named_save_point do
-      st = db.prepare('insert into users (name, email) values (?, ?)')
+      st = db.prepare('insert into users (name, email) values (?, ?) returning id')
       puts st.execute('Apple Arthurton', 'apple@arthurton.local').insert_id
       puts st.execute('Benny Arthurton', 'benny@arthurton.local').insert_id
     end
@@ -60,6 +61,7 @@ Rudimentary object mapping. Provides a definition to the db methods for prepared
 primitive Ruby type conversion.
 
   require 'swift'
+  require 'swift/migrations'
 
   Swift.trace true # Debugging.
   Swift.setup :default, Swift::DB::Postgres, db: 'swift'
@@ -92,6 +94,7 @@ primitive Ruby type conversion.
 Scheme/relation level helpers.
 
   require 'swift'
+  require 'swift/migrations'
 
   Swift.trace true # Debugging.
   Swift.setup :default, Swift::DB::Postgres, db: 'swift'
@@ -145,6 +148,7 @@ Swift comes with a simple identity map. Just require it after you load swift.
 
   require 'swift'
   require 'swift/identity_map'
+  require 'swift/migrations'
 
   class User < Swift::Scheme
     store     :users
@@ -154,10 +158,15 @@ Swift comes with a simple identity map. Just require it after you load swift.
     attribute :email, Swift::Type::String,  field: 'liame'
   end # User
 
+  # Migrate it.
+  User.migrate!
+
+  # Create
+  User.create name: 'James Arthurton', email: 'james@arthurton.local' # => User
+
   User.first(':name = ?', 'James Arthurton')
   User.first(':name = ?', 'James Arthurton') # Gets same object reference
 
-
 === Bulk inserts
 
 Swift comes with adapter level support for bulk inserts for MySQL and PostgreSQL. This
@@ -185,7 +194,6 @@ But you can do it almost as fast in ruby,
 You are not just limited to files - you can stream data from anywhere into MySQL and
 PostgreSQL directly without creating temporary files.
 
-
 == Performance
 
 Swift prefers performance when it doesn't compromise the Ruby-ish interface. It's unfair to compare Swift to DataMapper
@@ -222,12 +230,12 @@ Intel Core2Duo P8700 2.53GHz and stock PostgreSQL 8.4.1.
     swift #update   0.250000    0.610000    0.860000    1.996165     29.35m
     swift #write    0.000000    0.100000    0.100000    0.167199      6.23m
 
-
 == TODO
 
 * Tests.
-* Assertions for dumb stuff. model < Model for methods in Adapter.
-* Profile.
+* Extension performance. Remove all repeated rb_intern() calls etc.
+* Assertions for dumb stuff.
+* Abstract interface for other adapters? Move dbic++ to Swift::DBI::(Adapter, Pool, Result, Statment etc.)
 
 == Contributing
 

data/Rakefile

@@ -13,6 +13,7 @@ begin
     gem.files.reject!{|f| f =~ %r{\.gitignore|examples|benchmarks|memory/.*}}
 
     gem.add_development_dependency 'minitest', '>= 1.7.0'
+    gem.add_development_dependency 'eventmachine'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.5.0

data/examples/async.rb

@@ -19,16 +19,21 @@ Swift.db do |db|
 
   puts '-- insert --'
   ins = db.prepare('insert into users(name, email) values(?, ?)')
-  10.times {|n| ins.execute(*sample[n%3]) }
+  9.times {|n| ins.execute(*sample[n%3]) }
 end
 
+sleep_clause = {
+  Swift::DB::Postgres => "case length(pg_sleep(%s)::text) when 0 then '%s' else '%s' end as sleep",
+  Swift::DB::Mysql    => "if (sleep(%s), '%s', '%s') as sleep"
+}
+
 puts '-- select 9 times with a pool of size 5 --'
 Swift.trace false
 Swift.pool(5) do |db|
   (1..9).each do |n|
     pause = '%0.3f' % ((20-n)/20.0)
-    pause = "case length(pg_sleep(#{pause})::text) when 0 then '#{pause}' else '' end as sleep"
-    db.execute("select #{pause}, * from users where id = ?", n) {|r| p r.first }
+    pause = sleep_clause[adapter] % 3.times.map { pause }
+    db.execute("select *, #{pause} from users where id = ?", n) {|r| p r.first }
   end
 end
 Swift.trace true
@@ -38,17 +43,17 @@ EM.run {
   pool1 = Swift.pool(2)
   pool2 = Swift.pool(1)
 
-  pool1.execute("select * from users limit 5 offset 0") do |rs|
+  pool1.execute("select * from users limit 3 offset 0") do |rs|
     puts '-- Inside pool1 #callback --'
     rs.each {|r| p r }
-    pool1.execute("select * from users limit 5 offset 5") do |rs|
+    pool1.execute("select * from users limit 3 offset 3") do |rs|
       puts '-- Inside pool1 #callback again --'
       rs.each {|r| p r }
       EM.stop
     end
   end
 
-  pool2.execute("select * from users limit 5 offset 10") do |rs|
+  pool2.execute("select * from users limit 3 offset 6") do |rs|
     puts '-- Inside pool2 #callback --'
     rs.each {|r| p r }
   end

data/examples/db.rb

@@ -1,6 +1,10 @@
 #!/usr/bin/env ruby
-require_relative '../lib/swift'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
 require 'pp'
+require 'swift'
+require 'swift/migrations'
 
 class User < Swift::Scheme
   store     :users

data/examples/scheme.rb

@@ -1,6 +1,11 @@
 #!/usr/bin/env ruby
-require_relative '../lib/swift'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
 require 'pp'
+require 'swift'
+require 'swift/migrations'
+require 'swift/validations'
 
 class User < Swift::Scheme
   store     :users
@@ -10,6 +15,10 @@ class User < Swift::Scheme
   attribute :active,   Swift::Type::Boolean
   attribute :created,  Swift::Type::Time,   default: proc { Time.now }
   attribute :optional, Swift::Type::String, default: 'woot'
+
+  validations do |errors|
+    errors << [:name, 'is blank'] if name.to_s.empty?
+  end
 end # User
 
 adapter = ARGV.first =~ /mysql/i ? Swift::DB::Mysql : Swift::DB::Postgres
@@ -27,7 +36,6 @@ User.create name: 'Benny Arthurton', email: 'benny@arthurton.local'
 
 puts '', '-- all --'
 pp User.all.to_a
-# pp User.all(':name like ?', '%Arthurton').to_a
 
 puts '', '-- first --'
 pp User.first(':name like ?', '%Arthurton')

data/ext/adapter.cc

@@ -0,0 +1,259 @@
+#include "adapter.h"
+
+static VALUE cSwiftAdapter;
+
+static void adapter_free(dbi::Handle *handle) {
+    if (handle) delete handle;
+}
+
+VALUE adapter_alloc(VALUE klass) {
+    dbi::Handle *handle = 0;
+    return Data_Wrap_Struct(klass, 0, adapter_free, handle);
+}
+
+dbi::Handle* adapter_handle(VALUE self) {
+  dbi::Handle *handle;
+  Data_Get_Struct(self, dbi::Handle, handle);
+  if (!handle) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
+
+  return handle;
+}
+
+static VALUE adapter_begin(int argc, VALUE *argv, VALUE self) {
+  VALUE save_point;
+  rb_scan_args(argc, argv, "01", &save_point);
+
+  dbi::Handle *handle = adapter_handle(self);
+  try {
+    NIL_P(save_point) ? handle->begin() : handle->begin(CSTRING(save_point));
+  }
+  CATCH_DBI_EXCEPTIONS();
+  return Qtrue;
+}
+
+static VALUE adapter_close(VALUE self) {
+  dbi::Handle *handle = adapter_handle(self);
+  try { handle->close(); } CATCH_DBI_EXCEPTIONS();
+  return Qtrue;
+}
+
+// TODO:
+static VALUE adapter_clone(VALUE self) {
+  rb_raise(eSwiftRuntimeError, "clone is not allowed.");
+}
+
+static VALUE adapter_commit(int argc, VALUE *argv, VALUE self) {
+  VALUE save_point;
+  rb_scan_args(argc, argv, "01", &save_point);
+  dbi::Handle *handle = adapter_handle(self);
+
+  try {
+    NIL_P(save_point) ? handle->commit() : handle->commit(CSTRING(save_point));
+  }
+  CATCH_DBI_EXCEPTIONS();
+  return Qtrue;
+}
+
+// TODO:
+static VALUE adapter_dup(VALUE self) {
+  rb_raise(eSwiftRuntimeError, "dup is not allowed.");
+}
+
+// TODO: Attempt TO_S() before escaping?
+static VALUE adapter_escape(VALUE self, VALUE value) {
+  if (TYPE(value) != T_STRING) rb_raise(eSwiftArgumentError, "Cannot escape non-string value.");
+
+  dbi::Handle *handle = adapter_handle(self);
+  try {
+    std::string safe = handle->escape(std::string(RSTRING_PTR(value), RSTRING_LEN(value)));
+    return rb_str_new(safe.data(), safe.length());
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+// TODO: Change bind_values to an array in the interface? Avoid array -> splat -> array.
+static VALUE adapter_execute(int argc, VALUE *argv, VALUE self) {
+  VALUE statement, bind_values, block, rows;
+
+  dbi::Handle *handle = adapter_handle(self);
+  rb_scan_args(argc, argv, "1*&", &statement, &bind_values, &block);
+
+  try {
+    Query query;
+    query.sql    = CSTRING(statement);
+    query.handle = handle;
+
+    if (RARRAY_LEN(bind_values) > 0) query_bind_values(&query, bind_values);
+    if (dbi::_trace)                 dbi::logMessage(dbi::_trace_fd, dbi::formatParams(query.sql, query.bind));
+
+    // TODO: http://redmine.ruby-lang.org/issues/show/3762
+    //       rb_thread_blocking_region and C++ exceptions don't mix in 1.9.2.
+    // rows = rb_thread_blocking_region(((VALUE (*)(void*))query_execute), &query, RUBY_UBF_IO, 0);
+    rows = query_execute(&query);
+    if (rb_block_given_p()) {
+      dbi::AbstractResultSet *result = handle->results();
+      return result_each(Data_Wrap_Struct(cSwiftResult, 0, result_free, result));
+    }
+    else
+      return rows;
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+static VALUE adapter_initialize(VALUE self, VALUE options) {
+  VALUE db       = rb_hash_aref(options, ID2SYM(rb_intern("db")));
+  VALUE driver   = rb_hash_aref(options, ID2SYM(rb_intern("driver")));
+  VALUE user     = rb_hash_aref(options, ID2SYM(rb_intern("user")));
+
+  if (NIL_P(db))     rb_raise(eSwiftArgumentError, "Adapter#new called without :db");
+  if (NIL_P(driver)) rb_raise(eSwiftArgumentError, "Adapter#new called without :driver");
+
+  user = NIL_P(user) ? rb_str_new2(getlogin()) : user;
+
+  try {
+    DATA_PTR(self) = new dbi::Handle(
+      CSTRING(driver),
+      CSTRING(user),
+      CSTRING(rb_hash_aref(options, ID2SYM(rb_intern("password")))),
+      CSTRING(db),
+      CSTRING(rb_hash_aref(options, ID2SYM(rb_intern("host")))),
+      CSTRING(rb_hash_aref(options, ID2SYM(rb_intern("port"))))
+    );
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  rb_iv_set(self, "@options", options);
+  return Qnil;
+}
+
+static VALUE adapter_prepare(int argc, VALUE *argv, VALUE self) {
+  VALUE sql, scheme, prepared;
+  dbi::AbstractStatement *statement;
+
+  rb_scan_args(argc, argv, "11", &scheme, &sql);
+  if (TYPE(scheme) != T_CLASS) {
+    sql    = scheme;
+    scheme = Qnil;
+  }
+
+  dbi::Handle *handle = adapter_handle(self);
+  try {
+    // TODO: Move to statement_* constructor.
+    statement = handle->conn()->prepare(CSTRING(sql));
+    prepared  = Data_Wrap_Struct(cSwiftStatement, 0, statement_free, statement);
+    rb_iv_set(prepared, "@scheme",  scheme);
+    return prepared;
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+static VALUE adapter_rollback(int argc, VALUE *argv, VALUE self) {
+  VALUE save_point;
+  dbi::Handle *handle = adapter_handle(self);
+  rb_scan_args(argc, argv, "01", &save_point);
+
+  try {
+    NIL_P(save_point) ? handle->rollback() : handle->rollback(CSTRING(save_point));
+  }
+  CATCH_DBI_EXCEPTIONS();
+  return Qtrue;
+}
+
+static VALUE adapter_transaction(int argc, VALUE *argv, VALUE self) {
+  int status;
+  VALUE sp, block;
+
+  dbi::Handle *handle = adapter_handle(self);
+
+  rb_scan_args(argc, argv, "01&", &sp, &block);
+
+  if (NIL_P(block)) rb_raise(eSwiftArgumentError, "Transaction called without a block.");
+  std::string save_point = NIL_P(sp) ? "SP" + dbi::generateCompactUUID() : CSTRING(sp);
+
+  try {
+    handle->begin(save_point);
+    rb_protect(rb_yield, self, &status);
+    if (!status && handle->transactions().size() > 0) {
+      handle->commit(save_point);
+    }
+    else if (status && handle->transactions().size() > 0) {
+      handle->rollback(save_point);
+      rb_jump_tag(status);
+    }
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  return Qtrue;
+}
+
+static VALUE adapter_write(int argc, VALUE *argv, VALUE self) {
+  uint64_t rows = 0;
+  VALUE stream, table, fields;
+  dbi::Handle *handle = adapter_handle(self);
+
+  rb_scan_args(argc, argv, "30", &table, &fields, &stream);
+  if (TYPE(stream) != T_STRING && !rb_respond_to(stream, rb_intern("read")))
+    rb_raise(eSwiftArgumentError, "Stream must be a String or IO object.");
+  if (TYPE(fields) != T_ARRAY)
+    rb_raise(eSwiftArgumentError, "Fields must be an Array.");
+
+  try {
+    dbi::FieldSet write_fields;
+    for (int i = 0; i < RARRAY_LEN(fields); i++) {
+      VALUE field = TO_S(rb_ary_entry(fields, i));
+      write_fields << std::string(RSTRING_PTR(field), RSTRING_LEN(field));
+    }
+
+    /*
+      TODO: Adapter specific code is balls.
+      This is just for the friggin mysql support - mysql does not like a statement close command being send on a
+      handle when the writing has started.
+    */
+    rb_gc();
+
+    if (TYPE(stream) == T_STRING) {
+      dbi::IOStream io(RSTRING_PTR(stream), RSTRING_LEN(stream));
+      rows = handle->write(RSTRING_PTR(table), write_fields, &io);
+    }
+    else {
+      IOStream io(stream);
+      rows = handle->write(RSTRING_PTR(table), write_fields, &io);
+    }
+    return SIZET2NUM(rows);
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+VALUE adapter_results(VALUE self) {
+  dbi::Handle *handle = adapter_handle(self);
+  try {
+      dbi::AbstractResultSet *result = handle->results();
+      return Data_Wrap_Struct(cSwiftResult, 0, result_free, result);
+  }
+  CATCH_DBI_EXCEPTIONS();
+}
+
+void init_swift_adapter() {
+  VALUE mSwift   = rb_define_module("Swift");
+  cSwiftAdapter = rb_define_class_under(mSwift, "Adapter", rb_cObject);
+
+  rb_define_method(cSwiftAdapter, "begin",       RUBY_METHOD_FUNC(adapter_begin),       -1);
+  rb_define_method(cSwiftAdapter, "clone",       RUBY_METHOD_FUNC(adapter_clone),       0);
+  rb_define_method(cSwiftAdapter, "close",       RUBY_METHOD_FUNC(adapter_close),       0);
+  rb_define_method(cSwiftAdapter, "commit",      RUBY_METHOD_FUNC(adapter_commit),      -1);
+  rb_define_method(cSwiftAdapter, "dup",         RUBY_METHOD_FUNC(adapter_dup),         0);
+  rb_define_method(cSwiftAdapter, "escape",      RUBY_METHOD_FUNC(adapter_escape),      1);
+  rb_define_method(cSwiftAdapter, "execute",     RUBY_METHOD_FUNC(adapter_execute),     -1);
+  rb_define_method(cSwiftAdapter, "initialize",  RUBY_METHOD_FUNC(adapter_initialize),  1);
+  rb_define_method(cSwiftAdapter, "prepare",     RUBY_METHOD_FUNC(adapter_prepare),     -1);
+  rb_define_method(cSwiftAdapter, "rollback",    RUBY_METHOD_FUNC(adapter_rollback),    -1);
+  rb_define_method(cSwiftAdapter, "transaction", RUBY_METHOD_FUNC(adapter_transaction), -1);
+  rb_define_method(cSwiftAdapter, "write",       RUBY_METHOD_FUNC(adapter_write),       -1);
+
+  rb_define_alloc_func(cSwiftAdapter, adapter_alloc);
+
+  // TODO Figure out how to avoid race conditions.
+  rb_define_method(cSwiftAdapter, "results",     RUBY_METHOD_FUNC(adapter_results),     0);
+}
+
+

data/ext/adapter.h

@@ -0,0 +1,13 @@
+#ifndef SWIFT_ADAPTER_H
+#define SWIFT_ADAPTER_H
+
+#include "swift.h"
+#include "query.h"
+#include "result.h"
+#include "statement.h"
+
+void init_swift_adapter();
+dbi::Handle *adapter_handle(VALUE);
+
+#endif
+

data/ext/extconf.rb

@@ -32,8 +32,29 @@ def library_installed? name, hint
   end
 end
 
+def assert_dbicpp_version ver
+  passed  = false
+  header  = '/usr/include/dbic++.h'
+  message = "Swift needs dbic++ >= #{ver}. Please update your dbic++ installation."
+
+  if File.exists?(header) && match = File.read(header).match(/DBI_VERSION\s+(.*?)\n/mi)
+    rmajor, rminor, rbuild = ver.strip.split(/\./).map(&:to_i)
+    imajor, iminor, ibuild = match.captures.first.strip.split(/\./).map(&:to_i)
+    passed = (imajor >  rmajor) ||
+             (imajor == rmajor && iminor >  rminor) ||
+             (imajor == rmajor && iminor == rminor && ibuild >= rbuild)
+  else
+    message = "Cannot find #{header} or version number. You need to install dbic++ >= #{ver}"
+    passed  = false
+  end
+
+  raise message unless passed
+end
+
 exit 1 unless library_installed? 'pcrecpp', apt_install_hint('libpcre3-dev')
 exit 1 unless library_installed? 'uuid',    apt_install_hint('uuid-dev')
 exit 1 unless library_installed? 'dbic++',  apt_install_hint('dbic++-dev')
 
+assert_dbicpp_version '0.3.0'
+
 create_makefile 'swift'

data/ext/iostream.cc

@@ -0,0 +1,44 @@
+#include "iostream.h"
+
+IOStream::IOStream(VALUE s) {
+  stream = s;
+}
+
+std::string& IOStream::read() {
+  VALUE response = rb_funcall(stream, rb_intern("read"), 0);
+  if (response == Qnil) {
+    return empty;
+  }
+  else {
+    // Attempt TO_S first before complaining?
+    if (TYPE(response) != T_STRING) {
+      rb_raise(
+        CONST_GET(rb_mKernel, "ArgumentError"),
+        "Write can only process string data. You need to stringify values returned in the callback."
+      );
+    }
+    data = string(RSTRING_PTR(response), RSTRING_LEN(response));
+    return data;
+  }
+}
+
+uint32_t IOStream::read(char *buffer, uint32_t length) {
+  VALUE response = rb_funcall(stream, rb_intern("read"), 1, INT2NUM(length));
+  if (response == Qnil) {
+    return 0;
+  }
+  else {
+    length = length < RSTRING_LEN(response) ? length : RSTRING_LEN(response);
+    memcpy(buffer, RSTRING_PTR(response), length);
+    return length;
+  }
+}
+
+void IOStream::write(const char *str) {
+  rb_funcall(stream, rb_intern("write"), 1, rb_str_new2(str));
+}
+
+void IOStream::write(const char *str, uint64_t l) {
+  rb_funcall(stream, rb_intern("write"), 1, rb_str_new(str, l));
+}
+

data/ext/iostream.h

@@ -0,0 +1,17 @@
+#ifndef SWIFT_IOSTREAM_H
+#define SWIFT_IOSTREAM_H
+
+#include "swift.h"
+
+class IOStream : public dbi::IOStream {
+    private:
+      VALUE stream;
+    public:
+      IOStream(VALUE);
+      std::string& read();
+      uint32_t read(char *, uint32_t);
+      void write(const char *);
+      void write(const char *, uint64_t);
+};
+
+#endif