sql_munger 0.0.7

data/lib/sql_munger/sql_parser.rb

@@ -0,0 +1,47 @@
+require 'treetop'
+require 'sql_munger/nodes.rb'
+
+Treetop.load "#{File.dirname(__FILE__)}/sql.tt"
+
+class SqlParser
+  unless instance_methods.include? 'case_sensitive_parse'
+    alias_method :case_sensitive_parse, :parse
+  end
+  
+  # Allow for case-insensitive parsing. Convert
+  # to downcase, then parse, then replace the string
+  # with the original version. The numeric indices
+  # will still point to the right places.
+  def parse( st, *args )
+    ds = st.downcase
+    begin
+      root = case_sensitive_parse( ds, *args )
+    ensure
+      ds.replace st
+    end
+    
+    # raise exception on failure
+    # or return the root of the parse tree on success
+    if root.nil?
+      raise "SQL error at #{failure_line}:#{failure_column}. #{failure_reason}"
+    else
+      root
+    end
+  end
+
+  def dump( sql )
+    root = parse( sql )
+    root.statements.map do |table|
+      if table.respond_to? :name
+        puts table.name
+        columns = %w{name sql_type length precision scale}
+        table.fields.each do |field|
+          puts "  " + columns.map{|x| field.send(x) }.join(', ')
+        end
+      else
+        puts table.text_value
+      end
+    end
+    puts
+  end
+end

data/lib/sql_munger/table_name.rb

@@ -0,0 +1,47 @@
+require 'sql_munger/sql_parser.rb'
+require 'sql_munger/quoter.rb'
+
+module SqlMunger
+
+# Essentially a qualified table name that's parsed
+# and makes the parts accessible.
+# TODO reduce dependency on Treetop and parser.
+class TableName
+  include Quoter
+  
+  def initialize( qualified_identifier, quoter = nil )
+    @quoter = quoter
+    @qualified_identifier = qualified_identifier
+    @tree = self.class.sql_parser.parse( @qualified_identifier )
+  end
+  
+  attr_reader :tree
+  
+  def self.sql_parser
+    if @sql_parser.nil?
+      @sql_parser = SqlParser.new
+      @sql_parser.root = :qualified_identifier
+    end
+    @sql_parser
+  end
+  
+  def name
+    @tree.parts.last
+  end
+  
+  def parts
+    @tree.parts
+  end
+  
+  def quote
+    parts.map do |part|
+      quoter.quote_ident( part )
+    end.join('.')
+  end
+  
+  def to_s
+    @tree.parts.join( '.' )
+  end
+end
+
+end

data/lib/sql_munger/value_quoter.rb

@@ -0,0 +1,30 @@
+require 'date'
+
+module SqlMunger
+
+# Quote a value in default SQL standard style. Probably
+# won't work for many backends, so the quote
+# method from, for example, DBI should be used.
+module ValueQuoter
+  def quote( value )
+    case value
+      when NilClass
+        "null"
+      
+      when Numeric
+        value
+      
+      when DateTime
+        # 2004-10-19 10:23:54
+        "'#{value.strftime "%Y-%m-%d %H:%M:%S"}'"
+      
+      when Date, Time
+        "'#{value}'"
+        
+      else
+        "'#{escape( value  )}'"
+    end
+  end
+end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib sql_munger]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/spec/sql_munger_spec.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe SqlMunger do
+end
+
+# EOF

data/test/mock_field.rb

@@ -0,0 +1,2 @@
+class MockField < Struct.new( :name, :sql_type, :null, :default )
+end

data/test/test_field_set.rb

@@ -0,0 +1,462 @@
+require File.dirname(__FILE__) + '/test_sql_munger.rb'
+require File.dirname(__FILE__) + '/mock_field.rb'
+
+class TestFieldSet < Test::Unit::TestCase
+  def setup
+    @fields = [
+      MockField.new( :id, 'int', false, 'nextval'),
+      MockField.new( :name, 'varchar(20)' ),
+      MockField.new( :key, 'varchar(50)' ),
+      MockField.new( :value, 'varchar(200)' ),
+    ]
+    
+    @hash_values = {
+      :key => 'cut',
+      :value => 15,
+      :name => 'Egoyan',
+      :id => '700822',
+      :extra => 'movie',
+    }
+    
+    @name_block = lambda{|x| x.name}
+    @field_name_objects = @fields.map{|x| FieldSet::Field.new( @name_block.call(x) ) }
+    @field_names = @fields.map( &@name_block )
+    
+    @values = @field_names.map{|x| @hash_values[x] }
+    
+    @quoted_values = @values.dup.map do |value| 
+      case value
+        when Numeric
+          value
+        else
+          %Q{'#{value}'}
+        end
+    end
+    
+    @fs = FieldSet.new( @fields, &@name_block )
+  end
+  
+  def self.should_have_empty_names
+    should "have no field_names" do
+      assert_nil @fs.instance_variable_get( '@field_names' ) 
+    end
+  end
+  
+  def self.should_build_field_names
+    should_have_empty_names
+    
+    should "have a field transform" do
+      block = @fs.instance_variable_get( '@field_name_block' )
+      assert_kind_of Proc, block
+      
+      # check that both blocks return the name from a field object
+      the_name = Struct.new( :name ).new( 'my name' )
+      assert_equal @name_block.call( the_name ), block.call( the_name )
+    end
+    
+    should "create field names" do 
+      names = @fs.send :sanity_check_fields
+      assert_equal @field_names, names
+    end
+    
+    should "return field names" do
+      assert_equal @field_names, @fs.field_names
+    end
+  end
+  
+  def self.should_fields_as_names
+    should "have the same fields" do
+      assert_equal @field_name_objects, @fs.fields
+      assert_equal @field_names, @fs.field_names
+    end
+  end
+  
+  def self.should_have_field_objects
+    should "have field objects" do
+      @fs.fields.each { |e| assert_instance_of MockField, e }
+      assert_equal @fields, @fs.fields
+    end
+  end
+  
+  should "have symbols for field names" do
+    assert @field_names.all?{|x| x.is_a? Symbol}, "#{@field_names} are not all symbols"
+  end
+  
+  context "Field" do
+    setup do 
+      @name = 'some_name'
+      @field = FieldSet::Field.new( @name )
+      @other_field = FieldSet::Field.new( @name )
+    end
+    
+    should "be equal" do
+      assert_equal @name.to_sym, @field.name
+      assert_equal @name.to_sym, @other_field.name
+      assert_equal @field, @other_field
+    end
+  end
+
+  context "Construct" do
+    context "FieldSet.new( Array<Field> ) {|x| x.name}" do
+      setup do 
+        @fs = FieldSet.new( @fields, &@name_block )
+      end
+      
+      should_build_field_names
+      should_have_field_objects
+    end
+    
+    context "FieldSet.new( Array<Field> ) with no block" do
+      setup do 
+        @fs = FieldSet.new( @fields )
+      end
+      
+      should_build_field_names
+      should_have_field_objects
+    end
+    
+    context "FieldSet.new( Array<String> )" do
+      setup do 
+        @fs = FieldSet.new @field_names
+      end
+      
+      should_fields_as_names
+    end
+    
+    context "FieldSet.new( Array<Symbol> )" do
+      setup do 
+        @fs = FieldSet.new @field_names.map( &:to_sym )
+      end
+      
+      should_fields_as_names
+    end
+    
+    context "name block" do
+      setup do
+        @blah_fs = FieldSet.new( @field_names ) {|x| x.blah_name}
+        @fs = FieldSet.new( @field_names ) {|x| x.name}
+      end
+      
+      should "fail" do
+        assert_raise( NoMethodError ) { @blah_fs.field_names }
+      end
+      
+      should "succeed" do
+        assert_nothing_raised( Exception ) { @fs.field_names }
+      end
+  end
+    
+    context "FieldSet[Array<FieldObject>]" do
+      setup do
+        assert_raise RuntimeError { @fs = FieldSet[@fields] }
+      end
+    end
+    
+    context "FieldSet[Array<String>]" do
+      setup do 
+        @fs = FieldSet[@field_names]
+      end
+      
+      should_fields_as_names
+    end
+  end
+  
+  context "reconstruct" do 
+    setup do
+      @recon = @fs.reconstruct do |fields|
+        fields.select{|x| [:key, :value].include?( x.name )}
+      end
+    end
+    
+    should "have the correct fields" do
+      assert_equal [:key, :value], @recon.field_names
+    end
+  end
+  
+  context "assign fields" do
+    setup do
+      # create new field objects
+      @new_field_names = %w{religion member holiday}
+      @new_fields = @new_field_names.map{|x| MockField.new(x)}
+      
+      # now assign the fields, which should clear out @field_names
+      @fs.fields = @new_fields
+    end
+    
+    should_have_empty_names
+    
+    should "have new names" do
+      assert_equal @new_field_names, @fs.field_names
+    end
+    
+    should "be different to old names" do
+      assert_not_equal @fields, @fs.fields
+      assert_not_equal @field_names, @fs.field_names
+    end
+  end
+  
+  context "qualify field names" do
+    setup do 
+      @qualifier = 'table_name'
+      @fs.qualifier = @qualifier
+    end
+    
+    should "qualify" do
+      assert_equal %Q{"table_name"."id"}, @fs.qualify( 'id' )
+      assert_equal %Q{"scheman"."id"}, @fs.qualify( 'scheman', 'id' )
+      assert_equal %Q{"scheman"."tbk"."id"}, @fs.qualify( ['scheman', 'tbk'], 'id' )
+      assert_equal %Q{"scheman"."tbk"."id"}, @fs.qualify( %w{scheman tbk id} )
+      assert_equal %Q{"scheman"."tbk"."id"}, @fs.qualify( 'scheman', 'tbk', 'id' )
+    end
+    
+    context "TableName" do
+      setup do
+        @qualifier = TableName.new( 'more.than.one' )
+        @fs.qualifier = @qualifier
+      end
+      
+      should "qualify" do
+        assert_equal %Q{"more"."than"."one"."id"}, @fs.qualify( 'id' )
+      end
+    end
+    
+    should "no qualifier" do
+      assert_equal @field_names.map{|x| %Q{"#{x}"}}.join(', '), @fs.list
+    end
+    
+    should "have qualifier" do
+      assert_equal [ @qualifier ], @fs.qualifier
+    end
+    
+    should "with builtin qualifier" do
+      assert_equal @field_names.map{|x| %Q{"#{@qualifier}"."#{x}"}}.join(', '), @fs.qualified_list
+    end
+    
+    should "with other qualifier" do
+      qualifier = 'hello'
+      assert_equal @field_names.map{|x| %Q{"#{qualifier}"."#{x}"}}.join(', '), @fs.list( qualifier )
+    end
+    
+    context "quoter" do
+      should_eventually "test alternative quoter"
+      should_eventually "test with DBI quoter"
+    end
+    
+    context "array qualifier" do
+      setup do 
+        @qualifier = %w{namespace user}
+        @fs.qualifier = @qualifier
+      end
+      
+      should "list" do
+        assert_equal @field_names.map{|x| %Q{"namespace"."user"."#{x}"}}.join(', '), @fs.qualified_list
+      end
+    end
+  end
+  
+  context "Collections" do
+    should "be enumerable" do
+      assert_kind_of Enumerable, @fs 
+    end
+    
+    should "enumerate" do
+      @fs.each do |field|
+        assert_instance_of Symbol, field
+        assert @field_names.include?( field )
+      end
+    end
+    
+    context "values" do
+      should "fetch values only" do
+        assert_equal( (@values - [ 'movie' ]), @fs.values( @hash_values ) )
+      end
+      
+      should "fetch values transformed" do
+        assert_equal( (@values - [ 'movie' ]), @fs.values( @hash_values ){|x| x} )
+      end
+      
+      should "fetch quoted values only" do
+        assert_equal( (@quoted_values - [ "'movie'" ]), @fs.quoted_values( @hash_values ) )
+      end
+      
+      should "fetch hash" do
+        assert_equal @hash_values.reject{ |k,v| v == 'movie' }, @fs.hash_values( @hash_values )
+      end
+
+      should "fetch hash transformed" do
+        assert_equal @hash_values.reject{ |k,v| v == 'movie' }, @fs.hash_values( @hash_values ){|x| x}
+      end
+    end
+  end
+  
+  context "express" do
+    should "fail on array size mismatch" do
+      assert_raise( RuntimeError ) { @fs.express( 1,2,3 ) }
+    end
+    
+    should_eventually "test with Array"
+    should_eventually "test with Hash"
+    should_eventually "test with to_hash"
+  end
+  
+  context "generate SQL fragments" do
+    context "comparison" do
+      setup do 
+        @fs.qualifier = "table"
+        
+        @result = <<EOF.chomp
+( "table"."id" = "other"."id" and "table"."name" = "other"."name" and "table"."key" = "other"."key" and "table"."value" = "other"."value" )
+EOF
+
+        @value_result = <<EOF.chomp
+( "table"."id" = '700822' and "table"."name" = 'Egoyan' and "table"."key" = 'cut' and "table"."value" = 15 )
+EOF
+      end
+      
+      context "no local qualifier" do
+        setup do 
+          @fs.qualifier = nil
+        end
+        
+        should "raise exception" do
+          assert_nil @fs.qualifier
+          assert_raise( RuntimeError ) { @fs.comparison( 'other' ) }
+        end
+      end
+    
+      should "other table" do
+        assert_not_nil @fs.qualifier
+        assert_equal @result, @fs.comparison( 'other' )
+        assert_equal @result.gsub( '=', '<' ), @fs.comparison( 'other', '<' )
+      end
+      
+      should "values" do
+        assert_equal @value_result, @fs.comparison( @values )
+        assert_equal @value_result, @fs.comparison( @hash_values )
+      end
+    end
+    
+    context "update" do
+      setup do
+        @table_result = <<EOF.chomp
+"id" = "oops"."id", "name" = "oops"."name", "key" = "oops"."key", "value" = "oops"."value"
+EOF
+        
+        @value_result = <<EOF.chomp
+"id" = '700822', "name" = 'Egoyan', "key" = 'cut', "value" = 15
+EOF
+      end
+      
+      should "produce update fragment" do
+        assert_equal @value_result, @fs.update( @hash_values )
+        assert_equal @value_result, @fs.update( @values )
+        assert_equal @table_result, @fs.update( 'oops' )
+      end
+    end
+    
+    context "definition" do
+      should "create table" do
+        result = "id int, name varchar(20), key varchar(50), value varchar(200)"
+        assert_equal result, @fs.definitions
+        assert_equal result.gsub(', ', ",\n"), @fs.definitions( :joiner => ",\n" )
+      end
+    end
+  end
+  
+  context "Set operations" do
+    
+    context "difference" do
+      setup do 
+        @other = FieldSet.new( @fields[1..-1] )
+        @difference = @fs - @other
+      end
+      
+      should "have only id" do
+        assert_not_nil @difference
+        # Field objects
+        assert_equal [ @fields.first ], @difference.fields
+        
+        # strings
+        assert_equal [ @fields.first ], ( @fs - ( @field_names - [:id] ) ).fields
+        
+        # symbols
+        assert_equal [ @fields.first ], ( @fs - ( @field_names.map{|x| x.to_sym} - [:id] ) ).fields
+      end
+      
+      should "copy qualifier" do
+        assert_equal @fs.qualifier, @difference.qualifier
+      end
+      
+      should "copy quoter" do
+        assert_equal @fs.quoter, @difference.quoter
+      end
+    end
+    
+    context "append" do
+      setup do
+        @timestamp_field = MockField.new( 'date', 'timestamp' )
+        @sum = @fs + FieldSet.new( [@timestamp_field] )
+      end
+      
+      should "have timestamp as well" do
+        assert_not_nil @sum
+        assert_equal @fields + [@timestamp_field], @sum.fields
+      end
+      
+      should "not fail on String extension" do
+        assert_nothing_raised( RuntimeError ) { @fs + [ 'date' ] }
+      end
+    end
+    
+    context "union" do
+      setup do
+        @timestamp_field = MockField.new( :date, 'timestamp' )
+        @other_id_field = MockField.new( :id, 'string' )
+        @union = @fs | FieldSet.new( [@timestamp_field, @other_id_field] )
+        @string_union = @fs | %w{date id}.map( &:to_sym )
+      end
+      
+      should "have only one extra field" do
+        assert_equal @fs.fields.size+1, @union.fields.size
+        assert_equal @fs.fields.size+1, @string_union.fields.size
+      end
+      
+      should "have the right field names" do
+        assert_equal @field_names + [:date], @union.field_names
+        assert_equal @field_names + [:date], @string_union.field_names
+      end
+      
+      should "have timestamp" do
+        assert_not_nil @union
+        assert_equal @fields + [@timestamp_field], @union.fields
+        assert_equal @field_names + [:date], @string_union.field_names
+      end
+      
+      should "have original id only" do
+        assert_not_nil @union
+        assert_equal @fields + [@timestamp_field], @union.fields
+        assert_not_equal @fs.find_field('id'), @other_id_field
+      end
+      
+      should "not fail on String extension" do
+        assert_nothing_raised( RuntimeError ) { @fs | [ 'date' ] }
+      end
+    end
+    
+    context "intersection" do
+      setup do 
+        @id_only = @fs & FieldSet.new( ['id'] )
+      end
+      
+      should "accept String subset" do
+        assert_nothing_raised( Exception ) { @fs & [ 'date' ] }
+      end
+      
+      should "should have only id" do
+        #~ puts "id_only.field_names: #{@id_only.field_names.inspect}"
+        assert_equal [:id], @id_only.field_names
+      end
+    end
+    
+  end
+end