teradata-cli 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in teradata-cli.gemspec
+gemspec

data/README.md

@@ -0,0 +1,47 @@
+# Teradata::Cli
+
+Teradata::Cli is an access module which allows Ruby scripts
+to access Teradata RDBMS by CLIv2 interface.
+
+It's based on the [Ruby/CLIv2](http://sourceforge.net/projects/rubycli/) library.
+
+
+## Requirements
+
+    CLIv2 (32bit / 64bit)
+    C compiler
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'teradata-cli'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install teradata-cli
+
+
+## Usage
+
+Look the examples folder
+
+
+## Tests
+
+    $ export TEST_LOGON_STRING=dbc/user,password
+    $ ruby -Ilib:test test/all
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/query.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+#
+# Dispatches SQL query and shows result records.
+#
+# Usage:
+#    $ export LOGON_STRING=dbc/user,pass
+#    $ ruby example/query.rb 'SELECT * FROM x'
+#
+
+require 'teradata'
+require 'logger'
+require 'pp'
+
+logon_string = ENV['LOGON_STRING']
+unless logon_string
+  $stderr.puts "set environment variable LOGON_STRING"
+  exit 1
+end
+
+sql = ARGV[0]
+unless sql
+  $stderr.puts "Usage: ruby #{File.basename($0)} QUERY"
+  exit 1
+end
+
+log = Logger.new($stderr)
+log.sev_threshold = $DEBUG ? Logger::DEBUG : Logger::INFO
+
+Teradata.connect(logon_string, :logger => log) {|conn|
+  conn.query(sql) {|result_sets|
+    result_sets.each_result_set do |rs|
+      pp rs
+      rs.each_record do |rec|
+        pp rec
+      end
+    end
+  }
+}

data/examples/show-queryband.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#
+# Show Query Bands of current sessions.
+#
+# Usage:
+#    $ export LOGON_STRING=dbc/user,pass
+#    $ ruby example/show-queryband.rb
+#
+
+require 'teradata'
+
+logon_string = ENV['LOGON_STRING']
+unless logon_string
+  $stderr.puts "set environment variable LOGON_STRING"
+  exit 1
+end
+
+Teradata.connect(logon_string) {|conn|
+  conn.query("SELECT * FROM dbc.sessionInfo") {|rs|
+    rs.each do |rec|
+      user = rec[:UserName].strip
+      band = rec[:QueryBand]
+      puts "#{user}\t#{band}"
+    end
+  }
+}

data/examples/tu/excel/excel.rb

@@ -0,0 +1,86 @@
+require 'win32ole'
+require 'fileutils'
+
+class Excel
+
+  def Excel.open_worksheet(path, sheet_name, mode, &block)
+    open {|app| app.open_worksheet(path, sheet_name, mode, &block) }
+  end
+
+  def Excel.open_book(path, mode, &block)
+    open {|app| app.open_book(path, mode, &block) }
+  end
+
+  FileSystem = WIN32OLE.new('Scripting.FileSystemObject')
+
+  def Excel.open(visible = $DEBUG, &block)
+    new(visible, &block)
+  end
+
+  @@const_loaded = false
+
+  def initialize(visible = $DEBUG)
+    @app = WIN32OLE.new('Excel.Application')
+    unless @@const_loaded
+      WIN32OLE.const_load @app, Excel
+      @@const_loaded = true
+    end
+    @app.visible = true if visible
+    yield self if block_given?
+  ensure
+    quit if block_given? and @app
+  end
+
+  def quit
+    @app.quit
+  end
+
+  def open_book(path, mode)
+    begin
+      book = @app.workbooks.open(win_extend_path(path))
+      yield book
+      book.save if mode == 'w'
+    ensure
+      book.saved = true   # avoid confirmation message
+      @app.workbooks.close
+    end
+  end
+
+  def open_worksheet(path, sheet_name, mode)
+    open_book(path, mode) {|book|
+      sheet = book.worksheets.item(1)
+      sheet.extend WorkSheetMethods
+      yield sheet
+    }
+  end
+
+  def win_extend_path(path)
+    FileSystem.getAbsolutePathName(path)
+  end
+  private :win_extend_path
+
+  module WorkSheetMethods
+    def [](y, x)
+      cell = cells().item(y, x)
+      if cell.mergeCells
+        cell.mergeArea.item(1, 1).value
+      else
+        cell.value
+      end
+    end
+
+    def []=(y, x, value)
+      cell = cells().item(y, x)
+      if cell.mergeCells
+        cell.mergeArea.item(1, 1).value = value
+      else
+        cell.value = value
+      end
+    end
+
+    def last_cell
+      cells().specialCells(Excel::XlLastCell)
+    end
+  end
+
+end

data/examples/tu/excel/fill.rb

@@ -0,0 +1,94 @@
+require 'excel'
+require 'fileutils'
+require 'pp'
+require 'teradata'
+
+def main
+  logon_string, template, output = ARGV
+  usage_exit unless logon_string
+  usage_exit unless template
+  output ||= 'out.xls'
+
+  FileUtils.cp template, output
+  Excel.open(true) {|app|
+    app.open_worksheet(output, 'Sheet1', 'w') {|sheet|
+      fill_sheet sheet, logon_string
+    }
+  }
+end
+
+def fill_sheet(sheet, logon_string)
+  # Get SQL Cell
+  sql_cell = sheet.cells.find('%SQL')
+  p ['sql_cell', sql_cell.address]
+  sql = sql_cell.value.slice(/%SQL\s+(.*)/m, 1).strip
+  p sql
+
+  # Get Value Cells
+  value_cell = sheet.cells.find('%=', sql_cell)
+  p ['value', value_cell.address]
+  exprs = [expr_proc(value_cell)]
+  c = value_cell
+  while true
+    next_c = sheet.range(address(c.row.to_i, c.column.to_i + 1))
+    break unless /^%=/ =~ next_c.value
+    c = next_c
+    p ['value', c.address]
+    exprs.push expr_proc(c)
+  end
+  pp exprs
+
+  tmpl_range = sheet.range(value_cell.address + ':' + c.address)
+  xl = value_cell.column
+  xr = c.column
+  y = value_cell.row + 1
+
+  # Execute SQL and fill cells by data
+  Teradata.connect(logon_string) {|conn|
+    conn.query(sql) {|rs|
+      rs.each do |rec|
+        pp rec
+        values = exprs.map {|expr| expr.call(rec) }
+        pp values
+        tmpl_range.copy
+        sheet.range(address(y, xl) + ':' + address(y, xr)).insert Excel::XlShiftDown
+        sheet.range(address(y, xl) + ':' + address(y, xr)).value = values
+        y += 1
+      end
+    }
+  }
+
+  # remove metadata cells
+  tmpl_range.delete Excel::XlShiftUp
+  sheet.rows(sql_cell.row).delete
+end
+
+def usage_exit
+  $stderr.puts "Usage: #{$0} LOGON_STRING TEMPLATE [OUTPUT]"
+  exit 1
+end
+
+def expr_proc(cell)
+  expr = cell.value.slice(/%=(.*)/m, 1).strip
+  lambda {|_| eval(expr).to_s }
+end
+
+def address(row, col)
+  "$#{column_string(col)}$#{row}"
+end
+
+ALPHA = ('a'..'z').to_a
+
+def column_string(col)
+  result = []
+  n = col - 1
+  while n >= 26
+    n, mod = n.divmod(26)
+    result.unshift mod
+    n -= 1
+  end
+  result.unshift n
+  result.map {|i| ALPHA[i] }.join('')
+end
+
+main

data/examples/tu/tusample1.rb

@@ -0,0 +1,6 @@
+require 'teradata'
+Teradata.connect(ENV['LOGON_STRING']) {|conn|
+  conn.tables("tudemo").
+      select {|table| /_bak$/ =~ table.name }.
+      each {|table| conn.drop table }
+}

data/examples/tu/tusample2.rb

@@ -0,0 +1,7 @@
+require 'teradata'
+Teradata.connect(ENV['LOGON_STRING']) {|conn|
+  conn.tables("tudemo").
+      sort_by {|table| -table.size }.
+      first(5).
+      each {|table| puts "#{table.name}\t#{table.size}" }
+}

data/examples/tu/web/bitdao.rb

@@ -0,0 +1,197 @@
+# $Id: bitdao.rb 184 2009-08-12 08:46:22Z aamine $
+
+class BitDAO
+  module Error; end
+
+  class BaseError < ::StandardError
+    include Error
+  end
+
+  class IntegrityError < BaseError; end
+  class ObjectNotExist < BaseError; end
+
+  def error
+    @connection.error_class
+  end
+
+  def sql_error
+    @connection.sql_error_class
+  end
+
+  def initialize(log, connection)
+    @log = log
+    @connection = connection
+  end
+
+  def load_object(_class, sql)
+    list = load_objects(_class, sql)
+    if list.empty?
+      raise ObjectNotExist, "no record exist: #{_class}"
+    end
+    if list.size > 1
+      raise IntegrityError, "too many #{_class} loaded: #{list.size} for 1"
+    end
+    list.first
+  end
+
+  def load_objects(_class, sql)
+    @log.info(self.class) { "[SEL] #{sql}" }
+    result = []
+    @connection.execute_query(sql) {|rs|
+      rs.each_record do |rec|
+        result.push _class.for_record(self, rec)
+      end
+    }
+    @log.info(self.class) { "#{result.size} records" }
+    result
+  end
+
+  def exec_sql(sql, level = Logger::INFO)
+    @log.add(level, nil, self.class) { "[UPD] #{sql}" } if level
+    @connection.execute_update sql
+  end
+
+  def transaction
+    aborting = false
+    exec_sql "BEGIN TRANSACTION;"
+    begin
+      yield
+    rescue Teradata::CLI::UserAbort => err
+      aborting = true
+      raise err
+    ensure
+      if $@
+        begin
+          abort unless aborting
+        rescue Teradata::CLI::UserAbort   # do not override original exception
+        end
+      else
+        exec_sql "END TRANSACTION;"
+      end
+    end
+  end
+
+  def abort
+    exec_sql "ABORT;"
+  end
+
+  private
+
+  def int(n)
+    return 'NULL' unless n
+    n
+  end
+
+  def string(str)
+    return 'NULL' unless str
+    "'" + str.gsub(/'/, "''") + "'"
+  end
+
+  def date(d)
+    return 'NULL' unless d
+    "DATE '#{d.strftime('%Y-%m-%d')}'"
+  end
+
+  def timestamp(t)
+    return 'NULL' unless t
+    "TIMESTAMP '#{t.strftime('%Y-%m-%d %H:%M:%S')}'"
+  end
+
+
+  def BitDAO.define(&block)
+    PersistentObject.define(&block)
+  end
+
+  class PersistentObject
+
+    def PersistentObject.define(&block)
+      c = Class.new(PersistentObject)
+      c.module_eval(&block)
+      c.define_initialize c.slots
+      c
+    end
+
+    def PersistentObject.slot(name, _class, column = nil)
+      attr_reader name
+      (@slots ||= []).push Slot.new(name, _class, column)
+    end
+
+    class << self
+      attr_reader :slots
+    end
+
+    class Slot
+      def initialize(name, _class, column)
+        @name = name
+        @class = _class
+        @column = column || name
+      end
+
+      attr_reader :name
+      attr_reader :column
+
+      def parse(s)
+        @class.parse(s)
+      end
+    end
+
+    def PersistentObject.sql_integer
+      SQLInteger.new
+    end
+
+    class SQLInteger
+      def parse(i)
+        i
+      end
+    end
+
+    def PersistentObject.sql_string
+      SQLString.new
+    end
+
+    class SQLString
+      # CHAR/VARCHAR field returns extra spaces, remove it always.
+      def parse(str)
+        str ? str.rstrip : nil
+      end
+    end
+
+    def PersistentObject.sql_date
+      SQLDate.new
+    end
+
+    def PersistentObject.sql_timestamp
+      SQLDate.new
+    end
+
+    class SQLDate
+      def parse(str)
+        # "2009-01-23"
+        Time.parse(str)
+      end
+    end
+
+    def PersistentObject.for_record(dao, rec)
+      unless rec.size >= @slots.size
+        raise DatabaseError, "wrong column number of record (#{rec.size} for #{@slots.size})"
+      end
+      obj = new(* @slots.map {|slot| slot.parse(rec[slot.column]) })
+      obj._dao = dao
+      obj
+    end
+
+    def PersistentObject.define_initialize(slots)
+      param_list = slots.map {|s| s.name }.join(', ')
+      ivar_list = slots.map {|s| "@#{s.name}" }.join(', ')
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def initialize(#{param_list})
+          #{ivar_list} = #{param_list}
+        end
+      End
+    end
+
+    attr_writer :_dao
+
+  end
+
+end