rsql 0.2.6 → 0.2.7

data/bin/rsql

@@ -20,6 +20,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+# todo: look into using the logger class
+# (http://ruby-doc.org/stdlib-1.8.7/libdoc/logger/rdoc/Logger.html)
+
 begin
     # this isn't required unless that's how mysql and net/ssh have
     # been installed
@@ -27,6 +30,7 @@ begin
 rescue LoadError
 end
 
+require 'ostruct'
 require 'tmpdir'
 require 'thread'
 require 'timeout'
@@ -50,7 +54,8 @@ include RSQL
 
 bn = File.basename($0, '.rb')
 
-eval_context = EvalContext.new
+opts = OpenStruct.new
+eval_context = EvalContext.new(opts)
 
 # rewrite all double hyphen options into singles so both are supported
 ARGV.map!{|a| a.sub(/^--/,'-')}
@@ -132,8 +137,8 @@ if ARGV.delete('-version')
     exit
 end
 
-verbose = ARGV.delete('-verbose')
-eval_context.verbose = verbose
+opts.verbose = !ARGV.delete('-verbose').nil?
+eval_context.verbose = opts.verbose
 
 if i = ARGV.index('-maxrows')
     ARGV.delete_at(i)
@@ -144,7 +149,7 @@ if i = ARGV.index('-batch')
     ARGV.delete_at(i)
     MySQLResults.field_separator = ARGV.delete_at(i)
     MySQLResults.field_separator = "\t" if MySQLResults.field_separator == '\t'
-    batch_output = true
+    opts.batch_output = true
 end
 
 if i = ARGV.index('-ssh')
@@ -152,22 +157,24 @@ if i = ARGV.index('-ssh')
 
     ARGV.delete_at(i)
 
-    (ssh_host, ssh_user, ssh_password, ssh_port) = split_login(ARGV.delete_at(i))
+    (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)
-        ssh_cfghash = Net::SSH::Config.load(default_config, ssh_host)
+        opts.ssh_config = default_config
+        opts.ssh_cfghash = Net::SSH::Config.load(default_config, opts.ssh_host)
     end
 
-    if ssh_user.nil? || ssh_user.empty?
-        ssh_user = ssh_cfghash['user'] || ENV['USER'] || ENV['USERNAME']
+    if opts.ssh_user.nil? || opts.ssh_user.empty?
+        opts.ssh_user = opts.ssh_cfghash['user'] || ENV['USER'] || ENV['USERNAME']
     end
 end
 
 if i = ARGV.index('-sshconfig')
     ARGV.delete_at(i)
-    ssh_config = ARGV.delete_at(i)
-    ssh_cfghash = Net::SSH::Config.load(ssh_config, ssh_host)
+    opts.ssh_config = ARGV.delete_at(i)
+    opts.ssh_cfghash = Net::SSH::Config.load(opts.ssh_config, opts.ssh_host)
 end
 
 if i = ARGV.index('-e')
@@ -212,16 +219,18 @@ USAGE
     exit 1
 end
 
-(mysql_host, mysql_user, mysql_password, mysql_port) = split_login(ARGV.shift)
-mysql_password ||= get_password("#{mysql_user}@#{mysql_host} MySQL password: ")
-real_mysql_host = mysql_host
+(opts.mysql_host, opts.mysql_user, opts.mysql_password, opts.mysql_port) =
+    split_login(ARGV.shift)
+opts.mysql_password ||=
+    get_password("#{opts.mysql_user}@#{opts.mysql_host} MySQL password: ")
+opts.remote_mysql_host = opts.mysql_host
 
-if ssh_host
+if opts.ssh_host
     # randomly pick a tcp port above 1024
-    remote_mysql_port = mysql_port || 3306
-    mysql_port = rand(0xffff-1025) + 1025
-elsif mysql_port.nil?
-    mysql_port = 3306
+    opts.remote_mysql_port = opts.mysql_port || 3306
+    opts.mysql_port = rand(0xffff-1025) + 1025
+elsif opts.mysql_port.nil?
+    opts.mysql_port = 3306
 end
 
 MySQLResults.database_name = ARGV.shift
@@ -259,9 +268,9 @@ rescue Exception => ex
     false
 end
 
-MySQLResults.max_rows ||= batch_output ? 5000 : 1000
+MySQLResults.max_rows ||= opts.batch_output ? 5000 : 1000
 
-if ssh_host
+if opts.ssh_host
 
     # might need to open an idle channel here so server doesn't close on
     # us...or just loop reconnection here in the thread...
@@ -269,7 +278,7 @@ if ssh_host
     password_retry_cnt = 0
 
     unless batch_input
-        print "SSH #{ssh_user}#{ssh_user ? '@' : ''}#{ssh_host}..."
+        print "SSH #{opts.ssh_user}#{opts.ssh_user ? '@' : ''}#{opts.ssh_host}..."
         $stdout.flush
     end
 
@@ -291,16 +300,18 @@ if ssh_host
             $stderr.puts 'Closing SSH connection...' unless batch_input
             ssh_enabled = false
         end
-        opts = {:timeout => 15}
-        opts[:config] = ssh_config if ssh_config
-        if verbose
-            opts[:verbose] = :debug
-            puts "SSH options: #{opts.inspect}"
-            puts "SSH config: #{ssh_cfghash.inspect}"
+        ssh_opts = {:timeout => 15}
+        ssh_opts[:config] = opts.ssh_config if opts.ssh_config
+        if opts.verbose
+            ssh_opts[:verbose] = :debug
+            puts "SSH options: #{ssh_opts.inspect}"
+            puts "SSH config: #{opts.ssh_cfghash.inspect}"
         end
         begin
-            opts[:password] = ssh_password if ssh_password
-            ssh = Net::SSH.start(ssh_host, ssh_user, opts)
+            ssh_opts[:password] = opts.ssh_password if opts.ssh_password
+            opts.delete_field(:ssh_password)
+            ssh = Net::SSH.start(opts.ssh_host, opts.ssh_user, ssh_opts)
+            ssh_opts.delete(:password)
             ssh_enabled = true
             printf "connected (#{$$})..." unless batch_input
             $stdout.flush
@@ -308,20 +319,26 @@ if ssh_host
             if 2 < password_retry_cnt
                 $stderr.puts 'Permission denied. Giving up.'
             else
-                $stderr.puts 'Permission denied, please try again.' if ssh_password
-                ssh_password = get_password("#{ssh_user}@#{ssh_host} SSH password: ")
-                unless ssh_password.empty?
+                $stderr.puts 'Permission denied, please try again.' if opts.ssh_password
+                opts.ssh_password = get_password("#{opts.ssh_user}@#{opts.ssh_host} SSH password: ")
+                unless opts.ssh_password.empty?
                     password_retry_cnt += 1
                     retry
                 end
             end
         rescue Timeout::Error => ex
             $stderr.puts ex.message
+        rescue Exception => ex
+            if opts.verbose
+                $stderr.puts("#{ex.class}: #{ex.message}", ex.backtrace)
+            else
+                $stderr.puts(ex.message)
+            end
         ensure
             if ssh_enabled
-                ssh.forward.local(mysql_port, mysql_host, remote_mysql_port)
+                ssh.forward.local(opts.mysql_port, opts.mysql_host, opts.remote_mysql_port)
                 unless batch_input
-                    puts(verbose ? "ready (#{mysql_port} => #{remote_mysql_port})" : 'ready')
+                    puts(opts.verbose ? "ready (#{opts.mysql_port} => #{opts.remote_mysql_port})" : 'ready')
                 end
                 File.open(ipc_fn,'w'){|f| f.puts('ready')}
                 ssh.loop(1) { ssh_enabled }
@@ -343,9 +360,14 @@ if ssh_host
                     sleep 1
                 end
                 Process.kill('KILL', ssh_pid) unless killed
+            rescue Errno::ESRCH
+                # do nothing, process is already gone
             rescue Exception => ex
-                $stderr.puts ex.message
-                $stderr.puts ex.backtrace if verbose
+                if opts.verbose
+                    $stderr.puts("#{ex.class}: #{ex.message}", ex.backtrace)
+                else
+                    $stderr.puts(ex.message)
+                end
             end
         end
         File.unlink(ipc_fn) if File.exists?(ipc_fn)
@@ -363,24 +385,23 @@ if ssh_host
     unless ipc_state == 'ready'
         # give the child time to exit
         sleep(0.5)
-        $stderr.puts "failed to connect to #{ssh_host} SSH host"
+        $stderr.puts "failed to connect to #{opts.ssh_host} SSH host"
         exit 1
     end
 
     # now have our mysql connection use our port forward...
-    mysql_host = '127.0.0.1'
+    opts.mysql_host = '127.0.0.1'
 end
 
 unless batch_input
-    print "MySQL #{mysql_user}@#{real_mysql_host}..."
+    print "MySQL #{opts.mysql_user}@#{opts.remote_mysql_host}..."
     $stdout.flush
 end
 
-mysql_conn = "#{mysql_host}:#{remote_mysql_port || mysql_port}"
-
+mysql_conn = "#{opts.mysql_host}:#{opts.remote_mysql_port || opts.mysql_port}"
 begin
-    MySQLResults.conn = Mysql.new(mysql_host, mysql_user, mysql_password,
-                                  MySQLResults.database_name, mysql_port)
+    MySQLResults.conn = Mysql.new(opts.mysql_host, opts.mysql_user, opts.mysql_password,
+                                  MySQLResults.database_name, opts.mysql_port)
     MySQLResults.conn.reconnect = true
     puts 'connected' unless batch_input
 rescue Mysql::Error => ex
@@ -389,20 +410,19 @@ rescue Mysql::Error => ex
     else
         $stderr.puts "failed to connect to #{mysql_conn} mysql server: #{ex.message}"
     end
-    $stderr.puts ex.backtrace if verbose
+    $stderr.puts ex.backtrace if opts.verbose
     exit 1
 rescue NoMethodError
-    # this happens when mysql tries to read four bytes and assume it
-    # can index into them even when read returned nil...this happens
-    # because the connect succeeds due to the SSH forwarded port but
-    # then there isn't anybody connected on the remote side of the
-    # proxy
+    # this happens when mysql tries to read four bytes and assume it can index
+    # into them even when read returned nil...this happens because the connect
+    # succeeds due to the SSH forwarded port but then there isn't anybody
+    # connected on the remote side of the proxy
     $stderr.puts "failed to connect to #{mysql_conn} mysql server"
-    $stderr.puts ex.backtrace if verbose
+    $stderr.puts ex.backtrace if opts.verbose
     exit 1
 rescue Exception => ex
     $stderr.puts "failed to connect to #{mysql_conn} mysql server: #{ex.message} (#{ex.class})"
-    $stderr.puts ex.backtrace if verbose
+    $stderr.puts ex.backtrace if opts.verbose
     exit 1
 end
 
@@ -421,11 +441,11 @@ cmd_thread = Thread.new do
     until me[:shutdown] do
         default_displayer = :display_by_column
         if batch_input
-            default_displayer = :display_by_batch if batch_output
+            default_displayer = :display_by_batch if opts.batch_output
             me[:shutdown] = true         # only run once
             input = batch_input
         else
-            puts '',"[#{mysql_user}@#{ssh_host||mysql_host}:#{MySQLResults.database_name}]"
+            puts '',"[#{opts.mysql_user}@#{opts.ssh_host||opts.mysql_host}:#{MySQLResults.database_name}]"
             input = ''
             prompt = eval_context.prompt || (bn + '> ')
             loop do
@@ -465,8 +485,9 @@ cmd_thread = Thread.new do
 end
 
 # keep a secondary connection to allow us to kill off a running query
-kill_conn = Mysql.new(mysql_host, mysql_user, mysql_password,
-                      MySQLResults.database_name, mysql_port)
+kill_conn = Mysql.new(opts.mysql_host, opts.mysql_user, opts.mysql_password,
+                      MySQLResults.database_name, opts.mysql_port)
+opts.delete_field(:mysql_password)
 
 Signal.trap('INT') do
     # emulate MySQL's behavior
@@ -479,6 +500,7 @@ Signal.trap('INT') do
             sleep(0.5)
         end
         MySQLResults.conn.select_db(MySQLResults.database_name)
+        eval_context.call_init_registrations
     else
         $stderr.puts 'Ctrl-C -- exit!'
         cmd_thread[:shutdown] = true
@@ -488,7 +510,9 @@ Signal.trap('INT') do
 end
 
 Signal.trap('CHLD') do
-    $stderr.puts "SSH child (#{ssh_pid}) stopped--shutting down..."
+    unless opts.batch_output
+        $stderr.puts "SSH child (#{ssh_pid}) stopped--shutting down..."
+    end
     if MySQLResults.conn && MySQLResults.conn.busy?
         $stderr.puts 'Closing MySQL connection...'
         safe_timeout(MySQLResults.conn, :close, 'MySQL')
@@ -502,7 +526,7 @@ end
 begin
     cmd_thread.join
 rescue Exception => ex
-    $stderr.puts ex.message, ex.backtrace
+    $stderr.puts("#{ex.class}: #{ex.message}", ex.backtrace)
 end
 
 unless MySQLResults.conn.nil?

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsql
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 2
-  - 6
-  version: 0.2.6
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - Brad Robel-Forrest
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-16 00:00:00 Z
+date: 2012-02-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: net-ssh
@@ -120,18 +120,8 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- LICENSE
-- README.rdoc
 - bin/rsql
-- example.rsqlrc
-- extra/mysql-client-5.1.59-1.tgz
-- lib/rsql.rb
-- lib/rsql/commands.rb
-- lib/rsql/eval_context.rb
-- lib/rsql/mysql_results.rb
-- test/test_commands.rb
-- test/test_eval_context.rb
-- test/test_mysql_results.rb
+- README.rdoc
 homepage: https://rubygems.org/gems/rsql
 licenses: []
 
@@ -166,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: Ruby based MySQL command line with recipes.

data/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2011-2012 by brad+rsql@gigglewax.com
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/example.rsqlrc

@@ -1,291 +0,0 @@
-# -*- Mode: ruby -*-
-
-# This file is meant to be a working illustration of how RSQL might be
-# used and to show off various features of the application.
-
-# All examples below will use this temporary table. You will need to
-# "use" a database first before loading this file since it will need
-# to create this temporary table.
-#
-@rsql_table = 'rsql_example'
-
-# To use this file, change directory to the one containing this file,
-# run rsql connecting to your MySQL server (run rsql with no arguments
-# for usage).
-#
-#   rsql> .load 'example.rsqlrc';
-
-# After it's loaded try listing out all the registered recipes (along
-# with parameter notes and descriptions).
-#
-#   rsql> .list;
-
-# If you make changes to the example to try out new things (and please
-# do!), you can simply have the recipe file reloaded to have your
-# changes pulled in immediately without exiting your session.
-#
-#   rsql> .reload;
-
-# Notice that any command issued starting with a period (.) results in
-# evaluation of Ruby. Thus, any valid Ruby syntax is applicable
-# following a period on a command.
-
-################################################################################
-
-# This type of registration is automatically invoked when this file is
-# loaded. Often, this is useful to run set up routines like setting
-# MySQL variables for different read levels (e.g. SET SESSION
-# TRANSACTION ISOLATION LEVEL READ COMMITTED). Any number of these may
-# be defined.
-#
-# Here we are merely setting up the example table.
-#
-register_init :setup_example, %q{
-CREATE TEMPORARY TABLE IF NOT EXISTS #{@rsql_table} (
-  name VARCHAR(100),
-  value INT(11),
-  stuff BLOB
-)
-}, :desc => 'Sets up example table for trying out RSQL.'
-
-# This recipe is simply building up a string with a single variable
-# interpolated into it (our table name). The string will then be used
-# as if typed at the command line.
-#
-#   rsql> .cleanup_example;
-#
-# In this case, we are simply dropping the table created by our
-# initialization recipe. If you do this, you'll need to call the
-# setup_example initialization recipe again before moving on.
-#
-#   rsql> .setup_example;
-#
-register :cleanup_example, %q{
-DROP TEMPORARY TABLE IF EXISTS #{@rsql_table}
-}, :desc => 'Cleans up the example table.'
-
-# This is an example of a recipe that utilizes a Ruby block for
-# running code to generate the SQL we eventually return.
-#
-# Here we are just populating the table (if it isn't already).
-#
-#   rsql> .fill_table;
-#
-# Notice the use of hexify and squeeze! methods available from
-# EvalContext.
-#
-register :fill_table, :desc => 'Populate the example table.' do
-    sql = ''
-    9.times do |i|
-        sql << %{
-INSERT IGNORE INTO #{@rsql_table}
-   SET  name='fancy#{i}',
-       value=#{i**i},
-       stuff=#{hexify(rand((i+1)**100))};
-}
-    end
-    # one more that isn't randomly generated so we can reference it
-    # later
-        sql << %{
-INSERT IGNORE INTO #{@rsql_table}
-   SET  name='fancy9',
-       value=#{9**9},
-       stuff=0x1234567891234567891234567890;
-}
-    squeeze!(sql)
-end
-
-# A very common reason for recipes is simply to add parameters to be
-# dropped in to our query. To facilitate this, simply declare one or
-# more variables immediately following the name of the recipe. Then
-# these values can be listed by embedded interpolation points into the
-# string (just as you would with any Ruby string).
-#
-# This call will simply return results only for those bigger than some
-# value passed in.
-#
-#   rsql> .get_big_values 80000;
-#
-register :get_big_values, :val, %q{
-SELECT name, value FROM #{@rsql_table} WHERE #{val} <= value
-}, :desc => 'Get values bigger than the one provided as an argument.'
-
-# Sometimes we make mistakes (never!). Normally, the command history
-# kept in RSQL only stores the last thing entered at the prompt--not
-# any query that the previous command may have generated and invoked.
-# When writing a recipe that generates a query that has an error
-# reported by MySQL, it is really handy to see the query.
-#
-# Here's an example of a recipe that will fail. Run it and then hit the
-# "up arrow" key to see the previous command.
-#
-#   rsql> .bad_query;
-#
-# So the command in our history is the recipe and not the query. To
-# see the query the EvalContext has a recipe ready for us:
-#
-#   rsql> .history;
-#
-register :bad_query, %q{
-SELECT name, value FROM #{@rsql_table} WHERE valu < 10000
-}, :desc => 'Make a query that will result in an error.'
-
-# After you have a table with content in it, you can run queries
-# against it and have the contents changed into something a little
-# more meaningful. For example, what if the values in our table were
-# bytes that we wanted to humanize? Try this command:
-#
-#   rsql> select name, value from rsql_example ! value => humanize_bytes;
-#
-# The humanize_bytes method is a helper in the EvalContext
-# class. There are several others available. Check out the rdoc for
-# details.
-#
-# Additional mappings can be added, separated by commas.
-#
-# You can also declare these column mappings in your recipes, though
-# the syntax is slightly different, using Ruby symbols.
-#
-#   rsql> .show_values_as_bytes;
-#
-register :show_values_as_bytes, %q{
-SELECT value FROM #{@rsql_table}
-}, 'value' => :humanize_bytes,
-   :desc => 'Show values as humanized bytes.'
-
-# It is even possible to make up your own column mapping helpers. Just
-# create a Ruby method and reference it as a symbol mapped to whatever
-# column the helper is expecting for content. The return of the helper
-# will be replaced as the column entry's content. Your method is
-# called once for each value in the column from the results.
-#
-#   rsql> .show_pretty_names;
-#
-# Make sure if your method doesn't understand the content passed to it
-# that it just reflects it back out so you don't lose data when
-# printed.
-#
-def pretty_names(name)
-    if m = name.match(/^(\w+)(\d+)$/)
-        "#{m[1]} (#{m[2]})"
-    else
-        name
-    end
-end
-
-register :show_pretty_names, %q{
-SELECT name FROM #{@rsql_table}
-}, 'name' => :pretty_names,
-   :desc => 'Show names separated to be more readable.'
-
-# It's also possible to work with the full set of query results in a
-# recipe. This can be useful if there is some coordination necessary
-# across multiple columns to result in some new kind of report. Much
-# like a shell's ability to pipe output from one command to the next,
-# RSQL takes a similar approach. Try this:
-#
-#   rsql> select name, value from rsql_example | p @results;
-#
-# The EvalContext manages the results from a previous query in the
-# @results member variable accessible by any Ruby recipe code. This is
-# an instance of the MySQLResults class. Below we make use of the
-# each_hash method to walk over all rows. There are other helpful
-# routines available as well that are documented in rdoc.
-#
-# Here's an example that writes a simple report of the data we are
-# working with. To try this out, enter the following at the prompt:
-#
-#   rsql> select name, value from rsql_example | to_report;
-#
-register :to_report, :desc => 'Report on a count of small and big values.' do
-    small_cnt = 0
-    big_cnt   = 0
-    @results.each_hash do |row|
-        if row['value'].to_i < 10000
-            small_cnt +=1
-        else
-            big_cnt += 1
-        end
-    end
-    puts "There are #{small_cnt} small values and #{big_cnt} big values."
-end
-
-# There may be other moments where it's necessary to take arguments,
-# say if we want to process results and keep our data around in a
-# file.
-#
-#   rsql> select name, value from rsql_example | save_values 'myobj';
-#
-# After running this, a myobj.yml file should be created in the local
-# directory containing all the content from the query. To accomplish
-# this, the use of EvalContext's safe_save method is invoked which
-# serializes our object so that we may later decided to run some post
-# processing on the content.
-#
-# Inspect the YAML content written out:
-#
-#   rsql> .puts IO.read('myobj.yml');
-#
-register :save_values, :desc => 'Save results from a query into a file.' do |fn|
-    myobj = {}
-    @results.each_hash do |row|
-        myobj[row['name']] = row['value']
-    end
-    safe_save(myobj, fn)
-end
-
-# Dealing with variable arguments is pretty straightforward as well,
-# but with a little syntactic twist.
-#
-#   rsql> .find_names 'fancy3', 'fancy8';
-#
-# Here we simply expand the arguments.
-#
-register :find_names, :'*names', %q{
-SELECT name, value
-  FROM #{@rsql_table}
- WHERE name IN (#{names.collect{|n| "'#{n}'"}.join(',')})
-}, :desc => 'Find names from example table.'
-
-# Sometimes it just isn't enough to be able to rely on generating SQL
-# queries and piping into handlers. Sometimes we just need to roll up
-# our sleeves and run queries directly so we can start processing
-# results and dealing with presentation all on our own. That's where
-# EvalContext's query helper comes in handy.
-#
-# The intention here is to just create a series of sentences out of
-# two separate queries.
-#
-#   rsql> .show_sentences;
-#
-register :show_sentences, :desc => 'Show results as sentences.' do
-    query("SELECT name FROM #{@rsql_table}").each_hash do |nrow|
-        name = nrow['name']
-        vals = query("SELECT value FROM #{@rsql_table} WHERE name='#{name}'")
-        puts "The #{name} has #{vals[0]['value']} fanciness levels."
-    end
-end
-
-# The MySQLResults class built in to RSQL handles binary content
-# gracefully, automatically converting it to something a little nicer
-# to our consoles than just dumping it. It converts it into a
-# hexadecimal string.
-#
-#   rsql> SELECT stuff FROM rsql_example;
-#
-# The default is to limit the hex strings to 32 "bytes" reported. This
-# can be configured any time by setting the @hexstr_limit.
-#
-# RSQL makes querying for hex strings from within a recipe easy too.
-#
-#   rsql> .find_stuff 0x1234567891234567891234567890;
-#
-register :find_stuff, :stuff, %q{
-SELECT * FROM #{@rsql_table} WHERE stuff=#{hexify stuff}
-}, :desc => 'Find some hex stuff.'
-
-# There are many other things to try out left as an "exercise for the
-# reader". Browsing the rdoc for EvalContext and MySQLResults would be
-# an excellent start.
-
-# vi: set filetype=ruby