rsql 0.2.11 → 0.3.1

data/bin/rsql

@@ -63,11 +63,13 @@ ARGV.map!{|a| a.sub(/^--/,'-')}
 if i = ARGV.index('-rc')
     ARGV.delete_at(i)
     rc_fn = ARGV.delete_at(i)
-else
+elsif ENV['HOME']
     rc_fn = File.join(ENV['HOME'], ".#{bn}rc")
 end
 
-eval_context.load(rc_fn, :skip_init_registrations) if File.exists?(rc_fn)
+if rc_fn && File.exists?(rc_fn)
+    eval_context.load(rc_fn, :skip_init_registrations)
+end
 
 def get_password(prompt)
     STDOUT.print(prompt)
@@ -160,10 +162,14 @@ if i = ARGV.index('-ssh')
     (opts.ssh_host, opts.ssh_user, opts.ssh_password, opts.ssh_port) =
         split_login(ARGV.delete_at(i))
 
-    default_config = File.join(ENV['HOME'], '.ssh', 'config')
-    if File.exists?(default_config)
-        opts.ssh_config = default_config
-        opts.ssh_cfghash = Net::SSH::Config.load(default_config, opts.ssh_host)
+    opts.ssh_cfghash = {}
+
+    if ENV['HOME']
+        default_config = File.join(ENV['HOME'], '.ssh', 'config')
+        if File.exists?(default_config)
+            opts.ssh_config = default_config
+            opts.ssh_cfghash = Net::SSH::Config.load(default_config, opts.ssh_host)
+        end
     end
 
     if opts.ssh_user.nil? || opts.ssh_user.empty?
@@ -237,7 +243,7 @@ MySQLResults.database_name = ARGV.shift
 
 if !$stdin.tty? && opts.batch_input.nil?
     # accept commands from stdin
-    opts.batch_input = $stdin.read.gsub(/\r?\n/,';')
+    opts.batch_input = $stdin.read
 end
 
 # make sure we remove any duplicates when we add to the history to
@@ -381,7 +387,8 @@ if opts.ssh_host
     ipc_state = ''
     15.times do
         sleep(1)
-        ipc_state = IO.read(ipc_fn).strip
+        # if the fork fails, it'll call our at_exit which removes the ipc file
+        ipc_state = File.exists?(ipc_fn) ? IO.read(ipc_fn).strip : 'fail'
         break if ipc_state == 'ready' || ipc_state == 'fail'
     end
 
@@ -428,9 +435,11 @@ rescue Exception => ex
     exit 1
 end
 
-history_fn = File.join(ENV['HOME'], ".#{bn}_history")
-if File.exists?(history_fn) && 0 < File.size(history_fn)
-    YAML.load_file(history_fn).each {|i| Readline::HISTORY.push(i)}
+if ENV['HOME']
+    history_fn = File.join(ENV['HOME'], ".#{bn}_history")
+    if File.exists?(history_fn) && 0 < File.size(history_fn)
+        YAML.load_file(history_fn).each {|i| Readline::HISTORY.push(i)}
+    end
 end
 
 Readline.completion_proc = eval_context.method(:complete)
@@ -515,6 +524,7 @@ end
 
 child_pids << kill_pid
 opts.delete_field(:mysql_password)
+# fixme: consider emulating a shell prompt and have this cancel any current cmd line
 Signal.trap('INT', nil)
 
 Signal.trap('CHLD') do
@@ -544,7 +554,7 @@ end
 
 sleep(0.3)
 
-if Readline::HISTORY.any?
+if Readline::HISTORY.any? && history_fn
     if 100 < Readline::HISTORY.size
         (Readline::HISTORY.size - 100).times do |i|
             Readline::HISTORY.delete_at(i)

data/lib/rsql.rb

@@ -5,7 +5,25 @@
 # information.
 #
 module RSQL
-    VERSION = '0.2.11'
+    VERSION = [0,3,1]
+
+    def VERSION.to_s
+        self.join('.')
+    end
+
+    # Set up our version to be comparable to version strings.
+    #
+    VERSION.extend(Comparable)
+    def VERSION.eql?(version)
+        self.<=>(version) == 0
+    end
+    def VERSION.<=>(version)
+        version = version.split('.').map!{|v|v.to_i}
+        r = self[0] <=> version[0]
+        r = self[1] <=> version[1] if r == 0
+        r = self[2] <=> version[2] if r == 0
+        r
+    end
 
     require 'rsql/mysql_results'
     require 'rsql/eval_context'

data/lib/rsql/commands.rb

@@ -21,6 +21,16 @@
 
 module RSQL
 
+    # FIXME:
+    #
+    # select Count(*) from BcheckResults where LastResult != 'Succeeded' and LastResultTime > DATE_SUB(UTC_TIMESTAMP, INTERVAL 1 DAY);
+    # NoMethodError: undefined method `+' for nil:NilClass
+    # /usr/lib/ruby/gems/1.8/gems/rsql-0.2.11/lib/rsql/commands.rb:82:in `initialize'
+    # /usr/lib/ruby/gems/1.8/gems/rsql-0.2.11/bin/rsql:535:in `join'
+    # /usr/lib/ruby/gems/1.8/gems/rsql-0.2.11/bin/rsql:535
+    # /bin/rsql:19:in `load'
+    # /bin/rsql:19
+
     require 'stringio'
 
     EvalResults = Struct.new(:value, :stdout)

data/lib/rsql/eval_context.rb

@@ -125,7 +125,7 @@ module RSQL
             if Exception === ret
                 @loaded_fns_state[fn] = :failed
                 if @verbose
-                    $stderr.puts("#{ex.class}: #{ex.message}", ex.backtrace)
+                    $stderr.puts("#{ret.class}: #{ret.message}", ex.backtrace)
                 else
                     bt = ret.backtrace.collect{|line| line.start_with?(fn) ? line : nil}.compact
                     $stderr.puts("#{ret.class}: #{ret.message}", bt, '')
@@ -513,15 +513,57 @@ EOF
                 nil
             end
 
-            # Call MySQLResults#grep to remove (or show) only those lines that
-            # have content matching the patterrn.
+            # Remove all rows that do NOT match the expression. Returns true if
+            # any matches were found.
             #
-            def grep(*args) # :doc:
-                if @results.grep(*args)
-                    @results
+            # Options:
+            #   :fixed   => indicates that the string should be escaped of any
+            #               special characters
+            #   :nocolor => will not add color escape codes to indicate the
+            #               match
+            #   :inverse => reverses the regular expression match
+            #
+            def grep(pattern, *gopts) # :doc:
+                nocolor = gopts.include?(:nocolor)
+
+                if inverted = gopts.include?(:inverse)
+                    # there's no point in coloring matches we are removing
+                    nocolor = true
+                end
+
+                if gopts.include?(:fixed)
+                    regexp = Regexp.new(/#{Regexp.escape(pattern.to_str)}/)
+                elsif Regexp === pattern
+                    regexp = pattern
                 else
-                    $stderr.puts 'No matches found'
+                    regexp = Regexp.new(/#{pattern.to_str}/)
+                end
+
+                rval = inverted
+
+                @results.delete_if do |row|
+                    matched = false
+                    row.each do |val|
+                        val = val.to_s unless String === val
+                        if nocolor
+                            if matched = !val.match(regexp).nil?
+                                rval = inverted ? false : true
+                                break
+                            end
+                        else
+                            # in the color case, we want to colorize all hits in
+                            # all columns, so we can't early terminate our
+                            # search
+                            if val.gsub!(regexp){|m| "\e[31;1m#{m}\e[0m"}
+                                matched = true
+                                rval = inverted ? false : true
+                            end
+                        end
+                    end
+                    inverted ? matched : !matched
                 end
+
+                return rval
             end
 
             # Register bangs to evaluate on all displayers as long as a column

data/lib/rsql/mysql_results.rb

@@ -63,8 +63,8 @@ module RSQL
             #
             def conn; @@conn; end
 
-            # Set the underlying MySQL connection object to use which
-            # implicitly resets the name cache.
+            # Set the underlying MySQL connection object to use which implicitly
+            # resets the name cache.
             #
             def conn=(conn)
                 if @@conn = conn
@@ -73,23 +73,21 @@ module RSQL
                 reset_cache
             end
 
-            # Get the field separator to use when writing rows in
-            # columns.
+            # Get the field separator to use when writing rows in columns.
             #
             def field_separator; @@field_separator; end
 
-            # Set the field separator to use when writing rows in
-            # columns.
+            # Set the field separator to use when writing rows in columns.
             #
             def field_separator=(sep); @@field_separator = sep; end
 
-            # Get the maximum number of rows to process before
-            # throwing a MaxRowsException.
+            # Get the maximum number of rows to process before throwing a
+            # MaxRowsException.
             #
             def max_rows; @@max_rows; end
 
-            # Set the maximum number of rows to process before
-            # throwing a MaxRowsException.
+            # Set the maximum number of rows to process before throwing a
+            # MaxRowsException.
             #
             def max_rows=(cnt); @@max_rows = cnt; end
 
@@ -131,8 +129,8 @@ module RSQL
                 @@name_cache.keys.sort
             end
 
-            # Get the list of tables available for the current
-            # database or a specific one.
+            # Get the list of tables available for the current database or a
+            # specific one.
             #
             def tables(database=@@database_name)
                 @@name_cache[database] || []
@@ -206,7 +204,7 @@ module RSQL
                     @@conn.select_db(@@database_name) if @@database_name
                 end
 
-                @@history.shift if @@max_history <= @@history.size 
+                @@history.shift if @@max_history <= @@history.size
                 @@history << sql
 
                 start   = Time.now.to_f
@@ -215,80 +213,115 @@ module RSQL
 
                 affected_rows = @@conn.affected_rows
                 unless results && 0 < results.num_rows
-                    return new(sql, elapsed, affected_rows)
+                    return new(nil, nil, affected_rows, sql, elapsed)
                 end
 
                 if max_rows < results.num_rows
                     raise MaxRowsException.new(results.num_rows, max_rows)
                 end
 
-                # extract mysql results into our own table so we can predetermine the
-                # lengths of columns and give users a chance to reformat column data
-                # before it's displayed (via the bang maps)
+                # extract mysql results into our own table so we can
+                # predetermine the lengths of columns and give users a chance to
+                # reformat column data before it's displayed (via the bang maps)
 
                 fields = results.fetch_fields
-                fields.collect! do |field|
-                    def field.longest_length=(len); @longest_length = len; end
-                    def field.longest_length; @longest_length; end
-                    field.longest_length = field.name.length
-                    field
-                end
+                extend_fields!(fields)
 
                 results_table = []
                 while vals = results.fetch_row
                     row = []
                     fields.each_with_index do |field, i|
-                        if raw
-                            val = vals[i]
-                        else
-                            val = eval_context.bang_eval(field.name, vals[i])
+                        val = vals[i]
+                        orig_vlen = val.respond_to?(:length) ? val.length : 0
+                        if val && field.is_num?
+                            val = field.decimals == 0 ? val.to_i : val.to_f
+                        end
+                        unless raw
+                            val = eval_context.bang_eval(field.name, val)
                             if val.nil?
                                 val = 'NULL'
                             elsif HEX_RANGE.include?(field.type) && val =~ /[^[:print:]\s]/
                                 val = eval_context.to_hexstr(val)
                             end
                         end
-                        vlen = val.respond_to?(:length) ? val.length : 0
-                        if field.longest_length < vlen
-                            if String === val
-                                # consider only the longest line length since some
-                                # output contains multiple lines like "show create table"
-                                longest_line = val.split(/\r?\n/).collect{|l|l.length}.max
-                                if field.longest_length < longest_line
-                                    field.longest_length = longest_line
-                                end
-                            else
-                                field.longest_length = val.length
-                            end
-                        end
+                        update_longest!(field, val, orig_vlen)
                         row << val
                     end
                     results_table << row
                 end
 
-                return new(sql, elapsed, affected_rows, fields, results_table)
+                return new(fields, results_table, affected_rows, sql, elapsed)
             end
 
+            ########################################
+            private
+
+                def extend_fields!(fields)
+                    fields.collect! do |field|
+                        def field.name; to_s; end unless field.respond_to?(:name)
+                        def field.longest_length=(len); @longest_length = len; end
+                        def field.longest_length; @longest_length; end
+                        field.longest_length = field.name.length
+                        field
+                    end
+                end
+
+                def update_longest!(field, val, default_vlen=nil)
+                    vlen = if val.respond_to?(:length)
+                               val.length
+                           elsif default_vlen
+                               default_vlen
+                           else
+                               val.to_s.length
+                           end
+
+                    if field.longest_length < vlen
+                        if String === val
+                            # consider only the longest line length since some
+                            # output contains multiple lines like "show create
+                            # table"
+                            longest_line = val.split(/\r?\n/).collect{|l|l.length}.max
+                            if field.longest_length < longest_line
+                                field.longest_length = longest_line
+                            end
+                        else
+                            field.longest_length = vlen
+                        end
+                    end
+                end
+
         end # class << self
 
         ########################################
 
-        def initialize(sql, elapsed, affected_rows,
-                       fields=nil, table=nil, field_separator=@@field_separator)
-            @sql             = sql;
-            @elapsed         = elapsed;
-            @affected_rows   = affected_rows;
+        def initialize(fields, table, affected_rows=nil, sql=nil, elapsed=nil,
+                       field_separator=@@field_separator)
+
             @fields          = fields
             @table           = table
+            @affected_rows   = affected_rows || table.size
+            @sql             = sql
+            @elapsed         = elapsed
             @field_separator = field_separator
 
-            # we set this here so that (a) it occurs _after_ we are
-            # successful and so we can show an appropriate messge in a
-            # displayer
-            if @sql.match(/use\s+(\S+)/i)
+            # we set this here so that it occurs _after_ we are successful and
+            # so we can show an appropriate messge in a displayer
+            if @sql && @sql.match(/use\s+(\S+)/i)
                 @database_changed = true
                 @@database_name = $1
             end
+
+            # if we're not given fields from a query we need to find the column
+            # widths
+            if @fields && @table && @fields.size > 0 &&
+                    !@fields.first.respond_to?(:longest_length)
+                self.class.send(:extend_fields!, @fields)
+                @table.each do |row|
+                    @fields.each_with_index do |field, i|
+                        self.class.send(:update_longest!, field, row[i])
+                    end
+                end
+            end
         end
 
         # Get the query associated with these results.
@@ -321,19 +354,33 @@ module RSQL
             @table ? @table.size : 0
         end
 
-        # Get a row from the table hashed with the field names.
+        # Convenience helper to grab the value in the very first entry for those
+        # times when the query only has one expected value returned.
         #
-        def [](index)
-            if !@fields || !@table
-                return nil
-            end
-            if row = @table[index]
-                hash = {}
-                @fields.each_with_index {|f,i| hash[f.name] = row[i]}
-                return hash
-            else
-                return nil
+        def scalar
+            self[0,0]
+        end
+
+        # Get an entire row as a hash or a single value from the table of
+        # results. The value of row_j may be an integer index or a string column
+        # name.
+        #
+        def [](row_i, row_j=nil)
+            if @table
+                if row = @table[row_i]
+                    if row_j
+                        return row[row_j] if Integer === row_j
+                        if row_j = @fields.index{|f| f.name == row_j}
+                            return row[row_j]
+                        end
+                    else
+                        hash = {}
+                        @fields.each_with_index{|f,i| hash[f.name] = row[i]}
+                        return hash
+                    end
+                end
             end
+            return nil
         end
 
         # Iterate through each row of the table hashed with the field names.
@@ -348,59 +395,21 @@ module RSQL
             end
         end
 
-        # Remove all rows that do NOT match the expression. Returns true if any
-        # matches were found.
-        #
-        # Options:
-        #   :fixed   => indicates that the string should be escaped of any special characters
-        #   :nocolor => will not add color escape codes to indicate the match
-        #   :inverse => reverses the regular expression match
+        # Conditionally delete rows from the results.
         #
-        def grep(pattern, *gopts)
+        def delete_if(opts=nil, &block)
             if @table
-                nocolor = gopts.include?(:nocolor)
-
-                if inverted = gopts.include?(:inverse)
-                    # there's no point in coloring matches we are removing
-                    nocolor = true
-                end
-
-                if gopts.include?(:fixed)
-                    regexp = Regexp.new(/#{Regexp.escape(pattern.to_str)}/)
-                elsif Regexp === pattern
-                    regexp = pattern
-                else
-                    regexp = Regexp.new(/#{pattern.to_str}/)
-                end
-
-                rval = inverted
-
                 @table.delete_if do |row|
-                    matched = false
-                    row.each do |val|
-                        val = val.to_str unless String === val
-                        if nocolor
-                            if matched = !val.match(regexp).nil?
-                                rval = inverted ? false : true
-                                break
-                            end
-                        else
-                            # in the color case, we want to colorize all hits in
-                            # all columns, so we can't early terminate our
-                            # search
-                            if val.gsub!(regexp){|m| "\e[31;1m#{m}\e[0m"}
-                                matched = true
-                                rval = inverted ? false : true
-                            end
-                        end
+                    if opts == :row_hash
+                        hash = {}
+                        @fields.each_with_index{|f,i| hash[f.name] = row[i]}
+                        yield(hash)
+                    else
+                        yield(row)
                     end
-                    inverted ? matched : !matched
                 end
-
-                return rval
-            else
-                return false
             end
+            self
         end
 
         # Show a set of results in a decent fashion.
@@ -458,19 +467,20 @@ module RSQL
         # Show a summary line of the results.
         #
         def display_stats(io=$stdout, hdr='')
+            estr = @elapsed ? " (#{'%0.2f'%@elapsed} sec)" : ''
             if @table
                 if @database_changed
                     io.puts(hdr, "Database changed");
                     hdr = ''
                 end
                 s = 1 == @table.size ? 'row' : 'rows'
-                io.puts(hdr, "#{@table.size} #{s} in set (#{'%0.2f'%@elapsed} sec)")
+                io.puts(hdr, "#{@table.size} #{s} in set#{estr}")
             else
                 if @database_changed
                     io.puts(hdr, "Database changed");
                 else
                     s = 1 == @affected_rows ? 'row' : 'rows'
-                    io.puts(hdr, "Query OK, #{@affected_rows} #{s} affected (#{'%0.2f'%@elapsed} sec)")
+                    io.puts(hdr, "Query OK, #{@affected_rows} #{s} affected#{estr}")
                 end
             end
         end

data/test/test_eval_context.rb

@@ -179,4 +179,39 @@ class TestEvalContext < Test::Unit::TestCase
         File.unlink(tf+'~') if File.exists?(tf+'~')
     end
 
+    def test_grep
+        out = StringIO.new
+
+        res = [[11,'one$'],[12,'one and two'],[13,'four and none']]
+        @ctx.safe_eval('grep "two"', res, out)
+        assert(out.string.empty?)
+        assert_equal([[12,"one and \e[31;1mtwo\e[0m"]], res)
+
+        res = [[11,'one'],[12,'one and two'],[13,'four and none']]
+        out = StringIO.new
+        @ctx.safe_eval('grep /four/, :nocolor', res, out)
+        assert(out.string.empty?)
+        assert_equal([[13,'four and none']], res)
+
+        res = [[11,'one'],[12,'one and two'],[13,'four and none']]
+        out = StringIO.new
+        @ctx.safe_eval('grep "and", :inverse, :fixed', res, out)
+        assert(out.string.empty?)
+        assert_equal([[11,'one']], res)
+    end
+
+    def test_help
+        out = StringIO.new
+        @ctx.safe_eval('help', nil, out)
+        assert_match(/only rows/, out.string)
+    end
+
+    def test_exception
+        orig_err = $stderr
+        $stderr = err = StringIO.new
+        @ctx.safe_eval('this should fail', nil, nil)
+        $stderr = orig_err
+        assert_match(/test_eval_context.rb/, err.string)
+    end
+
 end # class TestEvalContext

data/test/test_mysql_results.rb

@@ -76,9 +76,14 @@ class TestMySQLResults < Test::Unit::TestCase
         f1 = mock('f1')
         f1.expects(:name).returns('c1').times(12)
         f1.expects(:type).returns(1).times(2)
+        f1.stubs(:is_num?).returns(false)
+        f1.stubs(:longest_length)
+
         f2 = mock('f2')
         f2.expects(:name).returns('c2').times(11)
         f2.expects(:type).returns(1).times(2)
+        f2.stubs(:is_num?).returns(false)
+        f2.stubs(:longest_length)
 
         res = mock('results')
         res.expects(:num_rows).returns(2).times(2)
@@ -132,68 +137,31 @@ class TestMySQLResults < Test::Unit::TestCase
                      dout.string.gsub(/\s+/,''))
     end
 
-    def test_grep
-        f1 = mock('f1')
-        f1.stubs(:name).returns('c1')
-        f1.stubs(:type).returns(1)
-        f2 = mock('f2')
-        f2.stubs(:name).returns('c2')
-        f2.stubs(:type).returns(1)
-
-        res = mock('results')
-        res.stubs(:num_rows).returns(2)
-        res.stubs(:fetch_fields).returns([f1,f2])
-
-        rows = sequence(:rows)
-        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+    def test_init
+        mres = MySQLResults.new([], [])
+        assert_equal(0, mres.num_rows)
 
-        conn = mock('Mysql')
-        conn.expects(:reconnect=)
-        conn.stubs(:list_dbs).returns([])
-        conn.stubs(:query).with(instance_of(String)).returns(res)
-        conn.stubs(:affected_rows).returns(1)
-        conn.expects(:reconnected?).times(4)
-        MySQLResults.reset_history
-        MySQLResults.conn = conn
-
-        mres = MySQLResults.query('ignored1', eval_context=nil, raw=true)
-        assert_equal(false, mres.grep(/val/))
-
-        rows = sequence(:rows)
-        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(nil)
-
-        mres = MySQLResults.query('ignored2', eval_context=nil, raw=true)
-        assert_equal(true, mres.grep('v1', :fixed))
-        assert_equal("\e[31;1mv1\e[0m.1", mres[0]['c1'])
-        assert_equal("\e[31;1mv1\e[0m.2", mres[0]['c2'])
-
-        rows = sequence(:rows)
-        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(nil)
-
-        mres = MySQLResults.query('ignored3', eval_context=nil, raw=true)
-        assert_equal(false, mres.grep('v', :fixed, :inverse))
-
-        rows = sequence(:rows)
-        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
-        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+        mres = MySQLResults.new(['col1', 'col2'], [[1,2], [3,4]])
+        assert_equal(2, mres.num_rows)
+        dout = StringIO.new
+        mres.display_by_column(dout)
+        assert_equal('col1col2----------1234----------2rowsinset',
+                     dout.string.gsub(/\s+/,''))
+    end
 
-        mres = MySQLResults.query('ignored4', eval_context=nil, raw=true)
-        assert_equal(true, mres.grep('v1.1', :nocolor))
-        assert_equal("v1.1", mres[0]['c1'])
+    def test_row_access
+        mres = MySQLResults.new(['col1', 'col2'], [[1,2], [3,4]])
+        assert_equal(3, mres[1,0])
+        assert_equal(4, mres[1,'col2'])
+        assert_equal({'col1'=>3,'col2'=>4}, mres[1])
+    end
 
-        # fixme: technically should be in it's only test...
-        cmds = []
-        4.times{|i| cmds << "ignored#{i+1}"}
-        assert_equal(cmds, MySQLResults.history)
-        assert_equal([cmds.last], MySQLResults.history(1))
-        assert_equal(cmds, MySQLResults.history(15))
+    def test_delete
+        mres = MySQLResults.new(['col1', 'col2'], [[1,2], [3,4]])
+        mres.delete_if{|r| r[1] == 4}
+        assert_equal(nil, mres[1])
+        mres.delete_if(:row_hash){|r| r['col1'] == 1}
+        assert_equal(nil, mres[0])
     end
 
 end # class TestMySQLResults

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsql
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 17
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 11
-  version: 0.2.11
+  - 3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Brad Robel-Forrest
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-24 00:00:00 Z
+date: 2012-04-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: net-ssh
@@ -165,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Ruby-based MySQL command line with recipes.