mao 0.0.3

data/lib/mao.rb

@@ -0,0 +1,180 @@
+require 'pg'
+require 'bigdecimal'
+
+# The top-level module to access Mao.
+module Mao
+  require 'mao/query'
+
+  # Connect to the database.  +options+ is currently the straight Postgres gem
+  # options.
+  def self.connect!(options)
+    unless @conn
+      @conn = PG.connect(options)
+      @conn.internal_encoding = Encoding::UTF_8
+    end
+  end
+
+  # Disconnect from the database.
+  def self.disconnect!
+    @conn.close
+    @conn = nil
+  end
+
+  # Execute the raw SQL +sql+ with positional +args+.  The returned object
+  # varies depending on the database vendor.
+  def self.sql(sql, *args, &block)
+    STDERR.puts "#{sql}#{args ? " " + args.inspect : ""}"
+    @conn.exec(sql, *args, &block)
+  end
+
+  # Quote +name+ as appropriate for a table or column name in an SQL statement.
+  def self.quote_ident(name)
+    case name
+    when Symbol
+      @conn.quote_ident(name.to_s)
+    else
+      @conn.quote_ident(name)
+    end
+  end
+
+  # Escape +value+ as appropriate for a literal in an SQL statement.
+  def self.escape_literal(value)
+    case value
+    when String
+      @conn.escape_literal(value)
+    when NilClass
+      "null"
+    when TrueClass
+      "true"
+    when FalseClass
+      "false"
+    when Numeric
+      value.to_s
+    when Array
+      if value == []
+        # NULL IN NULL is NULL in SQL, so this is "safe".  Empty lists () are
+        # apparently part of the standard, but not widely supported (!).
+        "(null)"
+      else
+        "(#{value.map {|v| escape_literal(v)}.join(", ")})"
+      end
+    when Mao::Query::Raw
+      value.text
+    when Time
+      escape_literal(value.utc.strftime("%Y-%m-%d %H:%M:%S.%6N"))
+    else
+      raise ArgumentError, "don't know how to escape #{value.class}"
+    end
+  end
+
+  # Returns a new Mao::Query object for +table+.
+  def self.query(table)
+    @queries ||= {}
+    @queries[table] ||= Query.new(table).freeze
+  end
+
+  # When raised in a transaction, causes a rollback without the exception
+  # bubbling.
+  Rollback = Class.new(Exception)
+
+  # Executes +block+ in a transaction.
+  #
+  # If +block+ executes without an exception, the transaction is committed.
+  #
+  # If a Mao::Rollback is raised, the transaction is rolled back, and
+  # #transaction returns false.
+  #
+  # If any other Exception is raised, the transaction is rolled back, and the
+  # exception is re-raised.
+  #
+  # Otherwise, the transaction is committed, and the result of +block+ is
+  # returned.
+  def self.transaction(&block)
+    return block.call if @in_transaction
+    @in_transaction = true
+
+    sql("BEGIN")
+    begin
+      r = block.call
+    rescue Rollback
+      sql("ROLLBACK")
+      return false
+    rescue Exception
+      sql("ROLLBACK")
+      raise
+    ensure
+      @in_transaction = false
+    end
+    sql("COMMIT")
+    r
+  end
+
+  # Normalizes the Hash +result+ (of Strings to Strings), with +col_types+
+  # specifying Symbol column names to String PostgreSQL types.
+  def self.normalize_result(result, col_types)
+    Hash[result.map {|k,v|
+      k = k.to_sym
+      [k, convert_type(v, col_types[k])]
+    }]
+  end
+
+  # Normalizes the Hash +result+ (of Strings to Strings), with the joining
+  # tables of +from_query+ and +to_query+.  Assumes the naming convention for
+  # result keys of Mao::Query#join (see Mao::Query#sql) has been followed.
+  def self.normalize_join_result(result, from_query, to_query)
+    results = {}
+    n = 0
+
+    from_table = from_query.table
+    from_types = from_query.col_types
+    from_types.keys.sort.each do |k|
+      n += 1
+      key = "c#{n}"
+      if result.include?(key)
+        results[from_table] ||= {}
+        results[from_table][k] = convert_type(result[key], from_types[k])
+      end
+    end
+
+    to_table = to_query.table
+    to_types = to_query.col_types
+    to_types.keys.sort.each do |k|
+      n += 1
+      key = "c#{n}"
+      if result.include?(key)
+        results[to_table] ||= {}
+        results[to_table][k] = convert_type(result[key], to_types[k])
+      end
+    end
+
+    results
+  end
+
+  # Converts +value+ to a native Ruby value, based on the PostgreSQL type
+  # +type+.
+  def self.convert_type(value, type)
+    return nil if value.nil?
+
+    case type
+    when "integer", "smallint", "bigint", "serial", "bigserial"
+      value.to_i
+    when /^character varying/, "text"
+      value
+    when "timestamp without time zone"
+      # We assume it's in UTC.  (Dangerous?)
+      value =~ /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)$/
+      Time.new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_f, 0)
+    when "boolean"
+      value == "t"
+    when "bytea"
+      PG::Connection.unescape_bytea(value)
+    when "numeric"
+      BigDecimal.new(value)
+    else
+      STDERR.puts "#{self.name}: unknown type: #{type}"
+      value
+    end
+  end
+end
+
+# vim: set sw=2 cc=80 et:

data/mao.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path('../lib/mao/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Timothy Leslie Allen", "Arlen Christian Mart Cuss"]
+  gem.email         = ["allen.timothy.email@gmail.com", "ar@len.me"]
+  gem.description   = %q{Mao Ain't an ORM}
+  gem.summary       = %q{A database access layer.  Currently supports PG.}
+  gem.homepage      = "https://github.com/unnali/mao" # TBD
+
+  gem.add_dependency('pg')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('rspec')
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "mao"
+  gem.require_paths = ["lib"]
+  gem.version       = Mao::VERSION
+end
+
+# vim: set sw=2 et cc=80:

data/spec/filter_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Mao::Filter do
+  before { prepare_spec }
+
+  let(:col_x) { Mao::Filter::Column.new(:name => :x) }
+  let(:col_y) { Mao::Filter::Column.new(:name => :y) }
+
+  describe ".finalize_or_literal" do
+    context "with Mao::Filter" do
+      before { col_x.should_receive(:finalize).
+                   with(no_args).and_return("blah") }
+      it { Mao::Filter.finalize_or_literal(col_x).should eq "blah" }
+    end
+
+    context "with non-Mao::Filter" do
+      before { Mao.should_receive(:escape_literal).
+                   with(42).and_return("ha") }
+      it { Mao::Filter.finalize_or_literal(42).should eq "ha" }
+    end
+  end
+
+  describe ".sql" do
+    context "Arrays" do
+      let(:klass) { double("klass") }
+      before { Mao::Filter.should_receive(:const_get).
+                 with(:Hullo).and_return(klass) }
+      before { klass.should_receive(:sql).with(:mao).and_return :dengxiaoping }
+      it { Mao::Filter.sql([:Hullo, :mao]).should eq :dengxiaoping }
+    end
+
+    context "Strings" do
+      it { Mao::Filter.sql("BATTLE ROYALE").should eq "BATTLE ROYALE" }
+    end
+  end
+
+  describe "#and" do
+    subject { col_x.and(col_y) }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "AND" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#or" do
+    subject { col_x.or(col_y) }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "OR" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#==" do
+    subject { col_x == col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "=" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#!=" do
+    subject { col_x != col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "<>" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#>" do
+    subject { col_x > col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq ">" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#>=" do
+    subject { col_x >= col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq ">=" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#<" do
+    subject { col_x < col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "<" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#<=" do
+    subject { col_x <= col_y }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "<=" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be col_y }
+  end
+
+  describe "#null?" do
+    subject { col_x.null? }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "IS" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should be_nil }
+  end
+
+  describe "#in" do
+    subject { col_x.in([1, 2, 3]) }
+
+    it { should be_an_instance_of Mao::Filter::Binary }
+    it { subject.options[:op].should eq "IN" }
+    it { subject.options[:lhs].should be col_x }
+    it { subject.options[:rhs].should eq [1, 2, 3] }
+  end
+end
+
+describe Mao::Filter::Column do
+  before { prepare_spec }
+
+  context "without table" do
+    subject { Mao::Filter::Column.new(:name => :Margorth) }
+    its(:finalize) { should eq [:Column, :Margorth] }
+    it { Mao::Filter.sql(subject.finalize).should eq '"Margorth"' }
+  end
+
+  context "with table" do
+    subject { Mao::Filter::Column.new(:table => :Lol, :name => :Margorth) }
+    its(:finalize) { should eq [:Column, :Lol, :Margorth] }
+    it { Mao::Filter.sql(subject.finalize).should eq '"Lol"."Margorth"' }
+  end
+end
+
+describe Mao::Filter::Binary do
+  before { prepare_spec }
+  subject { Mao::Filter::Binary.new(:lhs => 42, :op => '=', :rhs => 42) }
+
+  its(:finalize) { should eq [:Binary, '=', "42", "42"] }
+  it { Mao::Filter.sql(subject.finalize).should eq "(42 = 42)" }
+end
+
+describe Mao::Filter::Table do
+  before { prepare_spec }
+
+  context "non-explicit" do
+    let(:some) { Mao::Filter::Table.new(Mao.query(:some), false) }
+    it { some.value.should be_an_instance_of Mao::Filter::Column }
+    it { some.value.finalize.should eq [:Column, :value] }
+  end
+
+  context "explicit" do
+    let(:some) { Mao::Filter::Table.new(Mao.query(:some), true) }
+    it { some.value.should be_an_instance_of Mao::Filter::Column }
+    it { some.value.finalize.should eq [:Column, :some, :value] }
+  end
+
+  context "non-extant" do
+    let(:some) { Mao::Filter::Table.new(Mao.query(:some), false) }
+    it { expect { some.blargh }.to raise_exception(ArgumentError) }
+  end
+end
+
+# vim: set sw=2 cc=80 et:

data/spec/fixture.sql

@@ -0,0 +1,38 @@
+DROP TABLE IF EXISTS empty;
+CREATE TABLE empty (
+  id INT,
+  value VARCHAR(200));
+
+DROP TABLE IF EXISTS one;
+CREATE TABLE one (
+  id INT,
+  value VARCHAR(200));
+
+INSERT INTO one (id, value) VALUES (42, '你好, Dave.');
+
+DROP TABLE IF EXISTS "some";
+CREATE TABLE "some" (
+  id INT,
+  value VARCHAR(100));
+
+INSERT INTO "some" (id, value) VALUES (1, 'Bah'), (2, 'Hah'), (3, '你好, Dave.');
+
+DROP TABLE IF EXISTS typey;
+CREATE TABLE typey (
+  korea BOOLEAN DEFAULT TRUE,
+  japan DECIMAL(19,3),
+  china BYTEA);
+
+INSERT INTO typey (korea, japan, china) VALUES (true, 1234567890123456.789, E'WHAT\\000'), (false, -1234567890123456.789, E'HUH\\001\\002');
+
+DROP TABLE IF EXISTS autoid;
+CREATE TABLE autoid (
+  id SERIAL PRIMARY KEY NOT NULL,
+  value VARCHAR(100));
+
+DROP TABLE IF EXISTS times;
+CREATE TABLE times (
+  id SERIAL PRIMARY KEY NOT NULL,
+  time TIMESTAMP WITHOUT TIME ZONE NOT NULL);
+
+INSERT INTO times (time) VALUES ('2012-11-10T19:45:00Z');

data/spec/mao_spec.rb

@@ -0,0 +1,220 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Mao do
+  before { prepare_spec }
+
+  describe ".connect!" do
+    let(:options) { double("options") }
+    let(:conn) { double("conn") }
+    before { PG.should_receive(:connect).with(options).and_return(conn) }
+    before { conn.should_receive(:internal_encoding=).with(Encoding::UTF_8) }
+    before { Mao.disconnect! rescue false }
+    it { Mao.connect!(options) }
+    after { Mao.instance_variable_set("@conn", nil) }
+  end
+
+  describe ".disconnect!" do
+    before { PG::Connection.any_instance.should_receive(:close) }
+    it { Mao.disconnect! }
+  end
+
+  describe ".sql" do
+    before { PG::Connection.any_instance.should_receive(:exec).
+                 with(:x).and_return(:y) }
+    it { Mao.sql(:x).should eq :y }
+  end
+
+  describe ".quote_ident" do
+    context "pass-thru" do
+      before { PG::Connection.any_instance.should_receive(:quote_ident).
+                   with("table").and_return(%q{"table"}) }
+      it { Mao.quote_ident("table").should eq %q{"table"} }
+    end
+
+    context "Symbols" do
+      before { PG::Connection.any_instance.should_receive(:quote_ident).
+                   with("table").and_return(%q{"table"}) }
+      it { Mao.quote_ident(:table).should eq %q{"table"} }
+    end
+  end
+
+  describe ".escape_literal" do
+    describe "verify pass-thru String" do
+      before { PG::Connection.any_instance.should_receive(:escape_literal).
+                   with("table").and_return(%q{'table'}) }
+      it { Mao.escape_literal("table").should eq %q{'table'} }
+    end
+
+    describe "verify not pass-thru others" do
+      before { PG::Connection.any_instance.
+                   should_not_receive(:escape_literal) }
+      it { Mao.escape_literal(nil).should eq "null" }
+    end
+
+    describe "actual values" do
+      it { Mao.escape_literal("table").should eq %q{'table'} }
+      it { Mao.escape_literal(42).should eq %q{42} }
+      it { Mao.escape_literal(true).should eq %q{true} }
+      it { Mao.escape_literal(false).should eq %q{false} }
+      it { Mao.escape_literal(nil).should eq %q{null} }
+      it { Mao.escape_literal([]).should eq %q{(null)} }
+      it { Mao.escape_literal([1]).should eq %q{(1)} }
+      it { Mao.escape_literal([1, "xzy"]).should eq %q{(1, 'xzy')} }
+      it { Mao.escape_literal(Mao::Query.raw("\n\"'%")).should eq "\n\"'%" }
+
+      # Times are escaped to UTC always.
+      it { Mao.escape_literal(Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600)).
+               should eq %q{'2012-11-10 19:45:00.000000'} }
+      it { Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0, 0)).
+               should eq %q{'2012-11-10 19:45:00.000000'} }
+      it { Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0.1, 0)).
+               should eq %q{'2012-11-10 19:45:00.100000'} }
+    end
+  end
+
+  describe ".query" do
+    subject { Mao.query(:empty) }
+    it { should be_an_instance_of Mao::Query }
+    it { should be_frozen }
+  end
+
+  describe ".transaction" do
+    context "empty" do
+      before { PG::Connection.any_instance.should_receive(:exec).
+                   with("BEGIN") }
+      before { PG::Connection.any_instance.should_receive(:exec).
+                   with("COMMIT") }
+      it { Mao.transaction {} }
+    end
+
+    context "success" do
+      before { Mao.should_receive(:sql).with("BEGIN") }
+      before { Mao.should_receive(:sql).with(:some_sql).and_return :ok }
+      before { Mao.should_receive(:sql).with("COMMIT") }
+      it { Mao.transaction { Mao.sql(:some_sql) }.
+               should eq :ok }
+    end
+
+    context "failure" do
+      before { Mao.should_receive(:sql).with("BEGIN") }
+      before { Mao.should_receive(:sql).with(:some_sql).
+                   and_raise(Exception.new) }
+      before { Mao.should_receive(:sql).with("ROLLBACK") }
+      it { expect { Mao.transaction { Mao.sql(:some_sql) }
+                  }.to raise_exception }
+    end
+
+    context "rollback" do
+      before { Mao.should_receive(:sql).with("BEGIN") }
+      before { Mao.should_receive(:sql).with(:some_sql).
+                   and_raise(Mao::Rollback) }
+      before { Mao.should_receive(:sql).with("ROLLBACK") }
+      it { expect { Mao.transaction { Mao.sql(:some_sql) }
+                  }.to_not raise_exception }
+    end
+
+    context "nested transactions" do
+      # Currently not supported: the inner transactions don't add transactions
+      # at all.
+      before { Mao.should_receive(:sql).with("BEGIN").once }
+      before { Mao.should_receive(:sql).with("ROLLBACK").once }
+
+      it do
+        Mao.transaction { Mao.transaction { raise Mao::Rollback } }.
+            should be_false
+      end
+    end
+  end
+
+  describe ".normalize_result" do
+    before { Mao.should_receive(:convert_type).
+                 with("y", "zzz").and_return("q") }
+    it { Mao.normalize_result({"x" => "y"}, {:x => "zzz"}).
+             should eq({:x => "q"}) }
+  end
+
+  describe ".normalize_join_result" do
+    let(:from) { double("from") }
+    let(:to) { double("to") }
+
+    before { from.should_receive(:table).and_return(:from) }
+    before { from.should_receive(:col_types).and_return({:a => "integer"}) }
+    before { to.should_receive(:table).and_return(:to) }
+    before { to.should_receive(:col_types).
+                 and_return({:b => "character varying"}) }
+
+    it { Mao.normalize_join_result(
+             {"c1" => "1", "c2" => "2"}, from, to).
+             should eq({:from => {:a => 1},
+                        :to => {:b => "2"}}) }
+
+    it { Mao.normalize_join_result(
+             {"c1" => "1"}, from, to).
+             should eq({:from => {:a => 1}}) }
+  end
+
+  describe ".convert_type" do
+    context "integers" do
+      it { Mao.convert_type(nil, "integer").should be_nil }
+      it { Mao.convert_type("42", "integer").should eq 42 }
+      it { Mao.convert_type("42", "smallint").should eq 42 }
+      it { Mao.convert_type("42", "bigint").should eq 42 }
+      it { Mao.convert_type("42", "serial").should eq 42 }
+      it { Mao.convert_type("42", "bigserial").should eq 42 }
+    end
+
+    context "character" do
+      it { Mao.convert_type(nil, "character varying").should be_nil }
+      it { Mao.convert_type("blah", "character varying").
+               should eq "blah" }
+      it { Mao.convert_type("blah", "character varying").encoding.
+               should be Encoding::UTF_8 }
+
+      it { Mao.convert_type(nil, "character varying(200)").should be_nil }
+      it { Mao.convert_type("blah", "character varying(200)").
+               should eq "blah" }
+      it { Mao.convert_type("blah", "character varying(200)").encoding.
+               should be Encoding::UTF_8 }
+
+      it { Mao.convert_type(nil, "text").should be_nil }
+      it { Mao.convert_type("blah", "text").
+               should eq "blah" }
+      it { Mao.convert_type("blah", "text").encoding.
+               should be Encoding::UTF_8 }
+    end
+
+    context "dates" do
+      it { Mao.convert_type(nil, "timestamp without time zone").
+               should be_nil }
+      # Note: without timezone is assumed to be in UTC.
+      it { Mao.convert_type("2012-11-10 19:45:00",
+                             "timestamp without time zone").
+               should eq Time.new(2012, 11, 10, 19, 45, 0, 0) }
+      it { Mao.convert_type("2012-11-10 19:45:00.1",
+                             "timestamp without time zone").
+               should eq Time.new(2012, 11, 10, 19, 45, 0.1, 0) }
+    end
+
+    context "booleans" do
+      it { Mao.convert_type(nil, "boolean").should be_nil }
+      it { Mao.convert_type("t", "boolean").should eq true }
+      it { Mao.convert_type("f", "boolean").should eq false }
+    end
+
+    context "bytea" do
+      it { Mao.convert_type(nil, "bytea").should be_nil }
+      it { Mao.convert_type("\\x5748415400", "bytea").should eq "WHAT\x00" }
+      it { Mao.convert_type("\\x5748415400", "bytea").encoding.
+               should eq Encoding::ASCII_8BIT }
+    end
+
+    context "numeric" do
+      it { Mao.convert_type(nil, "numeric").should be_nil }
+      it { Mao.convert_type("1234567890123456.789", "numeric").
+               should eq BigDecimal.new("1234567890123456.789") }
+    end
+  end
+end
+
+# vim: set sw=2 cc=80 et: