mssql 0.0.2

data/lib/command_parser.rb

@@ -0,0 +1,28 @@
+class CommandParser
+
+  def initialize(line)
+    @line = line
+    @command = nil
+    @params = nil
+    parse
+  end
+
+  attr_reader :command, :params
+
+  def is_command?
+    !@command.nil?
+  end
+
+  def parse
+    m = @line.match /^\s*\.(\w+) *(.*)$/
+    return if m.nil?
+    @command = m[1].to_sym
+    @params = m[2].split(' ').compact.map{|p| p.split(".")}.flatten
+    case @command
+      when "find"
+      when "explain"
+      when "use"
+    end
+  end
+ 
+end

data/lib/connection.rb

@@ -0,0 +1,58 @@
+class Connection
+  
+  def initialize(configs, after_connect_handler=nil)
+    @configs = configs
+    @after_connect_handler = after_connect_handler
+    use :default_connection
+  end
+  
+  attr_reader :results, :error, :name
+
+  def error?
+    !@error.nil?
+  end
+
+  def one_column_one_row?
+    return false if error?
+    @results.rows.size == 1 && @results.columns.size == 1
+  rescue
+    false
+  end
+
+  def exec(sql)
+    begin
+      result = @client.execute sql
+      rows = result.each(:symbolize_keys => true, :empty_sets => true, :as => :array)
+      @results = Hashie::Mash.new({
+                                    :columns => result.fields, 
+                                    :rows => rows, 
+                                    :affected => result.do, 
+                                    :return_code => @client.return_code
+                                  })
+      @error = nil
+      @results
+    rescue TinyTds::Error => e
+      @result = nil
+      @error = Hashie::Mash.new(:error => e.to_s, :severity => e.severity, :db_error_number => e.db_error_number)
+    end
+  end
+
+  KEYS = [:username, :password, :host, :database] 
+
+  def use(name = :default_connection)
+    return false unless @configs.has_key?(name.to_s)
+    connect @configs[name.to_s]
+    return true
+  end
+
+  private
+  
+  def connect(config)
+    new_client = TinyTds::Client.new(config.to_hash.symbolize_keys)
+    @client.close if @client
+    @client = new_client
+    @name = config.name || "#{config.username}@#{config.host}"   
+    @after_connect_handler.call(@name) if @after_connect_handler 
+  end
+  
+end

data/lib/controller.rb

@@ -0,0 +1,126 @@
+require 'readline'
+
+class Controller
+  
+  def initialize
+    connect
+    trap_int
+    @lines = []
+  end
+
+  def run
+    if ENV["EMACS"] == "t"
+      emacs_run_loop
+    elsif @options.input_file
+      show File.read(@options.input_file)
+    elsif @options.query
+      show @options.query
+    else
+      run_loop
+    end
+  end
+
+  private
+
+  def emacs_run_loop    
+    print @prompt
+    $stdin.flush
+    $stdin.each_line do |line|
+      #print "emacs_run_loop #{line}"
+      ret = handle_line(line)      
+      print @prompt unless has_more?
+      $stdout.fsync
+      break if ret && ret < 0      
+    end
+  end
+
+  def has_more?
+    c = $stdin.read_nonblock(1) rescue nil
+    $stdin.ungetbyte(c) if c
+    !!c
+  end
+
+  def run_loop
+    loop do
+      while line = Readline.readline(@prompt, true)
+        ret = handle_line(line)
+        return if ret && ret < 0
+      end
+      exec_lines
+    end
+  end
+
+  def handle_line(line)
+    line = line.strip
+    return if line.empty?
+    command = Command.new(line, @connection)
+    if command.exit?
+      exec_lines
+      return -1 
+    end      
+    if command.go?
+      exec_lines
+    end
+    return 0 if command.exec
+    @lines << line    
+    # if $stdin.eof?
+    #   exec_lines 
+    #   return -1
+    # end
+    0
+  end
+
+  def exec_lines
+    show @lines.join("\n")
+    @lines = []
+  end
+
+  def trap_int
+    #stty_save = `stty -g`.chomp
+    trap('INT') do
+      #system('stty', stty_save); 
+      exit       
+    end
+  end
+
+  def show(query)
+    QueryOutput.new(@connection, query).show
+  end
+
+  def connect
+    read_configs
+    @connection = Connection.new @configs, Proc.new{ |name| @prompt = "#{name}> " }
+  rescue TinyTds::Error => e
+    print "#{e.to_s}\n"
+    exit
+  end
+
+  def read_configs
+    file_configs = YAML.load(File.read("#{ENV['HOME']}/.mssql")) rescue {}
+    @configs = Hashie::Mash.new(file_configs)    
+    params = ParamsParser.new
+    @options = params.options
+    unless params.options.empty?      
+      if params.options.connection
+        key = params.options.connection.to_s
+        if @configs.has_key?(key)
+          @configs.default_connection = @configs[key]
+        else
+          print "unkonwn connection #{key}\n"
+          exit 1
+        end
+      else
+        if missing = params.missing_key(Connection::KEYS)
+          print "missing #{missing} param\n"
+          exit 2
+        end
+        @configs.default_connection = params.options 
+      end
+    end
+    unless @configs.default_connection
+      params.print_usage
+      exit 3
+    end
+  end
+
+end

data/lib/mssql.rb

@@ -0,0 +1,22 @@
+require 'optparse'
+require 'pp'
+require 'yaml'
+
+require 'rubygems'
+#require "bundler/setup" 
+
+require 'tiny_tds'
+require 'hashie'
+require 'active_support/core_ext/hash/keys.rb'
+
+$: << File.join(File.dirname(__FILE__))
+
+require 'params_parser'
+require 'connection'
+require 'table_output'
+require 'command'
+require 'controller'
+require 'query_output'
+require 'command_parser'
+
+STDOUT.sync = true

data/lib/params_parser.rb

@@ -0,0 +1,49 @@
+class ParamsParser
+
+  def initialize    
+    @options = Hashie::Mash.new
+    parse
+  end
+
+  def parse
+    @opts = OptionParser.new do |opts|
+      opts.banner = ""
+      available_options = [ 
+                           ['-c', 'connection', 'use connection defined in ~/.mssql'],
+                           ['-h', 'host',       'server host'],
+                           ['-u', 'username',   'username'],
+                           ['-p', 'password',   'password'],
+                           ['-d', 'database',   'use database name'],
+                           ['-i', 'input_file', 'input file name'],
+                           ['-q', 'query',      'run query and exit']
+                          ]
+      available_options.each do |o|
+        opts.on(o[0], "--#{o[1]} #{o[1].upcase}", o[2]) do |value|
+          @options[o[1]] = value
+        end
+      end
+      opts.on_tail("-?", "--help", "show syntax summary") do
+        print_usage
+        exit
+      end
+    end
+    @opts
+    @opts.parse!(ARGV)
+    @opts
+  end
+
+  def print_usage
+    puts <<-END
+  Usage: #{File.basename($0)} <options>
+  #{@opts.to_s}
+END
+  end
+
+  def missing_key(keys)
+    keys.find do |key|
+      !@options.has_key?(key.to_s)      
+    end
+  end
+
+  attr_reader :options
+end

data/lib/query_output.rb

@@ -0,0 +1,55 @@
+class QueryOutput
+
+  def initialize(connection, query)
+    @connection = connection
+    @query = query
+  end
+
+  def show
+    exec 
+    @connection.error? ? print_error : print_tables
+  end
+
+  def show_text_or_table
+    exec 
+    if @connection.one_column_one_row?
+      print_text
+    else
+      print_tables unless @connection.error?
+    end
+    print_error if @connection.error?
+  end
+
+  private
+
+  def print_error
+    error = @connection.error
+    print "\nmsg: #{error.db_error_number}, severity: #{error.severity}\n#{error.error}\n" 
+  end
+
+  def print_text
+    print @connection.results.rows[0][0]
+    print "\n"
+  rescue
+  end
+  
+  def print_tables
+    results = @connection.results
+    if results.columns.first.kind_of?(Array)
+      (0..results.columns.size-1).each do |index|
+        print TableOutput.new(results.columns[index], results.rows[index]).to_s
+      end
+    else
+      if results.columns.size > 0
+        print TableOutput.new(results.columns, results.rows).to_s
+      else
+        print "#{results.affected} rows affected\n"
+      end
+    end
+  end
+
+  def exec
+    @connection.exec @query
+  end
+
+end

data/lib/simple_update.in

@@ -0,0 +1,50 @@
+class TableOutput
+
+  def initialize(cols, rows)
+    @cols = cols
+    @rows = rows
+    calc_sizes
+    @ascii_encoding = Encoding.find("ASCII-8BIT")  
+  end
+
+  def calc_sizes
+    @sizes = []
+    @cols.each_with_index do |col, index|
+      @sizes[index] = col.to_s.length
+    end
+    @rows.each do |row|
+      data_row = []
+      row.each_with_index do |value, index|
+        # TODO - fix for binary data (timestams)
+        if value.class == String && value.encoding.to_s == "ASCII-8BIT"
+          value = "***"
+          row[index] = value
+        end
+        size = value.to_s.length
+        if @sizes[index] < size
+          @sizes[index] = size
+        end
+      end
+    end
+  end
+
+  def to_s
+    format = @sizes.map{|s| " %-#{s}s "}.join("|")
+    output = []
+
+    separator = @sizes.map{|s| "-" * (s+2)}.join("+")
+    separator = "+#{separator}+"
+    output << ""
+    output << separator
+    output << "|#{format}|" % @cols
+    output << separator
+    @rows.each do |row|
+      output << "|#{format}|" % row
+    end
+    output << separator
+    output << "#{@rows.size} rows affected"
+    output << ""
+    output.join("\n")
+  end
+
+end

data/lib/simple_update.sql

@@ -0,0 +1,50 @@
+class TableOutput
+
+  def initialize(cols, rows)
+    @cols = cols
+    @rows = rows
+    calc_sizes
+    @ascii_encoding = Encoding.find("ASCII-8BIT")  
+  end
+
+  def calc_sizes
+    @sizes = []
+    @cols.each_with_index do |col, index|
+      @sizes[index] = col.to_s.length
+    end
+    @rows.each do |row|
+      data_row = []
+      row.each_with_index do |value, index|
+        # TODO - fix for binary data (timestams)
+        if value.class == String && value.encoding.to_s == "ASCII-8BIT"
+          value = "***"
+          row[index] = value
+        end
+        size = value.to_s.length
+        if @sizes[index] < size
+          @sizes[index] = size
+        end
+      end
+    end
+  end
+
+  def to_s
+    format = @sizes.map{|s| " %-#{s}s "}.join("|")
+    output = []
+
+    separator = @sizes.map{|s| "-" * (s+2)}.join("+")
+    separator = "+#{separator}+"
+    output << ""
+    output << separator
+    output << "|#{format}|" % @cols
+    output << separator
+    @rows.each do |row|
+      output << "|#{format}|" % row
+    end
+    output << separator
+    output << "#{@rows.size} rows affected"
+    output << ""
+    output.join("\n")
+  end
+
+end